Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

fix(engine-formula): improve formula compatibility stability (#7212)

Univer124836d4df90
diff --git a/packages/drawing/src/services/drawing-manager-impl.service.ts b/packages/drawing/src/services/drawing-manager-impl.service.ts
index e1f460e31b..10fb3138cb 100644
--- a/packages/drawing/src/services/drawing-manager-impl.service.ts
+++ b/packages/drawing/src/services/drawing-manager-impl.service.ts
@@ -225,6 +225,9 @@ export class UnitDrawingService<T extends IDrawingParam> implements IUnitDrawing
this._establishDrawingMap(unitId, subUnitId);
const subUnitData = data[subUnitId];
+ if (subUnitData?.data == null) {
+ return;
+ }
Object.keys(subUnitData.data).forEach((drawingId) => {
const drawing = subUnitData.data[drawingId];
diff --git a/packages/engine-formula/src/basics/__tests__/inverted-index-cache.spec.ts b/packages/engine-formula/src/basics/__tests__/inverted-index-cache.spec.ts
new file mode 100644
index 0000000000..2051e1c738
--- /dev/null
+++ b/packages/engine-formula/src/basics/__tests__/inverted-index-cache.spec.ts
@@ -0,0 +1,36 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { InvertedIndexCache } from '../inverted-index-cache';
+
+describe('InvertedIndexCache', () => {
+ it('keeps empty string lookups distinct from numeric zero lookups', () => {
+ const cache = new InvertedIndexCache();
+ const unitId = 'unit';
+ const sheetId = 'sheet';
+ const column = 0;
+ const rows: [number, number][] = [[0, 2]];
+
+ cache.setContinueBuildingCache(unitId, sheetId, column, 0, 2);
+ cache.set(unitId, sheetId, column, 0, 0, true);
+ cache.set(unitId, sheetId, column, '', 1, true);
+ cache.set(unitId, sheetId, column, null, 2, true);
+
+ expect(cache.getCellPositions(unitId, sheetId, column, 0, rows)?.matchingRows).toEqual([0, 1, 2]);
+ expect(cache.getCellPositions(unitId, sheetId, column, '', rows)?.matchingRows).toEqual([1, 2]);
+ });
+});
diff --git a/packages/engine-formula/src/basics/__tests__/regex.spec.ts b/packages/engine-formula/src/basics/__tests__/regex.spec.ts
index 11a9d8b5ae..7cd4644d62 100644
--- a/packages/engine-formula/src/basics/__tests__/regex.spec.ts
+++ b/packages/engine-formula/src/basics/__tests__/regex.spec.ts
@@ -169,6 +169,13 @@ describe('Test ref regex', () => {
expect(RE_SINGLE.test('Table1[[Order-ID]]')).toBe(true);
});
+ it('matches line-break column name', () => {
+ RE_SINGLE.lastIndex = 0;
+ expect(RE_SINGLE.test('Table1[CASH\r\nOUT]')).toBe(true);
+ RE_SINGLE.lastIndex = 0;
+ expect(RE_SINGLE.test('Table1[[#Totals],[CASH\r\nOUT]]')).toBe(true);
+ });
+
it('matches pure unicode column name', () => {
RE_SINGLE.lastIndex = 0;
expect(RE_SINGLE.test('Table1[[中文列名]]')).toBe(true);
@@ -262,6 +269,11 @@ describe('Test ref regex', () => {
expect(RE_MULTI.test('Table1[[#Data], [ Column1 ] : [ Column10 ]]')).toBe(true);
});
+ it('matches line-break column names in range', () => {
+ RE_MULTI.lastIndex = 0;
+ expect(RE_MULTI.test('Table1[[CASH\r\nOUT]:[CASH\r\nIN]]')).toBe(true);
+ });
+
it('matches unicode/special char names in range', () => {
RE_MULTI.lastIndex = 0;
expect(RE_MULTI.test('Table1[[客户 名称]:[订单-ID]]')).toBe(true);
diff --git a/packages/engine-formula/src/basics/date.ts b/packages/engine-formula/src/basics/date.ts
index 1542de58ab..1c0e24e91e 100644
--- a/packages/engine-formula/src/basics/date.ts
+++ b/packages/engine-formula/src/basics/date.ts
@@ -158,6 +158,57 @@ export function parseFormattedTime(value: string) {
return numfmt.parseTime(value);
}
+function parseEnglishMonthNameDate(value: string): Date | null {
+ const match = value.trim().match(/^(\d{1,2})\s*([A-Za-z]{3,9})\s*(\d{2,4})$/);
+
+ if (!match) {
+ return null;
+ }
+
+ const [, dayText, monthText, yearText] = match;
+ const monthMap: Record<string, number> = {
+ jan: 0,
+ january: 0,
+ feb: 1,
+ february: 1,
+ mar: 2,
+ march: 2,
+ apr: 3,
+ april: 3,
+ may: 4,
+ jun: 5,
+ june: 5,
+ jul: 6,
+ july: 6,
+ aug: 7,
+ august: 7,
+ sep: 8,
+ sept: 8,
+ september: 8,
+ oct: 9,
+ october: 9,
+ nov: 10,
+ november: 10,
+ dec: 11,
+ december: 11,
+ };
+ const month = monthMap[monthText.toLowerCase()];
+
+ if (month == null) {
+ return null;
+ }
+
+ const day = Number(dayText);
+ const year = Number(yearText.length === 2 ? `20${yearText}` : yearText);
+ const date = new Date(Date.UTC(year, month, day));
+
+ if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) {
+ return null;
+ }
+
+ return date;
+}
+
export function isDate(format: string) {
return numfmt.getFormatInfo(format).isDate;
}
@@ -297,6 +348,8 @@ export function getDateSerialNumberByObject(serialNumberObject: BaseValueObject)
dateSerial = parseFormattedDate(`${dateValue}`)!.v;
} else if (parseFormattedTime(`${dateValue}`)) {
dateSerial = parseFormattedTime(`${dateValue}`)!.v;
+ } else if (parseEnglishMonthNameDate(`${dateValue}`)) {
+ dateSerial = parseEnglishMonthNameDate(`${dateValue}`)!;
} else if (isRealNum(dateValue)) {
dateSerial = +dateValue;
} else {
@@ -386,19 +439,19 @@ function getDaysByNASD(startDateSerialNumber: number, endDateSerialNumber: numbe
let endMonth = endDateSerialNumber > 0 ? endDateDate.getUTCMonth() + 1 : 1;
let endDay = endDateSerialNumber > 0 ? endDateDate.getUTCDate() : 0;
+ const startIsLastDayOfFebruary = startMonth === 2 && startDay === getDaysInMonth(startYear, startMonth - 1);
+
// If the starting date is the last day of a month, it becomes equal to the 30th day of the same month.
// If the ending date is the last day of a month and the starting date is earlier than the 30th day of a month, the ending date becomes equal to the 1st day of the next month; otherwise the ending date becomes equal to the 30th day of the same month.
- if (startMonth === 2) {
- const startDateAfterDay = excelSerialToDate(startDateSerialNumber + 1);
-
- if (startDateAfterDay.getUTCMonth() + 1 === 3) {
- startDay = 30;
- }
+ if (startIsLastDayOfFebruary) {
+ startDay = 30;
} else if (startDay === 31) {
startDay = 30;
}
- if (endDay === 31) {
+ if (endMonth === 2 && endDay === getDaysInMonth(endYear, endMonth - 1) && startIsLastDayOfFebruary) {
+ endDay = 30;
+ } else if (endDay === 31) {
if (startDay < 30) {
endDateDate = excelSerialToDate(endDateSerialNumber + 1);
endYear = endDateDate.getUTCFullYear();
diff --git a/packages/engine-formula/src/basics/inverted-index-cache.ts b/packages/engine-formula/src/basics/inverted-index-cache.ts
index 34b3c5b3f3..7ebcc4575b 100644
--- a/packages/engine-formula/src/basics/inverted-index-cache.ts
+++ b/packages/engine-formula/src/basics/inverted-index-cache.ts
@@ -136,7 +136,7 @@ export class InvertedIndexCache {
if (ERROR_TYPE_SET.has(_value as ErrorType)) {
result.errorType = _value as ErrorType;
- } else if (_value === 0 || _value === DEFAULT_EMPTY_CELL_KEY) {
+ } else if (_value === 0) {
const rows = [];
const rowsForZero = columnMap.get(0);
@@ -150,6 +150,8 @@ export class InvertedIndexCache {
}
result.matchingRows = rows.filter((row) => rowsInCache.some(([start, end]) => row >= start && row <= end));
+ } else if (_value === DEFAULT_EMPTY_CELL_KEY) {
+ result.matchingRows = Array.from(columnMap.get(DEFAULT_EMPTY_CELL_KEY) ?? []).filter((row) => rowsInCache.some(([start, end]) => row >= start && row <= end));
} else {
result.matchingRows = Array.from(columnMap.get(_value) ?? []).filter((row) => rowsInCache.some(([start, end]) => row >= start && row <= end));
}
diff --git a/packages/engine-formula/src/basics/regex.ts b/packages/engine-formula/src/basics/regex.ts
index c4ee86f8ea..df951637d4 100644
--- a/packages/engine-formula/src/basics/regex.ts
+++ b/packages/engine-formula/src/basics/regex.ts
@@ -66,7 +66,7 @@ const TABLE_NAME_REGEX = '((?![~!@#$%^&*()_+<>?:,./;’,。、‘:“《》
const TABLE_TITLE_REGEX = '\\[#.+\\]\\s*?,\\s*?';
-const TABLE_CONTENT_REGEX = '\\[((?<!#).)*\\]';
+const TABLE_CONTENT_REGEX = '\\[((?<!#)[\\s\\S])*\\]';
const TABLE_MULTIPLE_COLUMN_REGEX = `${TABLE_CONTENT_REGEX}${RANGE_SYMBOL}${TABLE_CONTENT_REGEX}`;
diff --git a/packages/engine-formula/src/basics/statistical.ts b/packages/engine-formula/src/basics/statistical.ts
index e0163e1f1c..32f104f72e 100644
--- a/packages/engine-formula/src/basics/statistical.ts
+++ b/packages/engine-formula/src/basics/statistical.ts
@@ -1465,7 +1465,16 @@ export function getArrayValuesByAggregateIgnoreOptions(
return valueObject as ErrorValueObject;
}
- if (!valueObject || valueObject.isNull() || valueObject.isBoolean() || valueObject.isString()) {
+ if (!valueObject || valueObject.isNull() || valueObject.isString()) {
+ continue;
+ }
+
+ if (!array.isArray() && valueObject.isBoolean()) {
+ values.push(valueObject.getValue() ? 1 : 0);
+ continue;
+ }
+
+ if (valueObject.isBoolean()) {
continue;
}
diff --git a/packages/engine-formula/src/engine/analysis/__tests__/lexer-tree-builder.spec.ts b/packages/engine-formula/src/engine/analysis/__tests__/lexer-tree-builder.spec.ts
index aefee5cbbb..2064bd1712 100644
--- a/packages/engine-formula/src/engine/analysis/__tests__/lexer-tree-builder.spec.ts
+++ b/packages/engine-formula/src/engine/analysis/__tests__/lexer-tree-builder.spec.ts
@@ -31,6 +31,14 @@ describe('lexer nodeMaker test', () => {
const lexerTreeBuilder = new LexerTreeBuilder();
describe('lexer', () => {
+ it('preserves empty string comparison inside IF parameter', () => {
+ const node = lexerTreeBuilder.treeBuilder('=IF(A1="","blank","not blank")') as LexerNode;
+
+ expect(JSON.stringify(node.serialize())).toStrictEqual(
+ String.raw`{"token":"R_1","st":-1,"ed":-1,"children":[{"token":"IF","st":0,"ed":1,"children":[{"token":"P_1","st":-1,"ed":1,"children":["A1","\"\"","="]},{"token":"P_1","st":5,"ed":7,"children":["\"blank\""]},{"token":"P_1","st":13,"ed":15,"children":["\"not blank\""]}]}]}`
+ );
+ });
+
it('lambda simple1', () => {
const node = lexerTreeBuilder.treeBuilder(
'=lambda(x,y, x*y*x)(sum(1,(1+2)*3),2)+1-max(100,200)'
diff --git a/packages/engine-formula/src/engine/analysis/__tests__/lexer.spec.ts b/packages/engine-formula/src/engine/analysis/__tests__/lexer.spec.ts
index 6565f2d7ab..87c2b8a536 100644
--- a/packages/engine-formula/src/engine/analysis/__tests__/lexer.spec.ts
+++ b/packages/engine-formula/src/engine/analysis/__tests__/lexer.spec.ts
@@ -149,6 +149,90 @@ describe('lexer test', () => {
});
});
+ it('resolves workbook defined names that point to sheets with underscores', () => {
+ formulaCurrentConfigService.setSheetNameMap({
+ test: {
+ sheet1: 'sheetName1',
+ sheet2: 'Parameters_Constants',
+ },
+ });
+ definedNamesService.registerDefinedName('test', {
+ id: 'test-underscore-sheet',
+ name: 'CONST_GJpt',
+ formulaOrRefString: 'Parameters_Constants!$B$28',
+ localSheetId: 'AllDefaultWorkbook',
+ });
+
+ const node = lexer.treeBuilder('=CONST_GJpt') as LexerNode;
+
+ expect(JSON.stringify(node.serialize())).toContain('Parameters_Constants!$B$28');
+ expect(JSON.stringify(node.serialize())).not.toContain('#NAME?');
+ });
+
+ it('resolves defined names case-insensitively', () => {
+ definedNamesService.registerDefinedName('test', {
+ id: 'test-case-insensitive',
+ name: 'CONST_kNm3',
+ formulaOrRefString: '$B$27',
+ localSheetId: 'AllDefaultWorkbook',
+ });
+
+ const node = lexer.treeBuilder('=CONST_KNM3') as LexerNode;
+
+ expect(JSON.stringify(node.serialize())).toContain('$B$27');
+ expect(JSON.stringify(node.serialize())).not.toContain('#NAME?');
+ });
+
+ it('prefers sheet-local defined names over workbook defined names', () => {
+ formulaCurrentConfigService.setExecuteSubUnitId('sheet-weekly');
+ formulaCurrentConfigService.setSheetNameMap({
+ test: {
+ 'sheet-weekly': 'Weekly',
+ 'sheet-report': 'Report',
+ },
+ });
+ definedNamesService.registerDefinedName('test', {
+ id: 'date-begin-local',
+ name: 'date_begin',
+ formulaOrRefString: 'Weekly!$F$4',
+ localSheetId: 'sheet-weekly',
+ });
+ definedNamesService.registerDefinedName('test', {
+ id: 'date-begin-global',
+ name: 'date_begin',
+ formulaOrRefString: 'Report!$F$4',
+ localSheetId: 'AllDefaultWorkbook',
+ });
+
+ const node = lexer.treeBuilder('=date_begin+6') as LexerNode;
+ const serialized = JSON.stringify(node.serialize());
+
+ expect(serialized).toContain('Weekly!$F$4');
+ expect(serialized).not.toContain('Report!$F$4');
+ });
+
+ it('resolves defined names next to operators and spaces', () => {
+ definedNamesService.registerDefinedName('test', {
+ id: 'test-operator-left',
+ name: 'CONST_GJ',
+ formulaOrRefString: '$B$25',
+ localSheetId: 'AllDefaultWorkbook',
+ });
+ definedNamesService.registerDefinedName('test', {
+ id: 'test-operator-right',
+ name: 'CONST_t',
+ formulaOrRefString: '$B$26',
+ localSheetId: 'AllDefaultWorkbook',
+ });
+
+ const node = lexer.treeBuilder('=CONST_GJ & "/" &CONST_t') as LexerNode;
+ const serialized = JSON.stringify(node.serialize());
+
+ expect(serialized).toContain('$B$25');
+ expect(serialized).toContain('$B$26');
+ expect(serialized).not.toContain('#NAME?');
+ });
+
it('lambda', () => {
definedNamesService.registerDefinedName('test', {
id: 'test2',
diff --git a/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts b/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
index db2c7dcb2e..87c0fc8df7 100644
--- a/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
+++ b/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
@@ -21,15 +21,27 @@ import type { BaseValueObject } from '../../value-object/base-value-object';
import type { LexerNode } from '../lexer-node';
import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../basics/error-type';
+import { FUNCTION_NAMES_LOGICAL } from '../../../functions/logical/function-names';
+import { Groupby } from '../../../functions/logical/groupby';
+import { If } from '../../../functions/logical/if';
+import { Percentof } from '../../../functions/logical/percentof';
+import { FUNCTION_NAMES_LOOKUP } from '../../../functions/lookup/function-names';
+import { Hstack } from '../../../functions/lookup/hstack';
import { FUNCTION_NAMES_MATH } from '../../../functions/math/function-names';
import { Pi } from '../../../functions/math/pi';
+import { Subtotal } from '../../../functions/math/subtotal';
import { Sum } from '../../../functions/math/sum';
+import { Compare } from '../../../functions/meta/compare';
import { Divided } from '../../../functions/meta/divided';
import { FUNCTION_NAMES_META } from '../../../functions/meta/function-names';
import { Minus } from '../../../functions/meta/minus';
import { Plus } from '../../../functions/meta/plus';
+import { Counta } from '../../../functions/statistical/counta';
import { Countif } from '../../../functions/statistical/countif';
import { FUNCTION_NAMES_STATISTICAL } from '../../../functions/statistical/function-names';
+import { StdevP } from '../../../functions/statistical/stdev-p';
+import { FUNCTION_NAMES_TEXT } from '../../../functions/text/function-names';
+import { Regexmatch } from '../../../functions/text/regexmatch';
import { IFormulaCurrentConfigService } from '../../../services/current-data.service';
import { IFunctionService } from '../../../services/function.service';
import { IFormulaRuntimeService } from '../../../services/runtime.service';
@@ -91,11 +103,20 @@ describe('Test indirect', () => {
functionService.registerExecutors(
new Sum(FUNCTION_NAMES_MATH.SUM),
+ new Subtotal(FUNCTION_NAMES_MATH.SUBTOTAL),
+ new Compare(FUNCTION_NAMES_META.COMPARE),
new Plus(FUNCTION_NAMES_META.PLUS),
new Minus(FUNCTION_NAMES_META.MINUS),
new Divided(FUNCTION_NAMES_META.DIVIDED),
new Pi(FUNCTION_NAMES_MATH.PI),
- new Countif(FUNCTION_NAMES_STATISTICAL.COUNTIF)
+ new Countif(FUNCTION_NAMES_STATISTICAL.COUNTIF),
+ new Counta(FUNCTION_NAMES_STATISTICAL.COUNTA),
+ new StdevP(FUNCTION_NAMES_STATISTICAL.STDEV_P),
+ new Regexmatch(FUNCTION_NAMES_TEXT.REGEXMATCH),
+ new Hstack(FUNCTION_NAMES_LOOKUP.HSTACK),
+ new Groupby(FUNCTION_NAMES_LOGICAL.GROUPBY),
+ new If(FUNCTION_NAMES_LOGICAL.IF),
+ new Percentof(FUNCTION_NAMES_LOGICAL.PERCENTOF)
);
superTableService.registerTable(testBed.unitId, 'Table1', {
@@ -105,6 +126,8 @@ describe('Test indirect', () => {
['col2', 1],
['col3', 2],
['col4', 3],
+ ['CASH\nOUT', 0],
+ ['CASH\nIN', 1],
]),
range: {
startRow: 0,
@@ -116,6 +139,17 @@ describe('Test indirect', () => {
});
describe('normal', () => {
+ it('preserves xleta aggregator tokens inside GROUPBY', () => {
+ const lexerNode = lexer.treeBuilder('=_xlfn.GROUPBY(A1:A3,A1:A3,_xlfn.HSTACK(_xleta.COUNTA,_xleta.PERCENTOF),0)');
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode) as BaseAstNode;
+ const groupbyNode = astNode.getChildren()[0];
+ const hstackNode = groupbyNode.getChildren()[2];
+
+ expect(groupbyNode.getToken()).toBe('GROUPBY');
+ expect(hstackNode.getToken()).toBe('HSTACK');
+ expect(hstackNode.getChildren().map((node) => node.getToken())).toEqual(['COUNTA', 'PERCENTOF']);
+ });
+
it('Ref error', async () => {
const lexerNode = lexer.treeBuilder(`=sum(${ErrorType.REF} + 1)`);
@@ -176,6 +210,42 @@ describe('Test indirect', () => {
expect((result as ArrayValueObject).getFirstCell().getValue()).toStrictEqual(1);
});
+ it('normalizes xlfn REGEXTEST to REGEXMATCH during formula execution', async () => {
+ const lexerNode = lexer.treeBuilder('=_xlfn.REGEXTEST(D4,"^(?=.*e)test$")');
+
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
+
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
+
+ expect((result as BaseValueObject).getValue()).toStrictEqual(true);
+ });
+
+ it('normalizes xlfn STDEV.P to registered statistical function during formula execution', async () => {
+ const lexerNode = lexer.treeBuilder('=_xlfn.STDEV.P(0,0,0)');
+
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
+
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
+
+ expect((result as BaseValueObject).getValue()).toStrictEqual(0);
+ });
+
+ it('treats a numeric zero cell as non-blank in IF comparisons', async () => {
+ const lexerNode = lexer.treeBuilder('=IF(A4="","blank","not blank")');
+
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
+
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
+
+ expect((result as BaseValueObject).getValue()).toStrictEqual('not blank');
+ });
+
+ it('parses xlfn LAMBDA parameters with xlpm prefixes', async () => {
+ const lexerNode = lexer.treeBuilder('=_xlfn.LAMBDA(_xlpm.a,_xlpm.i,_xlpm.a)(1,2)');
+
+ expect(() => astTreeBuilder.parse(lexerNode as LexerNode)).not.toThrow();
+ });
+
it('Minus Minus Minus ref', async () => {
const lexerNode = lexer.treeBuilder('=---A1');
@@ -183,7 +253,7 @@ describe('Test indirect', () => {
const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
- expect((result as ArrayValueObject).getFirstCell().getValue()).toStrictEqual(-1);
+ expect((result as BaseValueObject).getValue()).toStrictEqual(-1);
});
it('Minus Minus Minus Minus sum', async () => {
@@ -431,6 +501,27 @@ describe('Test indirect', () => {
expect((result as BaseValueObject).getValue()).toStrictEqual(4);
});
+ it('supports line-break column names in structured references', async () => {
+ const lexerNode = lexer.treeBuilder('=SUM(Table1[CASH\r\nOUT])') as LexerNode;
+ const astNode = astTreeBuilder.parse(lexerNode) as BaseAstNode;
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode));
+ expect((result as BaseValueObject).getValue()).toStrictEqual(4);
+ });
+
+ it('supports line-break column names in SUBTOTAL structured references', async () => {
+ const lexerNode = lexer.treeBuilder('=SUBTOTAL(109,Table1[CASH\r\nOUT])') as LexerNode;
+ const astNode = astTreeBuilder.parse(lexerNode) as BaseAstNode;
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode));
+ expect((result as BaseValueObject).getValue()).toStrictEqual(4);
+ });
+
+ it('supports totals row arithmetic with line-break column names', async () => {
+ const lexerNode = lexer.treeBuilder('=Table1[[#Totals],[CASH\r\nIN]]-Table1[[#Totals],[CASH\r\nOUT]]+A1') as LexerNode;
+ const astNode = astTreeBuilder.parse(lexerNode) as BaseAstNode;
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode));
+ expect((result as BaseValueObject).getValue()).toStrictEqual(101);
+ });
+
it('ignores text in numeric aggregations: SUM(Table1[col2]) => 4', async () => {
const lexerNode = lexer.treeBuilder('=SUM(Table1[col2])') as LexerNode;
const astNode = astTreeBuilder.parse(lexerNode) as BaseAstNode;
diff --git a/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts b/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
index 73c6ad8af0..49fd71c1f5 100644
--- a/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
+++ b/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
@@ -80,7 +80,8 @@ export const FormulaSequenceNodeCache = new FormulaAstLRU<Array<string | ISequen
interface IInjectDefinedNameParam {
unitId: Nullable<string>;
- getValueByName(unitId: string, name: string): Nullable<IDefinedNamesServiceParam>;
+ sheetId?: Nullable<string>;
+ getValueByName(unitId: string, name: string, sheetId?: Nullable<string>): Nullable<IDefinedNamesServiceParam>;
getDirtyDefinedNameMap(): IDirtyUnitDefinedNameMap;
getSheetName: (unitId: string, sheetId: string) => string;
}
@@ -767,7 +768,7 @@ export class LexerTreeBuilder extends Disposable {
hasDefinedName: boolean;
definedNames: string[];
} {
- const { unitId, getValueByName, getSheetName } = param;
+ const { unitId, sheetId, getValueByName, getSheetName } = param;
if (unitId == null) {
return {
@@ -796,7 +797,8 @@ export class LexerTreeBuilder extends Disposable {
token = this._getHasSheetNameDefinedName(tokenRaw, unitId, param);
}
- const definedContent = getValueByName(unitId, token);
+ const definedNameToken = token.trim();
+ const definedContent = getValueByName(unitId, definedNameToken, sheetId);
if (definedContent) {
const refString = definedContent.formulaOrRefString;
// if (refString.substring(0, 1) === operatorToken.EQUALS) {
@@ -807,7 +809,7 @@ export class LexerTreeBuilder extends Disposable {
if (nestedDefinedNameParam == null || typeof nestedDefinedNameParam !== 'object') {
sequenceString += nestedDefinedNameParam || ErrorType.NAME;
hasDefinedName = true;
- definedNames.push(token);
+ definedNames.push(definedNameToken);
} else if (typeof nestedDefinedNameParam === 'object') {
const { sequenceString: nestedSequenceString, definedNames: nestedDefinedNames } = nestedDefinedNameParam;
sequenceString += nestedSequenceString;
@@ -816,10 +818,10 @@ export class LexerTreeBuilder extends Disposable {
});
hasDefinedName = true;
}
- } else if (this._checkDefinedNameDirty(token, param)) {
+ } else if (this._checkDefinedNameDirty(definedNameToken, param)) {
sequenceString += ErrorType.NAME;
hasDefinedName = true;
- definedNames.push(token);
+ definedNames.push(definedNameToken);
} else {
sequenceString += token;
}
@@ -1500,8 +1502,9 @@ export class LexerTreeBuilder extends Disposable {
// without a standalone lexer phase
// eslint-disable-next-line max-lines-per-function, complexity
private _nodeMaker(formulaStringRaw: string, sequenceArray?: ISequenceArray[], matchCurrentNodeIndex?: number) {
- // Editor will add '\r\n' at the end of the formula string
- let formulaString = formulaStringRaw.replace(/\r\n$|\r|\n/g, ' ');
+ // Editor may add a line break at the end of the formula string.
+ // Keep internal line breaks because Excel table column names can contain them.
+ let formulaString = formulaStringRaw.replace(/(?:\r\n|\r|\n)$/g, ' ');
if (formulaString.substring(0, 1) === operatorToken.EQUALS) {
formulaString = formulaString.substring(1);
}
diff --git a/packages/engine-formula/src/engine/analysis/lexer.ts b/packages/engine-formula/src/engine/analysis/lexer.ts
index c207a3e538..fda7a3d336 100644
--- a/packages/engine-formula/src/engine/analysis/lexer.ts
+++ b/packages/engine-formula/src/engine/analysis/lexer.ts
@@ -35,6 +35,7 @@ export class Lexer extends Disposable {
return this._lexerTreeBuilder.treeBuilder(formulaString, transformSuffix, {
unitId: this._formulaCurrentConfigService.getExecuteUnitId(),
+ sheetId: this._formulaCurrentConfigService.getExecuteSubUnitId(),
getValueByName: this._definedNamesService.getValueByName.bind(this._definedNamesService),
getDirtyDefinedNameMap: this._formulaCurrentConfigService.getDirtyDefinedNameMap.bind(this._formulaCurrentConfigService),
getSheetName: this._formulaCurrentConfigService.getSheetName.bind(this._formulaCurrentConfigService),
diff --git a/packages/engine-formula/src/engine/analysis/parser.ts b/packages/engine-formula/src/engine/analysis/parser.ts
index d8ff6d1420..dd406e9f62 100644
--- a/packages/engine-formula/src/engine/analysis/parser.ts
+++ b/packages/engine-formula/src/engine/analysis/parser.ts
@@ -15,8 +15,6 @@
*/
import type { Nullable } from '@univerjs/core';
-import type { BaseAstNode } from '../ast-node/base-ast-node';
-
import type { LambdaNode } from '../ast-node/lambda-node';
import { Disposable, Inject, sortRules } from '@univerjs/core';
import { ErrorType } from '../../basics/error-type';
@@ -30,7 +28,7 @@ import {
} from '../../basics/token-type';
import { IFormulaRuntimeService } from '../../services/runtime.service';
import { AstRootNode, AstRootNodeFactory } from '../ast-node/ast-root-node';
-import { ErrorNode } from '../ast-node/base-ast-node';
+import { BaseAstNode, ErrorNode } from '../ast-node/base-ast-node';
import { ErrorFunctionNode, FunctionNodeFactory } from '../ast-node/function-node';
import { LambdaNodeFactory } from '../ast-node/lambda-node';
import { LambdaParameterNodeFactory } from '../ast-node/lambda-parameter-node';
@@ -299,6 +297,9 @@ export class AstTreeBuilder extends Disposable {
switch (astNode.nodeType) {
// case NodeType.ERROR:
// return astNode;
+ case NodeType.BASE:
+ calculateStack.push(astNode);
+ break;
case NodeType.FUNCTION: {
const token = astNode.getToken().trim().toUpperCase();
if (FORCED_RECALCULATION_FUNCTION_NAME.has(token)) {
@@ -384,6 +385,11 @@ export class AstTreeBuilder extends Disposable {
}
if (astNode == null) {
+ const aggregatorNode = this._createGroupByAggregatorTokenNode(item);
+ if (aggregatorNode != null) {
+ return aggregatorNode;
+ }
+
return new ErrorFunctionNode();
}
@@ -391,6 +397,29 @@ export class AstTreeBuilder extends Disposable {
return astNode;
}
+ private _createGroupByAggregatorTokenNode(param: LexerNode | string): Nullable<BaseAstNode> {
+ const token = (typeof param === 'string' ? param : param.getToken()).trim().toUpperCase();
+ const prefix = '_XLETA.';
+ if (!token.startsWith(prefix)) {
+ return null;
+ }
+
+ const name = token.slice(prefix.length);
+ if (
+ name !== 'SUM' &&
+ name !== 'COUNT' &&
+ name !== 'COUNTA' &&
+ name !== 'PERCENTOF' &&
+ name !== 'MIN' &&
+ name !== 'MAX' &&
+ name !== 'ARRAYTOTEXT'
+ ) {
+ return null;
+ }
+
+ return new BaseAstNode(name);
+ }
+
private _initializeAstNode() {
this._astNodeFactoryList = [
this._astRootNodeFactory,
diff --git a/packages/engine-formula/src/engine/ast-node/function-node.ts b/packages/engine-formula/src/engine/ast-node/function-node.ts
index 1746404be4..6b1c593e6c 100644
--- a/packages/engine-formula/src/engine/ast-node/function-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/function-node.ts
@@ -31,6 +31,7 @@ import { AstNodePromiseType } from '../../basics/common';
import { ErrorType } from '../../basics/error-type';
import { matchToken } from '../../basics/token';
import { COLUMN_LIKE_FUNCTION_NAMES } from '../../functions/column-like-functions';
+import { FUNCTION_NAMES_TEXT } from '../../functions/text/function-names';
import { FormulaDataModel } from '../../models/formula-data.model';
import { IFormulaCurrentConfigService } from '../../services/current-data.service';
import { IDefinedNamesService } from '../../services/defined-names.service';
@@ -80,34 +81,23 @@ export class FunctionNode extends BaseAstNode {
}
override async executeAsync() {
- const variants: BaseValueObject[] = [];
const children = this.getChildren();
- const childrenCount = children.length;
this._compatibility();
- for (let i = 0; i < childrenCount; i++) {
- const child = children[i];
- const object = child.getValue();
- if (object == null) {
- continue;
- }
- if (object.isReferenceObject() && !this._functionExecutor.needsReferenceObject) {
- variants.push((object as BaseReferenceObject).toArrayValueObject());
- } else {
- variants.push(object as BaseValueObject);
- }
- }
-
- const resultVariant = await this._calculateAsync(variants);
+ const resultVariant = this._functionExecutor.needsAstChildren
+ ? this._calculateAst(children)
+ : await this._calculateAsync(this._collectVariants(children));
let result: FunctionVariantType;
if (resultVariant.isAsyncObject() || resultVariant.isAsyncArrayObject()) {
- result = await (resultVariant as AsyncObject | AsyncArrayObject).getValue();
+ result = await (resultVariant as AsyncObject | AsyncArrayObject).getValue() as FunctionVariantType;
} else {
result = resultVariant as FunctionVariantType;
}
+ result = this._normalizeTopLevelLegacyArrayResult(result);
+
this._setEmbeddedArrayFormulaToResult(result);
this._setRefData(result);
@@ -118,40 +108,58 @@ export class FunctionNode extends BaseAstNode {
}
override execute() {
- const variants: BaseValueObject[] = [];
const children = this.getChildren();
- const childrenCount = children.length;
this._compatibility();
+ const resultVariant = (this._functionExecutor.needsAstChildren
+ ? this._calculateAst(children)
+ : this._calculate(this._collectVariants(children))) as FunctionVariantType;
+
+ const result = this._normalizeTopLevelLegacyArrayResult(resultVariant);
+
+ this._setEmbeddedArrayFormulaToResult(result);
+
+ this._setRefData(result);
+
+ this.setValue(result as FunctionVariantType);
+ }
+
+ private _collectVariants(children: BaseAstNode[]): BaseValueObject[] {
+ const variants: BaseValueObject[] = [];
+ const childrenCount = children.length;
+
for (let i = 0; i < childrenCount; i++) {
- const child = children[i];
- const object = child.getValue();
+ const object = this._getChildVariant(children[i]);
if (object == null) {
continue;
}
- if (object.isReferenceObject() && this._functionExecutor.needsFilteredOutRows) {
- this._setFilteredOutRows(object as BaseReferenceObject);
- }
-
- // In the SUBTOTAL function, we need to get rowData information, we can only use ReferenceObject
- if (object.isReferenceObject() && !this._functionExecutor.needsReferenceObject) {
- // Array converted from reference object needs to be marked
- variants.push((object as BaseReferenceObject).toArrayValueObject());
- } else {
- variants.push(object as BaseValueObject);
- }
+ variants.push(object as BaseValueObject);
}
- const resultVariant = this._calculate(variants) as FunctionVariantType;
+ return variants;
+ }
+
+ private _getChildVariant(child: BaseAstNode): FunctionVariantType | undefined {
+ const object = child.getValue();
- this._setEmbeddedArrayFormulaToResult(resultVariant);
+ if (object == null) {
+ return;
+ }
- this._setRefData(resultVariant);
+ if (object.isReferenceObject() && this._functionExecutor.needsFilteredOutRows) {
+ this._setFilteredOutRows(object as BaseReferenceObject);
+ }
- this.setValue(resultVariant as FunctionVariantType);
+ // In the SUBTOTAL function, we need to get rowData information, we can only use ReferenceObject
+ if (object.isReferenceObject() && !this._functionExecutor.needsReferenceObject) {
+ // Array converted from reference object needs to be marked
+ return (object as BaseReferenceObject).toArrayValueObject();
+ }
+
+ return object;
}
isFunctionExecutorArgumentsIgnoreNumberPattern() {
@@ -176,6 +184,21 @@ export class FunctionNode extends BaseAstNode {
this._runtimeService.setUnitArrayFormulaEmbeddedMap();
}
+ private _normalizeTopLevelLegacyArrayResult(result: FunctionVariantType): FunctionVariantType {
+ const parent = this.getParent();
+ const isTopLevel = parent == null || parent.nodeType === NodeType.ROOT;
+ if (!this._functionExecutor.returnsLegacyArrayAsScalar || !isTopLevel || !result.isArray()) {
+ return result;
+ }
+
+ const array = result as ArrayValueObject;
+ if (array.getRowCount() <= 1 && array.getColumnCount() <= 1) {
+ return result;
+ }
+
+ return array.getFirstCell();
+ }
+
/**
* Compatibility handling for special functions.
*/
@@ -306,6 +329,18 @@ export class FunctionNode extends BaseAstNode {
return resultVariant;
}
+ private _calculateAst(children: BaseAstNode[]) {
+ const { minParams, maxParams } = this._functionExecutor;
+ if (minParams !== -1 && maxParams !== -1 && (children.length < minParams || children.length > maxParams)) {
+ return ErrorValueObject.create(ErrorType.NA);
+ }
+
+ this._setRefInfo();
+ this._handleAddressFunction();
+
+ return this._functionExecutor.calculateAst(children, (node) => this._getChildVariant(node) ?? null);
+ }
+
private async _calculateAsync(variants: BaseValueObject[]) {
// Check the number of parameters
const { minParams, maxParams } = this._functionExecutor;
@@ -345,9 +380,9 @@ export class FunctionNode extends BaseAstNode {
}
private _setRefInfo() {
- const { currentUnitId, currentSubUnitId, currentRow, currentColumn } = this._runtimeService;
+ const { currentUnitId, currentSubUnitId, currentRow, currentColumn, currentRowCount, currentColumnCount } = this._runtimeService;
- this._functionExecutor.setRefInfo(currentUnitId, currentSubUnitId, currentRow, currentColumn);
+ this._functionExecutor.setRefInfo(currentUnitId, currentSubUnitId, currentRow, currentColumn, currentRowCount, currentColumnCount);
if (this._functionExecutor.needsSheetRowColumnCount) {
const { rowCount, columnCount } = this._currentConfigService.getSheetRowColumnCount(currentUnitId, currentSubUnitId);
@@ -469,7 +504,7 @@ export class FunctionNodeFactory extends BaseAstNodeFactory {
return ErrorNode.create(ErrorType.VALUE);
}
- const tokenTrimUpper = tokenTrim.toUpperCase();
+ const tokenTrimUpper = normalizeFunctionToken(tokenTrim.toUpperCase());
if (isColon && COLUMN_LIKE_FUNCTION_NAMES.has(tokenTrimUpper)) {
return;
@@ -492,3 +527,17 @@ export class FunctionNodeFactory extends BaseAstNodeFactory {
return param.getParent()?.getParent()?.getToken() === matchToken.COLON;
}
}
+
+function normalizeFunctionToken(token: string): string {
+ if (token === 'REGEXTEST' || token === '_XLFN.REGEXTEST') {
+ return FUNCTION_NAMES_TEXT.REGEXMATCH;
+ }
+
+ for (const prefix of ['_XLFN.', '_XLWS.', '_XLETA.']) {
+ if (token.startsWith(prefix)) {
+ return token.slice(prefix.length);
+ }
+ }
+
+ return token;
+}
diff --git a/packages/engine-formula/src/engine/ast-node/lambda-node.ts b/packages/engine-formula/src/engine/ast-node/lambda-node.ts
index 9e56bae311..70538b9103 100644
--- a/packages/engine-formula/src/engine/ast-node/lambda-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/lambda-node.ts
@@ -130,9 +130,12 @@ export class LambdaNodeFactory extends BaseAstNodeFactory {
for (let i = 0; i < parameterArray.length; i++) {
const parameter = parameterArray[i];
if (parameter instanceof LexerNode) {
- const variant = parameter.getChildren()[0] as string;
+ const variant = getLambdaParameterName(parameter);
+ if (variant == null) {
+ return ErrorNode.create(ErrorType.VALUE);
+ }
parameter.setToken(DEFAULT_TOKEN_TYPE_LAMBDA_OMIT_PARAMETER);
- currentLambdaPrivacyVar.set(variant.trim(), undefined);
+ currentLambdaPrivacyVar.set(variant, undefined);
} else {
return ErrorNode.create(ErrorType.VALUE);
}
@@ -166,3 +169,23 @@ export class LambdaNodeFactory extends BaseAstNodeFactory {
updateLambdaStatement(functionStatementNode, lambdaId, currentLambdaPrivacyVar);
}
}
+
+function getLambdaParameterName(parameter: LexerNode): Nullable<string> {
+ const children = parameter.getChildren();
+ for (let i = 0; i < children.length; i++) {
+ const child = children[i];
+ if (typeof child === 'string') {
+ const token = child.trim();
+ if (token.length > 0) {
+ return token;
+ }
+ } else {
+ const token = getLambdaParameterName(child);
+ if (token != null) {
+ return token;
+ }
+ }
+ }
+
+ return null;
+}
diff --git a/packages/engine-formula/src/engine/ast-node/operator-node.ts b/packages/engine-formula/src/engine/ast-node/operator-node.ts
index 3cc6558a47..9f594f71ea 100644
--- a/packages/engine-formula/src/engine/ast-node/operator-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/operator-node.ts
@@ -75,11 +75,11 @@ export class OperatorNode extends BaseAstNode {
}
if (object1.isReferenceObject()) {
- object1 = (object1 as BaseReferenceObject).toArrayValueObject();
+ object1 = this._referenceToOperatorValue(object1 as BaseReferenceObject);
}
if (object2.isReferenceObject()) {
- object2 = (object2 as BaseReferenceObject).toArrayValueObject();
+ object2 = this._referenceToOperatorValue(object2 as BaseReferenceObject);
}
const result = this._functionExecutor.calculate(
@@ -92,6 +92,15 @@ export class OperatorNode extends BaseAstNode {
this.setValue(result);
}
+ private _referenceToOperatorValue(reference: BaseReferenceObject): BaseValueObject {
+ const array = reference.toArrayValueObject();
+ if (array.getRowCount() === 1 && array.getColumnCount() === 1) {
+ return array.get(0, 0) as BaseValueObject;
+ }
+
+ return array;
+ }
+
/**
* If it contains an array formula, set the current cell to the cache and send itself as a ref outward
*/
diff --git a/packages/engine-formula/src/engine/ast-node/prefix-node.ts b/packages/engine-formula/src/engine/ast-node/prefix-node.ts
index d113691cb2..10b5f12edf 100644
--- a/packages/engine-formula/src/engine/ast-node/prefix-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/prefix-node.ts
@@ -20,7 +20,8 @@ import type { BaseFunction } from '../../functions/base-function';
import type { BaseReferenceObject, FunctionVariantType } from '../reference-object/base-reference-object';
import type { BaseValueObject } from '../value-object/base-value-object';
import { ErrorType } from '../../basics/error-type';
-import { prefixToken } from '../../basics/token';
+import { OPERATOR_TOKEN_COMPARE_SET, prefixToken } from '../../basics/token';
+import { FUNCTION_NAMES_LOOKUP } from '../../functions/lookup/function-names';
import { FUNCTION_NAMES_META } from '../../functions/meta/function-names';
import { IFunctionService } from '../../services/function.service';
import { IFormulaRuntimeService } from '../../services/runtime.service';
@@ -81,6 +82,10 @@ export class PrefixNode extends BaseAstNode {
return ErrorValueObject.create(ErrorType.VALUE);
}
+ if (this._preserveAtRangeForFormula2LookupArray()) {
+ return currentValue;
+ }
+
const runtimeService = this._runtimeService;
const currentRow = runtimeService.currentRow || 0;
@@ -111,6 +116,34 @@ export class PrefixNode extends BaseAstNode {
return ErrorValueObject.create(ErrorType.VALUE);
}
+
+ private _preserveAtRangeForFormula2LookupArray(): boolean {
+ let node: BaseAstNode = this;
+ let parent = node.getParent();
+ let sawCompareOperator = false;
+
+ while (parent != null) {
+ if (parent.nodeType === NodeType.OPERATOR) {
+ sawCompareOperator ||= OPERATOR_TOKEN_COMPARE_SET.has(parent.getToken());
+ }
+
+ if (parent.nodeType === NodeType.FUNCTION) {
+ const functionName = parent.getToken().toUpperCase();
+ if (
+ sawCompareOperator &&
+ functionName === FUNCTION_NAMES_LOOKUP.XMATCH
+ ) {
+ return parent.getChildren().indexOf(node) === 1;
+ }
+ return false;
+ }
+
+ node = parent;
+ parent = parent.getParent();
+ }
+
+ return false;
+ }
}
export class PrefixNodeFactory extends BaseAstNodeFactory {
diff --git a/packages/engine-formula/src/engine/ast-node/value-node.ts b/packages/engine-formula/src/engine/ast-node/value-node.ts
index babeba35aa..49cff6be7e 100644
--- a/packages/engine-formula/src/engine/ast-node/value-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/value-node.ts
@@ -20,6 +20,7 @@ import { BooleanValue } from '../../basics/common';
import { ERROR_TYPE_SET } from '../../basics/error-type';
import { LexerNode } from '../analysis/lexer-node';
import { ValueObjectFactory } from '../value-object/array-value-object';
+import { StringValueObject } from '../value-object/primitive-object';
import { BaseAstNode } from './base-ast-node';
import { BaseAstNodeFactory, DEFAULT_AST_NODE_FACTORY_Z_INDEX } from './base-ast-node-factory';
import { NODE_ORDER_MAP, NodeType } from './node-type';
@@ -34,12 +35,19 @@ export class ValueNode extends BaseAstNode {
}
override execute(): void {
+ const token = this.getToken();
+ const tokenTrim = token.trim();
+ if (tokenTrim.startsWith('"') && tokenTrim.endsWith('"')) {
+ this.setValue(StringValueObject.create(tokenTrim.slice(1, -1).replace(/""/g, '"')));
+ return;
+ }
+
const parent = this.getParent();
let isIgnoreNumberPattern = true;
if (parent?.nodeType === NodeType.FUNCTION) {
isIgnoreNumberPattern = (parent as FunctionNode).isFunctionExecutorArgumentsIgnoreNumberPattern?.() ?? true;
}
- this.setValue(ValueObjectFactory.create(this.getToken(), isIgnoreNumberPattern));
+ this.setValue(ValueObjectFactory.create(token, isIgnoreNumberPattern));
}
}
diff --git a/packages/engine-formula/src/engine/dependency/formula-dependency.ts b/packages/engine-formula/src/engine/dependency/formula-dependency.ts
index 311df60457..817bf61146 100644
--- a/packages/engine-formula/src/engine/dependency/formula-dependency.ts
+++ b/packages/engine-formula/src/engine/dependency/formula-dependency.ts
@@ -522,7 +522,7 @@ export class FormulaDependencyGenerator extends Disposable implements IFormulaDe
}
protected _getTreeNode(tree: IFormulaDependencyTree) {
- return generateAstNode(tree.unitId, tree.formula, this._lexer, this._astTreeBuilder, this._currentConfigService);
+ return generateAstNode(tree.unitId, tree.formula, this._lexer, this._astTreeBuilder, this._currentConfigService, tree.subUnitId);
}
// eslint-disable-next-line style/generator-star-spacing
diff --git a/packages/engine-formula/src/engine/interpreter/interpreter.ts b/packages/engine-formula/src/engine/interpreter/interpreter.ts
index a69902e796..64bcbd086d 100644
--- a/packages/engine-formula/src/engine/interpreter/interpreter.ts
+++ b/packages/engine-formula/src/engine/interpreter/interpreter.ts
@@ -19,16 +19,20 @@ import type { BaseAstNode } from '../ast-node/base-ast-node';
import type { FunctionNode } from '../ast-node/function-node';
import type { LambdaNode } from '../ast-node/lambda-node';
import type { ReferenceNode } from '../ast-node/reference-node';
-import type { FunctionVariantType } from '../reference-object/base-reference-object';
+import type { BaseReferenceObject, FunctionVariantType } from '../reference-object/base-reference-object';
import type { IExecuteAstNodeData } from '../utils/ast-node-tool';
import type { PreCalculateNodeType } from '../utils/node-type';
+import type { ArrayValueObject } from '../value-object/array-value-object';
+import type { BaseValueObject } from '../value-object/base-value-object';
import { Disposable } from '@univerjs/core';
import { AstNodePromiseType } from '../../basics/common';
import { ErrorType } from '../../basics/error-type';
import { DEFAULT_TOKEN_LAMBDA_FUNCTION_NAME } from '../../basics/token-type';
+import { FUNCTION_NAMES_LOOKUP } from '../../functions/lookup/function-names';
import { IFormulaRuntimeService } from '../../services/runtime.service';
import { NodeType } from '../ast-node/node-type';
import { ErrorValueObject } from '../value-object/base-value-object';
+import { BooleanValueObject, NumberValueObject } from '../value-object/primitive-object';
export class Interpreter extends Disposable {
constructor(@IFormulaRuntimeService private readonly _runtimeService: IFormulaRuntimeService) {
@@ -119,6 +123,9 @@ export class Interpreter extends Disposable {
if (this._runtimeService.isStopExecution()) {
return Promise.resolve(AstNodePromiseType.ERROR);
}
+ if (await this._executeLazyFunctionAsync(node, refOffsetX, refOffsetY)) {
+ return Promise.resolve(AstNodePromiseType.SUCCESS);
+ }
const children = node.getChildren();
const childrenCount = children.length;
for (let i = 0; i < childrenCount; i++) {
@@ -154,6 +161,9 @@ export class Interpreter extends Disposable {
if (this._runtimeService.isStopExecution()) {
return AstNodePromiseType.ERROR;
}
+ if (this._executeLazyFunction(node, refOffsetX, refOffsetY)) {
+ return AstNodePromiseType.SUCCESS;
+ }
const children = node.getChildren();
const childrenCount = children.length;
for (let i = 0; i < childrenCount; i++) {
@@ -180,4 +190,254 @@ export class Interpreter extends Disposable {
return AstNodePromiseType.SUCCESS;
}
+
+ private async _executeLazyFunctionAsync(node: BaseAstNode, refOffsetX: number, refOffsetY: number): Promise<boolean> {
+ if (node.nodeType !== NodeType.FUNCTION) {
+ return false;
+ }
+
+ const token = node.getToken().toUpperCase();
+ if (token === 'IF') {
+ return await this._executeLazyIfAsync(node, refOffsetX, refOffsetY);
+ }
+ if (token === 'IFERROR') {
+ return await this._executeLazyIfErrorAsync(node, refOffsetX, refOffsetY);
+ }
+ return false;
+ }
+
+ private _executeLazyFunction(node: BaseAstNode, refOffsetX: number, refOffsetY: number): boolean {
+ if (node.nodeType !== NodeType.FUNCTION) {
+ return false;
+ }
+
+ const token = node.getToken().toUpperCase();
+ if (token === 'IF') {
+ return this._executeLazyIf(node, refOffsetX, refOffsetY);
+ }
+ if (token === 'IFERROR') {
+ return this._executeLazyIfError(node, refOffsetX, refOffsetY);
+ }
+ return false;
+ }
+
+ private async _executeLazyIfAsync(node: BaseAstNode, refOffsetX: number, refOffsetY: number): Promise<boolean> {
+ const children = node.getChildren();
+ if (children.length < 2 || children.length > 3) {
+ return false;
+ }
+
+ await this._executeAsync(children[0], refOffsetX, refOffsetY);
+ const condition = children[0].getValue();
+ if (condition == null || condition.isReferenceObject() || condition.isArray()) {
+ return false;
+ }
+ if (condition.isError()) {
+ node.setValue(condition);
+ return true;
+ }
+
+ const selected = (condition as BaseValueObject).getValue() ? children[1] : children[2];
+ if (selected == null) {
+ node.setValue(BooleanValueObject.create(false));
+ return true;
+ }
+
+ await this._executeAsync(selected, refOffsetX, refOffsetY);
+ node.setValue(this._toLazyIfSelectedValue(selected.getValue(), node));
+ return true;
+ }
+
+ private _executeLazyIf(node: BaseAstNode, refOffsetX: number, refOffsetY: number): boolean {
+ const children = node.getChildren();
+ if (children.length < 2 || children.length > 3) {
+ return false;
+ }
+
+ this._execute(children[0], refOffsetX, refOffsetY);
+ const condition = children[0].getValue();
+ if (condition == null || condition.isReferenceObject() || condition.isArray()) {
+ return false;
+ }
+ if (condition.isError()) {
+ node.setValue(condition);
+ return true;
+ }
+
+ const selected = (condition as BaseValueObject).getValue() ? children[1] : children[2];
+ if (selected == null) {
+ node.setValue(BooleanValueObject.create(false));
+ return true;
+ }
+
+ this._execute(selected, refOffsetX, refOffsetY);
+ node.setValue(this._toLazyIfSelectedValue(selected.getValue(), node));
+ return true;
+ }
+
+ private async _executeLazyIfErrorAsync(node: BaseAstNode, refOffsetX: number, refOffsetY: number): Promise<boolean> {
+ const children = node.getChildren();
+ if (children.length !== 2) {
+ return false;
+ }
+
+ await this._executeAsync(children[0], refOffsetX, refOffsetY);
+ const rawValue = children[0].getValue();
+ const value = this._toLazyIfErrorValue(rawValue);
+ if (value == null || value.isArray()) {
+ return false;
+ }
+ if (!value.isError()) {
+ node.setValue(value);
+ return true;
+ }
+
+ await this._executeAsync(children[1], refOffsetX, refOffsetY);
+ node.setValue(children[1].getValue() ?? ErrorValueObject.create(ErrorType.VALUE));
+ return true;
+ }
+
+ private _executeLazyIfError(node: BaseAstNode, refOffsetX: number, refOffsetY: number): boolean {
+ const children = node.getChildren();
+ if (children.length !== 2) {
+ return false;
+ }
+
+ this._execute(children[0], refOffsetX, refOffsetY);
+ const rawValue = children[0].getValue();
+ const value = this._toLazyIfErrorValue(rawValue);
+ if (value == null || value.isArray()) {
+ return false;
+ }
+ if (!value.isError()) {
+ node.setValue(value);
+ return true;
+ }
+
+ this._execute(children[1], refOffsetX, refOffsetY);
+ node.setValue(children[1].getValue() ?? ErrorValueObject.create(ErrorType.VALUE));
+ return true;
+ }
+
+ private _toLazyIfErrorValue(value: Nullable<FunctionVariantType>): Nullable<BaseValueObject> {
+ if (value == null) {
+ return null;
+ }
+
+ if (!value.isReferenceObject()) {
+ const baseValue = value as BaseValueObject;
+ return baseValue.isNull() ? NumberValueObject.create(0) : baseValue;
+ }
+
+ const reference = value as BaseReferenceObject;
+
+ if (reference.getRowCount() !== 1 || reference.getColumnCount() !== 1) {
+ return reference.toArrayValueObject();
+ }
+
+ const cellValue = reference.getCellByPosition();
+ return cellValue.isNull() ? NumberValueObject.create(0) : cellValue;
+ }
+
+ private _toLazyIfSelectedValue(value: Nullable<FunctionVariantType>, node: BaseAstNode): FunctionVariantType {
+ if (value == null) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ if (value.isReferenceObject()) {
+ const reference = value as BaseReferenceObject;
+ if (this._preserveLazyIfSelectedReferenceArray(node)) {
+ return reference.toArrayValueObject();
+ }
+ value = this._implicitLazyIfReferenceValue(reference);
+ }
+
+ if (value.isArray()) {
+ value = this._implicitLazyIfArrayValue(value as ArrayValueObject);
+ }
+
+ if (!value.isArray()) {
+ const baseValue = value as BaseValueObject;
+ return baseValue.isNull() ? NumberValueObject.create(0) : baseValue;
+ }
+
+ return value;
+ }
+
+ private _implicitLazyIfReferenceValue(reference: BaseReferenceObject): BaseValueObject {
+ const range = reference.getRangePosition();
+ const currentRow = this._runtimeService.currentRow || 0;
+ const currentColumn = this._runtimeService.currentColumn || 0;
+ const { startRow, startColumn, endRow, endColumn } = range;
+
+ if (startRow === endRow && startColumn === endColumn) {
+ return reference.getCellByPosition();
+ }
+
+ if (endRow === startRow && currentColumn >= startColumn && currentColumn <= endColumn) {
+ return reference.getCellByColumn(currentColumn);
+ }
+
+ if (startColumn === endColumn && currentRow >= startRow && currentRow <= endRow) {
+ return reference.getCellByRow(currentRow);
+ }
+
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ private _preserveLazyIfSelectedReferenceArray(node: BaseAstNode): boolean {
+ let child: BaseAstNode = node;
+ let parent = child.getParent();
+
+ while (parent != null) {
+ if (parent.nodeType === NodeType.FUNCTION) {
+ return parent.getToken().toUpperCase() === FUNCTION_NAMES_LOOKUP.MATCH && parent.getChildren().indexOf(child) === 1;
+ }
+
+ child = parent;
+ parent = parent.getParent();
+ }
+
+ return false;
+ }
+
+ private _implicitLazyIfArrayValue(array: ArrayValueObject): FunctionVariantType {
+ if (
+ array.getUnitId() === '' ||
+ array.getSheetId() === '' ||
+ array.getCurrentRow() < 0 ||
+ array.getCurrentColumn() < 0
+ ) {
+ return array;
+ }
+
+ const startRow = array.getCurrentRow();
+ const startColumn = array.getCurrentColumn();
+ const rowCount = array.getRowCount();
+ const columnCount = array.getColumnCount();
+ const currentRow = this._runtimeService.currentRow || 0;
+ const currentColumn = this._runtimeService.currentColumn || 0;
+
+ let rowIndex = -1;
+ let columnIndex = -1;
+ if (rowCount === 1 && columnCount === 1) {
+ rowIndex = 0;
+ columnIndex = 0;
+ } else if (rowCount === 1) {
+ rowIndex = 0;
+ columnIndex = currentColumn - startColumn;
+ } else if (columnCount === 1) {
+ rowIndex = currentRow - startRow;
+ columnIndex = 0;
+ } else {
+ rowIndex = currentRow - startRow;
+ columnIndex = currentColumn - startColumn;
+ }
+
+ if (rowIndex < 0 || rowIndex >= rowCount || columnIndex < 0 || columnIndex >= columnCount) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ return (array.get(rowIndex, columnIndex) as BaseValueObject) || ErrorValueObject.create(ErrorType.VALUE);
+ }
}
diff --git a/packages/engine-formula/src/engine/reference-object/__tests__/cell-reference-object.spec.ts b/packages/engine-formula/src/engine/reference-object/__tests__/cell-reference-object.spec.ts
new file mode 100644
index 0000000000..e686bedbbc
--- /dev/null
+++ b/packages/engine-formula/src/engine/reference-object/__tests__/cell-reference-object.spec.ts
@@ -0,0 +1,101 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CellValueType, ObjectMatrix } from '@univerjs/core';
+import { describe, expect, it } from 'vitest';
+import { CellReferenceObject } from '../cell-reference-object';
+
+describe('CellReferenceObject', () => {
+ it('should allow blank cells inside the Excel grid even when they are outside snapshot row data', () => {
+ const reference = new CellReferenceObject('Sheet2!A151');
+
+ reference.setForcedSheetIdDirect('sheet-2');
+
+ expect(reference.isExceedRange()).toBe(false);
+ });
+
+ it('should still reject cells outside the Excel grid', () => {
+ const reference = new CellReferenceObject('Sheet2!A1048577');
+
+ reference.setForcedSheetIdDirect('sheet-2');
+
+ expect(reference.isExceedRange()).toBe(true);
+ });
+
+ it('should still reject unresolved forced sheet names', () => {
+ const reference = new CellReferenceObject('Sheet2!A151');
+
+ expect(reference.isExceedRange()).toBe(true);
+ });
+
+ it('should preserve typed empty strings while iterating references', () => {
+ const reference = new CellReferenceObject('A1:B1');
+ reference.setDefaultUnitId('unit-1');
+ reference.setDefaultSheetId('sheet-1');
+ reference.setUnitData({
+ 'unit-1': {
+ 'sheet-1': {
+ rowCount: 1,
+ columnCount: 2,
+ rowData: {},
+ columnData: {},
+ cellData: new ObjectMatrix({
+ 0: {
+ 0: { v: '', t: CellValueType.STRING },
+ 1: { v: '' },
+ },
+ }),
+ },
+ },
+ });
+
+ const values: unknown[] = [];
+ reference.iterator((valueObject) => {
+ values.push(valueObject?.getValue() ?? null);
+ });
+
+ expect(values).toEqual(['', null]);
+ });
+
+ it('should return null value objects for missing cells inside the grid', () => {
+ const reference = new CellReferenceObject('A1');
+ reference.setDefaultUnitId('unit-1');
+ reference.setDefaultSheetId('sheet-1');
+ reference.setUnitData({
+ 'unit-1': {
+ 'sheet-1': {
+ rowCount: 1,
+ columnCount: 1,
+ rowData: {},
+ columnData: {},
+ cellData: new ObjectMatrix({}),
+ },
+ },
+ });
+
+ expect(reference.getCellByPosition().isNull()).toBe(true);
+ expect(reference.getCellByPosition().getValue()).toBe(0);
+ });
+
+ it('should treat string enum number cell types as numeric cells', () => {
+ const reference = new CellReferenceObject('A1');
+
+ const valueObject = reference.getCellValueObject({ v: '43497', t: String(CellValueType.NUMBER) as never });
+
+ expect(valueObject.isNumber()).toBe(true);
+ expect(valueObject.getValue()).toBe(43497);
+ });
+});
diff --git a/packages/engine-formula/src/engine/reference-object/base-reference-object.ts b/packages/engine-formula/src/engine/reference-object/base-reference-object.ts
index 8c657d1952..e04b225887 100644
--- a/packages/engine-formula/src/engine/reference-object/base-reference-object.ts
+++ b/packages/engine-formula/src/engine/reference-object/base-reference-object.ts
@@ -158,7 +158,7 @@ export class BaseReferenceObject extends ObjectClassType {
const { startRow, endRow, startColumn, endColumn } = this.getRangePosition();
if (this._checkIfWorksheetMiss()) {
- return callback(ErrorValueObject.create(ErrorType.VALUE), startRow, startColumn);
+ return callback(ErrorValueObject.create(ErrorType.REF), startRow, startColumn);
}
const unitId = this._forcedUnitId || this._defaultUnitId;
@@ -172,7 +172,7 @@ export class BaseReferenceObject extends ObjectClassType {
const cell = this.getCellData(r, c)!;
let result: Nullable<boolean> = false;
- if (isNullCell(cell)) {
+ if (isNullCell(cell) && !isTypedEmptyStringCell(cell)) {
result = callback(null, r, c);
continue;
}
@@ -200,7 +200,7 @@ export class BaseReferenceObject extends ObjectClassType {
getFirstCell() {
if (this._checkIfWorksheetMiss()) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ return ErrorValueObject.create(ErrorType.REF);
}
const { startRow, startColumn } = this.getRangePosition();
@@ -442,11 +442,12 @@ export class BaseReferenceObject extends ObjectClassType {
getCellValueObject(cell: ICellData) {
const value = getCellValue(cell);
+ const cellValueType = Number(cell.t);
if (ERROR_TYPE_SET.has(value as ErrorType)) {
return ErrorValueObject.create(value as ErrorType);
}
- if (cell.t === CellValueType.NUMBER) {
+ if (cellValueType === CellValueType.NUMBER) {
const pattern = this._getPatternByCell(cell);
if (isTextFormat(pattern)) {
@@ -455,11 +456,11 @@ export class BaseReferenceObject extends ObjectClassType {
return createNumberValueObjectByRawValue(value, pattern);
}
- if (cell.t === CellValueType.STRING || cell.t === CellValueType.FORCE_STRING) {
+ if (cellValueType === CellValueType.STRING || cellValueType === CellValueType.FORCE_STRING) {
// A1 is `"test"`, =A1 also needs to get `"test"`
return StringValueObject.create(value.toString());
}
- if (cell.t === CellValueType.BOOLEAN) {
+ if (cellValueType === CellValueType.BOOLEAN) {
return createBooleanValueObjectByRawValue(value);
}
@@ -574,7 +575,7 @@ export class BaseReferenceObject extends ObjectClassType {
const cell = this.getCellData(row, column);
if (!cell) {
- return ErrorValueObject.create(ErrorType.VALUE);
+ return NullValueObject.create();
}
return this.getCellValueObject(cell);
@@ -660,6 +661,7 @@ export class BaseReferenceObject extends ObjectClassType {
sheetId: this.getSheetId(),
row: startRow,
column: startColumn,
+ useInvertedIndexCache: true,
};
const arrayValueObject = ArrayValueObject.create(arrayValueObjectData);
@@ -699,6 +701,10 @@ export class BaseReferenceObject extends ObjectClassType {
}
}
+function isTypedEmptyStringCell(cell: Nullable<ICellData>): boolean {
+ return cell?.v === '' && (cell.t === CellValueType.STRING || cell.t === CellValueType.FORCE_STRING);
+}
+
export class AsyncObject extends ObjectClassType {
constructor(private _promise: Promise<BaseValueObject>) {
super();
diff --git a/packages/engine-formula/src/engine/reference-object/cell-reference-object.ts b/packages/engine-formula/src/engine/reference-object/cell-reference-object.ts
index 1bc62894e6..ebb3c31140 100644
--- a/packages/engine-formula/src/engine/reference-object/cell-reference-object.ts
+++ b/packages/engine-formula/src/engine/reference-object/cell-reference-object.ts
@@ -23,6 +23,9 @@ import { ErrorValueObject } from '../value-object/base-value-object';
import { BaseReferenceObject } from './base-reference-object';
import { RangeReferenceObject } from './range-reference-object';
+const EXCEL_MAX_ROWS = 1_048_576;
+const EXCEL_MAX_COLUMNS = 16_384;
+
export class CellReferenceObject extends BaseReferenceObject {
constructor(token: string) {
super(token);
@@ -36,6 +39,15 @@ export class CellReferenceObject extends BaseReferenceObject {
return true;
}
+ override isExceedRange() {
+ if ((this.getForcedSheetId() == null || this.getForcedSheetId()?.length === 0) && this.getForcedSheetName().length > 0) {
+ return true;
+ }
+
+ const { startRow, endRow, startColumn, endColumn } = this.getRangePosition();
+ return startRow < 0 || startColumn < 0 || endRow >= EXCEL_MAX_ROWS || endColumn >= EXCEL_MAX_COLUMNS;
+ }
+
override unionBy(referenceObject: BaseReferenceObject) {
if (!referenceObject.isCell()) {
return ErrorValueObject.create(ErrorType.REF);
diff --git a/packages/engine-formula/src/engine/reference-object/table-reference-object.ts b/packages/engine-formula/src/engine/reference-object/table-reference-object.ts
index 0401ca45f9..05fa3bd792 100644
--- a/packages/engine-formula/src/engine/reference-object/table-reference-object.ts
+++ b/packages/engine-formula/src/engine/reference-object/table-reference-object.ts
@@ -328,7 +328,16 @@ export class TableReferenceObject extends BaseReferenceObject {
// Defensive: Full-width space → half-width, then trim
const keyNorm = key.replace(/\u3000/g, ' ').trim();
- return titleMap.get(keyNorm) ?? -1;
+ const normalizedHit = titleMap.get(keyNorm);
+ if (normalizedHit !== undefined) return normalizedHit;
+
+ const lineBreakNorm = keyNorm.replace(/\r\n?/g, '\n');
+ for (const [title, index] of titleMap.entries()) {
+ if (title.replace(/\u3000/g, ' ').trim().replace(/\r\n?/g, '\n') === lineBreakNorm) {
+ return index;
+ }
+ }
+ return -1;
}
/** Resolve #This Row's row number; takes first data row (tableStartRow+1) when no context available */
diff --git a/packages/engine-formula/src/engine/utils/__tests__/cell.spec.ts b/packages/engine-formula/src/engine/utils/__tests__/cell.spec.ts
index 4ad09b6b9e..f3f0a06c86 100644
--- a/packages/engine-formula/src/engine/utils/__tests__/cell.spec.ts
+++ b/packages/engine-formula/src/engine/utils/__tests__/cell.spec.ts
@@ -44,6 +44,20 @@ describe('Test cell', () => {
expect(getCellValue(cell3)).toBe(0);
});
+ it('normalizes rich text line breaks for formula values', () => {
+ const cell: ICellData = {
+ p: {
+ id: 'p',
+ body: {
+ dataStream: 'line 1\rline 2\r\n',
+ },
+ documentStyle: {},
+ },
+ };
+
+ expect(getCellValue(cell)).toBe('line 1\r\nline 2');
+ });
+
it('Function extractFormulaError', () => {
expect(extractFormulaError({ v: ErrorType.DIV_BY_ZERO, f: '=1/0' })).toBe(ErrorType.DIV_BY_ZERO);
expect(extractFormulaError({ v: ErrorType.NAME, f: '=S' })).toBe(ErrorType.NAME);
diff --git a/packages/engine-formula/src/engine/utils/__tests__/generate-ast-node.spec.ts b/packages/engine-formula/src/engine/utils/__tests__/generate-ast-node.spec.ts
index f4ab96fefe..013849f8a1 100644
--- a/packages/engine-formula/src/engine/utils/__tests__/generate-ast-node.spec.ts
+++ b/packages/engine-formula/src/engine/utils/__tests__/generate-ast-node.spec.ts
@@ -27,6 +27,8 @@ describe('generateAstNode defined name cache invalidation', () => {
dirtySuperTableMap: Record<string, Record<string, string>> = {}
) {
let parseCount = 0;
+ let executeUnitId = 'unit-1';
+ let executeSubUnitId = 'sheet-1';
const node = {
hasDefinedName: () => false,
};
@@ -43,7 +45,14 @@ describe('generateAstNode defined name cache invalidation', () => {
const currentConfigService = {
getDirtyDefinedNameMap: () => dirtyDefinedNameMap,
getDirtySuperTableMap: () => dirtySuperTableMap,
- getExecuteUnitId: () => 'unit-1',
+ getExecuteUnitId: () => executeUnitId,
+ getExecuteSubUnitId: () => executeSubUnitId,
+ setExecuteUnitId: (unitId: string) => {
+ executeUnitId = unitId;
+ },
+ setExecuteSubUnitId: (subUnitId: string) => {
+ executeSubUnitId = subUnitId;
+ },
};
return {
@@ -203,4 +212,27 @@ describe('generateAstNode defined name cache invalidation', () => {
expect(harness.getParseCount()).toBe(1);
});
+
+ it('does not reuse cache across sheets in the same unit', () => {
+ const harness = createHarness({});
+
+ generateAstNode(
+ 'unit-1',
+ '=date_begin+6',
+ harness.lexer as never,
+ harness.astTreeBuilder as never,
+ harness.currentConfigService as never,
+ 'sheet-1'
+ );
+ generateAstNode(
+ 'unit-1',
+ '=date_begin+6',
+ harness.lexer as never,
+ harness.astTreeBuilder as never,
+ harness.currentConfigService as never,
+ 'sheet-2'
+ );
+
+ expect(harness.getParseCount()).toBe(2);
+ });
});
diff --git a/packages/engine-formula/src/engine/utils/__tests__/math-kit.spec.ts b/packages/engine-formula/src/engine/utils/__tests__/math-kit.spec.ts
index e00167d546..d9dc2557e2 100644
--- a/packages/engine-formula/src/engine/utils/__tests__/math-kit.spec.ts
+++ b/packages/engine-formula/src/engine/utils/__tests__/math-kit.spec.ts
@@ -196,6 +196,7 @@ describe('Test math kit', () => {
expect(equals(1.1, 1.2)).toBe(false);
expect(equals(1.11, 1.11)).toBe(true);
expect(equals(1.11, 1.12)).toBe(false);
+ expect(equals(11567.362145082292, 11567.362145082274)).toBe(true);
});
// test greaterThan
it('Function greaterThan', () => {
@@ -208,6 +209,7 @@ describe('Test math kit', () => {
expect(greaterThan(1.11, 1.11)).toBe(false);
expect(greaterThan(1.11, 1.12)).toBe(false);
expect(greaterThan(1.12, 1.11)).toBe(true);
+ expect(greaterThan(11567.362145082292, 11567.362145082274)).toBe(false);
});
// test greaterThanOrEquals
it('Function greaterThanOrEquals', () => {
@@ -220,6 +222,7 @@ describe('Test math kit', () => {
expect(greaterThanOrEquals(1.11, 1.11)).toBe(true);
expect(greaterThanOrEquals(1.11, 1.12)).toBe(false);
expect(greaterThanOrEquals(1.12, 1.11)).toBe(true);
+ expect(greaterThanOrEquals(11567.362145082292, 11567.362145082274)).toBe(true);
});
// test lessThan
it('Function lessThan', () => {
@@ -231,6 +234,7 @@ describe('Test math kit', () => {
expect(lessThan(1.2, 1.1)).toBe(false);
expect(lessThan(1.11, 1.11)).toBe(false);
expect(lessThan(1.11, 1.12)).toBe(true);
+ expect(lessThan(11567.362145082274, 11567.362145082292)).toBe(false);
});
// test lessThanOrEquals
it('Function lessThanOrEquals', () => {
@@ -242,6 +246,7 @@ describe('Test math kit', () => {
expect(lessThanOrEquals(1.2, 1.1)).toBe(false);
expect(lessThanOrEquals(1.11, 1.11)).toBe(true);
expect(lessThanOrEquals(1.11, 1.12)).toBe(true);
+ expect(lessThanOrEquals(11567.362145082274, 11567.362145082292)).toBe(true);
});
it('Function getFractionalPart', () => {
diff --git a/packages/engine-formula/src/engine/utils/__tests__/regexp-check.spec.ts b/packages/engine-formula/src/engine/utils/__tests__/regexp-check.spec.ts
index 3feda6da36..fe0479c695 100644
--- a/packages/engine-formula/src/engine/utils/__tests__/regexp-check.spec.ts
+++ b/packages/engine-formula/src/engine/utils/__tests__/regexp-check.spec.ts
@@ -64,4 +64,13 @@ describe('handleRegExp', () => {
expect(result.regExp).not.toBeNull();
expect(result.regExp?.test('(')).toBe(true);
});
+
+ it('should accept positive lookahead patterns used by REGEXTEST', () => {
+ const result = handleRegExp('^(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*[^\\w\\s])[^\\s]{8,15}$', false);
+
+ expect(result.isError).toBe(false);
+ expect(result.regExp).not.toBeNull();
+ expect(result.regExp?.test('Passw0rd!')).toBe(true);
+ expect(result.regExp?.test('password')).toBe(false);
+ });
});
diff --git a/packages/engine-formula/src/engine/utils/__tests__/value-object.spec.ts b/packages/engine-formula/src/engine/utils/__tests__/value-object.spec.ts
index 7353daa8cf..5715e270ba 100644
--- a/packages/engine-formula/src/engine/utils/__tests__/value-object.spec.ts
+++ b/packages/engine-formula/src/engine/utils/__tests__/value-object.spec.ts
@@ -17,6 +17,7 @@
import { cellToRange, CellValueType } from '@univerjs/core';
import { describe, expect, it } from 'vitest';
import { ErrorType } from '../../../basics/error-type';
+import { compareToken } from '../../../basics/token';
import { CellReferenceObject } from '../../reference-object/cell-reference-object';
import { ColumnReferenceObject } from '../../reference-object/column-reference-object';
import { RangeReferenceObject } from '../../reference-object/range-reference-object';
@@ -32,6 +33,11 @@ describe('Test object cover', () => {
expect(convertTonNumber(BooleanValueObject.create(false)).getValue()).toBe(0);
});
+ it('Boolean values are not equal to text values', () => {
+ expect(BooleanValueObject.create(false).compare(StringValueObject.create(''), compareToken.EQUALS).getValue()).toBe(false);
+ expect(BooleanValueObject.create(false).compare(StringValueObject.create(''), compareToken.NOT_EQUAL).getValue()).toBe(true);
+ });
+
it('Function isSingleValueObject', () => {
expect(isSingleValueObject(BooleanValueObject.create(true))).toBe(true);
expect(isSingleValueObject(BooleanValueObject.create(false))).toBe(true);
diff --git a/packages/engine-formula/src/engine/utils/cell.ts b/packages/engine-formula/src/engine/utils/cell.ts
index f50ea81147..7c3bc6a1d1 100644
--- a/packages/engine-formula/src/engine/utils/cell.ts
+++ b/packages/engine-formula/src/engine/utils/cell.ts
@@ -34,12 +34,16 @@ export function getCellValue(cell: Nullable<ICellData>) {
const data = body.dataStream;
const newDataStream = BuildTextUtils.transform.getPlainText(data);
- return newDataStream;
+ return normalizeRichTextFormulaValue(newDataStream);
}
return cell?.v ?? 0;
}
+function normalizeRichTextFormulaValue(value: string) {
+ return value.replace(/\r\n|\r|\n/g, '\r\n');
+}
+
/**
* Extract the formula error from the cell
* @param cell
diff --git a/packages/engine-formula/src/engine/utils/generate-ast-node.ts b/packages/engine-formula/src/engine/utils/generate-ast-node.ts
index e473625200..82b86805e7 100644
--- a/packages/engine-formula/src/engine/utils/generate-ast-node.ts
+++ b/packages/engine-formula/src/engine/utils/generate-ast-node.ts
@@ -37,9 +37,23 @@ type IDirtyStringMap = Record<string, string>;
const DIRTY_DEFINED_NAME_SET_CACHE = new WeakMap<IDirtyStringMap, Set<string>>();
const DIRTY_SUPER_TABLE_PATTERN_CACHE = new WeakMap<IDirtyStringMap, RegExp | null>();
-export function generateAstNode(unitId: string, formulaString: string, lexer: Lexer, astTreeBuilder: AstTreeBuilder, currentConfigService: IFormulaCurrentConfigService): AstRootNode {
+export function generateAstNode(
+ unitId: string,
+ formulaString: string,
+ lexer: Lexer,
+ astTreeBuilder: AstTreeBuilder,
+ currentConfigService: IFormulaCurrentConfigService,
+ subUnitId?: string
+): AstRootNode {
+ if (subUnitId) {
+ currentConfigService.setExecuteUnitId(unitId);
+ currentConfigService.setExecuteSubUnitId(subUnitId);
+ }
+
+ const executeSubUnitId = subUnitId ?? currentConfigService.getExecuteSubUnitId() ?? '';
+ const cacheKey = `${unitId}:${executeSubUnitId}:${formulaString}`;
// refOffsetX and refOffsetY are separated by -, otherwise x:1 y:10 will be repeated with x:11 y:0
- let astNode: Nullable<AstRootNode> = FORMULA_AST_CACHE.get(`${unitId}${formulaString}`);
+ let astNode: Nullable<AstRootNode> = FORMULA_AST_CACHE.get(cacheKey);
const noCache = checkIsChangedByDefinedName(unitId, formulaString, currentConfigService) || checkIsChangedBySuperTable(unitId, formulaString, currentConfigService);
@@ -65,7 +79,7 @@ export function generateAstNode(unitId: string, formulaString: string, lexer: Le
// astNode.setRefOffset(refOffsetX, refOffsetY);
if (!noCache) {
- FORMULA_AST_CACHE.set(`${unitId}${formulaString}`, astNode);
+ FORMULA_AST_CACHE.set(cacheKey, astNode);
}
return astNode;
diff --git a/packages/engine-formula/src/engine/utils/math-kit.ts b/packages/engine-formula/src/engine/utils/math-kit.ts
index 2c8c4b5985..1d9934b654 100644
--- a/packages/engine-formula/src/engine/utils/math-kit.ts
+++ b/packages/engine-formula/src/engine/utils/math-kit.ts
@@ -20,38 +20,20 @@
Reference https://en.wikipedia.org/wiki/Numeric_precision_in_Microsoft_Excel
*/
-import Decimal from 'decimal.js';
-
export function plus(a: number, b: number): number {
- const result = a + b;
- if (Number.isSafeInteger(result)) {
- return result;
- }
- return new Decimal(a).add(b).toNumber();
+ return a + b;
}
export function minus(a: number, b: number): number {
- const result = a - b;
- if (Number.isSafeInteger(result)) {
- return result;
- }
- return new Decimal(a).sub(b).toNumber();
+ return a - b;
}
export function multiply(a: number, b: number): number {
- const result = a * b;
- if (Number.isSafeInteger(result)) {
- return result;
- }
- return new Decimal(a).mul(b).toNumber();
+ return a * b;
}
export function divide(a: number, b: number): number {
- const result = a / b;
- if (Number.isSafeInteger(result)) {
- return result;
- }
- return new Decimal(a).div(b).toNumber();
+ return a / b;
}
/**
* Rounds a number to a specified number of decimal places.
@@ -130,7 +112,7 @@ export function sqrt(base: number): number {
* @returns True if numbers are equal, false otherwise.
*/
export function equals(a: number, b: number): boolean {
- return a === b;
+ return a === b || stripErrorMargin(a) === stripErrorMargin(b);
}
/**
@@ -140,7 +122,7 @@ export function equals(a: number, b: number): boolean {
* @returns True if a is greater than b, false otherwise.
*/
export function greaterThan(a: number, b: number): boolean {
- return a > b;
+ return !equals(a, b) && stripErrorMargin(a) > stripErrorMargin(b);
}
/**
@@ -150,7 +132,7 @@ export function greaterThan(a: number, b: number): boolean {
* @returns True if a is greater than or equal to b, false otherwise.
*/
export function greaterThanOrEquals(a: number, b: number): boolean {
- return a >= b;
+ return equals(a, b) || stripErrorMargin(a) > stripErrorMargin(b);
}
/**
@@ -160,7 +142,7 @@ export function greaterThanOrEquals(a: number, b: number): boolean {
* @returns True if a is less than b, false otherwise.
*/
export function lessThan(a: number, b: number): boolean {
- return a < b;
+ return !equals(a, b) && stripErrorMargin(a) < stripErrorMargin(b);
}
/**
@@ -170,7 +152,7 @@ export function lessThan(a: number, b: number): boolean {
* @returns True if a is less than or equal to b, false otherwise.
*/
export function lessThanOrEquals(a: number, b: number): boolean {
- return a <= b;
+ return equals(a, b) || stripErrorMargin(a) < stripErrorMargin(b);
}
/**
diff --git a/packages/engine-formula/src/engine/utils/reference-cache.ts b/packages/engine-formula/src/engine/utils/reference-cache.ts
index 77a12601dd..e67ddd4637 100644
--- a/packages/engine-formula/src/engine/utils/reference-cache.ts
+++ b/packages/engine-formula/src/engine/utils/reference-cache.ts
@@ -29,7 +29,7 @@ export function deserializeRangeWithSheetWithCache(refString: string): IUnitRang
referenceToRangeCache.set(refString, result);
- return deserializeRangeWithSheet(refString); ;
+ return result;
}
export function clearReferenceToRangeCache() {
diff --git a/packages/engine-formula/src/engine/utils/value-object.ts b/packages/engine-formula/src/engine/utils/value-object.ts
index 1582393c6d..29f59f8ca7 100644
--- a/packages/engine-formula/src/engine/utils/value-object.ts
+++ b/packages/engine-formula/src/engine/utils/value-object.ts
@@ -402,14 +402,14 @@ export function getPairedRangeAndCriteriaResult(
} else if (formulaName === 'MAXIFS') {
const picked = targetRange!.pick(finalCompareResult as ArrayValueObject);
if (picked.getColumnCount() === 0) {
- result = ArrayValueObject.create('0');
+ result = NumberValueObject.create(0);
} else {
result = picked.max();
}
} else if (formulaName === 'MINIFS') {
const picked = targetRange!.pick(finalCompareResult as ArrayValueObject);
if (picked.getColumnCount() === 0) {
- result = ArrayValueObject.create('0');
+ result = NumberValueObject.create(0);
} else {
result = picked.min();
}
@@ -429,10 +429,51 @@ export function getPairedRangeAndCriteriaResult(
* Two ArrayValueObject of the same type can be compared
*/
export function filterSameValueObjectResult(array: ArrayValueObject, range: ArrayValueObject, criteria: BaseValueObject): ArrayValueObject {
- const [operator, criteriaObject] = findCompareToken(`${criteria.getValue()}`);
+ const [operator, criteriaObject] = criteria.isString()
+ ? findCompareToken(`${criteria.getValue()}`)
+ : [compareToken.EQUALS, criteria];
return array.mapValue((valueObject, r, c) => {
const rangeValueObject = range.get(r, c);
+ const isBlankStringCriteria = criteriaObject.isString() && criteriaObject.getValue() === '';
+
+ if (operator === compareToken.NOT_EQUAL && isBlankStringCriteria && rangeValueObject?.isString() && rangeValueObject.getValue() === '') {
+ return BooleanValueObject.create(true);
+ }
+
+ if (
+ criteriaObject.isString() &&
+ criteriaObject.getValue() !== '' &&
+ (operator === compareToken.LESS_THAN || operator === compareToken.LESS_THAN_OR_EQUAL) &&
+ (rangeValueObject == null || rangeValueObject.isNull() || (rangeValueObject.isString() && rangeValueObject.getValue() === ''))
+ ) {
+ return BooleanValueObject.create(false);
+ }
+
+ if (
+ criteriaObject.isString() &&
+ rangeValueObject?.isString() &&
+ (operator === compareToken.LESS_THAN || operator === compareToken.LESS_THAN_OR_EQUAL) &&
+ isSameLowerBoundBucket(rangeValueObject.getValue() as string, criteriaObject.getValue() as string)
+ ) {
+ return BooleanValueObject.create(false);
+ }
+
+ if (rangeValueObject?.isNumber() && criteriaObject.isString()) {
+ const criteriaNumber = criteriaObject.convertToNumberObjectValue();
+
+ if (criteriaNumber.isNumber()) {
+ return rangeValueObject.compare(criteriaNumber, operator);
+ }
+ }
+
+ if (criteriaObject.isNumber() && criteriaObject.isDateFormat() && rangeValueObject?.isString()) {
+ const rangeNumber = rangeValueObject.convertToNumberObjectValue();
+
+ if (rangeNumber.isNumber()) {
+ return rangeNumber.compare(criteriaObject, operator);
+ }
+ }
if (rangeValueObject && isSameValueObjectType(rangeValueObject, criteriaObject)) {
return valueObject;
@@ -443,7 +484,7 @@ export function filterSameValueObjectResult(array: ArrayValueObject, range: Arra
}
/**
- * If the operator is '=' or '<>', we can compare numbers and strings directly in COUNTIF, COUNTIFS, SUMIF, SUMIFS, etc.
+ * If the operator is '=' or '<>', we can compare string numbers against numeric criteria directly in COUNTIF, COUNTIFS, SUMIF, SUMIFS, etc.
* Other operators require both valueObjects to be of the same type.
* For example:
* | A1 | B1 |
@@ -455,14 +496,6 @@ export function filterSameValueObjectResult(array: ArrayValueObject, range: Arra
* =COUNTIF(A1:B1, '<=123') will return 1
*/
if (operator === compareToken.EQUALS || operator === compareToken.NOT_EQUAL) {
- if (rangeValueObject?.isNumber() && criteriaObject.isString()) {
- const criteriaNumber = criteriaObject.convertToNumberObjectValue();
-
- if (criteriaNumber.isNumber()) {
- return rangeValueObject.compare(criteriaNumber, operator);
- }
- }
-
if (criteriaObject.isNumber() && rangeValueObject?.isString()) {
const rangeNumber = rangeValueObject.convertToNumberObjectValue();
@@ -484,6 +517,12 @@ export function filterSameValueObjectResult(array: ArrayValueObject, range: Arra
});
}
+function isSameLowerBoundBucket(rangeValue: string, criteriaValue: string): boolean {
+ const criteriaMatch = criteriaValue.match(/^(\d+)\|/);
+ const rangeMatch = rangeValue.match(/^(\d+)-/);
+ return criteriaMatch != null && rangeMatch != null && criteriaMatch[1] === rangeMatch[1];
+}
+
/**
* Check if the two valueObjects are of the same type
* @param left
diff --git a/packages/engine-formula/src/engine/value-object/__tests__/array-value-minus.spec.ts b/packages/engine-formula/src/engine/value-object/__tests__/array-value-minus.spec.ts
index 8e86de71e2..f4053d3e0a 100644
--- a/packages/engine-formula/src/engine/value-object/__tests__/array-value-minus.spec.ts
+++ b/packages/engine-formula/src/engine/value-object/__tests__/array-value-minus.spec.ts
@@ -37,11 +37,12 @@ describe('ArrayValueObject minus method test', () => {
});
const valueObject = new NumberValueObject(1);
const result = arrayValueObject.minus(valueObject);
+ const resultValue = getObjectValue(result) as (string | number)[][];
- expect(getObjectValue(result)).toStrictEqual([
- [0, ErrorType.VALUE, 0.23, 0, -1, -1],
- [-1, 99, 1.34, ErrorType.VALUE, -4, ErrorType.VALUE],
- ]);
+ expect(resultValue[0]).toStrictEqual([0, ErrorType.VALUE, resultValue[0][2], 0, -1, -1]);
+ expect(resultValue[0][2] as number).toBeCloseTo(0.23);
+ expect(resultValue[1]).toStrictEqual([-1, 99, resultValue[1][2], ErrorType.VALUE, -4, ErrorType.VALUE]);
+ expect(resultValue[1][2] as number).toBeCloseTo(1.34);
});
});
});
diff --git a/packages/engine-formula/src/engine/value-object/__tests__/array-value-object.spec.ts b/packages/engine-formula/src/engine/value-object/__tests__/array-value-object.spec.ts
index fdc6281e64..3cbd4d0f9f 100644
--- a/packages/engine-formula/src/engine/value-object/__tests__/array-value-object.spec.ts
+++ b/packages/engine-formula/src/engine/value-object/__tests__/array-value-object.spec.ts
@@ -21,7 +21,7 @@ import { ErrorType } from '../../../basics/error-type';
import { getObjectValue } from '../../../functions/util';
import { ArrayValueObject, transformToValueObject, ValueObjectFactory } from '../array-value-object';
import { ErrorValueObject } from '../base-value-object';
-import { BooleanValueObject, NumberValueObject } from '../primitive-object';
+import { BooleanValueObject, NumberValueObject, StringValueObject } from '../primitive-object';
describe('arrayValueObject test', () => {
const originArrayValueObject = ArrayValueObject.create({
@@ -38,6 +38,30 @@ describe('arrayValueObject test', () => {
column: 0,
});
+ it('maps sparse comparison arrays with their default value', () => {
+ const sparseValues: BaseValueObject[][] = [];
+ sparseValues[1] = [BooleanValueObject.create(true)];
+
+ const sparseArray = ArrayValueObject.create({
+ calculateValueList: sparseValues,
+ rowCount: 3,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: -1,
+ column: -1,
+ });
+ sparseArray.setDefaultValue(BooleanValueObject.create(false));
+
+ const result = sparseArray.getNegative().getNegative();
+
+ expect(getObjectValue(result)).toStrictEqual([
+ [0],
+ [1],
+ [0],
+ ]);
+ });
+
describe('slice', () => {
it('row==null;column=2,,', () => {
const result = originArrayValueObject.slice(null, [2])!;
@@ -254,7 +278,7 @@ describe('arrayValueObject test', () => {
});
const result = originValueObject.sum();
- expect(getObjectValue(result)).toStrictEqual(101.57);
+ expect(getObjectValue(result) as number).toBeCloseTo(101.57);
});
});
@@ -428,6 +452,13 @@ describe('arrayValueObject test', () => {
expect(stringValueObject.isString()).toBeTruthy();
});
+ it('StringValueObject empty string converts to VALUE error for arithmetic coercion', () => {
+ const number = StringValueObject.create('').convertToNumberObjectValue();
+
+ expect(number.isError()).toBeTruthy();
+ expect((number as ErrorValueObject).getErrorType()).toBe(ErrorType.VALUE);
+ });
+
it('ValueObjectFactory create ErrorValueObject ', () => {
let errorValueObject = ValueObjectFactory.create(Number.NaN);
diff --git a/packages/engine-formula/src/engine/value-object/array-value-object.ts b/packages/engine-formula/src/engine/value-object/array-value-object.ts
index cff8a0c020..2c67607fbc 100644
--- a/packages/engine-formula/src/engine/value-object/array-value-object.ts
+++ b/packages/engine-formula/src/engine/value-object/array-value-object.ts
@@ -152,6 +152,10 @@ export class ArrayValueObject extends BaseValueObject {
private _currentColumn: number = -1;
+ private _useInvertedIndexCache: boolean = false;
+
+ private _legacyImplicitForAggregate: boolean = false;
+
private _sliceCache = new Map<string, ArrayValueObject>();
private _flattenCache: Nullable<ArrayValueObject>;
@@ -241,6 +245,18 @@ export class ArrayValueObject extends BaseValueObject {
return this._currentColumn;
}
+ usesInvertedIndexCache() {
+ return this._useInvertedIndexCache;
+ }
+
+ usesLegacyImplicitForAggregate() {
+ return this._legacyImplicitForAggregate;
+ }
+
+ setLegacyImplicitForAggregate(value: boolean) {
+ this._legacyImplicitForAggregate = value;
+ }
+
override getArrayValue() {
return this._values;
}
@@ -656,6 +672,8 @@ export class ArrayValueObject extends BaseValueObject {
let matchObject: Nullable<BaseValueObject>;
if (isFuzzyMatching === true) {
matchObject = itemValue.compare(valueObject as StringValueObject, compareToken.EQUALS);
+ } else if (searchType === ArrayOrderSearchType.NORMAL && itemValue.isNumber() && valueObject.isNumber()) {
+ matchObject = BooleanValueObject.create(Number(itemValue.getValue()) === Number(valueObject.getValue()));
} else {
matchObject = itemValue.isEqual(valueObject);
}
@@ -869,9 +887,7 @@ export class ArrayValueObject extends BaseValueObject {
return true; // continue
}
- const result = accumulatorAll.isLessThan(valueObject) as BooleanValueObject;
-
- if (result.getValue()) {
+ if (Number(accumulatorAll.getValue()) < Number(valueObject.getValue())) {
accumulatorAll = valueObject as NumberValueObject;
}
});
@@ -945,8 +961,7 @@ export class ArrayValueObject extends BaseValueObject {
}
override getNegative(): BaseValueObject {
- const arrayValueObject = ArrayValueObject.create('{0}');
- return arrayValueObject.minus(this);
+ return this.mapValue((valueObject) => NumberValueObject.create(0).minus(valueObject));
}
override getReciprocal(): BaseValueObject {
@@ -1023,12 +1038,11 @@ export class ArrayValueObject extends BaseValueObject {
const rowList: BaseValueObject[] = [];
for (let c = 0; c < columnCount; c++) {
const row = this._values?.[r];
+ const currentValue = this.getValueOrDefault(r, c);
- if (row == null) {
+ if (row == null && currentValue == null) {
rowList[c] = ErrorValueObject.create(ErrorType.VALUE);
} else {
- const currentValue = row[c] || this._defaultValue;
-
if (currentValue) {
rowList[c] = callbackFn(currentValue, r, c);
} else {
@@ -1526,7 +1540,7 @@ export class ArrayValueObject extends BaseValueObject {
* If comparison operations are conducted for a single numerical value,
* then retrieve the judgment from the inverted index. This enhances performance.
*/
- if (batchOperatorType === BatchOperatorType.COMPARE) {
+ if (batchOperatorType === BatchOperatorType.COMPARE && this._useInvertedIndexCache) {
const { rowsInCache, rowsNotInCache } = CELL_INVERTED_INDEX_CACHE.canUseCache(
unitId,
sheetId,
@@ -1620,13 +1634,15 @@ export class ArrayValueObject extends BaseValueObject {
);
}
- CELL_INVERTED_INDEX_CACHE.setContinueBuildingCache(
- unitId,
- sheetId,
- column + startColumn,
- start,
- end
- );
+ if (this._useInvertedIndexCache) {
+ CELL_INVERTED_INDEX_CACHE.setContinueBuildingCache(
+ unitId,
+ sheetId,
+ column + startColumn,
+ start,
+ end
+ );
+ }
}
}
@@ -1650,13 +1666,15 @@ export class ArrayValueObject extends BaseValueObject {
);
}
- CELL_INVERTED_INDEX_CACHE.setContinueBuildingCache(
- unitId,
- sheetId,
- column + startColumn,
- startRow,
- startRow + rowCount - 1
- );
+ if (this._useInvertedIndexCache) {
+ CELL_INVERTED_INDEX_CACHE.setContinueBuildingCache(
+ unitId,
+ sheetId,
+ column + startColumn,
+ startRow,
+ startRow + rowCount - 1
+ );
+ }
}
// eslint-disable-next-line
@@ -1736,13 +1754,15 @@ export class ArrayValueObject extends BaseValueObject {
result[r][column] = ErrorValueObject.create(ErrorType.NA);
}
- CELL_INVERTED_INDEX_CACHE.set(
- unitId,
- sheetId,
- column + startColumn,
- currentValue?.isNull() ? null : currentValue?.getValue(),
- r + startRow
- );
+ if (this._useInvertedIndexCache) {
+ CELL_INVERTED_INDEX_CACHE.set(
+ unitId,
+ sheetId,
+ column + startColumn,
+ currentValue?.isNull() ? null : currentValue?.getValue(),
+ r + startRow
+ );
+ }
}
// eslint-disable-next-line max-lines-per-function, complexity
@@ -1859,7 +1879,12 @@ export class ArrayValueObject extends BaseValueObject {
result.push(rowList);
}
- return this._createNewArray(result, rowCount, columnCount);
+ const newArray = this._createNewArray(result, rowCount, columnCount);
+ if (batchOperatorType === BatchOperatorType.PLUS) {
+ newArray.setLegacyImplicitForAggregate(true);
+ }
+
+ return newArray;
}
private _checkArrayCalculateType(valueObject: ArrayValueObject) {
@@ -1893,6 +1918,10 @@ export class ArrayValueObject extends BaseValueObject {
this._currentColumn = rawValue.column;
+ this._useInvertedIndexCache = rawValue.useInvertedIndexCache === true;
+
+ this._legacyImplicitForAggregate = rawValue.legacyImplicitForAggregate === true;
+
return rawValue.calculateValueList;
}
rawValue = rawValue.slice(1, -1) as string;
@@ -1928,8 +1957,8 @@ export class ArrayValueObject extends BaseValueObject {
result: Nullable<BaseValueObject>[][],
rowCount: number,
columnCount: number,
- row: number = -1,
- column: number = -1
+ row: number = this._currentRow,
+ column: number = this._currentColumn
) {
if (this._currentColumn === -1 || this._currentRow === -1) {
row = -1;
diff --git a/packages/engine-formula/src/engine/value-object/base-value-object.ts b/packages/engine-formula/src/engine/value-object/base-value-object.ts
index ea4f9a9b7a..04a98193e5 100644
--- a/packages/engine-formula/src/engine/value-object/base-value-object.ts
+++ b/packages/engine-formula/src/engine/value-object/base-value-object.ts
@@ -31,6 +31,8 @@ export interface IArrayValueObject {
sheetId: string;
row: number;
column: number;
+ legacyImplicitForAggregate?: boolean;
+ useInvertedIndexCache?: boolean;
}
export class BaseValueObject extends ObjectClassType {
private _customData: CustomData;
@@ -270,7 +272,7 @@ export class BaseValueObject extends ObjectClassType {
}
concatenate(value: string | number | boolean, concatenateType = ConcatenateType.FRONT): string {
- let currentValue = this.getValue().toString();
+ let currentValue = formatValueForFormulaText(this.getValue());
if (typeof value === 'string') {
if (concatenateType === ConcatenateType.FRONT) {
currentValue = value + currentValue;
@@ -278,10 +280,11 @@ export class BaseValueObject extends ObjectClassType {
currentValue += value;
}
} else if (typeof value === 'number') {
+ const numberString = formatNumberForFormulaText(value);
if (concatenateType === ConcatenateType.FRONT) {
- currentValue = value.toString() + currentValue;
+ currentValue = numberString + currentValue;
} else {
- currentValue += value.toString();
+ currentValue += numberString;
}
} else if (typeof value === 'boolean') {
const booleanString = value ? 'TRUE' : 'FALSE';
@@ -488,6 +491,27 @@ export class BaseValueObject extends ObjectClassType {
}
}
+export function formatValueForFormulaText(value: string | number | boolean | null): string {
+ if (typeof value === 'number') {
+ return formatNumberForFormulaText(value);
+ }
+
+ if (typeof value === 'boolean') {
+ return value ? 'TRUE' : 'FALSE';
+ }
+
+ return value == null ? '' : value.toString();
+}
+
+export function formatNumberForFormulaText(value: number): string {
+ if (!Number.isFinite(value)) {
+ return value.toString();
+ }
+
+ const rounded = Number(value.toPrecision(15));
+ return Object.is(rounded, -0) ? '0' : rounded.toString();
+}
+
const Error_CACHE_LRU_COUNT = 1000;
export const ErrorValueObjectCache = new FormulaAstLRU<ErrorValueObject>(Error_CACHE_LRU_COUNT);
@@ -532,4 +556,12 @@ export class ErrorValueObject extends BaseValueObject {
override isError() {
return true;
}
+
+ override concatenateFront(_valueObject: BaseValueObject): BaseValueObject {
+ return this;
+ }
+
+ override concatenateBack(_valueObject: BaseValueObject): BaseValueObject {
+ return this;
+ }
}
diff --git a/packages/engine-formula/src/engine/value-object/primitive-object.ts b/packages/engine-formula/src/engine/value-object/primitive-object.ts
index 7d1cd28611..62369bc22e 100644
--- a/packages/engine-formula/src/engine/value-object/primitive-object.ts
+++ b/packages/engine-formula/src/engine/value-object/primitive-object.ts
@@ -311,8 +311,9 @@ export class BooleanValueObject extends BaseValueObject {
case compareToken.EQUALS:
case compareToken.LESS_THAN:
case compareToken.LESS_THAN_OR_EQUAL:
- case compareToken.NOT_EQUAL:
return false;
+ case compareToken.NOT_EQUAL:
+ return true;
}
}
@@ -1530,17 +1531,19 @@ export class StringValueObject extends BaseValueObject {
}
private _compareString(currentValue: string, value: string, operator: compareToken): boolean {
+ const compareResult = currentValue.localeCompare(value);
+
switch (operator) {
case compareToken.EQUALS:
return currentValue === value;
case compareToken.GREATER_THAN:
- return currentValue > value;
+ return compareResult > 0;
case compareToken.GREATER_THAN_OR_EQUAL:
- return currentValue >= value;
+ return currentValue === value || compareResult > 0;
case compareToken.LESS_THAN:
- return currentValue < value;
+ return compareResult < 0;
case compareToken.LESS_THAN_OR_EQUAL:
- return currentValue <= value;
+ return currentValue === value || compareResult < 0;
case compareToken.NOT_EQUAL:
return currentValue !== value;
}
@@ -1574,6 +1577,10 @@ export class StringValueObject extends BaseValueObject {
override convertToNumberObjectValue() {
const rawValue = this.getValue();
+ if (rawValue.trim() === '') {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
const parseData = getNumfmtParseValueFilter(rawValue);
if (parseData && parseData.z) {
diff --git a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
index cbb4435d1d..fcb4c4f6b6 100644
--- a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
+++ b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts
@@ -27,11 +27,16 @@ import { generateExecuteAstNodeData } from '../../engine/utils/ast-node-tool';
import { IFormulaCurrentConfigService } from '../../services/current-data.service';
import { IFunctionService } from '../../services/function.service';
import { IFormulaRuntimeService } from '../../services/runtime.service';
+import { DateFunction } from '../date/date';
import { Day } from '../date/day';
import { Edate } from '../date/edate';
import { FUNCTION_NAMES_DATE } from '../date/function-names';
+import { Month } from '../date/month';
+import { NetworkdaysIntl } from '../date/networkdays-intl';
import { Today } from '../date/today';
+import { Year } from '../date/year';
import { FUNCTION_NAMES_LOGICAL } from '../logical/function-names';
+import { If } from '../logical/if';
import { Iferror } from '../logical/iferror';
import { Address } from '../lookup/address';
import { Choose } from '../lookup/choose';
@@ -52,7 +57,9 @@ import { Compare } from '../meta/compare';
import { Divided } from '../meta/divided';
import { FUNCTION_NAMES_META } from '../meta/function-names';
import { Minus } from '../meta/minus';
+import { Multiply } from '../meta/multiply';
import { Plus } from '../meta/plus';
+import { Countif } from '../statistical/countif';
import { FUNCTION_NAMES_STATISTICAL } from '../statistical/function-names';
import { Max } from '../statistical/max';
import { Min } from '../statistical/min';
@@ -94,6 +101,14 @@ const getFunctionsTestWorkbookData = (): IWorkbookData => {
v: '"test"',
t: 1,
},
+ 20: {
+ v: '',
+ t: CellValueType.STRING,
+ },
+ 21: {
+ v: 0,
+ t: CellValueType.NUMBER,
+ },
},
1: {
0: {
@@ -112,6 +127,27 @@ const getFunctionsTestWorkbookData = (): IWorkbookData => {
v: 500,
t: 2,
},
+ 20: {
+ v: '0',
+ t: CellValueType.NUMBER,
+ },
+ 21: {
+ v: 21,
+ t: CellValueType.NUMBER,
+ },
+ 22: {
+ v: 21,
+ t: CellValueType.NUMBER,
+ },
+ 23: {
+ v: '43497',
+ t: CellValueType.NUMBER,
+ },
+ 24: {
+ v: '43497',
+ t: CellValueType.NUMBER,
+ f: '=DATE(YEAR(W2),MONTH(W2)+1,1)',
+ },
},
2: {
0: {
@@ -323,6 +359,12 @@ const getFunctionsTestWorkbookData = (): IWorkbookData => {
},
},
},
+ 13: {
+ 3: {
+ v: ErrorType.DIV_BY_ZERO,
+ t: CellValueType.STRING,
+ },
+ },
20: {
0: {
v: 'ID',
@@ -445,6 +487,10 @@ const getFunctionsTestWorkbookData = (): IWorkbookData => {
},
},
53: {
+ 0: {
+ v: 44613,
+ t: CellValueType.NUMBER,
+ },
1: {
v: '2026-01-05 23:25:23 UTC',
t: CellValueType.STRING,
@@ -492,6 +538,11 @@ const getFunctionsTestWorkbookData = (): IWorkbookData => {
t: CellValueType.STRING,
},
},
+ 98: {
+ 25: {
+ s: 'style-only-blank',
+ },
+ },
},
},
},
@@ -552,14 +603,19 @@ describe('Test nested functions', () => {
);
functionService.registerExecutors(
+ new If(FUNCTION_NAMES_LOGICAL.IF),
new Iferror(FUNCTION_NAMES_LOGICAL.IFERROR),
new Xlookup(FUNCTION_NAMES_LOOKUP.XLOOKUP),
new Max(FUNCTION_NAMES_STATISTICAL.MAX),
new Sumif(FUNCTION_NAMES_MATH.SUMIF),
new Sumifs(FUNCTION_NAMES_MATH.SUMIFS),
new Edate(FUNCTION_NAMES_DATE.EDATE),
+ new DateFunction(FUNCTION_NAMES_DATE.DATE),
new Today(FUNCTION_NAMES_DATE.TODAY),
new Day(FUNCTION_NAMES_DATE.DAY),
+ new Month(FUNCTION_NAMES_DATE.MONTH),
+ new Year(FUNCTION_NAMES_DATE.YEAR),
+ new NetworkdaysIntl(FUNCTION_NAMES_DATE.NETWORKDAYS_INTL),
new Address(FUNCTION_NAMES_LOOKUP.ADDRESS),
new Xmatch(FUNCTION_NAMES_LOOKUP.XMATCH),
new Min(FUNCTION_NAMES_STATISTICAL.MIN),
@@ -571,6 +627,7 @@ describe('Test nested functions', () => {
new Len(FUNCTION_NAMES_TEXT.LEN),
new Compare(FUNCTION_NAMES_META.COMPARE),
new Divided(FUNCTION_NAMES_META.DIVIDED),
+ new Multiply(FUNCTION_NAMES_META.MULTIPLY),
new Product(FUNCTION_NAMES_MATH.PRODUCT),
new Fact(FUNCTION_NAMES_MATH.FACT),
new T(FUNCTION_NAMES_TEXT.T),
@@ -579,6 +636,7 @@ describe('Test nested functions', () => {
new Row(FUNCTION_NAMES_LOOKUP.ROW),
new Match(FUNCTION_NAMES_LOOKUP.MATCH),
new Index(FUNCTION_NAMES_LOOKUP.INDEX),
+ new Countif(FUNCTION_NAMES_STATISTICAL.COUNTIF),
new Left(FUNCTION_NAMES_TEXT.LEFT)
);
@@ -624,6 +682,84 @@ describe('Test nested functions', () => {
]);
});
+ it('Nested functions IFERROR,INDEX,XMATCH catches no-match array lookup errors', () => {
+ const result = calculate('=IFERROR(INDEX(D2:D4,XMATCH(1,(B2:B4=999)*(A2:A4=45688),0)),"")');
+
+ expect(result).toBe('');
+ });
+
+ it('Nested functions IFERROR,INDEX catches errors from referenced cells', () => {
+ const result = calculate('=IFERROR(INDEX(D14:D14,1),"")');
+
+ expect(result).toBe('');
+ });
+
+ it('Nested functions IFERROR,INDEX converts blank referenced cells to zero', () => {
+ const result = calculate('=IFERROR(INDEX(Z99:Z99,1),"")');
+
+ expect(result).toBe(0);
+ });
+
+ it('Nested functions IF,INDEX converts selected blank referenced cells to zero', () => {
+ const result = calculate('=IF(FALSE,1,INDEX(Z99:Z99,1))');
+
+ expect(result).toBe(0);
+ });
+
+ it('Nested functions IF,INDEX writes selected style-only blank references as zero', () => {
+ const result = calculateByRuntime('=IF(FALSE,1,INDEX(Z99:Z99,1))');
+
+ expect(result?.v).toBe(0);
+ expect(result?.t).toBe(CellValueType.NUMBER);
+ });
+
+ it('Nested functions NETWORKDAYS.INTL ignores non-date values in dynamic holiday ranges', () => {
+ expect(calculate('=NETWORKDAYS.INTL(44613,44613,"0000000",A1:A54)')).toBe(0);
+ expect(calculate('=NETWORKDAYS.INTL(44613,44613,"0000000",A1:INDEX(A:A,MATCH(9E+99,A:A),1))')).toBe(0);
+ });
+
+ it('Nested date functions treat numeric-string cell values as serial numbers', () => {
+ expect(calculate('=DATE(YEAR(43497),MONTH(43497)+1,1)')).toBe(43525);
+ expect(calculate('=DATE(YEAR(X2),MONTH(X2)+1,1)')).toBe(43525);
+ expect(calculate('=DATE(YEAR(Y2),MONTH(Y2)+1,1)')).toBe(43525);
+ });
+
+ it('Nested functions MATCH keeps lazy IF selected reference branches as lookup arrays', () => {
+ const result = calculate('=MATCH(102,IF(@A1:A3=A1,B1:B3),0)');
+
+ expect(result).toBe(3);
+ });
+
+ it('Nested functions IF keeps selected single-cell references scalar', () => {
+ const result = calculate('=IF(TRUE,B2,0)');
+
+ expect(result).toBe(101);
+ });
+
+ it('Nested functions XMATCH keeps Formula2 binary lookup ranges as arrays', () => {
+ const result = calculate('=INDEX(C2:C4,XMATCH(1,(@A2:A4=A3)*(@B2:B4=B3),0))');
+
+ expect(result).toStrictEqual([[3]]);
+ });
+
+ it('Nested functions MATCH keeps bare Formula2 at ranges scalar in lookup products', () => {
+ const result = calculate('=IFERROR(INDEX(C2:C4,MATCH(44928,(@B2:B4=B3)*(@A2:A4),0)),"")');
+
+ expect(result).toBe('');
+ });
+
+ it('Nested functions INDEX,MATCH,COUNTIF returns the first unseen value from a range', () => {
+ const result = calculate('=INDEX(V1:V2,MATCH(0,COUNTIF($U$1:U2,V1:V2),0))');
+
+ expect(result).toStrictEqual([[21]]);
+ });
+
+ it('Nested functions INDEX,MATCH,COUNTIF skips blank criteria already present in the counted range', () => {
+ const result = calculate('=INDEX(W1:W2,MATCH(0,COUNTIF($U$1:U2,W1:W2),0))');
+
+ expect(result).toStrictEqual([[21]]);
+ });
+
it('Nested functions ADDRESS,XMATCH,MIN,SUMIFS,EDATE,TODAY,DAY', () => {
const result = calculate('=ADDRESS(XMATCH(MIN(SUMIFS(C2:C10, A2:A10, ">=" & EDATE(TODAY(), -1) + 1 - DAY(TODAY()), A2:A10, "<" & TODAY() - DAY(TODAY()) + 1)), SUMIFS(C2:C10, A2:A10, ">=" & EDATE(TODAY(), -1) + 1 - DAY(TODAY()), A2:A10, "<" & TODAY() - DAY(TODAY()) + 1), 0) + 1, 2)');
@@ -760,31 +896,31 @@ describe('Test nested functions', () => {
it('Index formula test', () => {
const result = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(22-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result).toStrictEqual([['January']]);
+ expect(result).toStrictEqual('January');
const result2 = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(23-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result2).toStrictEqual([['February']]);
+ expect(result2).toStrictEqual('February');
const result3 = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(24-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result3).toStrictEqual([['March']]);
+ expect(result3).toStrictEqual('March');
const result4 = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(25-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result4).toStrictEqual([['April']]);
+ expect(result4).toStrictEqual('April');
const result5 = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(26-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result5).toStrictEqual([['June']]);
+ expect(result5).toStrictEqual('June');
const result6 = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(27-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result6).toStrictEqual([['July']]);
+ expect(result6).toStrictEqual('July');
const result7 = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(28-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result7).toStrictEqual([['August']]);
+ expect(result7).toStrictEqual('August');
const result8 = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(29-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result8).toStrictEqual([['October']]);
+ expect(result8).toStrictEqual('October');
const result9 = calculate('=IFERROR(INDEX($B$22:$B$33,MATCH(30-ROW($D$21),$A$22:$A$33,0)),"")');
- expect(result9).toStrictEqual([['December']]);
+ expect(result9).toStrictEqual('December');
});
it('Left formula compare test', () => {
diff --git a/packages/engine-formula/src/functions/base-function.ts b/packages/engine-formula/src/functions/base-function.ts
index 0edac377f4..1f96ad542c 100644
--- a/packages/engine-formula/src/functions/base-function.ts
+++ b/packages/engine-formula/src/functions/base-function.ts
@@ -16,6 +16,7 @@
import type { IRange, LocaleType, Nullable } from '@univerjs/core';
import type { IFunctionNames } from '../basics/function';
+import type { BaseAstNode } from '../engine/ast-node/base-ast-node';
import type {
BaseReferenceObject,
FunctionVariantType,
@@ -46,6 +47,8 @@ export class BaseFunction {
private _subUnitId: Nullable<string>;
private _row: number = -1;
private _column: number = -1;
+ private _currentFormulaRowCount: number = 1;
+ private _currentFormulaColumnCount: number = 1;
private _definedNames: Nullable<IDefinedNameMapItem>;
private _locale: LocaleType;
private _sheetOrder: string[];
@@ -89,6 +92,17 @@ export class BaseFunction {
*/
needsFilteredOutRows: boolean = false;
+ /**
+ * Whether the function needs unevaluated AST children.
+ */
+ needsAstChildren: boolean = false;
+
+ /**
+ * Legacy CSE-style array functions should write only the first result cell
+ * when they are used as a top-level normal formula.
+ */
+ returnsLegacyArrayAsScalar: boolean = false;
+
/**
* Minimum number of parameters
*/
@@ -123,6 +137,14 @@ export class BaseFunction {
return this._column;
}
+ get currentFormulaRowCount() {
+ return this._currentFormulaRowCount;
+ }
+
+ get currentFormulaColumnCount() {
+ return this._currentFormulaColumnCount;
+ }
+
dispose() {
}
@@ -138,8 +160,9 @@ export class BaseFunction {
if (nameMap == null) {
return null;
}
+ const normalizedName = name.toLowerCase();
return Object.values(nameMap).find((value) => {
- return value.name === name;
+ return value.name.toLowerCase() === normalizedName;
});
}
@@ -198,11 +221,13 @@ export class BaseFunction {
return false;
}
- setRefInfo(unitId: string, subUnitId: string, row: number, column: number) {
+ setRefInfo(unitId: string, subUnitId: string, row: number, column: number, rowCount: number = 1, columnCount: number = 1) {
this._unitId = unitId;
this._subUnitId = subUnitId;
this._row = row;
this._column = column;
+ this._currentFormulaRowCount = rowCount;
+ this._currentFormulaColumnCount = columnCount;
}
calculateCustom(
@@ -215,6 +240,13 @@ export class BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
+ calculateAst(
+ _children: BaseAstNode[],
+ _getVariant: (node: BaseAstNode) => Nullable<FunctionVariantType>
+ ): NodeValueType {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
checkArrayType(variant: FunctionVariantType) {
return variant.isReferenceObject() || (variant.isValueObject() && (variant as BaseValueObject).isArray());
}
diff --git a/packages/engine-formula/src/functions/compatibility/rank/__tests__/index.spec.ts b/packages/engine-formula/src/functions/compatibility/rank/__tests__/index.spec.ts
index 331a97bba2..2fe6918f4a 100644
--- a/packages/engine-formula/src/functions/compatibility/rank/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/compatibility/rank/__tests__/index.spec.ts
@@ -28,6 +28,8 @@ import { IFormulaCurrentConfigService } from '../../../../services/current-data.
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';
+import { FUNCTION_NAMES_LOGICAL } from '../../../logical/function-names';
+import { If } from '../../../logical/if';
import { getObjectValue } from '../../../util';
import { FUNCTION_NAMES_COMPATIBILITY } from '../../function-names';
import { Rank } from '../index';
@@ -69,6 +71,34 @@ const getTestWorkbookData = (): IWorkbookData => {
v: ErrorType.NAME,
t: CellValueType.STRING,
},
+ 7: {
+ v: 7,
+ t: CellValueType.NUMBER,
+ },
+ 8: {
+ v: 1,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 1: {
+ 7: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 8: {
+ v: 0,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 2: {
+ 7: {
+ v: 9,
+ t: CellValueType.NUMBER,
+ },
+ 8: {
+ v: 1,
+ t: CellValueType.NUMBER,
+ },
},
},
},
@@ -130,7 +160,8 @@ describe('Test rank function', () => {
);
functionService.registerExecutors(
- new Rank(FUNCTION_NAMES_COMPATIBILITY.RANK)
+ new Rank(FUNCTION_NAMES_COMPATIBILITY.RANK),
+ new If(FUNCTION_NAMES_LOGICAL.IF)
);
calculate = (formula: string) => {
@@ -150,6 +181,21 @@ describe('Test rank function', () => {
expect(result).toStrictEqual(3);
});
+ it('Number matching uses tolerance for floating point noise', async () => {
+ const result = await calculate('=RANK(79.83520122378431,{79.8352012237843,81.08962868646151,80.56857259319648},0)');
+ expect(result).toStrictEqual(3);
+ });
+
+ it('Integer rank values are not tied with near-integer floating tails', async () => {
+ const result = await calculate('=RANK(43,{41,60,55.00000000000001,43,55.99999999999999,43.00000000000001,76,63.000000000000014},0)');
+ expect(result).toStrictEqual(7);
+ });
+
+ it('Accepts array returned by nested IF as ref', async () => {
+ const result = await calculate('=RANK(H1,IF(I1:I3,H1:H3),0)');
+ expect(result).toStrictEqual(2);
+ });
+
it('Number value test, string/true/false/blankCell/error/null', async () => {
const result = await calculate('=RANK("test",A1:F1,0)');
expect(result).toStrictEqual(ErrorType.VALUE);
@@ -175,7 +221,7 @@ describe('Test rank function', () => {
expect(result).toStrictEqual(ErrorType.NA);
const result2 = await calculate('=RANK(A1,{1,2,3},0)');
- expect(result2).toStrictEqual(ErrorType.NA);
+ expect(result2).toStrictEqual(3);
const result3 = await calculate('=RANK(A1,A1:G1,0)');
expect(result3).toStrictEqual(ErrorType.NAME);
@@ -207,5 +253,10 @@ describe('Test rank function', () => {
[3, 2, ErrorType.NA, ErrorType.NAME],
]);
});
+
+ it('Accepts array results and ignores non-number items in ref', async () => {
+ const result = await calculate('=RANK(H1,IF({TRUE;FALSE;TRUE},H1:H3),0)');
+ expect(result).toStrictEqual(2);
+ });
});
});
diff --git a/packages/engine-formula/src/functions/compatibility/rank/index.ts b/packages/engine-formula/src/functions/compatibility/rank/index.ts
index e63676c43d..6c40ebd4b5 100644
--- a/packages/engine-formula/src/functions/compatibility/rank/index.ts
+++ b/packages/engine-formula/src/functions/compatibility/rank/index.ts
@@ -29,6 +29,14 @@ interface IRefType {
refNumbers: number[];
}
+function isSameRankNumber(left: number, right: number): boolean {
+ if (left === right || Number.isInteger(left) || Number.isInteger(right)) {
+ return left === right;
+ }
+ const scale = Math.max(1, Math.abs(left), Math.abs(right));
+ return Math.abs(left - right) <= Number.EPSILON * scale * 2;
+}
+
export class Rank extends BaseFunction {
override minParams = 2;
@@ -86,9 +94,9 @@ export class Rank extends BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
- const refOrderNumbers = refNumbers.sort((a, b) => !orderValue ? b - a : a - b);
+ const refOrderNumbers = [...refNumbers].sort((a, b) => !orderValue ? b - a : a - b);
- const result = refOrderNumbers.indexOf(numberValue);
+ const result = refOrderNumbers.findIndex((refNumber) => isSameRankNumber(refNumber, numberValue));
if (result === -1) {
return ErrorValueObject.create(ErrorType.NA);
@@ -109,7 +117,7 @@ export class Rank extends BaseFunction {
let refErrorObject = ErrorValueObject.create(ErrorType.NA);
const refNumbers: number[] = [];
- if (!ref.isReferenceObject()) {
+ if (!ref.isReferenceObject() && !ref.isArray()) {
return {
refHasError: true,
refErrorObject,
@@ -117,7 +125,9 @@ export class Rank extends BaseFunction {
};
}
- const _ref = (ref as BaseReferenceObject).toArrayValueObject();
+ const _ref = ref.isReferenceObject()
+ ? (ref as BaseReferenceObject).toArrayValueObject()
+ : ref as ArrayValueObject;
_ref.iterator((refObject) => {
const _refObject = refObject as BaseValueObject;
diff --git a/packages/engine-formula/src/functions/date/edate/__tests__/index.spec.ts b/packages/engine-formula/src/functions/date/edate/__tests__/index.spec.ts
index 8e3e06635e..2094ba52e7 100644
--- a/packages/engine-formula/src/functions/date/edate/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/date/edate/__tests__/index.spec.ts
@@ -15,6 +15,7 @@
*/
import { describe, expect, it } from 'vitest';
+import { excelDateSerial } from '../../../../basics/date';
import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
import { NumberValueObject } from '../../../../engine/value-object/primitive-object';
import { FUNCTION_NAMES_DATE } from '../../function-names';
@@ -31,6 +32,20 @@ describe('Test edate function', () => {
expect(transformToValue(result.getArrayValue())).toStrictEqual([[43862]]);
});
+ it('Clamps month-end overflow to the target month last day', () => {
+ const startDate = NumberValueObject.create(excelDateSerial(new Date(Date.UTC(2025, 7, 31))));
+ const months = NumberValueObject.create(-2);
+ const result = testFunction.calculate(startDate, months);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[excelDateSerial(new Date(Date.UTC(2025, 5, 30)))]]);
+ });
+
+ it('Clamps to February for non-leap years', () => {
+ const startDate = NumberValueObject.create(excelDateSerial(new Date(Date.UTC(2025, 2, 31))));
+ const months = NumberValueObject.create(-1);
+ const result = testFunction.calculate(startDate, months);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([[excelDateSerial(new Date(Date.UTC(2025, 1, 28)))]]);
+ });
+
it('Start date is array', () => {
const startDate = ArrayValueObject.create({
calculateValueList: transformToValueObject([[43832], [43833]]),
diff --git a/packages/engine-formula/src/functions/date/edate/index.ts b/packages/engine-formula/src/functions/date/edate/index.ts
index d105480061..2e5913c89f 100644
--- a/packages/engine-formula/src/functions/date/edate/index.ts
+++ b/packages/engine-formula/src/functions/date/edate/index.ts
@@ -84,7 +84,8 @@ export class Edate extends BaseFunction {
const month = _startDate.getUTCMonth() + monthsValue;
const day = _startDate.getUTCDate();
- const resultDate = new Date(Date.UTC(year, month, day));
+ const lastDayOfTargetMonth = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+ const resultDate = new Date(Date.UTC(year, month, Math.min(day, lastDayOfTargetMonth)));
const currentSerial = excelDateSerial(resultDate);
return NumberValueObject.create(currentSerial, DEFAULT_DATE_FORMAT);
diff --git a/packages/engine-formula/src/functions/date/eomonth/__tests__/index.spec.ts b/packages/engine-formula/src/functions/date/eomonth/__tests__/index.spec.ts
index c637bdfb2e..78fec25ee4 100644
--- a/packages/engine-formula/src/functions/date/eomonth/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/date/eomonth/__tests__/index.spec.ts
@@ -64,6 +64,13 @@ describe('Test eomonth function', () => {
expect(result.getValue()).toStrictEqual(ErrorType.VALUE);
});
+ it('parses compact English month date strings like Excel', () => {
+ const startDate = StringValueObject.create('1Feb2016');
+ const months = NumberValueObject.create(0);
+ const result = testFunction.calculate(startDate, months);
+ expect(result.getValue()).toStrictEqual(42429);
+ });
+
it('value is array', () => {
const startDate = ArrayValueObject.create({
calculateValueList: transformToValueObject([
diff --git a/packages/engine-formula/src/functions/date/networkdays-intl/index.ts b/packages/engine-formula/src/functions/date/networkdays-intl/index.ts
index 61a2a1f013..00db3a1172 100644
--- a/packages/engine-formula/src/functions/date/networkdays-intl/index.ts
+++ b/packages/engine-formula/src/functions/date/networkdays-intl/index.ts
@@ -143,9 +143,16 @@ export class NetworkdaysIntl extends BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
+ if (cell.isNull()) {
+ continue;
+ }
+
const holidaySerialNumber = getDateSerialNumberByObject(cell);
if (typeof holidaySerialNumber !== 'number') {
+ if (cell.isString()) {
+ continue;
+ }
return holidaySerialNumber;
}
diff --git a/packages/engine-formula/src/functions/date/networkdays/index.ts b/packages/engine-formula/src/functions/date/networkdays/index.ts
index 420f4fb5fe..abbf780c55 100644
--- a/packages/engine-formula/src/functions/date/networkdays/index.ts
+++ b/packages/engine-formula/src/functions/date/networkdays/index.ts
@@ -105,9 +105,16 @@ export class Networkdays extends BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
+ if (cell.isNull()) {
+ continue;
+ }
+
const holidaySerialNumber = getDateSerialNumberByObject(cell);
if (typeof holidaySerialNumber !== 'number') {
+ if (cell.isString()) {
+ continue;
+ }
return holidaySerialNumber;
}
diff --git a/packages/engine-formula/src/functions/date/workday-intl/index.ts b/packages/engine-formula/src/functions/date/workday-intl/index.ts
index ae89082dd3..17a225b7b8 100644
--- a/packages/engine-formula/src/functions/date/workday-intl/index.ts
+++ b/packages/engine-formula/src/functions/date/workday-intl/index.ts
@@ -146,9 +146,16 @@ export class WorkdayIntl extends BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
+ if (cell.isNull()) {
+ continue;
+ }
+
const holidaySerialNumber = getDateSerialNumberByObject(cell);
if (typeof holidaySerialNumber !== 'number') {
+ if (cell.isString()) {
+ continue;
+ }
return holidaySerialNumber;
}
diff --git a/packages/engine-formula/src/functions/date/workday/index.ts b/packages/engine-formula/src/functions/date/workday/index.ts
index edfad390e8..79e65a4d15 100644
--- a/packages/engine-formula/src/functions/date/workday/index.ts
+++ b/packages/engine-formula/src/functions/date/workday/index.ts
@@ -109,9 +109,16 @@ export class Workday extends BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
+ if (cell.isNull()) {
+ continue;
+ }
+
const holidaySerialNumber = getDateSerialNumberByObject(cell);
if (typeof holidaySerialNumber !== 'number') {
+ if (cell.isString()) {
+ continue;
+ }
return holidaySerialNumber;
}
diff --git a/packages/engine-formula/src/functions/date/yearfrac/__tests__/index.spec.ts b/packages/engine-formula/src/functions/date/yearfrac/__tests__/index.spec.ts
index f1d01f0ce5..ddc7605375 100644
--- a/packages/engine-formula/src/functions/date/yearfrac/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/date/yearfrac/__tests__/index.spec.ts
@@ -38,6 +38,24 @@ describe('Test yearfrac function', () => {
expect(result.getValue()).toStrictEqual(9.102107856556255);
});
+ it('matches Excel basis 0 for February month-end dates', () => {
+ const startDate = NumberValueObject.create(44620);
+ const endDate = NumberValueObject.create(44985);
+
+ const result = testFunction.calculate(startDate, endDate);
+
+ expect(result.getValue()).toStrictEqual(1);
+ });
+
+ it('does not apply the February month-end rule to non-February start dates', () => {
+ const startDate = NumberValueObject.create(44804);
+ const endDate = NumberValueObject.create(44985);
+
+ const result = testFunction.calculate(startDate, endDate);
+
+ expect(result.getValue()).toBeCloseTo(0.494444444444444, 15);
+ });
+
it('value is normal, endDate < startDate', () => {
const startDate = StringValueObject.create('2021/3/11');
const endDate = StringValueObject.create('2012/2/2');
diff --git a/packages/engine-formula/src/functions/logical/function-map.ts b/packages/engine-formula/src/functions/logical/function-map.ts
index 0ae7920d90..fb41ba90f1 100644
--- a/packages/engine-formula/src/functions/logical/function-map.ts
+++ b/packages/engine-formula/src/functions/logical/function-map.ts
@@ -19,6 +19,7 @@ import { Bycol } from './bycol';
import { Byrow } from './byrow';
import { False } from './false';
import { FUNCTION_NAMES_LOGICAL } from './function-names';
+import { Groupby } from './groupby';
import { If } from './if';
import { Iferror } from './iferror';
import { Ifna } from './ifna';
@@ -29,6 +30,7 @@ import { Makearray } from './makearray';
import { Map } from './map';
import { Not } from './not';
import { Or } from './or';
+import { Percentof } from './percentof';
import { Reduce } from './reduce';
import { Scan } from './scan';
import { Switch } from './switch';
@@ -40,6 +42,7 @@ export const functionLogical = [
[Bycol, FUNCTION_NAMES_LOGICAL.BYCOL],
[Byrow, FUNCTION_NAMES_LOGICAL.BYROW],
[False, FUNCTION_NAMES_LOGICAL.FALSE],
+ [Groupby, FUNCTION_NAMES_LOGICAL.GROUPBY],
[If, FUNCTION_NAMES_LOGICAL.IF],
[Iferror, FUNCTION_NAMES_LOGICAL.IFERROR],
[Ifna, FUNCTION_NAMES_LOGICAL.IFNA],
@@ -50,6 +53,7 @@ export const functionLogical = [
[Map, FUNCTION_NAMES_LOGICAL.MAP],
[Not, FUNCTION_NAMES_LOGICAL.NOT],
[Or, FUNCTION_NAMES_LOGICAL.OR],
+ [Percentof, FUNCTION_NAMES_LOGICAL.PERCENTOF],
[Reduce, FUNCTION_NAMES_LOGICAL.REDUCE],
[Scan, FUNCTION_NAMES_LOGICAL.SCAN],
[Switch, FUNCTION_NAMES_LOGICAL.SWITCH],
diff --git a/packages/engine-formula/src/functions/logical/function-names.ts b/packages/engine-formula/src/functions/logical/function-names.ts
index 22c8e5eae9..d84afe6cc1 100644
--- a/packages/engine-formula/src/functions/logical/function-names.ts
+++ b/packages/engine-formula/src/functions/logical/function-names.ts
@@ -19,6 +19,7 @@ export enum FUNCTION_NAMES_LOGICAL {
BYCOL = 'BYCOL',
BYROW = 'BYROW',
FALSE = 'FALSE',
+ GROUPBY = 'GROUPBY',
IF = 'IF',
IFERROR = 'IFERROR',
IFNA = 'IFNA',
@@ -29,6 +30,7 @@ export enum FUNCTION_NAMES_LOGICAL {
MAP = 'MAP',
NOT = 'NOT',
OR = 'OR',
+ PERCENTOF = 'PERCENTOF',
REDUCE = 'REDUCE',
SCAN = 'SCAN',
SWITCH = 'SWITCH',
diff --git a/packages/engine-formula/src/functions/logical/groupby/index.ts b/packages/engine-formula/src/functions/logical/groupby/index.ts
new file mode 100644
index 0000000000..c59057b07e
--- /dev/null
+++ b/packages/engine-formula/src/functions/logical/groupby/index.ts
@@ -0,0 +1,371 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { BaseAstNode } from '../../../engine/ast-node/base-ast-node';
+import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorType } from '../../../basics/error-type';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NullValueObject, NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';
+import { BaseFunction } from '../../base-function';
+import { FUNCTION_NAMES_LOGICAL } from '../function-names';
+
+type GroupByAggregatorName = 'SUM' | 'COUNT' | 'COUNTA' | 'PERCENTOF' | 'MIN' | 'MAX' | 'ARRAYTOTEXT';
+
+interface ArrayInput {
+ rowCount: number;
+ columnCount: number;
+ valueAt: (row: number, column: number) => BaseValueObject;
+}
+
+interface GroupByGroup {
+ key: BaseValueObject[];
+ values: BaseValueObject[][];
+}
+
+export class Groupby extends BaseFunction {
+ override minParams = 3;
+
+ override maxParams = 7;
+
+ override needsReferenceObject = true;
+
+ override needsAstChildren = true;
+
+ override calculateAst(
+ children: BaseAstNode[],
+ getVariant: (node: BaseAstNode) => FunctionVariantType | null
+ ) {
+ const rowFields = this._arrayInput(getVariant(children[0]));
+ if (rowFields instanceof ErrorValueObject) {
+ return rowFields;
+ }
+
+ const values = this._arrayInput(getVariant(children[1]));
+ if (values instanceof ErrorValueObject) {
+ return values;
+ }
+
+ const aggregators = this._aggregators(children[2]);
+ if (aggregators.length === 0) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ if (values.rowCount !== rowFields.rowCount) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ const includeTotal = children[4] == null ? true : this._numberValue(getVariant(children[4])) !== 0;
+ const sortColumnValue = children[5] == null ? 0 : this._numberValue(getVariant(children[5]));
+ const sortColumn = sortColumnValue === 0 ? undefined : Math.trunc(sortColumnValue);
+ const filter = children[6] == null ? undefined : this._arrayInput(getVariant(children[6]));
+ if (filter instanceof ErrorValueObject) {
+ return filter;
+ }
+
+ const groupColumnCount = rowFields.columnCount;
+ const valueColumnCount = values.columnCount;
+ const outputValueColumnCount = this._outputValueColumnCount(valueColumnCount, aggregators.length);
+ const groups: GroupByGroup[] = [];
+ const allValues = Array.from({ length: valueColumnCount }, () => [] as BaseValueObject[]);
+
+ for (let row = 0; row < rowFields.rowCount; row++) {
+ if (filter != null && !this._truthy(filter.valueAt(row, 0))) {
+ continue;
+ }
+
+ const key: BaseValueObject[] = [];
+ for (let column = 0; column < groupColumnCount; column++) {
+ key.push(rowFields.valueAt(row, column));
+ }
+
+ let group = groups.find((item) => this._keysEqual(item.key, key));
+ if (group == null) {
+ group = {
+ key,
+ values: Array.from({ length: valueColumnCount }, () => [] as BaseValueObject[]),
+ };
+ groups.push(group);
+ }
+
+ for (let column = 0; column < valueColumnCount; column++) {
+ const value = values.valueAt(row, column);
+ group.values[column].push(value);
+ allValues[column].push(value);
+ }
+ }
+
+ this._sortGroups(groups, sortColumn);
+
+ const includeHeader = aggregators.length > 1;
+ const rowCount = groups.length + (includeHeader ? 1 : 0) + (includeTotal ? 1 : 0);
+ const columnCount = groupColumnCount + outputValueColumnCount;
+ const result: BaseValueObject[][] = [];
+
+ if (includeHeader) {
+ const header: BaseValueObject[] = [];
+ for (let column = 0; column < groupColumnCount; column++) {
+ header.push(StringValueObject.create(''));
+ }
+ for (let column = 0; column < outputValueColumnCount; column++) {
+ header.push(StringValueObject.create(this._aggregatorHeader(this._aggregatorForOutput(aggregators, valueColumnCount, column))));
+ }
+ result.push(header);
+ }
+
+ for (const group of groups) {
+ const row: BaseValueObject[] = [...group.key];
+ for (let column = 0; column < outputValueColumnCount; column++) {
+ const valueColumn = this._valueColumnForOutput(valueColumnCount, aggregators.length, column);
+ const aggregator = this._aggregatorForOutput(aggregators, valueColumnCount, column);
+ row.push(this._applyAggregator(aggregator, group.values[valueColumn], allValues[valueColumn]));
+ }
+ result.push(row);
+ }
+
+ if (includeTotal) {
+ const row: BaseValueObject[] = [];
+ for (let column = 0; column < groupColumnCount; column++) {
+ row.push(StringValueObject.create(column === 0 ? 'Total' : ''));
+ }
+ for (let column = 0; column < outputValueColumnCount; column++) {
+ const valueColumn = this._valueColumnForOutput(valueColumnCount, aggregators.length, column);
+ const aggregator = this._aggregatorForOutput(aggregators, valueColumnCount, column);
+ row.push(this._applyAggregator(aggregator, allValues[valueColumn], allValues[valueColumn]));
+ }
+ result.push(row);
+ }
+
+ return ArrayValueObject.create({
+ calculateValueList: result,
+ rowCount,
+ columnCount,
+ unitId: this.unitId as string,
+ sheetId: this.subUnitId as string,
+ row: this.row,
+ column: this.column,
+ });
+ }
+
+ private _arrayInput(variant: FunctionVariantType | null): ArrayInput | ErrorValueObject {
+ if (variant == null) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ let value = variant;
+ if (value.isReferenceObject()) {
+ value = (value as BaseReferenceObject).toArrayValueObject();
+ }
+
+ if (value.isError()) {
+ return value as ErrorValueObject;
+ }
+
+ if (value.isArray()) {
+ const array = value as ArrayValueObject;
+ return {
+ rowCount: array.getRowCount(),
+ columnCount: array.getColumnCount(),
+ valueAt: (row, column) => array.get(row, column) ?? NullValueObject.create(),
+ };
+ }
+
+ return {
+ rowCount: 1,
+ columnCount: 1,
+ valueAt: (row, column) => row === 0 && column === 0 ? value as BaseValueObject : NullValueObject.create(),
+ };
+ }
+
+ private _aggregators(node: BaseAstNode): GroupByAggregatorName[] {
+ const name = this._normalizedFunctionName(node.getToken());
+ if (name === FUNCTION_NAMES_LOGICAL.GROUPBY) {
+ return [];
+ }
+ if (name === 'HSTACK') {
+ return node.getChildren().flatMap((child) => this._aggregators(child));
+ }
+ if (this._isAggregatorName(name)) {
+ return [name];
+ }
+ return [];
+ }
+
+ private _normalizedFunctionName(token: string): string {
+ let normalized = token.toUpperCase();
+ for (;;) {
+ const prefix = ['_XLFN.', '_XLWS.', '_XLETA.'].find((item) => normalized.startsWith(item));
+ if (prefix == null) {
+ return normalized;
+ }
+ normalized = normalized.slice(prefix.length);
+ }
+ }
+
+ private _isAggregatorName(name: string): name is GroupByAggregatorName {
+ return name === 'SUM' ||
+ name === 'COUNT' ||
+ name === 'COUNTA' ||
+ name === 'PERCENTOF' ||
+ name === 'MIN' ||
+ name === 'MAX' ||
+ name === 'ARRAYTOTEXT';
+ }
+
+ private _outputValueColumnCount(valueColumnCount: number, aggregatorCount: number): number {
+ if (valueColumnCount === 1) {
+ return aggregatorCount;
+ }
+ if (aggregatorCount === 1 || valueColumnCount === aggregatorCount) {
+ return valueColumnCount;
+ }
+ return Math.min(valueColumnCount, aggregatorCount);
+ }
+
+ private _valueColumnForOutput(valueColumnCount: number, aggregatorCount: number, outputColumn: number): number {
+ if (valueColumnCount === 1) {
+ return 0;
+ }
+ if (aggregatorCount === 1 || valueColumnCount === aggregatorCount) {
+ return Math.min(outputColumn, valueColumnCount - 1);
+ }
+ return Math.min(outputColumn, valueColumnCount - 1);
+ }
+
+ private _aggregatorForOutput(aggregators: GroupByAggregatorName[], valueColumnCount: number, outputColumn: number): GroupByAggregatorName {
+ if (aggregators.length === 1 || valueColumnCount === aggregators.length) {
+ return aggregators[Math.min(outputColumn, aggregators.length - 1)];
+ }
+ return aggregators[Math.min(outputColumn, aggregators.length - 1)];
+ }
+
+ private _aggregatorHeader(aggregator: GroupByAggregatorName): string {
+ return aggregator === 'PERCENTOF' ? '%' : aggregator;
+ }
+
+ private _applyAggregator(
+ aggregator: GroupByAggregatorName,
+ groupValues: BaseValueObject[],
+ allValues: BaseValueObject[]
+ ): BaseValueObject {
+ switch (aggregator) {
+ case 'SUM':
+ return NumberValueObject.create(this._sum(groupValues));
+ case 'COUNT':
+ return NumberValueObject.create(groupValues.filter((value) => value.isNumber()).length);
+ case 'COUNTA':
+ return NumberValueObject.create(groupValues.filter((value) => !value.isNull() && !(value.isString() && value.getValue() === '')).length);
+ case 'PERCENTOF': {
+ const allTotal = this._sum(allValues);
+ if (allTotal === 0) {
+ return ErrorValueObject.create(ErrorType.DIV_BY_ZERO);
+ }
+ return NumberValueObject.create(this._sum(groupValues) / allTotal);
+ }
+ case 'MIN': {
+ const values = groupValues.map((value) => this._numericValue(value)).filter((value) => value != null) as number[];
+ return NumberValueObject.create(values.length === 0 ? 0 : Math.min(...values));
+ }
+ case 'MAX': {
+ const values = groupValues.map((value) => this._numericValue(value)).filter((value) => value != null) as number[];
+ return NumberValueObject.create(values.length === 0 ? 0 : Math.max(...values));
+ }
+ case 'ARRAYTOTEXT':
+ return StringValueObject.create(groupValues.map((value) => this._textValue(value)).filter(Boolean).join(', '));
+ }
+ }
+
+ private _sum(values: BaseValueObject[]): number {
+ return values.reduce((sum, value) => sum + (this._numericValue(value) ?? 0), 0);
+ }
+
+ private _numericValue(value: BaseValueObject): number | undefined {
+ return value.isNumber() ? Number(value.getValue()) : undefined;
+ }
+
+ private _numberValue(variant: FunctionVariantType | null): number {
+ if (variant == null || variant.isError()) {
+ return 0;
+ }
+ if (variant.isReferenceObject()) {
+ variant = (variant as BaseReferenceObject).getFirstCell();
+ }
+ if (variant.isArray()) {
+ variant = (variant as ArrayValueObject).get(0, 0) ?? NullValueObject.create();
+ }
+ const value = (variant as BaseValueObject).getValue();
+ return typeof value === 'number' ? Math.trunc(value) : Math.trunc(Number(value) || 0);
+ }
+
+ private _truthy(value: BaseValueObject): boolean {
+ if (value.isError() || value.isNull()) {
+ return false;
+ }
+ return Boolean(value.getValue());
+ }
+
+ private _keysEqual(left: BaseValueObject[], right: BaseValueObject[]): boolean {
+ return left.length === right.length && left.every((value, index) => this._keyValue(value) === this._keyValue(right[index]));
+ }
+
+ private _keyValue(value: BaseValueObject): string {
+ if (value.isError()) {
+ return `error:${(value as ErrorValueObject).getErrorType()}`;
+ }
+ if (value.isNull()) {
+ return 'null:';
+ }
+ return `${typeof value.getValue()}:${String(value.getValue())}`;
+ }
+
+ private _sortGroups(groups: GroupByGroup[], sortColumn?: number): void {
+ const descending = sortColumn != null && sortColumn < 0;
+ const sortIndex = sortColumn == null ? undefined : Math.abs(sortColumn) - 1;
+ groups.sort((left, right) => {
+ const compare = sortIndex != null && sortIndex < left.key.length
+ ? this._compareValue(left.key[sortIndex], right.key[sortIndex])
+ : this._compareKey(left.key, right.key);
+ return descending ? -compare : compare;
+ });
+ }
+
+ private _compareKey(left: BaseValueObject[], right: BaseValueObject[]): number {
+ for (let index = 0; index < Math.min(left.length, right.length); index++) {
+ const compare = this._compareValue(left[index], right[index]);
+ if (compare !== 0) {
+ return compare;
+ }
+ }
+ return left.length - right.length;
+ }
+
+ private _compareValue(left: BaseValueObject, right: BaseValueObject): number {
+ const leftNumber = this._numericValue(left);
+ const rightNumber = this._numericValue(right);
+ if (leftNumber != null && rightNumber != null) {
+ return leftNumber - rightNumber;
+ }
+ return this._textValue(left).toUpperCase().localeCompare(this._textValue(right).toUpperCase());
+ }
+
+ private _textValue(value: BaseValueObject): string {
+ if (value.isNull()) {
+ return '';
+ }
+ return String(value.getValue());
+ }
+}
diff --git a/packages/engine-formula/src/functions/logical/if/__tests__/index.spec.ts b/packages/engine-formula/src/functions/logical/if/__tests__/index.spec.ts
index 5d2aae968e..b1a07a0abb 100644
--- a/packages/engine-formula/src/functions/logical/if/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/logical/if/__tests__/index.spec.ts
@@ -15,6 +15,7 @@
*/
import { describe, expect, it } from 'vitest';
+import { ErrorType } from '../../../../basics/error-type';
import { ArrayValueObject, transformToValueObject } from '../../../../engine/value-object/array-value-object';
import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
import { getObjectValue } from '../../../util';
@@ -40,6 +41,18 @@ describe('Test if function', () => {
expect(getObjectValue(result)).toBe(2);
});
+ it('LogicalTest coerces Excel-compatible scalar values', () => {
+ const valueIfTrue = StringValueObject.create('yes');
+ const valueIfFalse = StringValueObject.create('no');
+
+ expect(getObjectValue(testFunction.calculate(NumberValueObject.create(0), valueIfTrue, valueIfFalse))).toBe('no');
+ expect(getObjectValue(testFunction.calculate(NumberValueObject.create(2), valueIfTrue, valueIfFalse))).toBe('yes');
+ expect(getObjectValue(testFunction.calculate(StringValueObject.create('FALSE'), valueIfTrue, valueIfFalse))).toBe('no');
+ expect(getObjectValue(testFunction.calculate(StringValueObject.create('TRUE'), valueIfTrue, valueIfFalse))).toBe('yes');
+ expect(getObjectValue(testFunction.calculate(StringValueObject.create(''), valueIfTrue, valueIfFalse))).toBe(ErrorType.VALUE);
+ expect(getObjectValue(testFunction.calculate(StringValueObject.create('0'), valueIfTrue, valueIfFalse))).toBe(ErrorType.VALUE);
+ });
+
it('LogicalTest is array', () => {
const logicTest = ArrayValueObject.create({
calculateValueList: transformToValueObject([
@@ -104,6 +117,96 @@ describe('Test if function', () => {
expect(getObjectValue(result)).toBe(false);
});
+ it('Direct IF preserves selected reference-derived array for scalar condition', () => {
+ testFunction.setRefInfo('unit', 'summary', 11, 0);
+
+ const logicTest = BooleanValueObject.create(false);
+ const valueIfTrue = NumberValueObject.create(1);
+ const valueIfFalse = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [false],
+ [true],
+ [false],
+ ]),
+ rowCount: 3,
+ columnCount: 1,
+ unitId: 'unit',
+ sheetId: 'data',
+ row: 10,
+ column: 3,
+ });
+ const result = testFunction.calculate(logicTest, valueIfTrue, valueIfFalse);
+ expect(getObjectValue(result)).toStrictEqual([[false], [true], [false]]);
+ });
+
+ it('Direct IF implicitly intersects selected reference-derived array when logical test was implicitly intersected', () => {
+ testFunction.setRefInfo('unit', 'summary', 11, 0);
+
+ const logicTest = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [true],
+ [false],
+ [true],
+ ]),
+ rowCount: 3,
+ columnCount: 1,
+ unitId: 'unit',
+ sheetId: 'data',
+ row: 10,
+ column: 0,
+ });
+ const valueIfTrue = StringValueObject.create('blank');
+ const valueIfFalse = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ ['first'],
+ ['second'],
+ ['third'],
+ ]),
+ rowCount: 3,
+ columnCount: 1,
+ unitId: 'unit',
+ sheetId: 'data',
+ row: 10,
+ column: 0,
+ });
+ const result = testFunction.calculate(logicTest, valueIfTrue, valueIfFalse);
+ expect(getObjectValue(result)).toBe('second');
+ });
+
+ it('Direct IF preserves arrays for array formula ranges', () => {
+ testFunction.setRefInfo('unit', 'summary', 23, 0, 3, 1);
+
+ const logicTest = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [false],
+ [false],
+ [true],
+ ]),
+ rowCount: 3,
+ columnCount: 1,
+ unitId: 'unit',
+ sheetId: 'data',
+ row: 12,
+ column: 0,
+ });
+ const valueIfTrue = StringValueObject.create('blank');
+ const valueIfFalse = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ ['first'],
+ ['second'],
+ ['third'],
+ ]),
+ rowCount: 3,
+ columnCount: 1,
+ unitId: 'unit',
+ sheetId: 'data',
+ row: 12,
+ column: 0,
+ });
+ const result = testFunction.calculate(logicTest, valueIfTrue, valueIfFalse);
+ expect(getObjectValue(result)).toStrictEqual([['first'], ['second'], ['blank']]);
+ });
+
it('ValueIfFalse is array', () => {
const logicTest = BooleanValueObject.create(false);
const valueIfTrue = NumberValueObject.create(1);
diff --git a/packages/engine-formula/src/functions/logical/if/index.ts b/packages/engine-formula/src/functions/logical/if/index.ts
index b9d59206cf..aaee7b779a 100644
--- a/packages/engine-formula/src/functions/logical/if/index.ts
+++ b/packages/engine-formula/src/functions/logical/if/index.ts
@@ -16,10 +16,11 @@
import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BooleanValue } from '../../../basics/common';
import { ErrorType } from '../../../basics/error-type';
import { expandArrayValueObject } from '../../../engine/utils/array-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
-import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
+import { BooleanValueObject, NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
export class If extends BaseFunction {
@@ -29,18 +30,29 @@ export class If extends BaseFunction {
override calculate(logicalTest: BaseValueObject, valueIfTrue: BaseValueObject, valueIfFalse: BaseValueObject = BooleanValueObject.create(false)) {
let _logicalTest = logicalTest;
+ let useLegacyImplicitSelectedValue = false;
if (logicalTest.isArray()) {
- const rowCount = (logicalTest as ArrayValueObject).getRowCount();
- const columnCount = (logicalTest as ArrayValueObject).getColumnCount();
+ const logicalTestArray = logicalTest as ArrayValueObject;
+ const rowCount = logicalTestArray.getRowCount();
+ const columnCount = logicalTestArray.getColumnCount();
if (rowCount === 1 && columnCount === 1) {
- _logicalTest = (logicalTest as ArrayValueObject).get(0, 0) as BaseValueObject;
+ _logicalTest = logicalTestArray.get(0, 0) as BaseValueObject;
+ } else if (
+ !this._isCurrentArrayFormula() &&
+ logicalTestArray.getUnitId() !== '' &&
+ logicalTestArray.getSheetId() !== '' &&
+ logicalTestArray.getCurrentRow() >= 0 &&
+ logicalTestArray.getCurrentColumn() >= 0
+ ) {
+ _logicalTest = this._legacyImplicitArrayValue(logicalTestArray);
+ useLegacyImplicitSelectedValue = true;
}
}
if (!_logicalTest.isArray()) {
- return this._handleSingleObject(_logicalTest, valueIfTrue, valueIfFalse);
+ return this._handleSingleObject(_logicalTest, valueIfTrue, valueIfFalse, useLegacyImplicitSelectedValue);
}
// get max row length
@@ -65,20 +77,112 @@ export class If extends BaseFunction {
const valueIfTrueValue = valueIfTrueArray.get(rowIndex, columnIndex) as BaseValueObject;
const valueIfFalseValue = valueIfFalseArray.get(rowIndex, columnIndex) as BaseValueObject;
- return this._handleSingleObject(logicalTestValue, valueIfTrueValue, valueIfFalseValue);
+ return this._handleSingleObject(logicalTestValue, valueIfTrueValue, valueIfFalseValue, false);
});
}
- private _handleSingleObject(logicalTest: BaseValueObject, valueIfTrue: BaseValueObject, valueIfFalse: BaseValueObject) {
+ private _handleSingleObject(logicalTest: BaseValueObject, valueIfTrue: BaseValueObject, valueIfFalse: BaseValueObject, useLegacyImplicitSelectedValue: boolean) {
if (logicalTest.isError()) {
return logicalTest;
}
- const logicalTestValue = logicalTest.getValue();
+ const logicalTestValue = this._coerceLogicalTest(logicalTest);
+ if (logicalTestValue.isError()) {
+ return logicalTestValue;
+ }
- // true or non-zero
- return logicalTestValue
+ let selectedValue = logicalTestValue.getValue()
? valueIfTrue
: valueIfFalse;
+ if (useLegacyImplicitSelectedValue) {
+ selectedValue = this._legacyImplicitSelectedValue(selectedValue);
+ }
+ return this._coerceSelectedValue(selectedValue);
+ }
+
+ private _coerceSelectedValue(value: BaseValueObject): BaseValueObject {
+ return value.isNull() ? NumberValueObject.create(0) : value;
+ }
+
+ private _coerceLogicalTest(logicalTest: BaseValueObject): BaseValueObject {
+ if (logicalTest.isNull()) {
+ return BooleanValueObject.create(false);
+ }
+
+ if (logicalTest.isBoolean()) {
+ return logicalTest;
+ }
+
+ if (logicalTest.isNumber()) {
+ return BooleanValueObject.create(Number(logicalTest.getValue()) !== 0);
+ }
+
+ if (logicalTest.isString()) {
+ const value = `${logicalTest.getValue()}`.trim().toUpperCase();
+ if (value === BooleanValue.TRUE) {
+ return BooleanValueObject.create(true);
+ }
+ if (value === BooleanValue.FALSE) {
+ return BooleanValueObject.create(false);
+ }
+ }
+
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ private _legacyImplicitSelectedValue(value: BaseValueObject): BaseValueObject {
+ if (!value.isArray()) {
+ return value;
+ }
+
+ const array = value as ArrayValueObject;
+
+ if (
+ array.getUnitId() === '' ||
+ array.getSheetId() === '' ||
+ array.getCurrentRow() < 0 ||
+ array.getCurrentColumn() < 0
+ ) {
+ return value;
+ }
+
+ return this._legacyImplicitArrayValue(array);
+ }
+
+ private _legacyImplicitArrayValue(logicalTest: ArrayValueObject): BaseValueObject {
+ const startRow = logicalTest.getCurrentRow();
+ const startColumn = logicalTest.getCurrentColumn();
+ const rowCount = logicalTest.getRowCount();
+ const columnCount = logicalTest.getColumnCount();
+
+ if (startRow < 0 || startColumn < 0) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ let rowIndex = -1;
+ let columnIndex = -1;
+ if (rowCount === 1 && columnCount === 1) {
+ rowIndex = 0;
+ columnIndex = 0;
+ } else if (rowCount === 1) {
+ rowIndex = 0;
+ columnIndex = this.column - startColumn;
+ } else if (columnCount === 1) {
+ rowIndex = this.row - startRow;
+ columnIndex = 0;
+ } else {
+ rowIndex = this.row - startRow;
+ columnIndex = this.column - startColumn;
+ }
+
+ if (rowIndex < 0 || rowIndex >= rowCount || columnIndex < 0 || columnIndex >= columnCount) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ return logicalTest.get(rowIndex, columnIndex) as BaseValueObject || ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ private _isCurrentArrayFormula(): boolean {
+ return this.currentFormulaRowCount > 1 || this.currentFormulaColumnCount > 1;
}
}
diff --git a/packages/engine-formula/src/functions/logical/iferror/__tests__/index.spec.ts b/packages/engine-formula/src/functions/logical/iferror/__tests__/index.spec.ts
index c3bb64f4c9..133b0d9a86 100644
--- a/packages/engine-formula/src/functions/logical/iferror/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/logical/iferror/__tests__/index.spec.ts
@@ -45,9 +45,10 @@ describe('Test iferror function', () => {
calculateValueList: transformToValueObject([
[1],
['#N/A'],
+ ['#DIV/0!'],
[1],
]),
- rowCount: 3,
+ rowCount: 4,
columnCount: 1,
unitId: '',
sheetId: '',
@@ -59,6 +60,7 @@ describe('Test iferror function', () => {
expect(transformToValue(result.getArrayValue())).toStrictEqual([
[1],
['error'],
+ ['error'],
[1],
]);
});
diff --git a/packages/engine-formula/src/functions/logical/iferror/index.ts b/packages/engine-formula/src/functions/logical/iferror/index.ts
index 5b7462b6ae..00566de8fb 100644
--- a/packages/engine-formula/src/functions/logical/iferror/index.ts
+++ b/packages/engine-formula/src/functions/logical/iferror/index.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { expandArrayValueObject } from '../../../engine/utils/array-object';
@@ -24,7 +25,12 @@ export class Iferror extends BaseFunction {
override maxParams = 2;
- override calculate(value: BaseValueObject, valueIfError: BaseValueObject) {
+ override needsReferenceObject = true;
+
+ override calculate(value: FunctionVariantType, valueIfError: FunctionVariantType) {
+ value = this._toValueObject(value);
+ valueIfError = this._toValueObject(valueIfError);
+
if (!value.isArray()) {
return value.isError() ? valueIfError : value;
}
@@ -52,4 +58,18 @@ export class Iferror extends BaseFunction {
return valueArray;
}
+
+ private _toValueObject(value: FunctionVariantType): BaseValueObject {
+ if (!value.isReferenceObject()) {
+ return value as BaseValueObject;
+ }
+
+ const reference = value as BaseReferenceObject;
+
+ if (reference.getRowCount() === 1 && reference.getColumnCount() === 1) {
+ return reference.getCellByPosition();
+ }
+
+ return reference.toArrayValueObject();
+ }
}
diff --git a/packages/engine-formula/src/functions/logical/percentof/index.ts b/packages/engine-formula/src/functions/logical/percentof/index.ts
new file mode 100644
index 0000000000..1a0cbf6a41
--- /dev/null
+++ b/packages/engine-formula/src/functions/logical/percentof/index.ts
@@ -0,0 +1,34 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorType } from '../../../basics/error-type';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+/**
+ * PERCENTOF is an Excel GROUPBY aggregator token. It is evaluated by GROUPBY's
+ * AST path, not as a standalone scalar function.
+ */
+export class Percentof extends BaseFunction {
+ override minParams = 0;
+
+ override maxParams = 0;
+
+ override calculate(..._variants: BaseValueObject[]) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+}
diff --git a/packages/engine-formula/src/functions/lookup/address/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/address/__tests__/index.spec.ts
index 9c0435e899..47ebf5532a 100644
--- a/packages/engine-formula/src/functions/lookup/address/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/address/__tests__/index.spec.ts
@@ -20,6 +20,7 @@ import { ArrayValueObject, transformToValue, transformToValueObject } from '../.
import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
import {
BooleanValueObject,
+ NullValueObject,
NumberValueObject,
StringValueObject,
} from '../../../../engine/value-object/primitive-object';
@@ -71,6 +72,19 @@ describe('Test address', () => {
it('Absolute reference to another worksheet', async () => {
expect(calculate(2, 3, 1, false, 'EXCEL SHEET')).toBe("'EXCEL SHEET'!R2C3");
});
+
+ it('Defaults omitted abs and A1 parameters', async () => {
+ const result = testFunction.calculate(
+ NumberValueObject.create(10),
+ NumberValueObject.create(1),
+ NullValueObject.create(),
+ NullValueObject.create(),
+ StringValueObject.create('Krycí List')
+ );
+
+ expect((getObjectValue(result) as string[][])[0][0]).toBe("'Krycí List'!$A$10");
+ });
+
it('Abs less than 1', async () => {
expect(calculate(2, 3, 0, false, 'EXCEL SHEET')).toBe(ErrorType.VALUE);
});
diff --git a/packages/engine-formula/src/functions/lookup/address/index.ts b/packages/engine-formula/src/functions/lookup/address/index.ts
index 36b8887b63..70418c7357 100644
--- a/packages/engine-formula/src/functions/lookup/address/index.ts
+++ b/packages/engine-formula/src/functions/lookup/address/index.ts
@@ -59,9 +59,9 @@ export class Address extends BaseFunction {
return sheetText;
}
- const _absNumber = absNumber ?? NumberValueObject.create(1);
- const _a1 = a1 ?? BooleanValueObject.create(true);
- const _sheetText = sheetText ?? StringValueObject.create('');
+ const _absNumber = absNumber == null || absNumber.isNull() ? NumberValueObject.create(1) : absNumber;
+ const _a1 = a1 == null || a1.isNull() ? BooleanValueObject.create(true) : a1;
+ const _sheetText = sheetText == null || sheetText.isNull() ? StringValueObject.create('') : sheetText;
// get max row length
const maxRowLength = Math.max(
diff --git a/packages/engine-formula/src/functions/lookup/anchorarray/index.ts b/packages/engine-formula/src/functions/lookup/anchorarray/index.ts
new file mode 100644
index 0000000000..ea9c399912
--- /dev/null
+++ b/packages/engine-formula/src/functions/lookup/anchorarray/index.ts
@@ -0,0 +1,30 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { BaseFunction } from '../../base-function';
+
+export class Anchorarray extends BaseFunction {
+ override minParams = 1;
+
+ override maxParams = 1;
+
+ override needsReferenceObject = true;
+
+ override calculate(reference: FunctionVariantType) {
+ return reference;
+ }
+}
diff --git a/packages/engine-formula/src/functions/lookup/function-map.ts b/packages/engine-formula/src/functions/lookup/function-map.ts
index 2ab467f914..883c1709e3 100644
--- a/packages/engine-formula/src/functions/lookup/function-map.ts
+++ b/packages/engine-formula/src/functions/lookup/function-map.ts
@@ -15,6 +15,7 @@
*/
import { Address } from './address';
+import { Anchorarray } from './anchorarray';
import { Areas } from './areas';
import { Choose } from './choose';
import { Choosecols } from './choosecols';
@@ -53,6 +54,7 @@ import { Xmatch } from './xmatch';
export const functionLookup = [
[Address, FUNCTION_NAMES_LOOKUP.ADDRESS],
+ [Anchorarray, FUNCTION_NAMES_LOOKUP.ANCHORARRAY],
[Areas, FUNCTION_NAMES_LOOKUP.AREAS],
[Choose, FUNCTION_NAMES_LOOKUP.CHOOSE],
[Choosecols, FUNCTION_NAMES_LOOKUP.CHOOSECOLS],
diff --git a/packages/engine-formula/src/functions/lookup/function-names.ts b/packages/engine-formula/src/functions/lookup/function-names.ts
index 288beb1cc6..962a4fb828 100644
--- a/packages/engine-formula/src/functions/lookup/function-names.ts
+++ b/packages/engine-formula/src/functions/lookup/function-names.ts
@@ -16,6 +16,7 @@
export enum FUNCTION_NAMES_LOOKUP {
ADDRESS = 'ADDRESS',
+ ANCHORARRAY = 'ANCHORARRAY',
AREAS = 'AREAS',
CHOOSE = 'CHOOSE',
CHOOSECOLS = 'CHOOSECOLS',
diff --git a/packages/engine-formula/src/functions/lookup/hlookup/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/hlookup/__tests__/index.spec.ts
index e2f3f37aec..6bf03c37f7 100644
--- a/packages/engine-formula/src/functions/lookup/hlookup/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/hlookup/__tests__/index.spec.ts
@@ -81,6 +81,22 @@ describe('Test hlookup', () => {
expect(resultObject.getValue().toString()).toBe(ErrorType.NA);
});
+ it('Blank return cell should be returned as zero', async () => {
+ const tableArray = ArrayValueObject.createByArray([
+ [1],
+ [null],
+ ]);
+
+ const resultObject = testFunction.calculate(
+ NumberValueObject.create(1),
+ tableArray,
+ NumberValueObject.create(2),
+ NumberValueObject.create(0)
+ ) as BaseValueObject;
+
+ expect(resultObject.getValue()).toBe(0);
+ });
+
it('array', async () => {
const resultObject = testFunction.calculate(
matchArrayValueObject.clone(),
diff --git a/packages/engine-formula/src/functions/lookup/hlookup/index.ts b/packages/engine-formula/src/functions/lookup/hlookup/index.ts
index 81f9183e5f..9038c87c71 100644
--- a/packages/engine-formula/src/functions/lookup/hlookup/index.ts
+++ b/packages/engine-formula/src/functions/lookup/hlookup/index.ts
@@ -18,6 +18,7 @@ import type { ArrayValueObject } from '../../../engine/value-object/array-value-
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
export class Hlookup extends BaseFunction {
@@ -85,9 +86,17 @@ export class Hlookup extends BaseFunction {
rangeLookupValue: number
) {
if (rangeLookupValue === 0) {
- return this.equalSearch(value, searchArray, resultArray);
+ return this._blankResultAsZero(this.equalSearch(value, searchArray, resultArray));
}
return this.binarySearch(value, searchArray, resultArray);
}
+
+ private _blankResultAsZero(value: BaseValueObject) {
+ if (value.isNull()) {
+ return NumberValueObject.create(0);
+ }
+
+ return value;
+ }
}
diff --git a/packages/engine-formula/src/functions/lookup/indirect/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/indirect/__tests__/index.spec.ts
index 27a398d6ce..703725bd48 100644
--- a/packages/engine-formula/src/functions/lookup/indirect/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/indirect/__tests__/index.spec.ts
@@ -20,6 +20,7 @@ import type { LexerNode } from '../../../../engine/analysis/lexer-node';
import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
import type { BaseReferenceObject } from '../../../../engine/reference-object/base-reference-object';
import type { ArrayValueObject } from '../../../../engine/value-object/array-value-object';
+import type { BaseValueObject } from '../../../../engine/value-object/base-value-object';
import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { Lexer } from '../../../../engine/analysis/lexer';
@@ -32,6 +33,8 @@ import { IFormulaRuntimeService } from '../../../../services/runtime.service';
import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';
import { FUNCTION_NAMES_META } from '../../../meta/function-names';
import { Multiply } from '../../../meta/multiply';
+import { Concatenate } from '../../../text/concatenate';
+import { FUNCTION_NAMES_TEXT } from '../../../text/function-names';
import { FUNCTION_NAMES_LOOKUP } from '../../function-names';
import { Indirect } from '../index';
@@ -86,6 +89,7 @@ describe('Test indirect', () => {
functionService.registerExecutors(
new Indirect(FUNCTION_NAMES_LOOKUP.INDIRECT),
+ new Concatenate(FUNCTION_NAMES_TEXT.CONCATENATE),
new Multiply(FUNCTION_NAMES_META.MULTIPLY)
);
});
@@ -111,6 +115,26 @@ describe('Test indirect', () => {
expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);
});
+ it('should propagate errors produced while building the reference text', () => {
+ const lexerNode = lexer.treeBuilder('=Indirect("A"&#N/A)');
+
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
+
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
+
+ expect((result as BaseValueObject).getValue()).toBe(ErrorType.NA);
+ });
+
+ it('missing sheet returns #REF', () => {
+ const lexerNode = lexer.treeBuilder('=Indirect("\'Missing Sheet\'!A1")');
+
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
+
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
+
+ expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[ErrorType.REF]]);
+ });
+
it('array', () => {
const lexerNode = lexer.treeBuilder('=Indirect(A1:D3)');
diff --git a/packages/engine-formula/src/functions/lookup/indirect/index.ts b/packages/engine-formula/src/functions/lookup/indirect/index.ts
index e9ef3949b3..77b3ea9ee7 100644
--- a/packages/engine-formula/src/functions/lookup/indirect/index.ts
+++ b/packages/engine-formula/src/functions/lookup/indirect/index.ts
@@ -30,6 +30,18 @@ import { deserializeRangeWithSheetWithCache } from '../../../engine/utils/refere
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
+const INDIRECT_ERROR_LITERALS = [
+ ErrorType.NULL,
+ ErrorType.DIV_BY_ZERO,
+ ErrorType.VALUE,
+ ErrorType.REF,
+ ErrorType.NAME,
+ ErrorType.NUM,
+ ErrorType.NA,
+ ErrorType.CYCLE,
+ ErrorType.CALC,
+] as const;
+
export class Indirect extends BaseFunction {
override minParams = 1;
@@ -80,6 +92,11 @@ export class Indirect extends BaseFunction {
return ErrorValueObject.create(ErrorType.REF);
}
+ const embeddedError = this._matchErrorLiteral(refTextValue);
+ if (embeddedError != null) {
+ return ErrorValueObject.create(embeddedError);
+ }
+
const refTextV = this._convertToDefinedName(refTextValue);
if (a1Value === 0) {
@@ -155,4 +172,9 @@ export class Indirect extends BaseFunction {
return formulaOrRefString;
}
+
+ private _matchErrorLiteral(refText: string) {
+ const normalizedRefText = refText.toUpperCase();
+ return INDIRECT_ERROR_LITERALS.find((errorType) => normalizedRefText.includes(errorType));
+ }
}
diff --git a/packages/engine-formula/src/functions/lookup/match/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/match/__tests__/index.spec.ts
index 184bf32879..9cb376dd15 100644
--- a/packages/engine-formula/src/functions/lookup/match/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/match/__tests__/index.spec.ts
@@ -17,7 +17,7 @@
import { describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { ArrayValueObject, transformToValueObject } from '../../../../engine/value-object/array-value-object';
-import { NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
import { FUNCTION_NAMES_LOOKUP } from '../../function-names';
import { Match } from '../index';
@@ -42,6 +42,29 @@ describe('Test match', () => {
const resultObject = testFunction.calculate(lookupValue, lookupArray);
expect(resultObject.getValue()).toBe(2);
});
+
+ it('treats an empty third argument as exact match', async () => {
+ const lookupValue = BooleanValueObject.create(true);
+ const lookupArray = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [false, false, false],
+ ]),
+ rowCount: 1,
+ columnCount: 3,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+
+ const emptyThirdArgument = NullValueObject.create();
+ const exactResult = testFunction.calculate(lookupValue, lookupArray, emptyThirdArgument);
+ const omittedResult = testFunction.calculate(lookupValue, lookupArray);
+
+ expect(exactResult.getValue()).toBe(ErrorType.NA);
+ expect(omittedResult.getValue()).toBe(3);
+ });
+
it('LookupArray asc, matchType is 1', async () => {
const lookupValue = NumberValueObject.create(5);
const lookupArray = ArrayValueObject.create({
@@ -100,6 +123,25 @@ describe('Test match', () => {
expect(resultObject.getValue()).toBe(ErrorType.NA);
});
+ it('uses strict numeric equality for exact match', async () => {
+ const lookupValue = NumberValueObject.create(5530.857777777778);
+ const lookupArray = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [5530.857777777777, 5530.857777777777, 5530.857777777778],
+ ]),
+ rowCount: 1,
+ columnCount: 3,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const matchType = NumberValueObject.create(0);
+
+ const resultObject = testFunction.calculate(lookupValue, lookupArray, matchType);
+ expect(resultObject.getValue()).toBe(3);
+ });
+
it('LookupArray asc, matchType is -1', async () => {
const lookupValue = NumberValueObject.create(5);
const lookupArray = ArrayValueObject.create({
diff --git a/packages/engine-formula/src/functions/lookup/match/index.ts b/packages/engine-formula/src/functions/lookup/match/index.ts
index ca74a3f6d0..9a9b46a9f5 100644
--- a/packages/engine-formula/src/functions/lookup/match/index.ts
+++ b/packages/engine-formula/src/functions/lookup/match/index.ts
@@ -56,7 +56,7 @@ export class Match extends BaseFunction {
return ErrorValueObject.create(ErrorType.NA);
}
- const matchTypeValue = this.getMatchTypeValue(matchType);
+ const matchTypeValue = matchType?.isNull() ? 0 : this.getMatchTypeValue(matchType);
if (matchTypeValue == null) {
return ErrorValueObject.create(ErrorType.VALUE);
diff --git a/packages/engine-formula/src/functions/lookup/sort/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/sort/__tests__/index.spec.ts
index 3d7ba64919..add445e677 100644
--- a/packages/engine-formula/src/functions/lookup/sort/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/sort/__tests__/index.spec.ts
@@ -217,6 +217,27 @@ describe('Test sort function', () => {
expect(getObjectValue(resultObject)).toStrictEqual([
['T-16-6-2', 'T-16-7-4'],
]);
+
+ const array2 = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([
+ [3, 1, 2],
+ ]),
+ rowCount: 1,
+ columnCount: 3,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const resultObject2 = testFunction.calculate(
+ array2,
+ NullValueObject.create(),
+ NullValueObject.create(),
+ BooleanValueObject.create(true)
+ );
+ expect(getObjectValue(resultObject2)).toStrictEqual([
+ [1, 2, 3],
+ ]);
});
});
});
diff --git a/packages/engine-formula/src/functions/lookup/sort/index.ts b/packages/engine-formula/src/functions/lookup/sort/index.ts
index 85357975fe..573397133c 100644
--- a/packages/engine-formula/src/functions/lookup/sort/index.ts
+++ b/packages/engine-formula/src/functions/lookup/sort/index.ts
@@ -30,13 +30,17 @@ export class Sort extends BaseFunction {
override calculate(array: BaseValueObject, sortIndex?: BaseValueObject, sortOrder?: BaseValueObject, byCol?: BaseValueObject) {
let _sortIndex = sortIndex ?? NumberValueObject.create(1);
- const _sortOrder = sortOrder ?? NumberValueObject.create(1);
+ let _sortOrder = sortOrder ?? NumberValueObject.create(1);
const _byCol = byCol ?? BooleanValueObject.create(false);
if (_sortIndex.isNull()) {
_sortIndex = NumberValueObject.create(1);
}
+ if (_sortOrder.isNull()) {
+ _sortOrder = NumberValueObject.create(1);
+ }
+
if (_byCol.isArray()) {
const byColRowCount = (_byCol as ArrayValueObject).getRowCount();
const byColColumnCount = (_byCol as ArrayValueObject).getColumnCount();
diff --git a/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts
index cbcd07a91a..a6b7b26c9e 100644
--- a/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/vlookup/__tests__/index.spec.ts
@@ -19,7 +19,7 @@ import { describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { ArrayValueObject } from '../../../../engine/value-object/array-value-object';
import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
import { getObjectValue } from '../../../util';
import { FUNCTION_NAMES_LOOKUP } from '../../function-names';
import { Vlookup } from '../index';
@@ -124,6 +124,37 @@ describe('Test vlookup', () => {
expect(getObjectValue(resultObject)).toStrictEqual([[ErrorType.NA]]);
});
+ it('Blank return cell should be returned as zero', async () => {
+ const tableArray = ArrayValueObject.createByArray([
+ [1, null],
+ ]);
+
+ const resultObject = testFunction.calculate(
+ NumberValueObject.create(1),
+ tableArray,
+ NumberValueObject.create(2),
+ NumberValueObject.create(0)
+ ) as BaseValueObject;
+
+ expect(getObjectValue(resultObject)).toStrictEqual([[0]]);
+ });
+
+ it('Blank lookup value should not match blank cells in the lookup column', async () => {
+ const tableArray = ArrayValueObject.createByArray([
+ [null, 'Blank'],
+ [0, 'Zero'],
+ ]);
+
+ const resultObject = testFunction.calculate(
+ NullValueObject.create(),
+ tableArray,
+ NumberValueObject.create(2),
+ NumberValueObject.create(0)
+ ) as BaseValueObject;
+
+ expect(getObjectValue(resultObject)).toStrictEqual([['Zero']]);
+ });
+
it('LookupValue is array, colIndexNum is single cell', async () => {
const resultObject = testFunction.calculate(
matchArrayValueObject.clone(),
diff --git a/packages/engine-formula/src/functions/lookup/vlookup/index.ts b/packages/engine-formula/src/functions/lookup/vlookup/index.ts
index 603807173c..3694bce3f9 100644
--- a/packages/engine-formula/src/functions/lookup/vlookup/index.ts
+++ b/packages/engine-formula/src/functions/lookup/vlookup/index.ts
@@ -21,7 +21,7 @@ import { ErrorType } from '../../../basics/error-type';
import { createNewArray, expandArrayValueObject } from '../../../engine/utils/array-object';
import { isSingleValueObject } from '../../../engine/utils/value-object';
import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
-import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
+import { BooleanValueObject, NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
export class Vlookup extends BaseFunction {
@@ -194,9 +194,35 @@ export class Vlookup extends BaseFunction {
rangeLookupValue: number
) {
if (rangeLookupValue === 0) {
- return this.equalSearch(value, searchArray, resultArray);
+ if (value.isNull()) {
+ return this._equalSearchBlankLookupValue(searchArray, resultArray);
+ }
+
+ return this._blankResultAsZero(this.equalSearch(value, searchArray, resultArray));
}
return this.binarySearch(value, searchArray, resultArray);
}
+
+ private _equalSearchBlankLookupValue(searchArray: ArrayValueObject, resultArray: ArrayValueObject) {
+ const zero = NumberValueObject.create(0);
+ const matched = searchArray.mapValue((value) => {
+ if (value.isNull()) {
+ return BooleanValueObject.create(false);
+ }
+
+ return value.isEqual(zero);
+ }) as ArrayValueObject;
+ const resultArrayValue = resultArray.pickRaw(matched);
+
+ return this._blankResultAsZero(resultArrayValue[0]?.[0] || ErrorValueObject.create(ErrorType.NA));
+ }
+
+ private _blankResultAsZero(value: BaseValueObject) {
+ if (value.isNull()) {
+ return NumberValueObject.create(0);
+ }
+
+ return value;
+ }
}
diff --git a/packages/engine-formula/src/functions/lookup/xlookup/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/xlookup/__tests__/index.spec.ts
index eb23fcc99a..ca2f8c14ba 100644
--- a/packages/engine-formula/src/functions/lookup/xlookup/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/lookup/xlookup/__tests__/index.spec.ts
@@ -20,6 +20,8 @@ import { ErrorType } from '../../../../basics/error-type';
import { ArrayValueObject } from '../../../../engine/value-object/array-value-object';
import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';
import { NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { Concatenate } from '../../../text/concatenate';
+import { FUNCTION_NAMES_TEXT } from '../../../text/function-names';
import { getObjectValue } from '../../../util';
import { FUNCTION_NAMES_LOOKUP } from '../../function-names';
import { Xlookup } from '../index';
@@ -105,6 +107,20 @@ describe('Test xlookup', () => {
expect(getObjectValue(resultObject).toString()).toBe('2');
});
+ it('Blank return cell should be returned as zero', async () => {
+ const tableArray = ArrayValueObject.createByArray([
+ ['A', null],
+ ]);
+
+ const resultObject = testFunction.calculate(
+ StringValueObject.create('A'),
+ tableArray.slice(undefined, [0, 1])!,
+ tableArray.slice(undefined, [1, 2])!
+ ) as BaseValueObject;
+
+ expect(getObjectValue(resultObject)).toBe(0);
+ });
+
it('Search array', async () => {
const resultObject = testFunction.calculate(
arrayValueObject2.slice(undefined, [1, 2])!,
@@ -118,6 +134,107 @@ describe('Test xlookup', () => {
]);
});
+ it('Reference-derived lookup array should use legacy implicit intersection', async () => {
+ const positionedFunction = new Xlookup(FUNCTION_NAMES_LOOKUP.XLOOKUP);
+ positionedFunction.setRefInfo('unit', 'summary', 2, 5);
+
+ const lookupValue = ArrayValueObject.createByArray([
+ ['A'],
+ ['B'],
+ ['C'],
+ ]);
+ lookupValue.setUnitId('unit');
+ lookupValue.setSheetId('source');
+ lookupValue.setCurrent(1, 1);
+
+ const resultObject = positionedFunction.calculate(
+ lookupValue,
+ ArrayValueObject.createByArray([
+ ['A'],
+ ['B'],
+ ['C'],
+ ]),
+ ArrayValueObject.createByArray([
+ [10],
+ [20],
+ [30],
+ ])
+ ) as BaseValueObject;
+
+ expect(getObjectValue(resultObject)).toBe(20);
+ });
+
+ it('Reference-derived single-cell lookup value should use the cell value directly', async () => {
+ const positionedFunction = new Xlookup(FUNCTION_NAMES_LOOKUP.XLOOKUP);
+ positionedFunction.setRefInfo('unit', 'summary', 8, 6);
+
+ const lookupValue = ArrayValueObject.createByArray([['B']]);
+ lookupValue.setUnitId('unit');
+ lookupValue.setSheetId('source');
+ lookupValue.setCurrent(8, 1);
+
+ const resultObject = positionedFunction.calculate(
+ lookupValue,
+ ArrayValueObject.createByArray([
+ ['A'],
+ ['B'],
+ ['C'],
+ ]),
+ ArrayValueObject.createByArray([
+ [10],
+ [20],
+ [30],
+ ])
+ ) as BaseValueObject;
+
+ expect(getObjectValue(resultObject)).toBe(20);
+ });
+
+ it('Reference-derived concatenated lookup array should use legacy implicit intersection', async () => {
+ const positionedFunction = new Xlookup(FUNCTION_NAMES_LOOKUP.XLOOKUP);
+ positionedFunction.setRefInfo('unit', 'scorecard', 1, 3);
+
+ const laneIds = ArrayValueObject.createByArray([
+ ['L001'],
+ ['L002'],
+ ['L003'],
+ ]);
+ laneIds.setUnitId('unit');
+ laneIds.setSheetId('shipments');
+ laneIds.setCurrent(1, 5);
+
+ const modes = ArrayValueObject.createByArray([
+ ['Ground'],
+ ['Air'],
+ ['Ground'],
+ ]);
+ modes.setUnitId('unit');
+ modes.setSheetId('shipments');
+ modes.setCurrent(1, 6);
+
+ const concatenateFunction = new Concatenate(FUNCTION_NAMES_TEXT.CONCATENATE);
+ const lookupValue = concatenateFunction.calculate(
+ concatenateFunction.calculate(laneIds, StringValueObject.create('|')),
+ modes
+ );
+
+ const resultObject = positionedFunction.calculate(
+ lookupValue,
+ ArrayValueObject.createByArray([
+ ['L001|Ground'],
+ ['L002|Air'],
+ ['L003|Ground'],
+ ]),
+ ArrayValueObject.createByArray([
+ [0.45],
+ [1.2],
+ [0.5],
+ ])
+ ) as BaseValueObject;
+
+ expect(getObjectValue(resultObject)).toBe(0.45);
+ });
+
it('Search across multiple columns', async () => {
const resultObject = testFunction.calculate(
NumberValueObject.create(5),
diff --git a/packages/engine-formula/src/functions/lookup/xlookup/index.ts b/packages/engine-formula/src/functions/lookup/xlookup/index.ts
index 85c059d275..6aa5053077 100644
--- a/packages/engine-formula/src/functions/lookup/xlookup/index.ts
+++ b/packages/engine-formula/src/functions/lookup/xlookup/index.ts
@@ -53,8 +53,10 @@ export class Xlookup extends BaseFunction {
_searchMode = NumberValueObject.create(1);
}
- if (lookupValue.isError()) {
- return lookupValue;
+ const _lookupValue = this._legacyImplicitLookupValue(lookupValue);
+
+ if (_lookupValue.isError()) {
+ return _lookupValue;
}
const rowCountLookup = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getRowCount() : 1;
@@ -91,7 +93,7 @@ export class Xlookup extends BaseFunction {
}
return this._getResult(
- lookupValue,
+ _lookupValue,
baseValueObjectToArrayValueObject(lookupArray),
baseValueObjectToArrayValueObject(returnArray),
_ifNotFound,
@@ -145,7 +147,7 @@ export class Xlookup extends BaseFunction {
return ifNotFound;
}
- return result;
+ return this._blankResultAsZero(result);
});
}
@@ -164,7 +166,7 @@ export class Xlookup extends BaseFunction {
return ifNotFound!;
}
- return result;
+ return this._blankResultAsZero(result);
}
let axis = 0;
@@ -185,6 +187,50 @@ export class Xlookup extends BaseFunction {
return resultArray;
}
+ private _legacyImplicitLookupValue(lookupValue: BaseValueObject): BaseValueObject {
+ if (!lookupValue.isArray()) {
+ return lookupValue;
+ }
+
+ const array = lookupValue as ArrayValueObject;
+
+ if (
+ array.getUnitId() === '' ||
+ array.getSheetId() === '' ||
+ array.getCurrentRow() < 0 ||
+ array.getCurrentColumn() < 0
+ ) {
+ return lookupValue;
+ }
+
+ const startRow = array.getCurrentRow();
+ const startColumn = array.getCurrentColumn();
+ const rowCount = array.getRowCount();
+ const columnCount = array.getColumnCount();
+
+ let rowIndex = -1;
+ let columnIndex = -1;
+ if (rowCount === 1 && columnCount === 1) {
+ rowIndex = 0;
+ columnIndex = 0;
+ } else if (rowCount === 1) {
+ rowIndex = 0;
+ columnIndex = this.column - startColumn;
+ } else if (columnCount === 1) {
+ rowIndex = this.row - startRow;
+ columnIndex = 0;
+ } else {
+ rowIndex = this.row - startRow;
+ columnIndex = this.column - startColumn;
+ }
+
+ if (rowIndex < 0 || rowIndex >= rowCount || columnIndex < 0 || columnIndex >= columnCount) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ return array.get(rowIndex, columnIndex) as BaseValueObject || ErrorValueObject.create(ErrorType.VALUE);
+ }
+
private _handleExpandObject(
value: BaseValueObject,
searchArray: ArrayValueObject,
@@ -253,6 +299,14 @@ export class Xlookup extends BaseFunction {
return this.equalSearch(value, searchArray, resultArray, searchModeValue !== -1);
}
+ private _blankResultAsZero(value: BaseValueObject) {
+ if (value.isNull()) {
+ return NumberValueObject.create(0);
+ }
+
+ return value;
+ }
+
/**
* Wildcard matching and binary search cannot appear at the same time
* @param matchModeValue
diff --git a/packages/engine-formula/src/functions/math/int/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/int/__tests__/index.spec.ts
index 96c288c703..a572b87e32 100644
--- a/packages/engine-formula/src/functions/math/int/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/math/int/__tests__/index.spec.ts
@@ -33,6 +33,12 @@ describe('Test int function', () => {
expect(getObjectValue(result)).toBe(8);
});
+ it('Value is near integer from floating point arithmetic', () => {
+ const number = NumberValueObject.create(5.999999999999999);
+ const result = testFunction.calculate(number);
+ expect(getObjectValue(result)).toBe(6);
+ });
+
it('Value is number negative', () => {
const number = NumberValueObject.create(-8.9);
const result = testFunction.calculate(number);
diff --git a/packages/engine-formula/src/functions/math/int/index.ts b/packages/engine-formula/src/functions/math/int/index.ts
index d7c0bbf794..ac7b70bf0e 100644
--- a/packages/engine-formula/src/functions/math/int/index.ts
+++ b/packages/engine-formula/src/functions/math/int/index.ts
@@ -16,6 +16,7 @@
import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { stripErrorMargin } from '../../../engine/utils/math-kit';
import { NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
@@ -43,7 +44,7 @@ export class Int extends BaseFunction {
return _number;
}
- const numberValue = Math.floor(+_number.getValue());
+ const numberValue = Math.floor(stripErrorMargin(+_number.getValue()));
return NumberValueObject.create(numberValue);
}
diff --git a/packages/engine-formula/src/functions/math/sum/index.ts b/packages/engine-formula/src/functions/math/sum/index.ts
index befacab36f..4901a6a227 100644
--- a/packages/engine-formula/src/functions/math/sum/index.ts
+++ b/packages/engine-formula/src/functions/math/sum/index.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
@@ -27,6 +28,7 @@ export class Sum extends BaseFunction {
let accumulatorAll: BaseValueObject = NumberValueObject.create(0);
for (let i = 0; i < variants.length; i++) {
let variant = variants[i];
+ variant = this._legacyImplicitDerivedArray(variant);
if (variant.isString()) {
variant = variant.convertToNumberObjectValue();
@@ -53,4 +55,42 @@ export class Sum extends BaseFunction {
return accumulatorAll;
}
+
+ private _legacyImplicitDerivedArray(variant: BaseValueObject): BaseValueObject {
+ if (!variant.isArray()) {
+ return variant;
+ }
+
+ const array = variant as ArrayValueObject;
+ if (array.usesInvertedIndexCache() || !array.usesLegacyImplicitForAggregate()) {
+ return variant;
+ }
+
+ const startRow = array.getCurrentRow();
+ const startColumn = array.getCurrentColumn();
+ if (startRow < 0 || startColumn < 0) {
+ return variant;
+ }
+
+ const rowCount = array.getRowCount();
+ const columnCount = array.getColumnCount();
+ let rowIndex = -1;
+ let columnIndex = -1;
+ if (rowCount === 1) {
+ rowIndex = 0;
+ columnIndex = this.column - startColumn;
+ } else if (columnCount === 1) {
+ rowIndex = this.row - startRow;
+ columnIndex = 0;
+ } else {
+ rowIndex = this.row - startRow;
+ columnIndex = this.column - startColumn;
+ }
+
+ if (rowIndex < 0 || rowIndex >= rowCount || columnIndex < 0 || columnIndex >= columnCount) {
+ return variant;
+ }
+
+ return array.get(rowIndex, columnIndex) as BaseValueObject || variant;
+ }
}
diff --git a/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts
index 08af711d52..ca7555a8b5 100644
--- a/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts
@@ -28,6 +28,8 @@ import { IFormulaCurrentConfigService } from '../../../../services/current-data.
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';
+import { Concatenate } from '../../../text/concatenate';
+import { FUNCTION_NAMES_TEXT } from '../../../text/function-names';
import { getObjectValue } from '../../../util';
import { FUNCTION_NAMES_MATH } from '../../function-names';
import { Sumifs } from '../index';
@@ -57,6 +59,26 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 4,
t: CellValueType.NUMBER,
},
+ 4: {
+ v: 3,
+ t: CellValueType.NUMBER,
+ },
+ 5: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 6: {
+ v: '2025-01',
+ t: CellValueType.STRING,
+ },
+ 7: {
+ v: '2025-03',
+ t: CellValueType.STRING,
+ },
+ 8: {
+ v: '2025-01',
+ t: CellValueType.STRING,
+ },
},
1: {
0: {
@@ -75,6 +97,18 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 5,
t: CellValueType.NUMBER,
},
+ 4: {
+ v: 4,
+ t: CellValueType.NUMBER,
+ },
+ 5: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ 8: {
+ v: '2025-02',
+ t: CellValueType.STRING,
+ },
},
2: {
0: {
@@ -93,6 +127,10 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 6,
t: CellValueType.NUMBER,
},
+ 8: {
+ v: '2025-03',
+ t: CellValueType.STRING,
+ },
},
3: {
0: {
@@ -111,6 +149,10 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 7,
t: CellValueType.NUMBER,
},
+ 8: {
+ v: '2025-04',
+ t: CellValueType.STRING,
+ },
},
},
},
@@ -172,7 +214,8 @@ describe('Test sumifs function', () => {
);
functionService.registerExecutors(
- new Sumifs(FUNCTION_NAMES_MATH.SUMIFS)
+ new Sumifs(FUNCTION_NAMES_MATH.SUMIFS),
+ new Concatenate(FUNCTION_NAMES_TEXT.CONCATENATE)
);
calculate = (formula: string) => {
@@ -229,5 +272,15 @@ describe('Test sumifs function', () => {
[4],
]);
});
+
+ it('Supports numeric criteria concatenated from cells', async () => {
+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">="&E1,B1:B4,"<="&F1)');
+ expect(result).toBe(5);
+ });
+
+ it('Supports text dates with criteria concatenated from cells', async () => {
+ const result = await calculate('=SUMIFS(A1:A4,I1:I4,">="&G1,I1:I4,"<="&H1)');
+ expect(result).toBe(6);
+ });
});
});
diff --git a/packages/engine-formula/src/functions/math/sumproduct/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/sumproduct/__tests__/index.spec.ts
index a9aeab16a6..3929a62d1e 100644
--- a/packages/engine-formula/src/functions/math/sumproduct/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/math/sumproduct/__tests__/index.spec.ts
@@ -14,16 +14,124 @@
* limitations under the License.
*/
-import { describe, expect, it } from 'vitest';
+import type { Injector, IWorkbookData } from '@univerjs/core';
+import type { LexerNode } from '../../../../engine/analysis/lexer-node';
+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';
+import { CellValueType, LocaleType } from '@univerjs/core';
+import { beforeEach, describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
+import { Lexer } from '../../../../engine/analysis/lexer';
+import { AstTreeBuilder } from '../../../../engine/analysis/parser';
+import { Interpreter } from '../../../../engine/interpreter/interpreter';
+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';
import { ArrayValueObject, transformToValueObject } from '../../../../engine/value-object/array-value-object';
import { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';
+import { IFunctionService } from '../../../../services/function.service';
+import { IFormulaRuntimeService } from '../../../../services/runtime.service';
+import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';
+import { Divided } from '../../../meta/divided';
+import { FUNCTION_NAMES_META } from '../../../meta/function-names';
+import { Plus } from '../../../meta/plus';
import { getObjectValue } from '../../../util';
import { FUNCTION_NAMES_MATH } from '../../function-names';
+import { Sum } from '../../sum';
import { Sumproduct } from '../index';
+const getTestWorkbookData = (): IWorkbookData => ({
+ id: 'test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ cellData: {
+ 0: {
+ 0: { v: 10, t: CellValueType.NUMBER },
+ 1: { v: 100, t: CellValueType.NUMBER },
+ 2: { v: 0.1, t: CellValueType.NUMBER },
+ },
+ 1: {
+ 0: { v: 20, t: CellValueType.NUMBER },
+ 1: { v: 200, t: CellValueType.NUMBER },
+ 2: { v: 0.2, t: CellValueType.NUMBER },
+ },
+ 2: {
+ 0: { v: 30, t: CellValueType.NUMBER },
+ 1: { v: 300, t: CellValueType.NUMBER },
+ 2: { v: 0.3, t: CellValueType.NUMBER },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: [],
+ styles: {},
+});
+
describe('Test sumproduct function', () => {
const testFunction = new Sumproduct(FUNCTION_NAMES_MATH.SUMPRODUCT);
+ let get: Injector['get'];
+ let lexer: Lexer;
+ let astTreeBuilder: AstTreeBuilder;
+ let interpreter: Interpreter;
+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;
+
+ beforeEach(() => {
+ const testBed = createFunctionTestBed(getTestWorkbookData());
+
+ get = testBed.get;
+
+ lexer = get(Lexer);
+ astTreeBuilder = get(AstTreeBuilder);
+ interpreter = get(Interpreter);
+
+ const functionService = get(IFunctionService);
+ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);
+ const formulaRuntimeService = get(IFormulaRuntimeService);
+
+ formulaCurrentConfigService.load({
+ formulaData: {},
+ arrayFormulaCellData: {},
+ arrayFormulaRange: {},
+ forceCalculate: false,
+ dirtyRanges: [],
+ dirtyNameMap: {},
+ dirtyDefinedNameMap: {},
+ dirtyUnitFeatureMap: {},
+ dirtyUnitOtherFormulaMap: {},
+ excludedCell: {},
+ allUnitData: {
+ [testBed.unitId]: testBed.sheetData,
+ },
+ });
+
+ const sheetItem = testBed.sheetData[testBed.sheetId];
+
+ formulaRuntimeService.setCurrent(
+ 0,
+ 0,
+ sheetItem.rowCount,
+ sheetItem.columnCount,
+ testBed.sheetId,
+ testBed.unitId
+ );
+
+ functionService.registerExecutors(
+ new Sumproduct(FUNCTION_NAMES_MATH.SUMPRODUCT),
+ new Sum(FUNCTION_NAMES_MATH.SUM),
+ new Plus(FUNCTION_NAMES_META.PLUS),
+ new Divided(FUNCTION_NAMES_META.DIVIDED)
+ );
+
+ calculate = (formula: string) => {
+ const lexerNode = lexer.treeBuilder(formula);
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));
+
+ return getObjectValue(result);
+ };
+ });
describe('Sumproduct', () => {
it('Array1 is array, not includes error', () => {
@@ -187,5 +295,11 @@ describe('Test sumproduct function', () => {
const result = testFunction.calculate(array1, array2);
expect(getObjectValue(result, true)).toBe(1209.32171126296);
});
+
+ it('uses legacy implicit intersection for derived arrays passed to SUM', async () => {
+ const result = await calculate('=SUMPRODUCT(C1:C3,A1:A3+B1:B3)/SUM(A1:A3+B1:B3)');
+
+ expect(result).toBeCloseTo((0.1 * 110 + 0.2 * 220 + 0.3 * 330) / 110, 12);
+ });
});
});
diff --git a/packages/engine-formula/src/functions/meta/compare/__tests__/index.spec.ts b/packages/engine-formula/src/functions/meta/compare/__tests__/index.spec.ts
index 7a2a297dcb..8eb7b83273 100644
--- a/packages/engine-formula/src/functions/meta/compare/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/meta/compare/__tests__/index.spec.ts
@@ -68,6 +68,15 @@ describe('Test compare function', () => {
expect(result.getValue()).toBe(true);
});
+ it('Comparing error literal propagates error', () => {
+ const value1 = StringValueObject.create(ErrorType.DIV_BY_ZERO);
+ const value2 = StringValueObject.create('Data Error');
+
+ testFunction.setCompareType(compareToken.EQUALS);
+ const result = testFunction.calculate(value1, value2);
+ expect(result.getValue()).toBe(ErrorType.DIV_BY_ZERO);
+ });
+
it('Array contains multi types cell, compare number', () => {
const value1 = ArrayValueObject.create({
calculateValueList: transformToValueObject([
diff --git a/packages/engine-formula/src/functions/meta/compare/index.ts b/packages/engine-formula/src/functions/meta/compare/index.ts
index 0df238c25c..8f185f00c7 100644
--- a/packages/engine-formula/src/functions/meta/compare/index.ts
+++ b/packages/engine-formula/src/functions/meta/compare/index.ts
@@ -14,8 +14,11 @@
* limitations under the License.
*/
+import type { ErrorType } from '../../../basics/error-type';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ERROR_TYPE_SET } from '../../../basics/error-type';
import { compareToken } from '../../../basics/token';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
import { BaseFunction } from '../../base-function';
export class Compare extends BaseFunction {
@@ -38,6 +41,26 @@ export class Compare extends BaseFunction {
return variant2;
}
+ const variant1Error = this._coerceErrorLiteral(variant1);
+ if (variant1Error) {
+ return variant1Error;
+ }
+
+ const variant2Error = this._coerceErrorLiteral(variant2);
+ if (variant2Error) {
+ return variant2Error;
+ }
+
return variant1.compare(variant2, this._compareType);
}
+
+ private _coerceErrorLiteral(variant: BaseValueObject) {
+ const value = variant.getValue();
+
+ if (typeof value === 'string' && ERROR_TYPE_SET.has(value as ErrorType)) {
+ return ErrorValueObject.create(value as ErrorType);
+ }
+
+ return null;
+ }
}
diff --git a/packages/engine-formula/src/functions/new-excel-functions.ts b/packages/engine-formula/src/functions/new-excel-functions.ts
index aeff35988d..8b8a1c6719 100644
--- a/packages/engine-formula/src/functions/new-excel-functions.ts
+++ b/packages/engine-formula/src/functions/new-excel-functions.ts
@@ -93,6 +93,7 @@ export const NEW_EXCEL_FUNCTIONS = new Set<IFunctionNames>([
// Logical extensions
FUNCTION_NAMES_LOGICAL.IFNA,
FUNCTION_NAMES_LOGICAL.IFS,
+ FUNCTION_NAMES_LOGICAL.GROUPBY,
FUNCTION_NAMES_LOGICAL.SWITCH,
FUNCTION_NAMES_LOGICAL.XOR,
diff --git a/packages/engine-formula/src/functions/statistical/average/index.ts b/packages/engine-formula/src/functions/statistical/average/index.ts
index a0a515a530..38174ec9f1 100644
--- a/packages/engine-formula/src/functions/statistical/average/index.ts
+++ b/packages/engine-formula/src/functions/statistical/average/index.ts
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { NumberValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
@@ -28,6 +29,7 @@ export class Average extends BaseFunction {
let accumulatorCount: BaseValueObject = NumberValueObject.create(0);
for (let i = 0; i < variants.length; i++) {
let variant = variants[i];
+ variant = this._legacyImplicitDerivedArray(variant);
if (variant.isString() || variant.isBoolean()) {
variant = variant.convertToNumberObjectValue();
@@ -53,4 +55,42 @@ export class Average extends BaseFunction {
return accumulatorSum.divided(accumulatorCount);
}
+
+ private _legacyImplicitDerivedArray(variant: BaseValueObject): BaseValueObject {
+ if (!variant.isArray()) {
+ return variant;
+ }
+
+ const array = variant as ArrayValueObject;
+ if (array.usesInvertedIndexCache()) {
+ return variant;
+ }
+
+ const startRow = array.getCurrentRow();
+ const startColumn = array.getCurrentColumn();
+ if (startRow < 0 || startColumn < 0) {
+ return variant;
+ }
+
+ const rowCount = array.getRowCount();
+ const columnCount = array.getColumnCount();
+ let rowIndex = -1;
+ let columnIndex = -1;
+ if (rowCount === 1) {
+ rowIndex = 0;
+ columnIndex = this.column - startColumn;
+ } else if (columnCount === 1) {
+ rowIndex = this.row - startRow;
+ columnIndex = 0;
+ } else {
+ rowIndex = this.row - startRow;
+ columnIndex = this.column - startColumn;
+ }
+
+ if (rowIndex < 0 || rowIndex >= rowCount || columnIndex < 0 || columnIndex >= columnCount) {
+ return variant;
+ }
+
+ return array.get(rowIndex, columnIndex) as BaseValueObject || variant;
+ }
}
diff --git a/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts
index 75a4c48674..a454e46f25 100644
--- a/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts
@@ -62,6 +62,18 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 5,
t: CellValueType.NUMBER,
},
+ 5: {
+ v: '',
+ t: CellValueType.STRING,
+ },
+ 6: {
+ v: '<30d',
+ t: CellValueType.STRING,
+ },
+ 7: {
+ v: '<25|Existing Workforce',
+ t: CellValueType.STRING,
+ },
},
1: {
0: {
@@ -84,6 +96,14 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 4,
t: CellValueType.NUMBER,
},
+ 6: {
+ v: '>180d',
+ t: CellValueType.STRING,
+ },
+ 7: {
+ v: '<25|New Hire (Last 12 Months)',
+ t: CellValueType.STRING,
+ },
},
2: {
0: {
@@ -106,6 +126,18 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 44,
t: CellValueType.NUMBER,
},
+ 5: {
+ v: 2,
+ t: CellValueType.NUMBER,
+ },
+ 6: {
+ v: '31-90d',
+ t: CellValueType.STRING,
+ },
+ 7: {
+ v: '25-34|Existing Workforce',
+ t: CellValueType.STRING,
+ },
},
3: {
0: {
@@ -128,6 +160,10 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 444,
t: CellValueType.NUMBER,
},
+ 7: {
+ v: '25-34|New Hire (Last 12 Months)',
+ t: CellValueType.STRING,
+ },
},
},
},
@@ -239,5 +275,28 @@ describe('Test countif function', () => {
const result2 = await calculate(`=COUNTIF(A1:A4,${error})`);
expect(result2).toBe(0);
});
+
+ it('Counts empty strings as non-blank for not-empty criteria', async () => {
+ const result = await calculate('=COUNTIF(F1:F3,"<>")');
+ expect(result).toBe(2);
+ });
+
+ it('Treats a blank cell reference criteria as zero', async () => {
+ const result = await calculate('=COUNTIF(F1:F3,F2)');
+ expect(result).toBe(0);
+ });
+
+ it('Compares text bucket criteria with locale ordering', async () => {
+ expect(await calculate('=COUNTIF(G1:G3,"<30d")')).toBe(2);
+ expect(await calculate('=COUNTIF(G1:G3,">180d")')).toBe(1);
+ });
+
+ it('Excludes blank cells in less-than text criteria', async () => {
+ expect(await calculate('=COUNTIF(F1:F2,"<1 hour")')).toBe(0);
+ });
+
+ it('Does not include same-lower-bound numeric buckets in pipe-delimited less-than criteria', async () => {
+ expect(await calculate('=COUNTIF(H1:H4,"<25|New Hire (Last 12 Months)")')).toBe(2);
+ });
});
});
diff --git a/packages/engine-formula/src/functions/statistical/countif/index.ts b/packages/engine-formula/src/functions/statistical/countif/index.ts
index b6d44e05f0..3f64d6688e 100644
--- a/packages/engine-formula/src/functions/statistical/countif/index.ts
+++ b/packages/engine-formula/src/functions/statistical/countif/index.ts
@@ -40,6 +40,10 @@ export class Countif extends BaseFunction {
if (criteria.isReferenceObject()) {
_criteria = (criteria as BaseReferenceObject).toArrayValueObject();
+ if ((_criteria as ArrayValueObject).getRowCount() === 1 && (_criteria as ArrayValueObject).getColumnCount() === 1) {
+ const firstCriteria = (_criteria as ArrayValueObject).get(0, 0) as BaseValueObject;
+ _criteria = firstCriteria.isNull() ? NumberValueObject.create(0) : firstCriteria;
+ }
}
if (_criteria.isArray()) {
diff --git a/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts
index f2b840be68..c92fb72f0b 100644
--- a/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts
@@ -28,6 +28,14 @@ import { IFormulaCurrentConfigService } from '../../../../services/current-data.
import { IFunctionService } from '../../../../services/function.service';
import { IFormulaRuntimeService } from '../../../../services/runtime.service';
import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';
+import { FUNCTION_NAMES_LOGICAL } from '../../../logical/function-names';
+import { If } from '../../../logical/if';
+import { FUNCTION_NAMES_MATH } from '../../../math/function-names';
+import { Sumproduct } from '../../../math/sumproduct';
+import { Compare } from '../../../meta/compare';
+import { FUNCTION_NAMES_META } from '../../../meta/function-names';
+import { Minus } from '../../../meta/minus';
+import { Multiply } from '../../../meta/multiply';
import { getObjectValue } from '../../../util';
import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';
import { Countifs } from '../index';
@@ -57,6 +65,30 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 4,
t: CellValueType.NUMBER,
},
+ 4: {
+ v: 'User001',
+ t: CellValueType.STRING,
+ },
+ 5: {
+ v: 'Active',
+ t: CellValueType.STRING,
+ },
+ 6: {
+ v: 'AP_Clerk',
+ t: CellValueType.STRING,
+ },
+ 7: {
+ v: 'AP_Clerk',
+ t: CellValueType.STRING,
+ },
+ 8: {
+ v: 'Vendor_Master',
+ t: CellValueType.STRING,
+ },
+ 9: {
+ v: 'High',
+ t: CellValueType.STRING,
+ },
},
1: {
0: {
@@ -75,6 +107,30 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 5,
t: CellValueType.NUMBER,
},
+ 4: {
+ v: 'User001',
+ t: CellValueType.STRING,
+ },
+ 5: {
+ v: 'Active',
+ t: CellValueType.STRING,
+ },
+ 6: {
+ v: 'Vendor_Master',
+ t: CellValueType.STRING,
+ },
+ 7: {
+ v: 'AR_Clerk',
+ t: CellValueType.STRING,
+ },
+ 8: {
+ v: 'AR_Manager',
+ t: CellValueType.STRING,
+ },
+ 9: {
+ v: 'Low',
+ t: CellValueType.STRING,
+ },
},
2: {
0: {
@@ -93,6 +149,30 @@ const getTestWorkbookData = (): IWorkbookData => {
v: 6,
t: CellValueType.NUMBER,
},
+ 4: {
+ v: 'User001',
+ t: CellValueType.STRING,
+ },
+ 5: {
+ v: 'Active',
+ t: CellValueType.STRING,
+ },
+ 6: {
+ v: 'AR_Clerk',
+ t: CellValueType.STRING,
+ },
+ 7: {
+ v: 'Payroll_Admin',
+ t: CellValueType.STRING,
+ },
+ 8: {
+ v: 'GL_Accountant',
+ t: CellValueType.STRING,
+ },
+ 9: {
+ v: 'Low',
+ t: CellValueType.STRING,
+ },
},
3: {
0: {
@@ -112,6 +192,52 @@ const getTestWorkbookData = (): IWorkbookData => {
t: CellValueType.NUMBER,
},
},
+ 4: {
+ 0: {
+ v: 'Compa',
+ t: CellValueType.STRING,
+ },
+ 1: {
+ v: '<0.90',
+ t: CellValueType.STRING,
+ },
+ 2: {
+ v: 0,
+ t: CellValueType.NUMBER,
+ },
+ 3: {
+ v: 0.86,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 5: {
+ 0: {
+ v: 'Compa',
+ t: CellValueType.STRING,
+ },
+ 1: {
+ v: '0.90-1.00',
+ t: CellValueType.STRING,
+ },
+ 2: {
+ v: 5,
+ t: CellValueType.NUMBER,
+ },
+ },
+ 6: {
+ 0: {
+ v: 'Compa',
+ t: CellValueType.STRING,
+ },
+ 1: {
+ v: '1.00-1.10',
+ t: CellValueType.STRING,
+ },
+ 2: {
+ v: 15,
+ t: CellValueType.NUMBER,
+ },
+ },
},
},
},
@@ -172,7 +298,12 @@ describe('Test countifs function', () => {
);
functionService.registerExecutors(
- new Countifs(FUNCTION_NAMES_STATISTICAL.COUNTIFS)
+ new Countifs(FUNCTION_NAMES_STATISTICAL.COUNTIFS),
+ new Sumproduct(FUNCTION_NAMES_MATH.SUMPRODUCT),
+ new If(FUNCTION_NAMES_LOGICAL.IF),
+ new Compare(FUNCTION_NAMES_META.COMPARE),
+ new Multiply(FUNCTION_NAMES_META.MULTIPLY),
+ new Minus(FUNCTION_NAMES_META.MINUS)
);
calculate = (formula: string) => {
@@ -229,5 +360,38 @@ describe('Test countifs function', () => {
[1],
]);
});
+
+ it('Multiple array criteria are paired by position', async () => {
+ const result = await calculate('=COUNTIFS(A1:A4,">0",C1:C4,{3;5},D1:D4,{4;7})');
+ expect(result).toStrictEqual([
+ [1],
+ [0],
+ ]);
+ });
+
+ it('Array criteria remain paired inside SUMPRODUCT masks', async () => {
+ const result = await calculate('=SUMPRODUCT({0;1;1},COUNTIFS(E1:E3,"User001",F1:F3,"Active",G1:G3,{"AP_Clerk";"AR_Clerk";"Payroll_Admin"}),COUNTIFS(E1:E3,"User001",F1:F3,"Active",G1:G3,{"Vendor_Master";"AR_Manager";"GL_Accountant"}))');
+ expect(result).toBe(0);
+ });
+
+ it('COUNTIFS array results compare element-wise inside SUMPRODUCT masks', async () => {
+ const result = await calculate('=SUMPRODUCT(--({"High";"Low";"Low"}="Low"),--(COUNTIFS(E1:E3,"User001",F1:F3,"Active",G1:G3,{"AP_Clerk";"AR_Clerk";"Payroll_Admin"})>0),--(COUNTIFS(E1:E3,"User001",F1:F3,"Active",G1:G3,{"Vendor_Master";"AR_Manager";"GL_Accountant"})>0))');
+ expect(result).toBe(0);
+ });
+
+ it('COUNTIFS criteria ranges compare element-wise inside SUMPRODUCT masks', async () => {
+ const result = await calculate('=SUMPRODUCT(--(J1:J3="Low"),--(COUNTIFS(E1:E3,"User001",F1:F3,"Active",G1:G3,H1:H3)>0),--(COUNTIFS(E1:E3,"User001",F1:F3,"Active",G1:G3,I1:I3)>0))');
+ expect(result).toBe(0);
+ });
+
+ it('SUMPRODUCT uses scalar IF criteria without shifting range masks', async () => {
+ const result = await calculate('=SUMPRODUCT((A5:A7="Compa")*(B5:B7=IF(D5<0.9,"<0.90",IF(D5<1,"0.90-1.00",IF(D5<1.1,"1.00-1.10",">1.10"))))*C5:C7)');
+ expect(result).toBe(0);
+ });
+
+ it('Excludes blank cells in less-than text criteria', async () => {
+ const result = await calculate('=COUNTIFS(B5:B8,"<1 hour")');
+ expect(result).toBe(2);
+ });
});
});
diff --git a/packages/engine-formula/src/functions/statistical/countifs/index.ts b/packages/engine-formula/src/functions/statistical/countifs/index.ts
index 4a55f8160a..329b99ab16 100644
--- a/packages/engine-formula/src/functions/statistical/countifs/index.ts
+++ b/packages/engine-formula/src/functions/statistical/countifs/index.ts
@@ -38,7 +38,7 @@ export class Countifs extends BaseFunction {
criteriaMaxRowLength,
criteriaMaxColumnLength,
variants: _variants,
- } = parsePairedRangeAndCriteria(variants);
+ } = parsePairedRangeAndCriteria(this._legacyImplicitDerivedCriteria(variants));
if (isError) {
return errorObject as ErrorValueObject;
@@ -73,4 +73,44 @@ export class Countifs extends BaseFunction {
column: this.column,
});
}
+
+ private _legacyImplicitDerivedCriteria(variants: FunctionVariantType[]): FunctionVariantType[] {
+ return variants.map((variant, index) => {
+ if (index % 2 === 0 || !variant.isArray()) {
+ return variant;
+ }
+
+ const array = variant as ArrayValueObject;
+ if (array.usesInvertedIndexCache()) {
+ return variant;
+ }
+
+ const startRow = array.getCurrentRow();
+ const startColumn = array.getCurrentColumn();
+ if (startRow < 0 || startColumn < 0) {
+ return variant;
+ }
+
+ const rowCount = array.getRowCount();
+ const columnCount = array.getColumnCount();
+ let rowIndex = -1;
+ let columnIndex = -1;
+ if (rowCount === 1) {
+ rowIndex = 0;
+ columnIndex = this.column - startColumn;
+ } else if (columnCount === 1) {
+ rowIndex = this.row - startRow;
+ columnIndex = 0;
+ } else {
+ rowIndex = this.row - startRow;
+ columnIndex = this.column - startColumn;
+ }
+
+ if (rowIndex < 0 || rowIndex >= rowCount || columnIndex < 0 || columnIndex >= columnCount) {
+ return variant;
+ }
+
+ return array.get(rowIndex, columnIndex) as FunctionVariantType || variant;
+ });
+ }
}
diff --git a/packages/engine-formula/src/functions/statistical/linest/index.ts b/packages/engine-formula/src/functions/statistical/linest/index.ts
index 91280e1db6..7af63aab65 100644
--- a/packages/engine-formula/src/functions/statistical/linest/index.ts
+++ b/packages/engine-formula/src/functions/statistical/linest/index.ts
@@ -28,6 +28,8 @@ export class Linest extends BaseFunction {
override maxParams = 4;
+ override returnsLegacyArrayAsScalar = true;
+
override calculate(knownYs: BaseValueObject, knownXs?: BaseValueObject, constb?: BaseValueObject, stats?: BaseValueObject): BaseValueObject {
const { isError, errorObject } = checkKnownsArrayDimensions(knownYs, knownXs);
diff --git a/packages/engine-formula/src/functions/statistical/max/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/max/__tests__/index.spec.ts
index e2047035bb..315ca54fb7 100644
--- a/packages/engine-formula/src/functions/statistical/max/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/max/__tests__/index.spec.ts
@@ -146,5 +146,23 @@ describe('Test max function', () => {
const result = testFunction.calculate(var1, var2);
expect(result.getValue()).toBe(0);
});
+
+ it('uses raw double ordering for close numeric array values', () => {
+ const values = ArrayValueObject.create({
+ calculateValueList: transformToValueObject([[
+ 5530.857777777777,
+ 5530.857777777777,
+ 5530.857777777778,
+ ]]),
+ rowCount: 1,
+ columnCount: 3,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ const result = testFunction.calculate(values);
+ expect(result.getValue()).toBe(5530.857777777778);
+ });
});
});
diff --git a/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts
index df33fdadd3..5f7e3027dc 100644
--- a/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts
@@ -171,9 +171,7 @@ describe('Test maxifs function', () => {
testBed.unitId
);
- functionService.registerExecutors(
- new Maxifs(FUNCTION_NAMES_STATISTICAL.MAXIFS)
- );
+ functionService.registerExecutors(new Maxifs(FUNCTION_NAMES_STATISTICAL.MAXIFS));
calculate = (formula: string) => {
const lexerNode = lexer.treeBuilder(formula);
@@ -192,6 +190,11 @@ describe('Test maxifs function', () => {
expect(result).toBe(4);
});
+ it('Value is zero when no cells match criteria', async () => {
+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">9")');
+ expect(result).toBe(0);
+ });
+
it('Value is array', async () => {
const result = await calculate('=MAXIFS({1;2;3;4},B1:B4,">3")');
expect(result).toBe(ErrorType.VALUE);
diff --git a/packages/engine-formula/src/functions/statistical/median/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/median/__tests__/index.spec.ts
index 4cf0f6b050..b2a35f032a 100644
--- a/packages/engine-formula/src/functions/statistical/median/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/median/__tests__/index.spec.ts
@@ -59,7 +59,10 @@ describe('Test median function', () => {
expect(getObjectValue(result2)).toStrictEqual(ErrorType.NAME);
const result3 = testFunction.calculate(number, number2, number3, number6);
- expect(getObjectValue(result3)).toStrictEqual(0);
+ expect(getObjectValue(result3)).toStrictEqual(1);
+
+ const result4 = testFunction.calculate(BooleanValueObject.create(false));
+ expect(getObjectValue(result4)).toStrictEqual(0);
});
it('Value is not has number', () => {
diff --git a/packages/engine-formula/src/functions/statistical/median/index.ts b/packages/engine-formula/src/functions/statistical/median/index.ts
index 11eb2eab04..253e190a2b 100644
--- a/packages/engine-formula/src/functions/statistical/median/index.ts
+++ b/packages/engine-formula/src/functions/statistical/median/index.ts
@@ -65,7 +65,12 @@ export class Median extends BaseFunction {
return variant;
}
- if (variant.isNull() || variant.isBoolean()) {
+ if (variant.isNull()) {
+ continue;
+ }
+
+ if (variant.isBoolean()) {
+ values.push(variant.getValue() ? 1 : 0);
continue;
}
diff --git a/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts
index 1a7018832d..76f1377d85 100644
--- a/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts
@@ -192,6 +192,11 @@ describe('Test minifs function', () => {
expect(result).toBe(3);
});
+ it('Value is zero when no cells match criteria', async () => {
+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">9")');
+ expect(result).toBe(0);
+ });
+
it('Value is array', async () => {
const result = await calculate('=MINIFS({1;2;3;4},B1:B4,">3")');
expect(result).toBe(ErrorType.VALUE);
diff --git a/packages/engine-formula/src/functions/statistical/percentile-inc/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/percentile-inc/__tests__/index.spec.ts
index f33571bc0f..c48ffc4abe 100644
--- a/packages/engine-formula/src/functions/statistical/percentile-inc/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/percentile-inc/__tests__/index.spec.ts
@@ -90,6 +90,9 @@ describe('Test percentileInc function', () => {
});
const result2 = testFunction.calculate(array2, k);
expect(getObjectValue(result2)).toBe(ErrorType.NUM);
+
+ const result3 = testFunction.calculate(BooleanValueObject.create(false), k);
+ expect(getObjectValue(result3)).toBe(0);
});
it('K value test', () => {
diff --git a/packages/engine-formula/src/functions/statistical/rank-avg/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/rank-avg/__tests__/index.spec.ts
index c59af78f4e..33eb914bca 100644
--- a/packages/engine-formula/src/functions/statistical/rank-avg/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/rank-avg/__tests__/index.spec.ts
@@ -158,6 +158,11 @@ describe('Test rank function', () => {
expect(result).toStrictEqual(4.5);
});
+ it('Number matching uses tolerance for floating point noise', async () => {
+ const result = await calculate('=RANK.AVG(79.83520122378431,{79.8352012237843,81.08962868646151,80.56857259319648},0)');
+ expect(result).toStrictEqual(3);
+ });
+
it('Number value test, string/true/false/blankCell/error/null', async () => {
const result = await calculate('=RANK.AVG("test",A1:H1,0)');
expect(result).toStrictEqual(ErrorType.VALUE);
@@ -183,7 +188,7 @@ describe('Test rank function', () => {
expect(result).toStrictEqual(ErrorType.NA);
const result2 = await calculate('=RANK.AVG(A1,{1,2,3},0)');
- expect(result2).toStrictEqual(ErrorType.NA);
+ expect(result2).toStrictEqual(3);
const result3 = await calculate('=RANK.AVG(A1,A1:I1,0)');
expect(result3).toStrictEqual(ErrorType.NAME);
diff --git a/packages/engine-formula/src/functions/statistical/rank-avg/index.ts b/packages/engine-formula/src/functions/statistical/rank-avg/index.ts
index 7786614f82..f130f7ed0f 100644
--- a/packages/engine-formula/src/functions/statistical/rank-avg/index.ts
+++ b/packages/engine-formula/src/functions/statistical/rank-avg/index.ts
@@ -29,6 +29,14 @@ interface IRefType {
refNumbers: number[];
}
+function isSameRankNumber(left: number, right: number): boolean {
+ if (left === right || Number.isInteger(left) || Number.isInteger(right)) {
+ return left === right;
+ }
+ const scale = Math.max(1, Math.abs(left), Math.abs(right));
+ return Math.abs(left - right) <= Number.EPSILON * scale * 2;
+}
+
export class RankAvg extends BaseFunction {
override minParams = 2;
@@ -97,15 +105,14 @@ export class RankAvg extends BaseFunction {
}
private _getResult(numberValue: number, orderValue: number, refNumbers: number[]): BaseValueObject {
- const refOrderNumbers = refNumbers.sort((a, b) => !orderValue ? b - a : a - b);
+ const refOrderNumbers = [...refNumbers].sort((a, b) => !orderValue ? b - a : a - b);
- let index = refOrderNumbers.indexOf(numberValue);
const results = [];
- while (index >= 0) {
- const start = index + 1;
- results.push(start);
- index = refOrderNumbers.indexOf(numberValue, start);
+ for (let index = 0; index < refOrderNumbers.length; index++) {
+ if (isSameRankNumber(refOrderNumbers[index], numberValue)) {
+ results.push(index + 1);
+ }
}
if (results.length === 0) {
@@ -122,7 +129,7 @@ export class RankAvg extends BaseFunction {
let refErrorObject = ErrorValueObject.create(ErrorType.NA);
const refNumbers: number[] = [];
- if (!ref.isReferenceObject()) {
+ if (!ref.isReferenceObject() && !ref.isArray()) {
return {
refHasError: true,
refErrorObject,
@@ -130,7 +137,9 @@ export class RankAvg extends BaseFunction {
};
}
- const _ref = (ref as BaseReferenceObject).toArrayValueObject();
+ const _ref = ref.isReferenceObject()
+ ? (ref as BaseReferenceObject).toArrayValueObject()
+ : ref as ArrayValueObject;
_ref.iterator((refObject) => {
const _refObject = refObject as BaseValueObject;
diff --git a/packages/engine-formula/src/functions/statistical/rank-eq/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/rank-eq/__tests__/index.spec.ts
index 1ba6617b7f..55a2a8e349 100644
--- a/packages/engine-formula/src/functions/statistical/rank-eq/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/statistical/rank-eq/__tests__/index.spec.ts
@@ -158,6 +158,11 @@ describe('Test rank function', () => {
expect(result).toStrictEqual(4);
});
+ it('Number matching uses tolerance for floating point noise', async () => {
+ const result = await calculate('=RANK.EQ(79.83520122378431,{79.8352012237843,81.08962868646151,80.56857259319648},0)');
+ expect(result).toStrictEqual(3);
+ });
+
it('Number value test, string/true/false/blankCell/error/null', async () => {
const result = await calculate('=RANK.EQ("test",A1:H1,0)');
expect(result).toStrictEqual(ErrorType.VALUE);
@@ -183,7 +188,7 @@ describe('Test rank function', () => {
expect(result).toStrictEqual(ErrorType.NA);
const result2 = await calculate('=RANK.EQ(A1,{1,2,3},0)');
- expect(result2).toStrictEqual(ErrorType.NA);
+ expect(result2).toStrictEqual(3);
const result3 = await calculate('=RANK.EQ(A1,A1:I1,0)');
expect(result3).toStrictEqual(ErrorType.NAME);
diff --git a/packages/engine-formula/src/functions/statistical/rank-eq/index.ts b/packages/engine-formula/src/functions/statistical/rank-eq/index.ts
index aedf85f766..76d343ce19 100644
--- a/packages/engine-formula/src/functions/statistical/rank-eq/index.ts
+++ b/packages/engine-formula/src/functions/statistical/rank-eq/index.ts
@@ -29,6 +29,14 @@ interface IRefType {
refNumbers: number[];
}
+function isSameRankNumber(left: number, right: number): boolean {
+ if (left === right || Number.isInteger(left) || Number.isInteger(right)) {
+ return left === right;
+ }
+ const scale = Math.max(1, Math.abs(left), Math.abs(right));
+ return Math.abs(left - right) <= Number.EPSILON * scale * 2;
+}
+
export class RankEq extends BaseFunction {
override minParams = 2;
@@ -86,9 +94,9 @@ export class RankEq extends BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
- const refOrderNumbers = refNumbers.sort((a, b) => !orderValue ? b - a : a - b);
+ const refOrderNumbers = [...refNumbers].sort((a, b) => !orderValue ? b - a : a - b);
- const result = refOrderNumbers.indexOf(numberValue);
+ const result = refOrderNumbers.findIndex((refNumber) => isSameRankNumber(refNumber, numberValue));
if (result === -1) {
return ErrorValueObject.create(ErrorType.NA);
@@ -109,7 +117,7 @@ export class RankEq extends BaseFunction {
let refErrorObject = ErrorValueObject.create(ErrorType.NA);
const refNumbers: number[] = [];
- if (!ref.isReferenceObject()) {
+ if (!ref.isReferenceObject() && !ref.isArray()) {
return {
refHasError: true,
refErrorObject,
@@ -117,7 +125,9 @@ export class RankEq extends BaseFunction {
};
}
- const _ref = (ref as BaseReferenceObject).toArrayValueObject();
+ const _ref = ref.isReferenceObject()
+ ? (ref as BaseReferenceObject).toArrayValueObject()
+ : ref as ArrayValueObject;
_ref.iterator((refObject) => {
const _refObject = refObject as BaseValueObject;
diff --git a/packages/engine-formula/src/functions/text/concat/index.ts b/packages/engine-formula/src/functions/text/concat/index.ts
index ac6f44517b..05efaaf2e8 100644
--- a/packages/engine-formula/src/functions/text/concat/index.ts
+++ b/packages/engine-formula/src/functions/text/concat/index.ts
@@ -16,6 +16,7 @@
import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { formatValueForFormulaText } from '../../../engine/value-object/base-value-object';
import { StringValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
@@ -39,11 +40,7 @@ export class Concat extends BaseFunction {
return false; // break
}
- if (valueObject.isBoolean()) {
- concatenatedString += `${valueObject.getValue()}`.toLocaleUpperCase();
- } else if (valueObject.isString() || valueObject.isNumber()) {
- concatenatedString += valueObject.getValue();
- }
+ concatenatedString += formatValueForFormulaText(valueObject.getValue());
});
if (isError) {
@@ -51,7 +48,7 @@ export class Concat extends BaseFunction {
}
} else if (!textValue.isError() && !textValue.isNull()) {
// Direct concatenation if it's a single value
- concatenatedString += textValue.getValue();
+ concatenatedString += formatValueForFormulaText(textValue.getValue());
}
}
diff --git a/packages/engine-formula/src/functions/text/concatenate/__tests__/index.spec.ts b/packages/engine-formula/src/functions/text/concatenate/__tests__/index.spec.ts
index b7bee2f498..1963ce3ecc 100644
--- a/packages/engine-formula/src/functions/text/concatenate/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/text/concatenate/__tests__/index.spec.ts
@@ -17,7 +17,7 @@
import { describe, expect, it } from 'vitest';
import { ErrorType } from '../../../../basics/error-type';
import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';
-import { StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';
import { FUNCTION_NAMES_TEXT } from '../../function-names';
import { Concatenate } from '../index';
@@ -38,6 +38,13 @@ describe('Test concatenate function', () => {
expect(transformToValue(result.getArrayValue())).toStrictEqual([['"Hello ""World"']]);
});
+ it('Formats floating point numbers as formula text', () => {
+ const text1 = NumberValueObject.create(2790.222849999999);
+ const text2 = StringValueObject.create(' (Eff)');
+ const result = testFunction.calculate(text1, text2);
+ expect(transformToValue(result.getArrayValue())).toStrictEqual([['2790.22285 (Eff)']]);
+ });
+
it('Text1 is single cell, text2 is array', () => {
const text1 = StringValueObject.create('a');
const text2 = ArrayValueObject.create({
diff --git a/packages/engine-formula/src/functions/text/concatenate/index.ts b/packages/engine-formula/src/functions/text/concatenate/index.ts
index c1a868242b..711460173d 100644
--- a/packages/engine-formula/src/functions/text/concatenate/index.ts
+++ b/packages/engine-formula/src/functions/text/concatenate/index.ts
@@ -18,7 +18,7 @@ import type { ArrayValueObject } from '../../../engine/value-object/array-value-
import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
import { ErrorType } from '../../../basics/error-type';
import { expandArrayValueObject } from '../../../engine/utils/array-object';
-import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorValueObject, formatValueForFormulaText } from '../../../engine/value-object/base-value-object';
import { StringValueObject } from '../../../engine/value-object/primitive-object';
import { BaseFunction } from '../../base-function';
@@ -43,6 +43,19 @@ export class Concatenate extends BaseFunction {
});
let result: BaseValueObject | null = null;
+ const referenceSource = textValues.find((textValue) => {
+ if (!textValue.isArray()) {
+ return false;
+ }
+
+ const arrayValue = textValue as ArrayValueObject;
+ return (
+ arrayValue.getUnitId() !== '' &&
+ arrayValue.getSheetId() !== '' &&
+ arrayValue.getCurrentRow() >= 0 &&
+ arrayValue.getCurrentColumn() >= 0
+ );
+ }) as ArrayValueObject | undefined;
for (const textValue of textValues) {
const textValueArray = expandArrayValueObject(maxRowLength, maxColumnLength, textValue, ErrorValueObject.create(ErrorType.NA));
@@ -57,19 +70,8 @@ export class Concatenate extends BaseFunction {
return textValueObject;
}
- let resultValue = resultValueObject?.getValue();
- let textValue = textValueObject?.getValue();
-
- if (resultValueObject?.isBoolean()) {
- resultValue = `${resultValue}`.toLocaleUpperCase();
- }
-
- if (textValueObject?.isBoolean()) {
- textValue = `${textValue}`.toLocaleUpperCase();
- }
-
- const resultValueObjectString = resultValueObject?.isNull() ? '' : resultValue ?? '';
- const textValueObjectString = textValueObject?.isNull() ? '' : textValue ?? '';
+ const resultValueObjectString = resultValueObject?.isNull() ? '' : formatValueForFormulaText(resultValueObject?.getValue() ?? null);
+ const textValueObjectString = textValueObject?.isNull() ? '' : formatValueForFormulaText(textValueObject?.getValue() ?? null);
return StringValueObject.create(`${resultValueObjectString}${textValueObjectString}`);
});
@@ -79,6 +81,13 @@ export class Concatenate extends BaseFunction {
return ErrorValueObject.create(ErrorType.VALUE);
}
+ if (referenceSource && result.isArray()) {
+ const resultArray = result as ArrayValueObject;
+ resultArray.setUnitId(referenceSource.getUnitId());
+ resultArray.setSheetId(referenceSource.getSheetId());
+ resultArray.setCurrent(referenceSource.getCurrentRow(), referenceSource.getCurrentColumn());
+ }
+
return result;
}
}
diff --git a/packages/engine-formula/src/functions/text/function-map.ts b/packages/engine-formula/src/functions/text/function-map.ts
index 32eb2c9a2e..b9b2799c40 100644
--- a/packages/engine-formula/src/functions/text/function-map.ts
+++ b/packages/engine-formula/src/functions/text/function-map.ts
@@ -89,6 +89,7 @@ export const functionText = [
[Numbervalue, FUNCTION_NAMES_TEXT.NUMBERVALUE],
[Regexextract, FUNCTION_NAMES_TEXT.REGEXEXTRACT],
[Regexmatch, FUNCTION_NAMES_TEXT.REGEXMATCH],
+ [Regexmatch, FUNCTION_NAMES_TEXT.REGEXTEST],
[Regexreplace, FUNCTION_NAMES_TEXT.REGEXREPLACE],
[Proper, FUNCTION_NAMES_TEXT.PROPER],
[Replace, FUNCTION_NAMES_TEXT.REPLACE],
diff --git a/packages/engine-formula/src/functions/text/function-names.ts b/packages/engine-formula/src/functions/text/function-names.ts
index 7e59d28606..24ac7d5c76 100644
--- a/packages/engine-formula/src/functions/text/function-names.ts
+++ b/packages/engine-formula/src/functions/text/function-names.ts
@@ -42,6 +42,7 @@ export enum FUNCTION_NAMES_TEXT {
PROPER = 'PROPER',
REGEXEXTRACT = 'REGEXEXTRACT',
REGEXMATCH = 'REGEXMATCH',
+ REGEXTEST = 'REGEXTEST',
REGEXREPLACE = 'REGEXREPLACE',
REPLACE = 'REPLACE',
REPLACEB = 'REPLACEB',
diff --git a/packages/engine-formula/src/functions/text/regexmatch/__tests__/index.spec.ts b/packages/engine-formula/src/functions/text/regexmatch/__tests__/index.spec.ts
index 65adfd1903..5a3472fa2e 100644
--- a/packages/engine-formula/src/functions/text/regexmatch/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/text/regexmatch/__tests__/index.spec.ts
@@ -104,5 +104,12 @@ describe('Test regexmatch function', () => {
result = testFunction.calculate(text, regularExpression); ;
expect(getObjectValue(result)).toStrictEqual(true);
});
+
+ it('supports REGEXTEST positive lookahead password patterns', () => {
+ const regularExpression = StringValueObject.create('^(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*[^\\w\\s])[^\\s]{8,15}$');
+
+ expect(getObjectValue(testFunction.calculate(StringValueObject.create('Passw0rd!'), regularExpression))).toStrictEqual(true);
+ expect(getObjectValue(testFunction.calculate(StringValueObject.create('password'), regularExpression))).toStrictEqual(false);
+ });
});
});
diff --git a/packages/engine-formula/src/functions/text/text/__tests__/index.spec.ts b/packages/engine-formula/src/functions/text/text/__tests__/index.spec.ts
index e5b6744176..bfd7a8ed2a 100644
--- a/packages/engine-formula/src/functions/text/text/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/text/text/__tests__/index.spec.ts
@@ -74,6 +74,14 @@ describe('Test text function', () => {
expect(getObjectValue(result)).toBe(expectedWeekday);
});
+ it('Text normalizes Excel Swedish weekday token to English weekday', () => {
+ const text1 = NumberValueObject.create(44926);
+ const formatText = StringValueObject.create('\u00C5\u00C5\u00C5\u00C5-MM-DD');
+ const result = testFunction.calculate(text1, formatText);
+
+ expect(getObjectValue(result)).toBe('Saturday-12-31');
+ });
+
it('Text is array, format text is array', () => {
const text1 = new ArrayValueObject({
calculateValueList: transformToValueObject([[1, ' ', 1.23, true, false, null, 0, '100', '2.34', 'test', -3, ErrorType.NAME]]),
diff --git a/packages/engine-formula/src/functions/text/text/index.ts b/packages/engine-formula/src/functions/text/text/index.ts
index 9caf280973..3b83da4c85 100644
--- a/packages/engine-formula/src/functions/text/text/index.ts
+++ b/packages/engine-formula/src/functions/text/text/index.ts
@@ -101,8 +101,9 @@ export class Text extends BaseFunction {
}
const formatTextValueString = `${formatTextValue.getValue()}`;
+ const normalizedFormatTextValueString = normalizeExcelWeekdayFormat(formatTextValueString);
- const previewText = getFormatPreview(formatTextValueString, textValueNumber);
+ const previewText = getFormatPreview(normalizedFormatTextValueString, textValueNumber);
return StringValueObject.create(formatTextValueString === ' ' ? previewText.trimEnd() : previewText);
});
@@ -114,3 +115,11 @@ export class Text extends BaseFunction {
return resultArray;
}
}
+
+function normalizeExcelWeekdayFormat(formatText: string): string {
+ if (!formatText.includes('\u00C5')) {
+ return formatText;
+ }
+
+ return formatText.replace(/\u00C5{4,}/g, 'dddd').replace(/\u00C5{1,3}/g, 'ddd');
+}
diff --git a/packages/engine-formula/src/functions/text/textsplit/__tests__/index.spec.ts b/packages/engine-formula/src/functions/text/textsplit/__tests__/index.spec.ts
index e966d872cb..b957054747 100644
--- a/packages/engine-formula/src/functions/text/textsplit/__tests__/index.spec.ts
+++ b/packages/engine-formula/src/functions/text/textsplit/__tests__/index.spec.ts
@@ -108,6 +108,18 @@ describe('Test textsplit function', () => {
expect(getObjectValue(result7)).toStrictEqual([
['To be ', ' not to be'],
]);
+
+ const colDelimiter8 = NullValueObject.create();
+ const rowDelimiter8 = StringValueObject.create(' ');
+ const result8 = testFunction.calculate(text, colDelimiter8, rowDelimiter8);
+ expect(getObjectValue(result8)).toStrictEqual([
+ ['To'],
+ ['be'],
+ ['or'],
+ ['not'],
+ ['to'],
+ ['be'],
+ ]);
});
it('ignoreEmpty value is true', () => {
diff --git a/packages/engine-formula/src/functions/text/textsplit/index.ts b/packages/engine-formula/src/functions/text/textsplit/index.ts
index 44fd69dc4b..d0a6e63f62 100644
--- a/packages/engine-formula/src/functions/text/textsplit/index.ts
+++ b/packages/engine-formula/src/functions/text/textsplit/index.ts
@@ -34,11 +34,23 @@ export class Textsplit extends BaseFunction {
const _matchMode = matchMode ?? NumberValueObject.create(0);
const _padWith = padWith ?? StringValueObject.create(ErrorType.NA);
- const { _variant: _colDelimiter, values: colDelimiterValue } = this._getStringValues(colDelimiter);
-
const { _variant, values: rowDelimiterValue } = this._getStringValues(_rowDelimiter, false);
_rowDelimiter = _variant;
+ const allowBlankColDelimiter =
+ rowDelimiter != null && !rowDelimiter.isNull() && !_rowDelimiter.isError() && rowDelimiterValue.length > 0;
+ let _colDelimiter: BaseValueObject;
+ let colDelimiterValue: string[];
+
+ if (allowBlankColDelimiter && this._isBlankScalarDelimiter(colDelimiter)) {
+ _colDelimiter = colDelimiter;
+ colDelimiterValue = [];
+ } else {
+ const { _variant: colDelimiterVariant, values } = this._getStringValues(colDelimiter);
+ _colDelimiter = colDelimiterVariant;
+ colDelimiterValue = values;
+ }
+
const maxRowLength = Math.max(
text.isArray() ? (text as ArrayValueObject).getRowCount() : 1,
_ignoreEmpty.isArray() ? (_ignoreEmpty as ArrayValueObject).getRowCount() : 1,
@@ -213,7 +225,7 @@ export class Textsplit extends BaseFunction {
let resultColsMaxCount = 1;
let result = resultRows.map((row) => {
- let cols = row.split(colDelimiterRegExp);
+ let cols = colDelimiterValue.length > 0 ? row.split(colDelimiterRegExp) : [row];
if (ignoreEmptyValue) {
cols = cols.filter((col) => col !== '');
@@ -264,4 +276,8 @@ export class Textsplit extends BaseFunction {
return escapeRegExp(value);
}
+
+ private _isBlankScalarDelimiter(valueObject: BaseValueObject): boolean {
+ return !valueObject.isArray() && (valueObject.isNull() || `${valueObject.getValue()}` === '');
+ }
}
diff --git a/packages/engine-formula/src/functions/web/filterxml/__tests__/index.spec.ts b/packages/engine-formula/src/functions/web/filterxml/__tests__/index.spec.ts
new file mode 100644
index 0000000000..5d8968acef
--- /dev/null
+++ b/packages/engine-formula/src/functions/web/filterxml/__tests__/index.spec.ts
@@ -0,0 +1,44 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { ErrorType } from '../../../../basics/error-type';
+import { StringValueObject } from '../../../../engine/value-object/primitive-object';
+import { getObjectValue } from '../../../util';
+import { FUNCTION_NAMES_WEB } from '../../function-names';
+import { Filterxml } from '../index';
+
+describe('Test filterxml function', () => {
+ const testFunction = new Filterxml(FUNCTION_NAMES_WEB.FILTERXML);
+
+ it('extracts descendant text nodes as a column array', () => {
+ const result = testFunction.calculate(
+ StringValueObject.create('<k><m>A</m><m>B &amp; C</m></k>'),
+ StringValueObject.create('//m')
+ );
+
+ expect(getObjectValue(result)).toStrictEqual([['A'], ['B & C']]);
+ });
+
+ it('returns VALUE for unsupported xpath', () => {
+ const result = testFunction.calculate(
+ StringValueObject.create('<k><m>A</m></k>'),
+ StringValueObject.create('/k/m')
+ );
+
+ expect(getObjectValue(result)).toBe(ErrorType.VALUE);
+ });
+});
diff --git a/packages/engine-formula/src/functions/web/filterxml/index.ts b/packages/engine-formula/src/functions/web/filterxml/index.ts
new file mode 100644
index 0000000000..556911cbc9
--- /dev/null
+++ b/packages/engine-formula/src/functions/web/filterxml/index.ts
@@ -0,0 +1,99 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ErrorType } from '../../../basics/error-type';
+import { ArrayValueObject, transformToValueObject } from '../../../engine/value-object/array-value-object';
+import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { BaseFunction } from '../../base-function';
+
+export class Filterxml extends BaseFunction {
+ override minParams = 2;
+
+ override maxParams = 2;
+
+ override calculate(xml: BaseValueObject, xpath: BaseValueObject): BaseValueObject {
+ if (xml.isError()) {
+ return xml;
+ }
+
+ if (xpath.isError()) {
+ return xpath;
+ }
+
+ const tagName = getDescendantTagName(`${xpath.getValue()}`);
+ if (tagName == null) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ const values = extractTagTexts(`${xml.getValue()}`, tagName);
+ if (values.length === 0) {
+ return ErrorValueObject.create(ErrorType.VALUE);
+ }
+
+ return ArrayValueObject.create({
+ calculateValueList: transformToValueObject(values.map((value) => [value])),
+ rowCount: values.length,
+ columnCount: 1,
+ unitId: '',
+ sheetId: '',
+ row: 0,
+ column: 0,
+ });
+ }
+}
+
+function getDescendantTagName(xpath: string): string | null {
+ const text = xpath.trim();
+ if (!text.startsWith('//')) {
+ return null;
+ }
+
+ const tagName = text.slice(2).replace(/\/text\(\)$/, '').trim();
+ return /^[A-Za-z0-9_.-]+$/.test(tagName) ? tagName : null;
+}
+
+function extractTagTexts(xml: string, tagName: string): string[] {
+ const open = `<${tagName}>`;
+ const close = `</${tagName}>`;
+ const values: string[] = [];
+ let offset = 0;
+
+ while (offset < xml.length) {
+ const openIndex = xml.indexOf(open, offset);
+ if (openIndex < 0) {
+ break;
+ }
+ const valueStart = openIndex + open.length;
+ const closeIndex = xml.indexOf(close, valueStart);
+ if (closeIndex < 0) {
+ break;
+ }
+ values.push(decodeXmlEntities(xml.slice(valueStart, closeIndex)));
+ offset = closeIndex + close.length;
+ }
+
+ return values;
+}
+
+function decodeXmlEntities(value: string): string {
+ return value
+ .replace(/&lt;/g, '<')
+ .replace(/&gt;/g, '>')
+ .replace(/&amp;/g, '&')
+ .replace(/&quot;/g, '"')
+ .replace(/&apos;/g, "'");
+}
diff --git a/packages/engine-formula/src/functions/web/function-map.ts b/packages/engine-formula/src/functions/web/function-map.ts
index e93694f6b8..8c6d653d0d 100644
--- a/packages/engine-formula/src/functions/web/function-map.ts
+++ b/packages/engine-formula/src/functions/web/function-map.ts
@@ -15,8 +15,10 @@
*/
import { Encodeurl } from './encodeurl';
+import { Filterxml } from './filterxml';
import { FUNCTION_NAMES_WEB } from './function-names';
export const functionWeb = [
[Encodeurl, FUNCTION_NAMES_WEB.ENCODEURL],
+ [Filterxml, FUNCTION_NAMES_WEB.FILTERXML],
];
diff --git a/packages/engine-formula/src/models/__tests__/formula-data.model.spec.ts b/packages/engine-formula/src/models/__tests__/formula-data.model.spec.ts
index 191f098d68..9eb6cbc324 100644
--- a/packages/engine-formula/src/models/__tests__/formula-data.model.spec.ts
+++ b/packages/engine-formula/src/models/__tests__/formula-data.model.spec.ts
@@ -15,6 +15,7 @@
*/
import type { IBaseSnapshot, ICellData, Injector, IWorkbookData, Nullable, Univer } from '@univerjs/core';
+import type { IFormulaData } from '../../basics/common';
import {
BaseDataModel,
BooleanNumber,
@@ -91,6 +92,11 @@ const TEST_WORKBOOK_DATA_EXTRA: IWorkbookData = {
3: {
0: { f: '=A4' },
},
+ 4: {
+ 0: { f: '=A5', v: '' },
+ 1: { f: '=B5', v: 0 },
+ 2: { f: '=C5', v: '0' },
+ },
},
},
},
@@ -621,6 +627,181 @@ describe('Test formula data model', () => {
expect(formulaDataModel.getArrayFormulaCellData().test?.sheet1?.[3]?.[3]?.v).toBe(11);
});
+ it('should initialize array formula range and cached cells from snapshot refs', () => {
+ univer.createUnit(UniverInstanceType.UNIVER_SHEET, {
+ id: 'array-test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ name: 'Sheet1',
+ rowCount: 20,
+ columnCount: 20,
+ cellData: {
+ 5: {
+ 10: {
+ f: '=IF(A1:A6,B1,0)',
+ ref: 'K6:K11',
+ v: 0,
+ t: CellValueType.NUMBER,
+ } as ICellData & { ref: string },
+ },
+ 6: {
+ 10: {
+ ref: 'K6:K11',
+ v: -5300,
+ t: CellValueType.NUMBER,
+ } as ICellData & { ref: string },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: ['sheet1'],
+ styles: {},
+ });
+
+ formulaDataModel.getFormulaData();
+
+ expect(formulaDataModel.getArrayFormulaRange()['array-test']?.sheet1?.[5]?.[10]).toEqual({
+ startRow: 5,
+ startColumn: 10,
+ endRow: 10,
+ endColumn: 10,
+ startAbsoluteRefType: 0,
+ endAbsoluteRefType: 0,
+ rangeType: RANGE_TYPE.NORMAL,
+ });
+ expect(formulaDataModel.getArrayFormulaCellData()['array-test']?.sheet1?.[6]?.[10]?.v).toBe(-5300);
+ });
+
+ it('should not initialize a single-cell ref as an array formula range', () => {
+ univer.createUnit(UniverInstanceType.UNIVER_SHEET, {
+ id: 'single-ref-test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ name: 'Sheet1',
+ rowCount: 20,
+ columnCount: 20,
+ cellData: {
+ 11: {
+ 5: {
+ f: '=IFERROR(1/0,"")',
+ ref: 'F12',
+ } as ICellData & { ref: string },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: ['sheet1'],
+ styles: {},
+ });
+
+ formulaDataModel.getFormulaData();
+
+ expect(formulaDataModel.getArrayFormulaRange()['single-ref-test']?.sheet1?.[11]?.[5]).toBeUndefined();
+ expect(formulaDataModel.getArrayFormulaCellData()['single-ref-test']?.sheet1?.[11]?.[5]).toBeUndefined();
+ });
+
+ it('should preserve a single-cell ref for array constant formulas', () => {
+ univer.createUnit(UniverInstanceType.UNIVER_SHEET, {
+ id: 'single-array-constant-test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ name: 'Sheet1',
+ rowCount: 20,
+ columnCount: 20,
+ cellData: {
+ 0: {
+ 1: {
+ f: '={1,2;3,4}',
+ ref: 'B1',
+ } as ICellData & { ref: string },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: ['sheet1'],
+ styles: {},
+ });
+
+ formulaDataModel.getFormulaData();
+
+ expect(formulaDataModel.getArrayFormulaRange()['single-array-constant-test']?.sheet1?.[0]?.[1]).toEqual({
+ startRow: 0,
+ startColumn: 1,
+ endRow: 0,
+ endColumn: 1,
+ startAbsoluteRefType: 0,
+ endAbsoluteRefType: 0,
+ });
+ });
+
+ it('should initialize array formula range for shared formula followers with refs', () => {
+ univer.createUnit(UniverInstanceType.UNIVER_SHEET, {
+ id: 'shared-array-test',
+ appVersion: '3.0.0-alpha',
+ sheets: {
+ sheet1: {
+ id: 'sheet1',
+ name: 'Sheet1',
+ rowCount: 20,
+ columnCount: 20,
+ cellData: {
+ 5: {
+ 6: {
+ f: '=SUMIFS($D$6:$D$13,$B$6:$B$13,G5,$C$6:$C$13,$F$10:$F$14)',
+ si: '0',
+ ref: 'G6:G10',
+ v: 0,
+ t: CellValueType.NUMBER,
+ } as ICellData & { ref: string },
+ 7: {
+ si: '0',
+ ref: 'H6:H10',
+ v: 0,
+ t: CellValueType.NUMBER,
+ } as ICellData & { ref: string },
+ },
+ 6: {
+ 7: {
+ ref: 'H6:H10',
+ v: 12,
+ t: CellValueType.NUMBER,
+ } as ICellData & { ref: string },
+ },
+ },
+ },
+ },
+ locale: LocaleType.ZH_CN,
+ name: '',
+ sheetOrder: ['sheet1'],
+ styles: {},
+ });
+
+ formulaDataModel.getFormulaData();
+
+ expect(formulaDataModel.getArrayFormulaRange()['shared-array-test']?.sheet1?.[5]?.[7]).toEqual({
+ startRow: 5,
+ startColumn: 7,
+ endRow: 9,
+ endColumn: 7,
+ startAbsoluteRefType: 0,
+ endAbsoluteRefType: 0,
+ rangeType: RANGE_TYPE.NORMAL,
+ });
+ expect(formulaDataModel.getArrayFormulaCellData()['shared-array-test']?.sheet1?.[6]?.[7]?.v).toBe(12);
+ });
+
it('should merge and update image formula data', () => {
const imageMatrix = new ObjectMatrix({
1: {
@@ -753,7 +934,7 @@ describe('Test formula data model', () => {
const unitId = 'workbook-01';
const sheetId = 'sheet-0011';
- const formulaData = {
+ const formulaData: IFormulaData = {
[unitId]: {},
};
@@ -809,5 +990,61 @@ describe('Test formula data model', () => {
initSheetFormulaData(formulaData, unitId, sheetId, cellMatrix);
expect(formulaData).toStrictEqual(result);
});
+
+ it('preserves Excel shared formula ids with relative offsets', () => {
+ const unitId = 'workbook-01';
+ const sheetId = 'sheet-0011';
+
+ const formulaData: IFormulaData = {
+ [unitId]: {},
+ };
+
+ const cellValue = {
+ 5: {
+ 4: {
+ v: 0,
+ f: '=E$4+$D6',
+ si: '0',
+ },
+ 5: {
+ v: 1,
+ si: '0',
+ },
+ },
+ 8: {
+ 5: {
+ v: 2,
+ si: '0',
+ },
+ },
+ };
+
+ const cellMatrix = new ObjectMatrix<Nullable<ICellData>>(cellValue);
+
+ initSheetFormulaData(formulaData, unitId, sheetId, cellMatrix);
+
+ expect(formulaData[unitId]?.[sheetId]).toEqual({
+ 5: {
+ 4: {
+ f: '=E$4+$D6',
+ si: '0',
+ },
+ 5: {
+ f: '=E$4+$D6',
+ si: '0',
+ x: 1,
+ y: 0,
+ },
+ },
+ 8: {
+ 5: {
+ f: '=E$4+$D6',
+ si: '0',
+ x: 1,
+ y: 3,
+ },
+ },
+ });
+ });
});
});
diff --git a/packages/engine-formula/src/models/formula-data.model.ts b/packages/engine-formula/src/models/formula-data.model.ts
index 279859a3b5..0a1ed073df 100644
--- a/packages/engine-formula/src/models/formula-data.model.ts
+++ b/packages/engine-formula/src/models/formula-data.model.ts
@@ -32,6 +32,7 @@ import type {
import type { IImageFormulaInfo } from '../engine/value-object/primitive-object';
import { BooleanNumber, CellValueType, Disposable, Inject, isFormulaId, isFormulaString, IUniverInstanceService, ObjectMatrix, RANGE_TYPE, Styles, UniverInstanceType } from '@univerjs/core';
import { LexerTreeBuilder } from '../engine/analysis/lexer-tree-builder';
+import { deserializeRangeWithSheet } from '../engine/utils/reference';
import { clearArrayFormulaCellDataByCell, updateFormulaDataByCellValue } from './utils/formula-data-util';
export interface IRangeChange {
@@ -175,6 +176,7 @@ export class FormulaDataModel extends Disposable {
const cellMatrix = worksheet.getCellMatrix();
const sheetId = worksheet.getSheetId();
+ this._initSheetArrayFormulaData(unitId, sheetId, cellMatrix);
initSheetFormulaData(formulaData, unitId, sheetId, cellMatrix);
}
}
@@ -244,6 +246,7 @@ export class FormulaDataModel extends Disposable {
const cellMatrix = worksheet.getCellMatrix();
+ this._initSheetArrayFormulaData(unitId, sheetId, cellMatrix);
initSheetFormulaData(formulaData, unitId, sheetId, cellMatrix);
return formulaData[unitId][sheetId];
@@ -687,7 +690,7 @@ export class FormulaDataModel extends Disposable {
// Calculation is only required when there is only a formula and no value
const isFormula = isFormulaString(currentCell?.f) || isFormulaId(currentCell?.si);
- const noValue = currentCell?.v === undefined || currentCell?.v === null || currentCell?.v === '' || currentCell?.v === 0 || currentCell?.v === '0';
+ const noValue = currentCell?.v === undefined || currentCell?.v === null;
if (!(isFormula && noValue)) continue;
@@ -757,6 +760,80 @@ export class FormulaDataModel extends Disposable {
return formulaIdMap;
}
+
+ private _initSheetArrayFormulaData(unitId: string, sheetId: string, cellMatrix: ObjectMatrix<Nullable<ICellData>>) {
+ let arrayFormulaRangeMatrix: Nullable<ObjectMatrix<IRange>>;
+ let arrayFormulaCellDataMatrix: Nullable<ObjectMatrix<Nullable<ICellData>>>;
+ const formulaIds = new Set<string>();
+
+ cellMatrix.forValue((_, __, cell) => {
+ const formulaId = cell?.si;
+ if (isFormulaString(cell?.f) && isFormulaId(formulaId)) {
+ formulaIds.add(String(formulaId));
+ }
+ });
+
+ cellMatrix.forValue((row, column, cell) => {
+ const ref = (cell as (ICellData & { ref?: string }) | null)?.ref;
+ const formula = cell?.f;
+ const formulaId = cell?.si;
+ const hasOwnFormula = isFormulaString(formula);
+ const hasSharedFormula = isFormulaId(formulaId) && formulaIds.has(String(formulaId));
+
+ if ((!hasOwnFormula && !hasSharedFormula) || typeof ref !== 'string' || ref.length === 0) {
+ return true;
+ }
+
+ const { range } = deserializeRangeWithSheet(ref);
+ if (!Number.isFinite(range.startRow) || !Number.isFinite(range.startColumn) || !Number.isFinite(range.endRow) || !Number.isFinite(range.endColumn)) {
+ return true;
+ }
+
+ if (
+ range.startRow === row &&
+ range.endRow === row &&
+ range.startColumn === column &&
+ range.endColumn === column &&
+ !isArrayConstantFormula(formula)
+ ) {
+ return true;
+ }
+
+ if (!this._arrayFormulaRange[unitId]) {
+ this._arrayFormulaRange[unitId] = {};
+ }
+ if (!this._arrayFormulaCellData[unitId]) {
+ this._arrayFormulaCellData[unitId] = {};
+ }
+
+ arrayFormulaRangeMatrix ??= new ObjectMatrix<IRange>(this._arrayFormulaRange[unitId]?.[sheetId]);
+ arrayFormulaCellDataMatrix ??= new ObjectMatrix<Nullable<ICellData>>(this._arrayFormulaCellData[unitId]?.[sheetId]);
+
+ if (arrayFormulaRangeMatrix.getValue(row, column) == null) {
+ arrayFormulaRangeMatrix.setValue(row, column, range);
+ }
+
+ for (let r = range.startRow; r <= range.endRow; r++) {
+ for (let c = range.startColumn; c <= range.endColumn; c++) {
+ if (arrayFormulaCellDataMatrix.getValue(r, c) != null) {
+ continue;
+ }
+
+ const rangeCell = cellMatrix.getValue(r, c);
+ if (rangeCell != null) {
+ arrayFormulaCellDataMatrix.setValue(r, c, { ...rangeCell });
+ }
+ }
+ }
+ });
+
+ if (arrayFormulaRangeMatrix && this._arrayFormulaRange[unitId]) {
+ this._arrayFormulaRange[unitId]![sheetId] = arrayFormulaRangeMatrix.getData();
+ }
+ if (arrayFormulaCellDataMatrix && this._arrayFormulaCellData[unitId]) {
+ this._arrayFormulaCellData[unitId]![sheetId] = arrayFormulaCellDataMatrix.getData();
+ }
+ }
}
export function initSheetFormulaData(
@@ -808,9 +885,9 @@ export function initSheetFormulaData(
if (isFormulaId(formulaId) && !isFormulaString(formulaString)) {
const formulaInfo = formulaIdMap.get(formulaId);
if (formulaInfo) {
- const f = formulaInfo.f;
const x = c - formulaInfo.c;
const y = r - formulaInfo.r;
+ const f = formulaInfo.f;
sheetFormulaDataMatrix.setValue(r, c, { f, si: formulaId, x, y });
} else {
@@ -961,6 +1038,10 @@ function inferBaseRuntimeCellType(value: IBaseCellData['v']): CellValueType | nu
return null;
}
+function isArrayConstantFormula(formula: unknown): formula is string {
+ return typeof formula === 'string' && /^=\s*\{/.test(formula);
+}
+
function isBaseCellData(value: unknown): value is IBaseCellData {
return !!value && typeof value === 'object' && (
Object.prototype.hasOwnProperty.call(value, 'v')
diff --git a/packages/engine-formula/src/services/__tests__/calculate-formula.service.spec.ts b/packages/engine-formula/src/services/__tests__/calculate-formula.service.spec.ts
index 4abfc3c672..4879834187 100644
--- a/packages/engine-formula/src/services/__tests__/calculate-formula.service.spec.ts
+++ b/packages/engine-formula/src/services/__tests__/calculate-formula.service.spec.ts
@@ -47,6 +47,8 @@ function createService() {
},
},
})),
+ setExecuteUnitId: vi.fn(),
+ setExecuteSubUnitId: vi.fn(),
getDirtyData: vi.fn(() => ({})),
getDirtyDefinedNameMap: vi.fn(() => ({})),
};
@@ -115,6 +117,8 @@ function createService() {
loadDirtyRangesAndExcludedCell = currentConfigService.loadDirtyRangesAndExcludedCell;
getRuntimeState = currentConfigService.getRuntimeState;
getUnitData = currentConfigService.getUnitData;
+ setExecuteUnitId = currentConfigService.setExecuteUnitId;
+ setExecuteSubUnitId = currentConfigService.setExecuteSubUnitId;
getDirtyData = currentConfigService.getDirtyData;
getDirtyDefinedNameMap = currentConfigService.getDirtyDefinedNameMap;
}
diff --git a/packages/engine-formula/src/services/__tests__/defined-names.service.spec.ts b/packages/engine-formula/src/services/__tests__/defined-names.service.spec.ts
index 4dd1c44189..ecfdd56efa 100644
--- a/packages/engine-formula/src/services/__tests__/defined-names.service.spec.ts
+++ b/packages/engine-formula/src/services/__tests__/defined-names.service.spec.ts
@@ -81,6 +81,28 @@ describe('DefinedNamesService', () => {
expect(service.getDefinedNameMap('unit-2')).toBeUndefined();
});
+ it('should prefer sheet-local defined names over workbook-scope names', () => {
+ const { service } = createDefinedNamesService();
+ service.registerDefinedNames('unit-local', {
+ local: {
+ id: 'local',
+ name: 'date_begin',
+ localSheetId: 'sheet-weekly',
+ formulaOrRefString: 'Weekly!$F$4',
+ },
+ global: {
+ id: 'global',
+ name: 'date_begin',
+ localSheetId: 'AllDefaultWorkbook',
+ formulaOrRefString: 'Report!$F$4',
+ },
+ });
+
+ expect(service.getValueByName('unit-local', 'date_begin', 'sheet-weekly')?.id).toBe('local');
+ expect(service.getValueByName('unit-local', 'date_begin', 'sheet-report')?.id).toBe('global');
+ expect(service.getValueByName('unit-local', 'DATE_BEGIN')?.id).toBe('global');
+ });
+
it('should emit update/current/focus streams', () => {
const { service } = createDefinedNamesService();
let updateCount = 0;
diff --git a/packages/engine-formula/src/services/__tests__/runtime.service.spec.ts b/packages/engine-formula/src/services/__tests__/runtime.service.spec.ts
index faf2f8ee98..f15edcbd33 100644
--- a/packages/engine-formula/src/services/__tests__/runtime.service.spec.ts
+++ b/packages/engine-formula/src/services/__tests__/runtime.service.spec.ts
@@ -31,7 +31,7 @@ import { describe, expect, it } from 'vitest';
import { ErrorType } from '../../basics/error-type';
import { LexerTreeBuilder } from '../../engine/analysis/lexer-tree-builder';
import { createNewArray } from '../../engine/utils/array-object';
-import { NumberValueObject, StringValueObject } from '../../engine/value-object/primitive-object';
+import { NullValueObject, NumberValueObject, StringValueObject } from '../../engine/value-object/primitive-object';
import { FormulaDataModel } from '../../models/formula-data.model';
import { FormulaCurrentConfigService, IFormulaCurrentConfigService } from '../current-data.service';
import { HyperlinkEngineFormulaService, IHyperlinkEngineFormulaService } from '../hyperlink-engine-formula.service';
@@ -229,6 +229,11 @@ describe('FormulaRuntimeService', () => {
runtime.setRuntimeData(oneCellArray as never);
expect(runtime.getUnitData().unit?.sheet?.getValue(1, 1)?.v).toBe(5);
+ runtime.setCurrent(2, 2, 10, 10, 'sheet', 'unit');
+ const blankOneCellArray = createNewArray([[NullValueObject.create()]], 1, 1);
+ runtime.setRuntimeData(blankOneCellArray as never);
+ expect(runtime.getUnitData().unit?.sheet?.getValue(2, 2)?.v).toBe(0);
+
runtime.setCurrent(3, 3, 10, 10, 'sheet', 'unit');
const twoByTwo = createNewArray(
[
@@ -267,6 +272,36 @@ describe('FormulaRuntimeService', () => {
expect(runtime.getRuntimeArrayFormulaCellData().unit?.sheet?.getValue(9, 9)?.v).toBe(ErrorType.SPILL);
});
+ it('should return #VALUE when a declared single-cell array formula produces multiple cells', () => {
+ const { runtime, arrayFormulaRange } = createRuntimeService();
+ arrayFormulaRange.unit.sheet = {
+ 1: {
+ 1: {
+ startRow: 1,
+ startColumn: 1,
+ endRow: 1,
+ endColumn: 1,
+ },
+ },
+ };
+
+ runtime.setCurrent(1, 1, 10, 10, 'sheet', 'unit');
+ const twoByTwo = createNewArray(
+ [
+ [NumberValueObject.create(1), NumberValueObject.create(2)],
+ [NumberValueObject.create(3), NumberValueObject.create(4)],
+ ],
+ 2,
+ 2
+ );
+
+ runtime.setRuntimeData(twoByTwo as never);
+ expect(runtime.getUnitData().unit?.sheet?.getValue(1, 1)?.v).toBe(ErrorType.VALUE);
+ expect(runtime.getRuntimeClearArrayFormulaCellData().unit?.sheet?.getValue(1, 1)?.v).toBe(ErrorType.VALUE);
+ expect(runtime.getRuntimeArrayFormulaCellData().unit?.sheet?.getValue(1, 1)?.v).toBe(ErrorType.VALUE);
+ expect(runtime.getRuntimeArrayFormulaCellData().unit?.sheet?.getValue(1, 2)).toBeUndefined();
+ });
+
it('should not treat previous cells of the same array formula as spill blockers', () => {
const { runtime, unitDataMatrix, arrayFormulaCellData, arrayFormulaRange } = createRuntimeService();
arrayFormulaRange.unit.sheet = {
diff --git a/packages/engine-formula/src/services/calculate-formula.service.ts b/packages/engine-formula/src/services/calculate-formula.service.ts
index 803bec9ba1..27a2683257 100644
--- a/packages/engine-formula/src/services/calculate-formula.service.ts
+++ b/packages/engine-formula/src/services/calculate-formula.service.ts
@@ -298,7 +298,7 @@ export class CalculateFormulaService extends Disposable implements ICalculateFor
const treeCount = treeList.length;
while (treeList.length > 0) {
const tree = treeList.pop()!;
- const node = generateAstNode(tree.unitId, tree.formula, this._lexer, this._astTreeBuilder, this._currentConfigService);
+ const node = generateAstNode(tree.unitId, tree.formula, this._lexer, this._astTreeBuilder, this._currentConfigService, tree.subUnitId);
const nodeData = {
node,
refOffsetX: tree.refOffsetX,
diff --git a/packages/engine-formula/src/services/defined-names.service.ts b/packages/engine-formula/src/services/defined-names.service.ts
index cd310fc601..b6acb2ac75 100644
--- a/packages/engine-formula/src/services/defined-names.service.ts
+++ b/packages/engine-formula/src/services/defined-names.service.ts
@@ -55,7 +55,7 @@ export interface IDefinedNamesService {
getDefinedNameMap(unitId: string): Nullable<IDefinedNameMapItem>;
- getValueByName(unitId: string, name: string): Nullable<IDefinedNamesServiceParam>;
+ getValueByName(unitId: string, name: string, sheetId?: Nullable<string>): Nullable<IDefinedNamesServiceParam>;
getValueById(unitId: string, id: string): Nullable<IDefinedNamesServiceParam>;
@@ -224,7 +224,36 @@ export class DefinedNamesService extends Disposable implements IDefinedNamesServ
return this._definedNameMap[unitId];
}
- getValueByName(unitId: string, name: string) {
+ getValueByName(unitId: string, name: string, sheetId?: Nullable<string>) {
+ const nameMap = this._definedNameMap[unitId];
+ if (nameMap === undefined) {
+ return null;
+ }
+
+ if (sheetId) {
+ const normalizedName = name.toLowerCase();
+ let workbookScope: Nullable<IDefinedNamesServiceParam> = null;
+ let firstMatch: Nullable<IDefinedNamesServiceParam> = null;
+ for (const item of Object.values(nameMap)) {
+ if (item.name.toLowerCase() !== normalizedName) {
+ continue;
+ }
+ if (firstMatch == null) {
+ firstMatch = item;
+ }
+ if (item.localSheetId === sheetId) {
+ return item;
+ }
+ if (item.localSheetId === 'AllDefaultWorkbook' || item.localSheetId == null) {
+ if (workbookScope == null) {
+ workbookScope = item;
+ }
+ }
+ }
+
+ return workbookScope ?? firstMatch;
+ }
+
// Check cache first
const cachedMap = this._nameCacheMap[unitId];
if (cachedMap) {
@@ -232,19 +261,27 @@ export class DefinedNamesService extends Disposable implements IDefinedNamesServ
}
// If not in cache, traverse the nameMap
- const nameMap = this._definedNameMap[unitId];
- if (nameMap === undefined) {
- return null;
- }
-
let result = null;
+ const normalizedName = name.toLowerCase();
for (const item of Object.values(nameMap)) {
- if (item.name === name) {
+ if (
+ item.name.toLowerCase() === normalizedName &&
+ (item.localSheetId === 'AllDefaultWorkbook' || item.localSheetId == null)
+ ) {
result = item;
break;
}
}
+ if (!result) {
+ for (const item of Object.values(nameMap)) {
+ if (item.name.toLowerCase() === normalizedName) {
+ result = item;
+ break;
+ }
+ }
+ }
+
// Cache the result if found
if (result) {
this._nameCacheMap[unitId] = this._nameCacheMap[unitId] || {};
@@ -298,7 +335,10 @@ export class DefinedNamesService extends Disposable implements IDefinedNamesServ
// Cache all name mappings for this unitId
for (const item of Object.values(nameMap)) {
- this._nameCacheMap[unitId][item.name.toLowerCase()] = item;
+ const normalizedName = item.name.toLowerCase();
+ if (item.localSheetId === 'AllDefaultWorkbook' || item.localSheetId == null || this._nameCacheMap[unitId][normalizedName] == null) {
+ this._nameCacheMap[unitId][normalizedName] = item;
+ }
}
}
diff --git a/packages/engine-formula/src/services/runtime.service.ts b/packages/engine-formula/src/services/runtime.service.ts
index b2fff5b7b7..ab4287a224 100644
--- a/packages/engine-formula/src/services/runtime.service.ts
+++ b/packages/engine-formula/src/services/runtime.service.ts
@@ -39,6 +39,7 @@ import { clearNumberFormatTypeCache, clearStringToNumberPatternCache } from '../
import { clearReferenceToRangeCache } from '../engine/utils/reference-cache';
import { objectValueToCellValue } from '../engine/utils/value-object';
import { ErrorValueObject } from '../engine/value-object/base-value-object';
+import { NumberValueObject } from '../engine/value-object/primitive-object';
import { IFormulaCurrentConfigService } from './current-data.service';
import { IHyperlinkEngineFormulaService } from './hyperlink-engine-formula.service';
@@ -98,6 +99,10 @@ export interface IFormulaRuntimeService {
currentColumn: number;
+ currentRowCount: number;
+
+ currentColumnCount: number;
+
currentSubUnitId: string;
currentUnitId: string;
@@ -115,6 +120,8 @@ export interface IFormulaRuntimeService {
unitId: string
): void;
+ setFunctionRefInfoOverride(rowCount: number, columnCount: number): () => void;
+
registerFunctionDefinitionPrivacyVar(lambdaId: string, lambdaVar: Map<string, Nullable<BaseAstNode>>): void;
getFunctionDefinitionPrivacyVar(lambdaId: string): Nullable<Map<string, Nullable<BaseAstNode>>>;
@@ -209,6 +216,8 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
private _currentRowCount: number = Number.NEGATIVE_INFINITY;
private _currentColumnCount: number = Number.NEGATIVE_INFINITY;
+ private _functionRefInfoOverrideStack: Array<{ rowCount: number; columnCount: number }> = [];
+
private _currentSubUnitId: string = '';
private _currentUnitId: string = '';
@@ -265,11 +274,13 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
}
get currentRowCount() {
- return this._currentRowCount;
+ return this._functionRefInfoOverrideStack[this._functionRefInfoOverrideStack.length - 1]?.rowCount ??
+ this._currentRowCount;
}
get currentColumnCount() {
- return this._currentColumnCount;
+ return this._functionRefInfoOverrideStack[this._functionRefInfoOverrideStack.length - 1]?.columnCount ??
+ this._currentColumnCount;
}
get currentSubUnitId() {
@@ -395,6 +406,7 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
this._isCycleDependency = false;
this._totalFormulasToCalculate = 0;
this._completedFormulasCount = 0;
+ this._functionRefInfoOverrideStack = [];
this.clearReferenceAndNumberformatCache();
}
@@ -414,6 +426,14 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
this._currentUnitId = unitId;
}
+ setFunctionRefInfoOverride(rowCount: number, columnCount: number) {
+ this._functionRefInfoOverrideStack.push({ rowCount, columnCount });
+
+ return () => {
+ this._functionRefInfoOverrideStack.pop();
+ };
+ }
+
clearFunctionDefinitionPrivacyVar() {
this._functionDefinitionPrivacyVar.clear();
}
@@ -551,7 +571,10 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
* then it is not treated as an array range and is directly assigned.
*/
if (startRow === endRow && startColumn === endColumn) {
- const firstCell = objectValueRefOrArray.getFirstCell();
+ const firstCellRaw = objectValueRefOrArray.getFirstCell();
+ const firstCell = firstCellRaw.isNull()
+ ? NumberValueObject.create(0)
+ : firstCellRaw;
// TODO @Dushusir set pattern style
const valueObject = this._getValueObjectOfRuntimeData(firstCell);
sheetData.setValue(row, column, valueObject);
@@ -570,6 +593,24 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
return;
}
+ if (this._isCurrentSingleCellArrayFormulaRange(unitId, sheetId, row, column)) {
+ const errorObject = this._getValueObjectOfRuntimeData(ErrorValueObject.create(ErrorType.VALUE));
+ sheetData.setValue(row, column, errorObject);
+ clearArrayUnitData.setValue(row, column, errorObject);
+ runtimeArrayUnitData.setValue(row, column, errorObject);
+
+ CELL_INVERTED_INDEX_CACHE.set(
+ unitId,
+ sheetId,
+ column,
+ ErrorType.VALUE,
+ row,
+ true
+ );
+
+ return;
+ }
+
const arrayRange = {
startRow: row,
startColumn: column,
@@ -925,6 +966,14 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntime
return isCellOverlapping;
}
+ private _isCurrentSingleCellArrayFormulaRange(unitId: string, sheetId: string, row: number, column: number) {
+ const range = this._currentConfigService.getArrayFormulaRange()[unitId]?.[sheetId]?.[row]?.[column];
+
+ return range != null &&
+ range.startRow === range.endRow &&
+ range.startColumn === range.endColumn;
+ }
+
private _isInArrayFormulaRange(range: Nullable<IRange>, r: number, c: number) {
if (range == null) {
return false;
diff --git a/packages/sheets-drawing-ui/src/controllers/sheet-drawing-transform-affected.controller.ts b/packages/sheets-drawing-ui/src/controllers/sheet-drawing-transform-affected.controller.ts
index 74cbba118e..303d9a3b47 100644
--- a/packages/sheets-drawing-ui/src/controllers/sheet-drawing-transform-affected.controller.ts
+++ b/packages/sheets-drawing-ui/src/controllers/sheet-drawing-transform-affected.controller.ts
@@ -1465,11 +1465,11 @@ export class SheetDrawingTransformAffectedController extends Disposable implemen
const removeDrawings: IDrawingParam[] = [];
// TODO@weird94: should add a iterating function
- Object.keys(drawingMap).forEach((unitId) => {
- const subUnitMap = drawingMap[unitId];
+ Object.keys(drawingMap ?? {}).forEach((unitId) => {
+ const subUnitMap = drawingMap[unitId] ?? {};
Object.keys(subUnitMap).forEach((subUnitId) => {
- const drawingData = subUnitMap[subUnitId].data;
+ const drawingData = subUnitMap[subUnitId]?.data ?? {};
Object.keys(drawingData).forEach((drawingId) => {
if (unitId === selfUnitId) {
@@ -1492,11 +1492,11 @@ export class SheetDrawingTransformAffectedController extends Disposable implemen
const insertDrawings: IDrawingParam[] = [];
const removeDrawings: IDrawingParam[] = [];
- Object.keys(drawingMap).forEach((unitId) => {
- const subUnitMap = drawingMap[unitId];
+ Object.keys(drawingMap ?? {}).forEach((unitId) => {
+ const subUnitMap = drawingMap[unitId] ?? {};
Object.keys(subUnitMap).forEach((subUnitId) => {
- const drawingData = subUnitMap[subUnitId].data;
+ const drawingData = subUnitMap[subUnitId]?.data ?? {};
Object.keys(drawingData).forEach((drawingId) => {
if (unitId === showUnitId && subUnitId === showSubunitId) {
@@ -1561,7 +1561,7 @@ export class SheetDrawingTransformAffectedController extends Disposable implemen
private _refreshDrawingTransform(unitId: string, subUnitId: string, ranges: IRange[]) {
const sheetSkeletonParam = this._sheetSkeletonService.getSkeletonParam(unitId, subUnitId);
- const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId);
+ const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId) ?? {};
const updateDrawings: ISheetDrawing[] = [];
Object.keys(drawingData).forEach((drawingId) => {
@@ -1570,6 +1570,9 @@ export class SheetDrawingTransformAffectedController extends Disposable implemen
if (anchorType === SheetDrawingAnchorType.None) {
return true;
}
+ if (!sheetTransform) {
+ return true;
+ }
const { from, to } = sheetTransform;
const { row: fromRow, column: fromColumn } = from;