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.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
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.tsindex 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 IUnitDrawingthis._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.tsnew file mode 100644index 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.tsindex 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.tsindex 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: numbelet 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 | ISequeninterface 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, complexityprivate _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.tsindex 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.tsindex 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.tsindex 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 parametersconst { 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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-spacingdiff --git a/packages/engine-formula/src/engine/interpreter/interpreter.ts b/packages/engine-formula/src/engine/interpreter/interpreter.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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 trimconst 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.tsindex 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.tsindex 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.tsindex 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 greaterThanit('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 greaterThanOrEqualsit('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 lessThanit('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 lessThanOrEqualsit('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.tsindex 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.tsindex 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.tsindex 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 celldiff --git a/packages/engine-formula/src/engine/utils/generate-ast-node.ts b/packages/engine-formula/src/engine/utils/generate-ast-node.tsindex 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.tsindex 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.tsindex 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): IUnitRangreferenceToRangeCache.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.tsindex 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 leftdiff --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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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 lengthconst maxRowLength = Math.max(diff --git a/packages/engine-formula/src/functions/lookup/anchorarray/index.ts b/packages/engine-formula/src/functions/lookup/anchorarray/index.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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/refereimport { 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 matchModeValuediff --git a/packages/engine-formula/src/functions/math/int/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/int/__tests__/index.spec.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 extensionsFUNCTION_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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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 & 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.tsnew file mode 100644index 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(/</g, '<')+ .replace(/>/g, '>')+ .replace(/&/g, '&')+ .replace(/"/g, '"')+ .replace(/'/g, "'");+}diff --git a/packages/engine-formula/src/functions/web/function-map.ts b/packages/engine-formula/src/functions/web/function-map.tsindex 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.tsindex 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.tsindex 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 valueconst 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 | nureturn 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 ICalculateForconst 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.tsindex 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 IDefinedNamesServreturn 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 firstconst 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 foundif (result) {this._nameCacheMap[unitId] = this._nameCacheMap[unitId] || {};@@ -298,7 +335,10 @@ export class DefinedNamesService extends Disposable implements IDefinedNamesServ// Cache all name mappings for this unitIdfor (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.tsindex 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 IFormulaRuntimeprivate _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 IFormulaRuntimethis._isCycleDependency = false;this._totalFormulasToCalculate = 0;this._completedFormulasCount = 0;+ this._functionRefInfoOverrideStack = [];this.clearReferenceAndNumberformatCache();}@@ -414,6 +426,14 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntimethis._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 styleconst valueObject = this._getValueObjectOfRuntimeData(firstCell);sheetData.setValue(row, column, valueObject);@@ -570,6 +593,24 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntimereturn;}+ 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 IFormulaRuntimereturn 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.tsindex 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 implemenconst 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 implemenconst 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 implemenprivate _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 implemenif (anchorType === SheetDrawingAnchorType.None) {return true;}+ if (!sheetTransform) {+ return true;+ }const { from, to } = sheetTransform;const { row: fromRow, column: fromColumn } = from;