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
perf(formula): calculation speed up (#3738)
Univercea4571fc0ba
diff --git a/packages/core/src/shared/generate.ts b/packages/core/src/shared/generate.tsindex 3c8f1a2cd7..e55a2fba76 100644--- a/packages/core/src/shared/generate.ts+++ b/packages/core/src/shared/generate.ts@@ -19,8 +19,9 @@* @param val The number or string to be judged* @returns Result*/+const $blank = /\s/g;export function isRealNum(val: string | number | boolean) {- if (val === null || val.toString().replace(/\s/g, '') === '') {+ if (val === null || val.toString().replace($blank, '') === '') {return false;}diff --git a/packages/core/src/shared/r-tree.ts b/packages/core/src/shared/r-tree.tsindex 0f909a29ed..7c0b5c59f1 100644--- a/packages/core/src/shared/r-tree.ts+++ b/packages/core/src/shared/r-tree.ts@@ -89,42 +89,28 @@ export class RTree {}}- search(search: IUnitRange): Map<string, IRTreeItem> {+ search(search: IUnitRange): IRTreeItem[] {const { unitId, sheetId: subUnitId, range } = search;const tree = this._tree.get(unitId)?.get(subUnitId);if (!tree) {- return new Map();+ return [];}- const result = new Map<string, IRTreeItem>();- tree.search({++ return tree.search({minX: range.startColumn,minY: range.startRow,maxX: range.endColumn,maxY: range.endRow,- }).forEach((item) => {- result.set(item.id, {- unitId,- sheetId: subUnitId,- id: item.id,- range: {- startColumn: item.minX,- startRow: item.minY,- endColumn: item.maxX,- endRow: item.maxY,- },- });- });- return result;+ }) as unknown as IRTreeItem[];}bulkSearch(searchList: IUnitRange[]): Map<string, IRTreeItem> {const result = new Map<string, IRTreeItem>();for (const search of searchList) {const items = this.search(search);- items.forEach((value, key) => {- result.set(key, value);- });- items.clear();+ for (const item of items) {+ result.set(item.id, item);+ }}return result;}diff --git a/packages/core/src/shared/range.ts b/packages/core/src/shared/range.tsindex e725142b45..790b710732 100644--- a/packages/core/src/shared/range.ts+++ b/packages/core/src/shared/range.ts@@ -20,6 +20,10 @@ import { AbsoluteRefType, RANGE_TYPE } from '../sheets/typedef';import { Rectangle } from './rectangle';export function moveRangeByOffset(range: IRange, refOffsetX: number, refOffsetY: number, ignoreAbsolute = false): IRange {+ if (refOffsetX === 0 && refOffsetY === 0) {+ return range;+ }+let newRange = { ...range };const startAbsoluteRefType = newRange.startAbsoluteRefType || AbsoluteRefType.NONE;diff --git a/packages/engine-formula/src/basics/__tests__/regex.spec.ts b/packages/engine-formula/src/basics/__tests__/regex.spec.tsindex 419d42ac53..3a3bcf360b 100644--- a/packages/engine-formula/src/basics/__tests__/regex.spec.ts+++ b/packages/engine-formula/src/basics/__tests__/regex.spec.ts@@ -15,39 +15,39 @@*/import { describe, expect, it } from 'vitest';-import { isReferenceString, REFERENCE_MULTIPLE_RANGE_REGEX, REFERENCE_REGEX_COLUMN, REFERENCE_REGEX_ROW, REFERENCE_SINGLE_RANGE_REGEX, REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX, REFERENCE_TABLE_SINGLE_COLUMN_REGEX } from '../regex';+import { isReferenceString, REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX, REFERENCE_TABLE_SINGLE_COLUMN_REGEX, regexTestColumn, regexTestMultipleRange, regexTestRow, regexTestSingeRange } from '../regex';describe('Test ref regex', () => {it('Single range', () => {- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('A1')).toBe(true);- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('Sheet1!A1')).toBe(true);- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('[workbook]Sheet1!A1')).toBe(true);- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('[workbook]\'Sheet-1\'!A1')).toBe(true);- expect(new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test('\'[workbook]Sheet1\'!A1')).toBe(true);+ expect(regexTestSingeRange('A1')).toBe(true);+ expect(regexTestSingeRange('Sheet1!A1')).toBe(true);+ expect(regexTestSingeRange('[workbook]Sheet1!A1')).toBe(true);+ expect(regexTestSingeRange('[workbook]\'Sheet-1\'!A1')).toBe(true);+ expect(regexTestSingeRange('\'[workbook]Sheet1\'!A1')).toBe(true);});it('Multiple range', () => {- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('A1:B10')).toBe(true);- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('Sheet1!A1:B10')).toBe(true);- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('[workbook]Sheet1!A1:B10')).toBe(true);- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('[workbook]\'Sheet-1\'!A1:B10')).toBe(true);- expect(new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test('\'[workbook]Sheet1\'!A1:B10')).toBe(true);+ expect(regexTestMultipleRange('A1:B10')).toBe(true);+ expect(regexTestMultipleRange('Sheet1!A1:B10')).toBe(true);+ expect(regexTestMultipleRange('[workbook]Sheet1!A1:B10')).toBe(true);+ expect(regexTestMultipleRange('[workbook]\'Sheet-1\'!A1:B10')).toBe(true);+ expect(regexTestMultipleRange('\'[workbook]Sheet1\'!A1:B10')).toBe(true);});it('Row range', () => {- expect(new RegExp(REFERENCE_REGEX_ROW).test('1:10')).toBe(true);- expect(new RegExp(REFERENCE_REGEX_ROW).test('Sheet1!1:10')).toBe(true);- expect(new RegExp(REFERENCE_REGEX_ROW).test('[workbook]Sheet1!1:10')).toBe(true);- expect(new RegExp(REFERENCE_REGEX_ROW).test('[workbook]\'Sheet-1\'!1:10')).toBe(true);- expect(new RegExp(REFERENCE_REGEX_ROW).test('\'[workbook]Sheet1\'!1:10')).toBe(true);+ expect(regexTestRow('1:10')).toBe(true);+ expect(regexTestRow('Sheet1!1:10')).toBe(true);+ expect(regexTestRow('[workbook]Sheet1!1:10')).toBe(true);+ expect(regexTestRow('[workbook]\'Sheet-1\'!1:10')).toBe(true);+ expect(regexTestRow('\'[workbook]Sheet1\'!1:10')).toBe(true);});it('Column range', () => {- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('A:B')).toBe(true);- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('Sheet1!A:B')).toBe(true);- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('[workbook]Sheet1!A:B')).toBe(true);- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('[workbook]\'Sheet-1\'!A:B')).toBe(true);- expect(new RegExp(REFERENCE_REGEX_COLUMN).test('\'[workbook]Sheet1\'!A:B')).toBe(true);+ expect(regexTestColumn('A:B')).toBe(true);+ expect(regexTestColumn('Sheet1!A:B')).toBe(true);+ expect(regexTestColumn('[workbook]Sheet1!A:B')).toBe(true);+ expect(regexTestColumn('[workbook]\'Sheet-1\'!A:B')).toBe(true);+ expect(regexTestColumn('\'[workbook]Sheet1\'!A:B')).toBe(true);});it('Table single range', () => {diff --git a/packages/engine-formula/src/basics/cache-lru.ts b/packages/engine-formula/src/basics/cache-lru.tsindex 57c1bac148..7eb4bf9743 100644--- a/packages/engine-formula/src/basics/cache-lru.ts+++ b/packages/engine-formula/src/basics/cache-lru.ts@@ -19,10 +19,10 @@ import { hashAlgorithm, LRUMap } from '@univerjs/core';// export const CACHE_FORMULA_AST = new LRUMap<string, AstRootNode>(100000);export class FormulaAstLRU<T> {- private _cache: LRUMap<number, T>;+ private _cache: LRUMap<string, T>;constructor(cacheCount: number) {- this._cache = new LRUMap<number, T>(cacheCount);+ this._cache = new LRUMap<string, T>(cacheCount);}set(formulaString: string, node: T) {@@ -40,6 +40,9 @@ export class FormulaAstLRU<T> {}private _hash(formulaString: string) {- return hashAlgorithm(formulaString);+ if (formulaString.length <= 64) {+ return formulaString;+ }+ return hashAlgorithm(formulaString).toString();}}diff --git a/packages/engine-formula/src/basics/object-class-type.ts b/packages/engine-formula/src/basics/object-class-type.tsindex 14bbfc21e5..a1f07e7b5e 100644--- a/packages/engine-formula/src/basics/object-class-type.ts+++ b/packages/engine-formula/src/basics/object-class-type.ts@@ -14,11 +14,13 @@* limitations under the License.*/-import { Disposable } from '@univerjs/core';--export class ObjectClassType extends Disposable {+export class ObjectClassType {pattern: string = '';+ dispose() {++ }+getPattern() {return this.pattern;}diff --git a/packages/engine-formula/src/basics/regex.ts b/packages/engine-formula/src/basics/regex.tsindex 5289252c3f..43a754a413 100644--- a/packages/engine-formula/src/basics/regex.ts+++ b/packages/engine-formula/src/basics/regex.ts@@ -22,6 +22,8 @@ import { prefixToken, suffixToken } from './token';export const UNIT_NAME_REGEX = '\\[([^\\[\\]\\/?:"<>|*\\\\]+)\\]'; // '[Book-1.xlsx]Sheet1'!$A$4 gets [Book-1.xlsx] as unitId+export const UNIT_NAME_REGEX_PRECOMPILING = new RegExp(UNIT_NAME_REGEX);+export const SHEET_NAME_REGEX = '((?![\\[\\]\\/?*\\\\]).)*!';export const ABSOLUTE_SYMBOL = '$';@@ -38,16 +40,28 @@ export const SIMPLE_SINGLE_RANGE_REGEX = `\\${ABSOLUTE_SYMBOL}?${COLUMN_REGEX}\\export const REFERENCE_MULTIPLE_RANGE_REGEX = `^(${prefixToken.AT})?${UNIT_NAME_SHEET_NAME_REGEX}${SIMPLE_SINGLE_RANGE_REGEX}${RANGE_SYMBOL}${SIMPLE_SINGLE_RANGE_REGEX}$`;+export const REFERENCE_MULTIPLE_RANGE_REGEX_PRECOMPILING = new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX);+export const REFERENCE_SINGLE_RANGE_REGEX = `^${UNIT_NAME_SHEET_NAME_REGEX}\\s*?${SIMPLE_SINGLE_RANGE_REGEX}(${suffixToken.POUND})?$`;+export const REFERENCE_SINGLE_RANGE_REGEX_PRECOMPILING = new RegExp(REFERENCE_SINGLE_RANGE_REGEX);+export const REFERENCE_REGEX_ROW = `^${UNIT_NAME_SHEET_NAME_REGEX}\\${ABSOLUTE_SYMBOL}?${ROW_REGEX}${RANGE_SYMBOL}\\${ABSOLUTE_SYMBOL}?${ROW_REGEX}$`;+export const REFERENCE_REGEX_ROW_PRECOMPILING = new RegExp(REFERENCE_REGEX_ROW);+export const REFERENCE_REGEX_COLUMN = `^${UNIT_NAME_SHEET_NAME_REGEX}\\${ABSOLUTE_SYMBOL}?${COLUMN_REGEX}${RANGE_SYMBOL}\\${ABSOLUTE_SYMBOL}?${COLUMN_REGEX}$`;+export const REFERENCE_REGEX_COLUMN_PRECOMPILING = new RegExp(REFERENCE_REGEX_COLUMN);+export const REFERENCE_REGEX_SINGLE_ROW = `^${UNIT_NAME_SHEET_NAME_REGEX}\\s*?\\${ABSOLUTE_SYMBOL}?${ROW_REGEX}$`;+export const REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING = new RegExp(REFERENCE_REGEX_SINGLE_ROW);+export const REFERENCE_REGEX_SINGLE_COLUMN = `^${UNIT_NAME_SHEET_NAME_REGEX}\\s*?\\${ABSOLUTE_SYMBOL}?${COLUMN_REGEX}$`;+export const REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING = new RegExp(REFERENCE_REGEX_SINGLE_COLUMN);+const TABLE_NAME_REGEX = '((?![~!@#$%^&*()_+<>?:,./;’,。、‘:“《》?~!@#¥%……()【】\\[\\]\\/\\\\]).)+';const TABLE_TITLE_REGEX = '\\[#.+\\]\\s*?,\\s*?';@@ -62,15 +76,59 @@ export const REFERENCE_TABLE_SINGLE_COLUMN_REGEX = `^(${UNIT_NAME_REGEX})?${TABLexport const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX = `^(${UNIT_NAME_REGEX})?${TABLE_NAME_REGEX}(\\[${TABLE_MULTIPLE_COLUMN_REGEX}\\])?$|^${TABLE_NAME_REGEX}(\\[${TABLE_TITLE_REGEX}${TABLE_MULTIPLE_COLUMN_REGEX}\\])?$`; // =Table1[[#Title],[Column1]:[Column2]] | =Table1[[Column1]:[Column2]]-export const $SUPER_TABLE_COLUMN_REGEX = '[.*?]';+export const SUPER_TABLE_COLUMN_REGEX = '[.*?]';-export const $ARRAY_VALUE_REGEX = '{.*?}';+export const SUPER_TABLE_COLUMN_REGEX_PRECOMPILING = new RegExp(SUPER_TABLE_COLUMN_REGEX, 'g');++export const ARRAY_VALUE_REGEX = '{.*?}';++export const ARRAY_VALUE_REGEX_PRECOMPILING = new RegExp(ARRAY_VALUE_REGEX, 'g');++export function regexTestSingeRange(token: string): boolean {+ REFERENCE_SINGLE_RANGE_REGEX_PRECOMPILING.lastIndex = 0;+ return REFERENCE_SINGLE_RANGE_REGEX_PRECOMPILING.test(token);+}++export function regexTestMultipleRange(token: string): boolean {+ REFERENCE_MULTIPLE_RANGE_REGEX_PRECOMPILING.lastIndex = 0;+ return REFERENCE_MULTIPLE_RANGE_REGEX_PRECOMPILING.test(token);+}++export function regexTestRow(token: string): boolean {+ REFERENCE_REGEX_ROW_PRECOMPILING.lastIndex = 0;+ return REFERENCE_REGEX_ROW_PRECOMPILING.test(token);+}++export function regexTestColumn(token: string): boolean {+ REFERENCE_REGEX_COLUMN_PRECOMPILING.lastIndex = 0;+ return REFERENCE_REGEX_COLUMN_PRECOMPILING.test(token);+}++export function regexTestSingleRow(token: string): boolean {+ REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING.lastIndex = 0;+ return REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING.test(token);+}++export function regexTestSingleColumn(token: string): boolean {+ REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING.lastIndex = 0;+ return REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING.test(token);+}++export function regexTestSuperTableColumn(token: string): boolean {+ SUPER_TABLE_COLUMN_REGEX_PRECOMPILING.lastIndex = 0;+ return SUPER_TABLE_COLUMN_REGEX_PRECOMPILING.test(token);+}++export function regexTestArrayValue(token: string): boolean {+ ARRAY_VALUE_REGEX_PRECOMPILING.lastIndex = 0;+ return ARRAY_VALUE_REGEX_PRECOMPILING.test(token);+}export function isReferenceString(refString: string) {return (- new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(refString) ||- new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test(refString) ||- new RegExp(REFERENCE_REGEX_ROW).test(refString) ||- new RegExp(REFERENCE_REGEX_COLUMN).test(refString)+ regexTestSingeRange(refString) ||+ regexTestMultipleRange(refString) ||+ regexTestRow(refString) ||+ regexTestColumn(refString));}diff --git a/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts b/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.tsindex 092582cfd4..722f416657 100644--- a/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts+++ b/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts@@ -33,6 +33,7 @@ import { IFormulaCurrentConfigService } from '../../../services/current-data.serimport { IFunctionService } from '../../../services/function.service';import { IFormulaRuntimeService } from '../../../services/runtime.service';import { Interpreter } from '../../interpreter/interpreter';+import { generateExecuteAstNodeData } from '../../utils/ast-node-tool';import { Lexer } from '../lexer';import { AstTreeBuilder } from '../parser';import { createCommandTestBed } from './create-command-test-bed';@@ -99,7 +100,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.REF);});@@ -109,7 +110,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NAME);});@@ -119,7 +120,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(1);});@@ -129,7 +130,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(-1);});@@ -139,7 +140,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(1);});@@ -149,7 +150,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).getFirstCell().getValue()).toStrictEqual(1);});@@ -159,7 +160,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).getFirstCell().getValue()).toStrictEqual(-1);});@@ -169,7 +170,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(4);});@@ -179,7 +180,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(4);});@@ -189,7 +190,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(5);});@@ -199,7 +200,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NAME);});@@ -209,7 +210,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(3);});@@ -219,7 +220,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NAME);});@@ -229,7 +230,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.VALUE);});@@ -239,7 +240,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NUM);});@@ -249,7 +250,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(10);});@@ -283,7 +284,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(0.1);});@@ -305,7 +306,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual('{1,2,3;4,5,6}');});@@ -315,7 +316,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).getFirstCell().getValue()).toStrictEqual(10);});diff --git a/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts b/packages/engine-formula/src/engine/analysis/lexer-tree-builder.tsindex 9da4f5674b..64bc150ae1 100644--- a/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts+++ b/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts@@ -21,7 +21,8 @@ import { AbsoluteRefType, Disposable, isValidRange, moveRangeByOffset, Tools } fimport { FormulaAstLRU } from '../../basics/cache-lru';import { ERROR_TYPE_COUNT_ARRAY, ERROR_TYPE_SET, ErrorType } from '../../basics/error-type';import { isFormulaLexerToken, isTokenCannotBeAtEnd, isTokenCannotPrecedeSuffixToken } from '../../basics/match-token';-import { REFERENCE_SINGLE_RANGE_REGEX } from '../../basics/regex';++import { regexTestSingeRange } from '../../basics/regex';import {matchToken,OPERATOR_TOKEN_PRIORITY,@@ -452,7 +453,7 @@ export class LexerTreeBuilder extends Disposable {if (maybeString === true && preSegmentTrim[preSegmentTrim.length - 1] === matchToken.DOUBLE_QUOTATION && preSegmentTrim[0] !== matchToken.OPEN_BRACES) {maybeString = false;this._processPushSequenceNode(sequenceNodes, sequenceNodeType.STRING, preSegment, startIndex, endIndex, deleteEndIndex);- } else if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(preSegmentNotPrefixToken) && isReferenceStringWithEffectiveColumn(preSegmentNotPrefixToken)) {+ } else if (regexTestSingeRange(preSegmentNotPrefixToken) && isReferenceStringWithEffectiveColumn(preSegmentNotPrefixToken)) {this._processPushSequenceNode(sequenceNodes, sequenceNodeType.REFERENCE, preSegment, startIndex, endIndex, deleteEndIndex);} else if (Tools.isStringNumber(preSegmentTrim)) {this._processPushSequenceNode(sequenceNodes, sequenceNodeType.NUMBER, preSegment, startIndex, endIndex, deleteEndIndex);diff --git a/packages/engine-formula/src/engine/analysis/parser.ts b/packages/engine-formula/src/engine/analysis/parser.tsindex 34b657ec67..ce8bf40e0e 100644--- a/packages/engine-formula/src/engine/analysis/parser.ts+++ b/packages/engine-formula/src/engine/analysis/parser.ts@@ -80,13 +80,8 @@ export class AstTreeBuilder extends Disposable {this._astNodeFactoryList = [];}- parse(lexerNode: LexerNode, refOffsetX: number = 0, refOffsetY: number = 0) {+ parse(lexerNode: LexerNode) {const astNode = new AstRootNode(DEFAULT_TOKEN_TYPE_ROOT);-- this._refOffsetX = refOffsetX;-- this._refOffsetY = refOffsetY;-const node = this._parse(lexerNode, astNode);/**@@ -328,7 +323,7 @@ export class AstTreeBuilder extends Disposable {break;}case NodeType.REFERENCE:- astNode.setRefOffset(this._refOffsetX, this._refOffsetY);+ // astNode.setRefOffset(this._refOffsetX, this._refOffsetY);calculateStack.push(astNode);break;case NodeType.ROOT:@@ -341,7 +336,7 @@ export class AstTreeBuilder extends Disposable {calculateStack.push(astNode);break;case NodeType.PREFIX:- this._setPrefixRefOffset(astNode);+ // this._setPrefixRefOffset(astNode);calculateStack.push(astNode);break;case NodeType.SUFFIX:@@ -360,16 +355,16 @@ export class AstTreeBuilder extends Disposable {return currentAstNode;}- private _setPrefixRefOffset(astNode: BaseAstNode) {- const children = astNode.getChildren();- const childrenCount = children.length;- for (let i = 0; i < childrenCount; i++) {- const item = children[i];- if (item.nodeType === NodeType.REFERENCE) {- item.setRefOffset(this._refOffsetX, this._refOffsetY);- }- }- }+ // private _setPrefixRefOffset(astNode: BaseAstNode) {+ // const children = astNode.getChildren();+ // const childrenCount = children.length;+ // for (let i = 0; i < childrenCount; i++) {+ // const item = children[i];+ // if (item.nodeType === NodeType.REFERENCE) {+ // item.setRefOffset(this._refOffsetX, this._refOffsetY);+ // }+ // }+ // }private _checkAstNode(item: LexerNode | string) {let astNode: Nullable<BaseAstNode> = null;diff --git a/packages/engine-formula/src/engine/ast-node/base-ast-node-factory.ts b/packages/engine-formula/src/engine/ast-node/base-ast-node-factory.tsindex d4a0b81761..9d321c77e2 100644--- a/packages/engine-formula/src/engine/ast-node/base-ast-node-factory.ts+++ b/packages/engine-formula/src/engine/ast-node/base-ast-node-factory.ts@@ -15,18 +15,21 @@*/import type { Nullable } from '@univerjs/core';-import { Disposable } from '@univerjs/core';import { LexerNode } from '../analysis/lexer-node';import { BaseAstNode } from './base-ast-node';export const DEFAULT_AST_NODE_FACTORY_Z_INDEX = 100;-export abstract class BaseAstNodeFactory extends Disposable {+export abstract class BaseAstNodeFactory {get zIndex() {return 0;}+ dispose(): void {++ }+create(param: LexerNode | string, currentRow?: number, currentColumn?: number): BaseAstNode {let token;if (param instanceof LexerNode) {diff --git a/packages/engine-formula/src/engine/ast-node/base-ast-node.ts b/packages/engine-formula/src/engine/ast-node/base-ast-node.tsindex 59ace9c597..fb0fb676d6 100644--- a/packages/engine-formula/src/engine/ast-node/base-ast-node.ts+++ b/packages/engine-formula/src/engine/ast-node/base-ast-node.ts@@ -18,7 +18,7 @@ import type { Nullable } from '@univerjs/core';import type { ErrorType } from '../../basics/error-type';import type { FunctionVariantType } from '../reference-object/base-reference-object';-import { Disposable } from '@univerjs/core';+import { AstNodePromiseType } from '../../basics/common';import { ErrorValueObject } from '../value-object/base-value-object';import { NodeType } from './node-type';@@ -31,7 +31,7 @@ interface IAstNodeNodeJson {export type LambdaPrivacyVarType = Map<string, Nullable<BaseAstNode>>;-export class BaseAstNode extends Disposable {+export class BaseAstNode {private _children: BaseAstNode[] = [];private _definedNames: Array<string> = [];@@ -46,17 +46,13 @@ export class BaseAstNode extends Disposable {private _address = false;- private _refOffsetX: number = 0;-- private _refOffsetY: number = 0;-private _isForcedCalculateFunction = false;constructor(private _token: string) {- super();+}- override dispose(): void {+ dispose(): void {this._children.forEach((node) => {node.dispose();});@@ -138,18 +134,6 @@ export class BaseAstNode extends Disposable {/* abstract */}- setRefOffset(x: number = 0, y: number = 0) {- this._refOffsetX = x;- this._refOffsetY = y;- }-- getRefOffset() {- return {- x: this._refOffsetX,- y: this._refOffsetY,- };- }-async executeAsync(): Promise<AstNodePromiseType> {/* abstract */return Promise.resolve(AstNodePromiseType.SUCCESS);diff --git a/packages/engine-formula/src/engine/ast-node/reference-node.ts b/packages/engine-formula/src/engine/ast-node/reference-node.tsindex 03bf4d9db0..f03637a9bb 100644--- a/packages/engine-formula/src/engine/ast-node/reference-node.ts+++ b/packages/engine-formula/src/engine/ast-node/reference-node.ts@@ -15,33 +15,34 @@*/import type { IAccessor, Nullable } from '@univerjs/core';-import { Inject, Injector } from '@univerjs/core';+import type { BaseReferenceObject } from '../reference-object/base-reference-object';+import { Inject, Injector } from '@univerjs/core';import { ErrorType } from '../../basics/error-type';import {- $SUPER_TABLE_COLUMN_REGEX,- REFERENCE_REGEX_SINGLE_COLUMN,- REFERENCE_REGEX_SINGLE_ROW,- REFERENCE_SINGLE_RANGE_REGEX,+ regexTestSingeRange,+ regexTestSingleColumn,+ regexTestSingleRow,} from '../../basics/regex';import { matchToken } from '../../basics/token';import { IFormulaCurrentConfigService } from '../../services/current-data.service';+import { IFunctionService } from '../../services/function.service';import { IFormulaRuntimeService } from '../../services/runtime.service';import { ISuperTableService } from '../../services/super-table.service';import { LexerNode } from '../analysis/lexer-node';-import type { BaseReferenceObject } from '../reference-object/base-reference-object';import { CellReferenceObject } from '../reference-object/cell-reference-object';import { ColumnReferenceObject } from '../reference-object/column-reference-object';import { RowReferenceObject } from '../reference-object/row-reference-object';-import { TableReferenceObject } from '../reference-object/table-reference-object';-import { ErrorValueObject } from '../value-object/base-value-object';import { prefixHandler } from '../utils/prefixHandler';-import { IFunctionService } from '../../services/function.service';+import { ErrorValueObject } from '../value-object/base-value-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';export class ReferenceNode extends BaseAstNode {+ private _refOffsetX = 0;+ private _refOffsetY = 0;+constructor(private _accessor: IAccessor,private _operatorString: string,@@ -87,6 +88,18 @@ export class ReferenceNode extends BaseAstNode {this.setValue(this._referenceObject);}}++ setRefOffset(x: number = 0, y: number = 0) {+ this._refOffsetX = x;+ this._refOffsetY = y;+ }++ getRefOffset() {+ return {+ x: this._refOffsetX,+ y: this._refOffsetY,+ };+ }}export class ReferenceNodeFactory extends BaseAstNodeFactory {@@ -123,7 +136,7 @@ export class ReferenceNodeFactory extends BaseAstNodeFactory {}// const tokenTrim = param.trim();- // if (new RegExp(REFERENCE_MULTIPLE_RANGE_REGEX).test(tokenTrim)) {+ // if (regexTestSingeRange(tokenTrim)) {// return true;// }@@ -134,36 +147,37 @@ export class ReferenceNodeFactory extends BaseAstNodeFactory {}let node: Nullable<ReferenceNode>;- if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(tokenTrim)) {+ if (regexTestSingeRange(tokenTrim)) {node = new ReferenceNode(this._injector, tokenTrim, new CellReferenceObject(tokenTrim), isPrepareMerge);} else if (isLexerNode && this._checkParentIsUnionOperator(param as LexerNode)) {- if (new RegExp(REFERENCE_REGEX_SINGLE_ROW).test(tokenTrim)) {+ if (regexTestSingleRow(tokenTrim)) {node = new ReferenceNode(this._injector, tokenTrim, new RowReferenceObject(tokenTrim), isPrepareMerge);- } else if (new RegExp(REFERENCE_REGEX_SINGLE_COLUMN).test(tokenTrim)) {+ } else if (regexTestSingleColumn(tokenTrim)) {node = new ReferenceNode(this._injector, tokenTrim, new ColumnReferenceObject(tokenTrim), isPrepareMerge);}- } else {- const unitId = this._formulaRuntimeService.currentUnitId;- // parserDataLoader.get-- const tableMap = this._superTableService.getTableMap(unitId);- const $regex = new RegExp($SUPER_TABLE_COLUMN_REGEX, 'g');- const tableName = tokenTrim.replace($regex, '');- if (!isLexerNode && tableMap?.has(tableName)) {- const columnResult = $regex.exec(tokenTrim);- let columnDataString = '';- if (columnResult) {- columnDataString = columnResult[0];- }- const tableData = tableMap.get(tableName)!;- const tableOption = this._superTableService.getTableOptionMap();- node = new ReferenceNode(- this._injector,- tokenTrim,- new TableReferenceObject(tokenTrim, tableData, columnDataString, tableOption)- );- }}+ // else {+ // const unitId = this._formulaRuntimeService.currentUnitId;+ // // parserDataLoader.get++ // const tableMap = this._superTableService.getTableMap(unitId);+ // const $regex = $SUPER_TABLE_COLUMN_REGEX_PRECOMPILING;+ // const tableName = tokenTrim.replace($regex, '');+ // if (!isLexerNode && tableMap?.has(tableName)) {+ // const columnResult = $regex.exec(tokenTrim);+ // let columnDataString = '';+ // if (columnResult) {+ // columnDataString = columnResult[0];+ // }+ // const tableData = tableMap.get(tableName)!;+ // const tableOption = this._superTableService.getTableOptionMap();+ // node = new ReferenceNode(+ // this._injector,+ // tokenTrim,+ // new TableReferenceObject(tokenTrim, tableData, columnDataString, tableOption)+ // );+ // }+ // }if (node) {if (atPrefixNode) {diff --git a/packages/engine-formula/src/engine/dependency/dependency-tree.ts b/packages/engine-formula/src/engine/dependency/dependency-tree.tsindex b8e1602826..06033c7875 100644--- a/packages/engine-formula/src/engine/dependency/dependency-tree.ts+++ b/packages/engine-formula/src/engine/dependency/dependency-tree.ts@@ -24,8 +24,9 @@ import type {import type { IFormulaDirtyData } from '../../services/current-data.service';import type { IAllRuntimeData } from '../../services/runtime.service';-import type { BaseAstNode } from '../ast-node/base-ast-node';-import { Disposable, generateRandomId } from '@univerjs/core';++import type { IExecuteAstNodeData } from '../utils/ast-node-tool';+import { generateRandomId } from '@univerjs/core';export enum FDtreeStateType {DEFAULT,@@ -42,10 +43,10 @@ export enum FDtreeStateType {* A dependency tree, capable of calculating mutual dependencies,* is used to determine the order of formula calculations.*/-export class FormulaDependencyTree extends Disposable {+export class FormulaDependencyTree {treeId: string = '';- node: Nullable<BaseAstNode>;+ nodeData: Nullable<IExecuteAstNodeData>;children: Set<FormulaDependencyTree> = new Set();@@ -74,7 +75,6 @@ export class FormulaDependencyTree extends Disposable {isCache: boolean = false;constructor(treeId?: string) {- super();if (treeId != null) {this.treeId = treeId;} else {@@ -91,9 +91,7 @@ export class FormulaDependencyTree extends Disposable {private _state = FDtreeStateType.DEFAULT;- override dispose(): void {- super.dispose();-+ dispose(): void {// this.children.forEach((tree) => {// tree.dispose();// });@@ -104,7 +102,9 @@ export class FormulaDependencyTree extends Disposable {this.parents = new Set();- this.node?.dispose();+ this.nodeData?.node.dispose();++ this.nodeData = null;}disposeWithChildren() {@@ -272,83 +272,3 @@ export class FormulaDependencyTree extends Disposable {this.parents.add(tree);}}--// interface IFormulaDependencyTreeCacheItem {-// unitRangeWithToken: IUnitRangeWithToken;-// treeList: FormulaDependencyTree[];-// }--// export class FormulaDependencyTreeCache extends Disposable {-// private _cacheItems = new Map<string, IFormulaDependencyTreeCacheItem>();--// override dispose(): void {-// this.clear();-// }--// size() {-// return this._cacheItems.size;-// }--// get length() {-// return this._cacheItems.size;-// }--// add(unitRangeWithToken: IUnitRangeWithToken, tree: FormulaDependencyTree) {-// const { token } = unitRangeWithToken;-// if (!this._cacheItems.has(token)) {-// this._cacheItems.set(token, {-// unitRangeWithToken,-// treeList: [tree],-// });-// return;-// }--// const cacheItem = this._cacheItems.get(token)!;-// cacheItem.treeList.push(tree);-// }--// clear() {-// this._cacheItems.clear();-// }--// remove(token: string, tree: FormulaDependencyTree) {-// if (!this._cacheItems.has(token)) {-// return;-// }--// const cacheItem = this._cacheItems.get(token)!;-// const index = cacheItem.treeList.indexOf(tree);-// if (index !== -1) {-// cacheItem.treeList.splice(index, 1);-// }-// }--// delete(token: string) {-// this._cacheItems.delete(token);-// }--// /**-// * Determine whether range is dependent on other trees.-// * @param dependenceTree-// */-// dependency(dependenceTree: FormulaDependencyTree) {-// this._cacheItems.forEach((cacheItem) => {-// const { unitRangeWithToken, treeList } = cacheItem;-// const { gridRange } = unitRangeWithToken;-// const { unitId, sheetId, range } = gridRange;--// if (-// dependenceTree.unitId === unitId &&-// dependenceTree.subUnitId === sheetId &&-// dependenceTree.inRangeData(range)-// ) {-// treeList.forEach((tree) => {-// if (tree === dependenceTree || tree.children.includes(dependenceTree)) {-// return true;-// }-// tree.pushChildren(dependenceTree);-// });-// }-// });-// }-// }diff --git a/packages/engine-formula/src/engine/dependency/formula-dependency.ts b/packages/engine-formula/src/engine/dependency/formula-dependency.tsindex ef901f0d62..f3f11c1212 100644--- a/packages/engine-formula/src/engine/dependency/formula-dependency.ts+++ b/packages/engine-formula/src/engine/dependency/formula-dependency.ts@@ -40,8 +40,8 @@ import { AstTreeBuilder } from '../analysis/parser';import { ErrorNode } from '../ast-node/base-ast-node';import { NodeType } from '../ast-node/node-type';import { Interpreter } from '../interpreter/interpreter';+import { generateExecuteAstNodeData, type IExecuteAstNodeData } from '../utils/ast-node-tool';import { FormulaDependencyTree } from './dependency-tree';-import { generateRandomDependencyTreeId } from './generate-tree-id';const FORMULA_CACHE_LRU_COUNT = 100000;@@ -51,6 +51,11 @@ interface IFeatureFormulaParam {featureId: string;}+function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): string {+ const idNum = dependencyManagerService.getLastTreeId() || 0;+ return idNum.toString();+}+export class FormulaDependencyGenerator extends Disposable {private _formulaASTCache = new FormulaAstLRU<AstRootNode>(FORMULA_CACHE_LRU_COUNT);private _updateRangeFlattenCache = new Map<string, Map<string, IRange[]>>();@@ -182,6 +187,8 @@ export class FormulaDependencyGenerator extends Disposable {const treeList: FormulaDependencyTree[] = [];+ const formulaRefCache = new Map<string, FormulaDependencyTree>();+// Recalculation can only be triggered after clearing the cache. For example, if a calculation error is reported for a non-existent formula and a custom formula is registered later, all formulas need to be calculated forcibly.const forceCalculate = this._currentConfigService.isForceCalculate();if (forceCalculate) {@@ -189,9 +196,9 @@ export class FormulaDependencyGenerator extends Disposable {this._formulaASTCache.clear();}- this._registerFormulas(formulaDataKeys, formulaData, unitData, treeList);+ this._registerFormulas(formulaDataKeys, formulaData, unitData, treeList, formulaRefCache);- this._registerOtherFormulas(otherFormulaData, otherFormulaDataKeys, treeList);+ this._registerOtherFormulas(otherFormulaData, otherFormulaDataKeys, treeList, formulaRefCache);this._registerFeatureFormulas(treeList);@@ -207,21 +214,57 @@ export class FormulaDependencyGenerator extends Disposable {tree.unitId);- if (tree.node == null) {+ const { unitId, formula, nodeData } = tree;++ if (nodeData == null) {continue;}- const rangeList = await this._getRangeListByNode(tree.node);- tree.pushRangeList(rangeList);+ const { refOffsetX, refOffsetY } = nodeData;++ let applyCacheRange = false;+ if (refOffsetX !== 0 || refOffsetY !== 0) {+ const refTreeNode = formulaRefCache.get(`${unitId}${formula}`);+ if (refTreeNode && refTreeNode.rangeList.length > 0) {+ tree.pushRangeList(this._moveRangeList(refTreeNode, refOffsetX, refOffsetY));+ applyCacheRange = true;+ }+ }++ if (!applyCacheRange) {+ const rangeList = await this._getRangeListByNode(nodeData);+ tree.pushRangeList(rangeList);+ }if (!tree.isCache) {this._dependencyManagerService.addDependencyRTreeCache(tree);}}+ formulaRefCache.clear();+return treeList;}+ private _moveRangeList(tree: FormulaDependencyTree, refOffsetX: number, refOffsetY: number) {+ const rangeList = tree.rangeList;+ const newRangeList = [];+ for (let i = 0, len = rangeList.length; i < len; i++) {+ const range = rangeList[i];+ const newRange = {+ unitId: tree.unitId,+ sheetId: tree.subUnitId,+ range: { ...range.range },+ };+ newRange.range.startRow += refOffsetY;+ newRange.range.endRow += refOffsetY;+ newRange.range.startColumn += refOffsetX;+ newRange.range.endColumn += refOffsetX;+ newRangeList.push(newRange);+ }+ return newRangeList;+ }+private _registerFeatureFormulas(treeList: FormulaDependencyTree[]) {/*** Register the external application relying on 'ref' into the formula system,@@ -262,7 +305,7 @@ export class FormulaDependencyGenerator extends Disposable {return FDtree;}- private _registerOtherFormulas(otherFormulaData: IOtherFormulaData, otherFormulaDataKeys: string[], treeList: FormulaDependencyTree[]) {+ private _registerOtherFormulas(otherFormulaData: IOtherFormulaData, otherFormulaDataKeys: string[], treeList: FormulaDependencyTree[], formulaRefCache: Map<string, FormulaDependencyTree>) {/*** Register formulas in doc, slide, and other types of applications.*/@@ -286,26 +329,32 @@ export class FormulaDependencyGenerator extends Disposable {for (const subFormulaDataId of subFormulaDataKeys) {const treeCache = this._dependencyManagerService.getOtherFormulaDependency(unitId, subUnitId, subFormulaDataId);+ const formulaDataItem = subFormulaData[subFormulaDataId];+ const { f: formulaString, x = 0, y = 0 } = formulaDataItem;+if (treeCache) {treeCache.isCache = true;+ if (x === 0 && y === 0) {+ formulaRefCache.set(`${unitId}${formulaString}`, treeCache);+ }continue;}- const formulaDataItem = subFormulaData[subFormulaDataId];-- const { f: formulaString } = formulaDataItem;-- const node = this._generateAstNode(unitId, formulaString);+ const nodeData = this._generateAstNode(unitId, formulaString, x, y);const FDtree = new FormulaDependencyTree(generateRandomDependencyTreeId(this._dependencyManagerService));- FDtree.node = node;+ FDtree.nodeData = nodeData;FDtree.formula = formulaString;FDtree.unitId = unitId;FDtree.subUnitId = subUnitId;FDtree.formulaId = subFormulaDataId;+ if (x === 0 && y === 0) {+ formulaRefCache.set(`${unitId}${formulaString}`, FDtree);+ }+this._dependencyManagerService.addOtherFormulaDependency(unitId, subUnitId, subFormulaDataId, FDtree);treeList.push(FDtree);@@ -314,7 +363,7 @@ export class FormulaDependencyGenerator extends Disposable {}}- private _registerFormulas(formulaDataKeys: string[], formulaData: IFormulaData, unitData: IUnitData, treeList: FormulaDependencyTree[]) {+ private _registerFormulas(formulaDataKeys: string[], formulaData: IFormulaData, unitData: IUnitData, treeList: FormulaDependencyTree[], formulaRefCache: Map<string, FormulaDependencyTree>) {/*** Register formulas in the sheet.*/@@ -335,21 +384,25 @@ export class FormulaDependencyGenerator extends Disposable {if (formulaDataItem == null) {return true;}- const { f: formulaString, x, y } = formulaDataItem;++ const { f: formulaString, x = 0, y = 0 } = formulaDataItem;const treeCache = this._dependencyManagerService.getFormulaDependency(unitId, sheetId, row, column);if (treeCache) {treeCache.isCache = true;+ if (x === 0 && y === 0) {+ formulaRefCache.set(`${unitId}${formulaString}`, treeCache);+ }return true;}- const node = this._generateAstNode(unitId, formulaString, x, y);+ const nodeData = this._generateAstNode(unitId, formulaString, x, y);const FDtree = new FormulaDependencyTree(generateRandomDependencyTreeId(this._dependencyManagerService));const sheetItem = unitData[unitId][sheetId];- FDtree.node = node;+ FDtree.nodeData = nodeData;FDtree.formula = formulaString;FDtree.unitId = unitId;FDtree.subUnitId = sheetId;@@ -359,6 +412,10 @@ export class FormulaDependencyGenerator extends Disposable {FDtree.rowCount = sheetItem.rowCount;FDtree.columnCount = sheetItem.columnCount;+ if (x === 0 && y === 0) {+ formulaRefCache.set(`${unitId}${formulaString}`, FDtree);+ }+this._dependencyManagerService.addFormulaDependency(unitId, sheetId, row, column, FDtree);treeList.push(FDtree);@@ -387,31 +444,38 @@ export class FormulaDependencyGenerator extends Disposable {}}- private _generateAstNode(unitId: string, formulaString: string, refOffsetX: number = 0, refOffsetY: number = 0) {+ private _generateAstNode(unitId: string, formulaString: string, refOffsetX: number = 0, refOffsetY: number = 0): IExecuteAstNodeData {// refOffsetX and refOffsetY are separated by -, otherwise x:1 y:10 will be repeated with x:11 y:0- let astNode: Nullable<AstRootNode> = this._formulaASTCache.get(`${unitId}${formulaString}##${refOffsetX}-${refOffsetY}`);+ let astNode: Nullable<AstRootNode> = this._formulaASTCache.get(`${unitId}${formulaString}`);if (astNode && !this._isDirtyDefinedForNode(astNode)) {- return astNode;+ // astNode.setRefOffset(refOffsetX, refOffsetY);+ return generateExecuteAstNodeData(astNode, refOffsetX, refOffsetY);}const lexerNode = this._lexer.treeBuilder(formulaString);if (ERROR_TYPE_SET.has(lexerNode as ErrorType)) {- return ErrorNode.create(lexerNode as ErrorType);+ return {+ node: ErrorNode.create(lexerNode as ErrorType),+ refOffsetX,+ refOffsetY,+ };}// suffix Express, 1+(3*4=4)*5+1 convert to 134*4=5*1++- astNode = this._astTreeBuilder.parse(lexerNode as LexerNode, refOffsetX, refOffsetY);+ astNode = this._astTreeBuilder.parse(lexerNode as LexerNode);if (astNode == null) {throw new Error('astNode is null');}- this._formulaASTCache.set(`${unitId}${formulaString}##${refOffsetX}-${refOffsetY}`, astNode);+ // astNode.setRefOffset(refOffsetX, refOffsetY);- return astNode;+ this._formulaASTCache.set(`${unitId}${formulaString}`, astNode);++ return generateExecuteAstNodeData(astNode, refOffsetX, refOffsetY);}private _addFlattenCache(unitId: string, sheetId: string, range: IRange) {@@ -497,12 +561,17 @@ export class FormulaDependencyGenerator extends Disposable {}}- private async _executeNode(node: PreCalculateNodeType | FunctionNode) {+ private async _executeNode(node: PreCalculateNodeType | FunctionNode, refOffsetX = 0, refOffsetY = 0) {let value: BaseReferenceObject;+ const nodeData = {+ node,+ refOffsetX,+ refOffsetY,+ };if (this._interpreter.checkAsyncNode(node)) {- value = (await this._interpreter.executeAsync(node)) as BaseReferenceObject;+ value = (await this._interpreter.executeAsync(nodeData)) as BaseReferenceObject;} else {- value = this._interpreter.execute(node) as BaseReferenceObject;+ value = this._interpreter.execute(nodeData) as BaseReferenceObject;}return value;}@@ -512,21 +581,24 @@ export class FormulaDependencyGenerator extends Disposable {* including references and location functions (such as OFFSET, INDIRECT, INDEX, etc.).* @param node*/- private async _getRangeListByNode(node: BaseAstNode) {+ private async _getRangeListByNode(nodeData: IExecuteAstNodeData) {// ref function in offset indirect INDEXconst preCalculateNodeList: PreCalculateNodeType[] = [];const referenceFunctionList: FunctionNode[] = [];- this._nodeTraversalRef(node, preCalculateNodeList);+ const refOffsetX = nodeData.refOffsetX;+ const refOffsetY = nodeData.refOffsetY;++ this._nodeTraversalRef(nodeData.node, preCalculateNodeList);- this._nodeTraversalReferenceFunction(node, referenceFunctionList);+ this._nodeTraversalReferenceFunction(nodeData.node, referenceFunctionList);const rangeList: IUnitRange[] = [];for (let i = 0, len = preCalculateNodeList.length; i < len; i++) {const node = preCalculateNodeList[i];- const value: BaseReferenceObject = await this._executeNode(node);+ const value: BaseReferenceObject = await this._executeNode(node, refOffsetX, refOffsetY);const gridRange = value.toUnitRange();@@ -537,7 +609,7 @@ export class FormulaDependencyGenerator extends Disposable {for (let i = 0, len = referenceFunctionList.length; i < len; i++) {const node = referenceFunctionList[i];- const value: BaseReferenceObject = await this._executeNode(node);+ const value: BaseReferenceObject = await this._executeNode(node, refOffsetX, refOffsetY);const gridRange = value.toUnitRange();@@ -622,6 +694,12 @@ export class FormulaDependencyGenerator extends Disposable {}private _dependencyFeatureCalculation(newTreeList: FormulaDependencyTree[]) {+ const featureMap = this._featureCalculationManagerService.getReferenceExecutorMap();++ if (featureMap.size === 0) {+ return;+ }+/*** Clear the dependency relationships of all featureCalculation nodes in the tree.* Because each execution requires rebuilding the reverse dependencies,@@ -632,7 +710,6 @@ export class FormulaDependencyGenerator extends Disposable {let hasFeatureCalculation = false;- const featureMap = this._featureCalculationManagerService.getReferenceExecutorMap();featureMap.forEach((subUnitMap, _) => {subUnitMap.forEach((featureMap, _) => {featureMap.forEach((params, featureId) => {@@ -778,7 +855,7 @@ export class FormulaDependencyGenerator extends Disposable {/*** Detect whether the dirty map contains a defined name.*/- const node = tree.node;+ const node = tree.nodeData?.node;if (node != null) {const dirtyDefinedName = this._isDirtyDefinedForNode(node);if (dirtyDefinedName) {@@ -789,7 +866,7 @@ export class FormulaDependencyGenerator extends Disposable {}private _detectForcedRecalculationNode(tree: FormulaDependencyTree) {- const node = tree.node;+ const node = tree.nodeData?.node;if (node == null) {return false;@@ -894,8 +971,9 @@ export class FormulaDependencyGenerator extends Disposable {* @param treeList*/private _calculateRunList(treeList: FormulaDependencyTree[]) {- let stack = treeList;+ const stack = treeList;const formulaRunList = [];+ const cacheStack: FormulaDependencyTree[] = [];while (stack.length > 0) {const tree = stack.pop();@@ -911,7 +989,8 @@ export class FormulaDependencyGenerator extends Disposable {continue;}- const cacheStack: FormulaDependencyTree[] = [];+ // It will clear the array.+ cacheStack.length = 0;for (const parentTree of tree.parents) {if (parentTree.isAdded() || tree.isSkip()) {@@ -925,8 +1004,7 @@ export class FormulaDependencyGenerator extends Disposable {tree.setSkip();} else {tree.setAdded();- stack.push(tree);- stack = stack.concat(cacheStack);+ stack.push(tree, ...cacheStack);}}diff --git a/packages/engine-formula/src/engine/dependency/generate-tree-id.ts b/packages/engine-formula/src/engine/dependency/generate-tree-id.tsdeleted file mode 100644index 1643cfe6d5..0000000000--- a/packages/engine-formula/src/engine/dependency/generate-tree-id.ts+++ /dev/null@@ -1,27 +0,0 @@-/**- * Copyright 2023-present DreamNum Inc.- *- * 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 { IDependencyManagerService } from '../../services/dependency-manager.service';-import { generateRandomId } from '@univerjs/core';--export function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): string {- let idLength = 4;- let id = generateRandomId(idLength);- while (dependencyManagerService.hasTreeIdInCache(id)) {- id = generateRandomId(++idLength);- }- return id;-}diff --git a/packages/engine-formula/src/engine/interpreter/interpreter.ts b/packages/engine-formula/src/engine/interpreter/interpreter.tsindex 152c95ec03..8497524d28 100644--- a/packages/engine-formula/src/engine/interpreter/interpreter.ts+++ b/packages/engine-formula/src/engine/interpreter/interpreter.ts@@ -14,10 +14,12 @@* limitations under the License.*/-import type { FunctionNode, LambdaNode } from '../ast-node';-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 { IExecuteAstNodeData } from '../utils/ast-node-tool';import type { PreCalculateNodeType } from '../utils/node-type';import { Disposable } from '@univerjs/core';import { AstNodePromiseType } from '../../basics/common';@@ -32,16 +34,20 @@ export class Interpreter extends Disposable {super();}- async executeAsync(node: BaseAstNode): Promise<FunctionVariantType> {+ async executeAsync(nodeData: IExecuteAstNodeData): Promise<FunctionVariantType> {// if (!this._interpreterCalculateProps) {// return ErrorValueObject.create(ErrorType.ERROR);// }- if (!node) {+ if (!nodeData) {return Promise.resolve(ErrorValueObject.create(ErrorType.VALUE));}- await this._executeAsync(node);+ const node = nodeData.node;+ const refOffsetX = nodeData.refOffsetX;+ const refOffsetY = nodeData.refOffsetY;++ await this._executeAsync(node, refOffsetX, refOffsetY);const value = node.getValue();@@ -52,16 +58,20 @@ export class Interpreter extends Disposable {return Promise.resolve(value);}- execute(node: BaseAstNode): FunctionVariantType {+ execute(nodeData: IExecuteAstNodeData): FunctionVariantType {// if (!this._interpreterCalculateProps) {// return ErrorValueObject.create(ErrorType.ERROR);// }- if (!node) {+ if (!nodeData) {return ErrorValueObject.create(ErrorType.VALUE);}- this._execute(node);+ const node = nodeData.node;+ const refOffsetX = nodeData.refOffsetX;+ const refOffsetY = nodeData.refOffsetY;++ this._execute(node, refOffsetX, refOffsetY);const value = node.getValue();@@ -101,7 +111,7 @@ export class Interpreter extends Disposable {}}- private async _executeAsync(node: BaseAstNode): Promise<AstNodePromiseType> {+ private async _executeAsync(node: BaseAstNode, refOffsetX = 0, refOffsetY = 0): Promise<AstNodePromiseType> {if (this._runtimeService.isStopExecution()) {return Promise.resolve(AstNodePromiseType.ERROR);}@@ -120,7 +130,11 @@ export class Interpreter extends Disposable {item.execute();continue;}- await this._executeAsync(item);+ await this._executeAsync(item, refOffsetX, refOffsetY);+ }++ if (node.nodeType === NodeType.REFERENCE) {+ (node as ReferenceNode).setRefOffset(refOffsetX, refOffsetY);}if (node.nodeType === NodeType.FUNCTION && (node as FunctionNode).isAsync()) {@@ -132,7 +146,7 @@ export class Interpreter extends Disposable {return Promise.resolve(AstNodePromiseType.SUCCESS);}- private _execute(node: BaseAstNode): AstNodePromiseType {+ private _execute(node: BaseAstNode, refOffsetX = 0, refOffsetY = 0): AstNodePromiseType {if (this._runtimeService.isStopExecution()) {return AstNodePromiseType.ERROR;}@@ -151,7 +165,11 @@ export class Interpreter extends Disposable {item.execute();continue;}- this._execute(item);+ this._execute(item, refOffsetX, refOffsetY);+ }++ if (node.nodeType === NodeType.REFERENCE) {+ (node as ReferenceNode).setRefOffset(refOffsetX, refOffsetY);}node.execute();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 7e7b5d9d53..3f3499c5a3 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@@ -17,7 +17,7 @@import type { IRange } from '@univerjs/core';import { ErrorType } from '../../basics/error-type';-import { deserializeRangeWithSheet } from '../utils/reference';+import { deserializeRangeWithSheetWithCache } from '../utils/reference';import { ErrorValueObject } from '../value-object/base-value-object';import { BaseReferenceObject } from './base-reference-object';import { RangeReferenceObject } from './range-reference-object';@@ -25,7 +25,7 @@ import { RangeReferenceObject } from './range-reference-object';export class CellReferenceObject extends BaseReferenceObject {constructor(token: string) {super(token);- const grid = deserializeRangeWithSheet(token);+ const grid = deserializeRangeWithSheetWithCache(token);this.setForcedUnitIdDirect(grid.unitId);this.setForcedSheetName(grid.sheetName);this.setRangeData(grid.range);diff --git a/packages/engine-formula/src/engine/reference-object/column-reference-object.ts b/packages/engine-formula/src/engine/reference-object/column-reference-object.tsindex 9ff9d1495e..5f9488524a 100644--- a/packages/engine-formula/src/engine/reference-object/column-reference-object.ts+++ b/packages/engine-formula/src/engine/reference-object/column-reference-object.ts@@ -18,14 +18,14 @@ import { type IRange, RANGE_TYPE } from '@univerjs/core';import { ErrorType } from '../../basics/error-type';import { matchToken } from '../../basics/token';-import { deserializeRangeWithSheet } from '../utils/reference';+import { deserializeRangeWithSheetWithCache } from '../utils/reference';import { ErrorValueObject } from '../value-object/base-value-object';import { BaseReferenceObject } from './base-reference-object';export class ColumnReferenceObject extends BaseReferenceObject {constructor(token: string) {super(token);- const grid = deserializeRangeWithSheet(token);+ const grid = deserializeRangeWithSheetWithCache(token);this.setForcedUnitIdDirect(grid.unitId);this.setForcedSheetName(grid.sheetName);const range: IRange = {diff --git a/packages/engine-formula/src/engine/reference-object/row-reference-object.ts b/packages/engine-formula/src/engine/reference-object/row-reference-object.tsindex 72e6f06f9b..99278010b1 100644--- a/packages/engine-formula/src/engine/reference-object/row-reference-object.ts+++ b/packages/engine-formula/src/engine/reference-object/row-reference-object.ts@@ -18,14 +18,14 @@ import { type IRange, RANGE_TYPE } from '@univerjs/core';import { ErrorType } from '../../basics/error-type';import { matchToken } from '../../basics/token';-import { deserializeRangeWithSheet } from '../utils/reference';+import { deserializeRangeWithSheetWithCache } from '../utils/reference';import { ErrorValueObject } from '../value-object/base-value-object';import { BaseReferenceObject } from './base-reference-object';export class RowReferenceObject extends BaseReferenceObject {constructor(token: string) {super(token);- const grid = deserializeRangeWithSheet(token);+ const grid = deserializeRangeWithSheetWithCache(token);this.setForcedUnitIdDirect(grid.unitId);this.setForcedSheetName(grid.sheetName);const range: IRange = {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 9b96c5a274..9d2143c5ef 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@@ -16,7 +16,8 @@import type { ISuperTable } from '../../basics/common';import { TableOptionType } from '../../basics/common';-import { $SUPER_TABLE_COLUMN_REGEX } from '../../basics/regex';+import { regexTestSuperTableColumn } from '../../basics/regex';+import { matchToken } from '../../basics/token';import { BaseReferenceObject } from './base-reference-object';@@ -115,7 +116,7 @@ export class TableReferenceObject extends BaseReferenceObject {let startColumn = -1;let endColumn = -1;const colonIndex = rightString.indexOf(matchToken.COLON);- if (new RegExp($SUPER_TABLE_COLUMN_REGEX, 'g').test(rightString)) {+ if (regexTestSuperTableColumn(rightString)) {// =Table2[[11111]:[222]]const startColumnString = rightString.substring(0, colonIndex).substring(1, -1);const endColumnString = rightString.substring(colonIndex + 1).substring(1, -1);diff --git a/packages/engine-formula/src/engine/utils/ast-node-tool.ts b/packages/engine-formula/src/engine/utils/ast-node-tool.tsindex 81937700e9..130efc7310 100644--- a/packages/engine-formula/src/engine/utils/ast-node-tool.ts+++ b/packages/engine-formula/src/engine/utils/ast-node-tool.ts@@ -17,6 +17,12 @@import type { Nullable } from '@univerjs/core';import type { BaseAstNode } from '../ast-node/base-ast-node';+export interface IExecuteAstNodeData {+ node: BaseAstNode;+ refOffsetX: number;+ refOffsetY: number;+}+export function getAstNodeTopParent(node: BaseAstNode) {let parent: Nullable<BaseAstNode> = node;while (parent?.getParent()) {@@ -25,3 +31,11 @@ export function getAstNodeTopParent(node: BaseAstNode) {}return parent;}++export function generateExecuteAstNodeData(node: BaseAstNode, refOffsetX: number = 0, refOffsetY: number = 0) {+ return {+ node,+ refOffsetX,+ refOffsetY,+ };+}diff --git a/packages/engine-formula/src/engine/utils/math-kit.ts b/packages/engine-formula/src/engine/utils/math-kit.tsindex 1757e29e4a..4c09d589b2 100644--- a/packages/engine-formula/src/engine/utils/math-kit.ts+++ b/packages/engine-formula/src/engine/utils/math-kit.ts@@ -23,21 +23,36 @@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();}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();}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();}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();}-/*** Rounds a number to a specified number of decimal places.* @param base The number to round.diff --git a/packages/engine-formula/src/engine/utils/numfmt-kit.ts b/packages/engine-formula/src/engine/utils/numfmt-kit.tsindex d2ea3863ea..c5e879fb88 100644--- a/packages/engine-formula/src/engine/utils/numfmt-kit.ts+++ b/packages/engine-formula/src/engine/utils/numfmt-kit.ts@@ -195,13 +195,30 @@ export function compareNumfmtPriority(oldPattern: string, pattern: string) {return oldPattern;}+const numberFormatTypeCache = new Map<string, NumberFormatType>();++function getNumberFormatType(pattern: string) {+ if (numberFormatTypeCache.has(pattern)) {+ return numberFormatTypeCache.get(pattern)!;+ }++ const type = getNumberFormatTypeRaw(pattern);+ numberFormatTypeCache.set(pattern, type);++ return type;+}++export function clearNumberFormatTypeCache() {+ numberFormatTypeCache.clear();+}+/*** Get the type of the number format** @param pattern* @returns*/-function getNumberFormatType(pattern: string): NumberFormatType {+function getNumberFormatTypeRaw(pattern: string): NumberFormatType {if (isAccounting(pattern)) {return NumberFormatType.Accounting;}diff --git a/packages/engine-formula/src/engine/utils/prefixHandler.ts b/packages/engine-formula/src/engine/utils/prefixHandler.tsindex f386fbc155..6857ebd68f 100644--- a/packages/engine-formula/src/engine/utils/prefixHandler.ts+++ b/packages/engine-formula/src/engine/utils/prefixHandler.ts@@ -20,19 +20,22 @@ import { prefixToken } from '../../basics/token';import { FUNCTION_NAMES_META } from '../../functions/meta/function-names';import { PrefixNode } from '../ast-node/prefix-node';+const minusRegExp = new RegExp(prefixToken.MINUS, 'g');+const atRegExp = new RegExp(prefixToken.AT, 'g');+export function prefixHandler(tokenTrimParam: string, functionService: IFunctionService, injector: Injector) {let minusPrefixNode: Nullable<PrefixNode>;let atPrefixNode: Nullable<PrefixNode>;let tokenTrim = tokenTrimParam;const prefix = tokenTrim.slice(0, 2);let sliceLength = 0;- if (new RegExp(prefixToken.MINUS, 'g').test(prefix)) {+ if (prefix[0] === prefixToken.MINUS) {const functionExecutor = functionService.getExecutor(FUNCTION_NAMES_META.MINUS);minusPrefixNode = new PrefixNode(injector, prefixToken.MINUS, functionExecutor);sliceLength++;}- if (new RegExp(prefixToken.AT, 'g').test(prefix)) {+ if (prefix[0] === prefixToken.AT) {atPrefixNode = new PrefixNode(injector, prefixToken.AT);if (minusPrefixNode) {// minusPrefixNode.addChildren(atPrefixNode);diff --git a/packages/engine-formula/src/engine/utils/reference.ts b/packages/engine-formula/src/engine/utils/reference.tsindex d8f9a0e46f..56b87573bb 100644--- a/packages/engine-formula/src/engine/utils/reference.ts+++ b/packages/engine-formula/src/engine/utils/reference.ts@@ -18,7 +18,7 @@ import type { IRange, IUnitRangeName, IUnitRangeWithName } from '@univerjs/core'import { AbsoluteRefType, RANGE_TYPE, Tools } from '@univerjs/core';import { includeFormulaLexerToken } from '../../basics/match-token';-import { isReferenceString, UNIT_NAME_REGEX } from '../../basics/regex';+import { isReferenceString, UNIT_NAME_REGEX_PRECOMPILING } from '../../basics/regex';import { prefixToken, SPACE_TOKEN } from '../../basics/token';const $ROW_REGEX = /[^0-9]/g;@@ -201,13 +201,13 @@ export function singleReferenceToGrid(refBody: string) {}export function handleRefStringInfo(refString: string) {- const unitIdMatch = new RegExp(UNIT_NAME_REGEX).exec(refString);+ const unitIdMatch = UNIT_NAME_REGEX_PRECOMPILING.exec(refString);let unitId = '';if (unitIdMatch != null) {unitId = unitIdMatch[0].trim();unitId = unitId.slice(1, unitId.length - 1);- refString = refString.replace(new RegExp(UNIT_NAME_REGEX), '');+ refString = refString.replace(UNIT_NAME_REGEX_PRECOMPILING, '');}const sheetNameIndex = refString.indexOf('!');@@ -294,6 +294,23 @@ export function deserializeRangeWithSheet(refString: string): IUnitRangeName {};}+const referenceToRangeCache = new Map<string, IUnitRangeName>();+export function deserializeRangeWithSheetWithCache(refString: string): IUnitRangeName {+ if (referenceToRangeCache.has(refString)) {+ return referenceToRangeCache.get(refString)!;+ }++ const result = deserializeRangeWithSheet(refString);++ referenceToRangeCache.set(refString, result);++ return deserializeRangeWithSheet(refString); ;+}++export function clearReferenceToRangeCache() {+ referenceToRangeCache.clear();+}+/*** LOG10 is a formula, google sheet support it on Log10:L* EXCEL support it on Log10:Log10diff --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 475b14d3ba..a31b3c8087 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@@ -21,7 +21,7 @@ import { isRealNum } from '@univerjs/core';import { BooleanValue } from '../../basics/common';import { ERROR_TYPE_SET, ErrorType } from '../../basics/error-type';import { CELL_INVERTED_INDEX_CACHE } from '../../basics/inverted-index-cache';-import { $ARRAY_VALUE_REGEX } from '../../basics/regex';+import { regexTestArrayValue } from '../../basics/regex';import { compareToken } from '../../basics/token';import { ArrayBinarySearchType, ArrayOrderSearchType, getCompare } from '../utils/compare';import { BaseValueObject, ErrorValueObject } from './base-value-object';@@ -1898,7 +1898,7 @@ export class ValueObjectFactory {}const rawValueSingleLine = rawValue.replace(/\n/g, '').replace(/\r/g, '');- if (!isStringWrappedByDoubleQuotes(rawValueSingleLine) && new RegExp($ARRAY_VALUE_REGEX, 'g').test(rawValueSingleLine)) {+ if (!isStringWrappedByDoubleQuotes(rawValueSingleLine) && regexTestArrayValue(rawValueSingleLine)) {return ArrayValueObject.create(rawValueSingleLine);}diff --git a/packages/engine-formula/src/engine/value-object/lambda-value-object.ts b/packages/engine-formula/src/engine/value-object/lambda-value-object.tsindex 4e772aabd0..ec834d078f 100644--- a/packages/engine-formula/src/engine/value-object/lambda-value-object.ts+++ b/packages/engine-formula/src/engine/value-object/lambda-value-object.ts@@ -16,14 +16,15 @@import type { Nullable } from '@univerjs/core';-import { ErrorType } from '../../basics/error-type';-import { DEFAULT_TOKEN_TYPE_LAMBDA_RUNTIME_PARAMETER } from '../../basics/token-type';-import { AsyncObject } from '../reference-object/base-reference-object';-import { BaseValueObject, ErrorValueObject } from './base-value-object';import type { BaseAstNode } from '../ast-node/base-ast-node';import type { LambdaParameterNode } from '../ast-node/lambda-parameter-node';import type { Interpreter } from '../interpreter/interpreter';import type { BaseReferenceObject, FunctionVariantType } from '../reference-object/base-reference-object';+import { ErrorType } from '../../basics/error-type';+import { DEFAULT_TOKEN_TYPE_LAMBDA_RUNTIME_PARAMETER } from '../../basics/token-type';+import { AsyncObject } from '../reference-object/base-reference-object';+import { generateExecuteAstNodeData } from '../utils/ast-node-tool';+import { BaseValueObject, ErrorValueObject } from './base-value-object';function getRootLexerHasValueNode(node: Nullable<BaseAstNode>): Nullable<BaseAstNode> {if (!node) {@@ -86,9 +87,9 @@ export class LambdaValueObjectObject extends BaseValueObject {let value: AsyncObject | BaseValueObject;if (this._interpreter.checkAsyncNode(this._lambdaNode)) {- value = new AsyncObject(this._interpreter.executeAsync(this._lambdaNode) as Promise<BaseValueObject>);+ value = new AsyncObject(this._interpreter.executeAsync(generateExecuteAstNodeData(this._lambdaNode)) as Promise<BaseValueObject>);} else {- const o = this._interpreter.execute(this._lambdaNode);+ const o = this._interpreter.execute(generateExecuteAstNodeData(this._lambdaNode));if (o.isReferenceObject()) {value = (o as BaseReferenceObject).toArrayValueObject();} else {diff --git a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.tsindex dbe73a6a06..a7e1fcc638 100644--- a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts+++ b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts@@ -24,6 +24,7 @@ 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 { IFormulaCurrentConfigService } from '../../services/current-data.service';import { IFunctionService } from '../../services/function.service';import { IFormulaRuntimeService } from '../../services/runtime.service';@@ -329,7 +330,7 @@ describe('Test nested functions', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));return getObjectValue(result);};diff --git a/packages/engine-formula/src/functions/base-function.ts b/packages/engine-formula/src/functions/base-function.tsindex 479c5c8bcc..930592aad8 100644--- a/packages/engine-formula/src/functions/base-function.ts+++ b/packages/engine-formula/src/functions/base-function.ts@@ -14,11 +14,16 @@* limitations under the License.*/-import { Disposable } from '@univerjs/core';import type { IRange, Nullable } from '@univerjs/core';+import type { IFunctionNames } from '../basics/function';++import type { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';+import type { ArrayBinarySearchType } from '../engine/utils/compare';+import type { ArrayValueObject } from '../engine/value-object/array-value-object';+import type { IDefinedNameMapItem } from '../services/defined-names.service';import { ErrorType } from '../basics/error-type';-import { REFERENCE_REGEX_SINGLE_COLUMN, REFERENCE_REGEX_SINGLE_ROW, REFERENCE_SINGLE_RANGE_REGEX } from '../basics/regex';+import { regexTestSingeRange, regexTestSingleColumn, regexTestSingleRow } from '../basics/regex';import { compareToken } from '../basics/token';import { CellReferenceObject } from '../engine/reference-object/cell-reference-object';import { ColumnReferenceObject } from '../engine/reference-object/column-reference-object';@@ -30,13 +35,8 @@ import { serializeRangeToRefString } from '../engine/utils/reference';import { convertTonNumber } from '../engine/utils/value-object';import { type BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';import { NullValueObject, NumberValueObject, type PrimitiveValueType } from '../engine/value-object/primitive-object';-import type { IFunctionNames } from '../basics/function';-import type { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';-import type { ArrayBinarySearchType } from '../engine/utils/compare';-import type { ArrayValueObject } from '../engine/value-object/array-value-object';-import type { IDefinedNameMapItem } from '../services/defined-names.service';-export class BaseFunction extends Disposable {+export class BaseFunction {private _unitId: Nullable<string>;private _subUnitId: Nullable<string>;private _row: number = -1;@@ -64,7 +64,7 @@ export class BaseFunction extends Disposable {maxParams: number = -1;constructor(private _name: IFunctionNames) {- super();+}get name() {@@ -87,6 +87,10 @@ export class BaseFunction extends Disposable {return this._column;}+ dispose() {++ }+/*** In Excel, to inject a defined name into a function that has positioning capabilities,* such as using the INDIRECT function to reference a named range,@@ -508,11 +512,11 @@ export class BaseFunction extends Disposable {let referenceObject: BaseReferenceObject;- if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(token)) {+ if (regexTestSingeRange(token)) {referenceObject = new CellReferenceObject(token);- } else if (new RegExp(REFERENCE_REGEX_SINGLE_ROW).test(token)) {+ } else if (regexTestSingleRow(token)) {referenceObject = new RowReferenceObject(token);- } else if (new RegExp(REFERENCE_REGEX_SINGLE_COLUMN).test(token)) {+ } else if (regexTestSingleColumn(token)) {referenceObject = new ColumnReferenceObject(token);} else {referenceObject = new RangeReferenceObject(range, sheetId, unitId);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 6c6b11bd47..d60f63053f 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@@ -24,6 +24,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -137,7 +138,7 @@ describe('Test rank function', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));return getObjectValue(result);};diff --git a/packages/engine-formula/src/functions/information/cell/__tests__/index.spec.ts b/packages/engine-formula/src/functions/information/cell/__tests__/index.spec.tsindex 8b5ee70ba2..4ade2ba6f1 100644--- a/packages/engine-formula/src/functions/information/cell/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/information/cell/__tests__/index.spec.ts@@ -26,6 +26,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -199,7 +200,7 @@ describe('Test cell function', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));if ((result as ErrorValueObject).isError()) {return (result as ErrorValueObject).getValue();diff --git a/packages/engine-formula/src/functions/information/cell/index.ts b/packages/engine-formula/src/functions/information/cell/index.tsindex 96fe8a8e78..2b61dcee80 100644--- a/packages/engine-formula/src/functions/information/cell/index.ts+++ b/packages/engine-formula/src/functions/information/cell/index.ts@@ -15,9 +15,9 @@*/import type { IColumnData, IObjectArrayPrimitiveType } from '@univerjs/core';+import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';import { Tools } from '@univerjs/core';import { ErrorType } from '../../../basics/error-type';-import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';import { ArrayValueObject } from '../../../engine/value-object/array-value-object';import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';import { NumberValueObject, StringValueObject } from '../../../engine/value-object/primitive-object';diff --git a/packages/engine-formula/src/functions/information/isformula/__tests__/index.spec.ts b/packages/engine-formula/src/functions/information/isformula/__tests__/index.spec.tsindex 3d3f4c02d0..658083714e 100644--- a/packages/engine-formula/src/functions/information/isformula/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/information/isformula/__tests__/index.spec.ts@@ -26,6 +26,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -137,7 +138,7 @@ describe('Test isformula function', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));if ((result as ErrorValueObject).isError()) {return (result as ErrorValueObject).getValue();diff --git a/packages/engine-formula/src/functions/information/isref/__tests__/index.spec.ts b/packages/engine-formula/src/functions/information/isref/__tests__/index.spec.tsindex 7293c5c19e..2930952603 100644--- a/packages/engine-formula/src/functions/information/isref/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/information/isref/__tests__/index.spec.ts@@ -25,6 +25,7 @@ import { beforeEach, describe, expect, it } from 'vitest';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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -197,7 +198,7 @@ describe('Test isref function', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));if ((result as ErrorValueObject).isError()) {return (result as ErrorValueObject).getValue();diff --git a/packages/engine-formula/src/functions/logical/bycol/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/bycol/__test__/index.spec.tsindex 78bcfd9dae..fe50b8c46e 100644--- a/packages/engine-formula/src/functions/logical/bycol/__test__/index.spec.ts+++ b/packages/engine-formula/src/functions/logical/bycol/__test__/index.spec.ts@@ -14,13 +14,16 @@* limitations under the License.*/-import { beforeEach, describe, expect, it } from 'vitest';import type { Injector } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+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 { IFunctionService } from '../../../../services/function.service';import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_META } from '../../../meta/function-names';@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';import { FUNCTION_NAMES_LOGICAL } from '../../function-names';import { Lambda } from '../../lambda';import { Bycol } from '../index';-import type { LexerNode } from '../../../../engine/analysis/lexer-node';-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';describe('Test bycol', () => {// const testFunction = new Bycol(FUNCTION_NAMES_LOGICAL.BYCOL);@@ -60,36 +61,36 @@ describe('Test bycol', () => {it('multiply', async () => {let lexerNode = lexer.treeBuilder('=BYCOL({1,2,3},LAMBDA(x,x*2))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[2, 4, 6],]);lexerNode = lexer.treeBuilder('=BYCOL(1,LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(2);lexerNode = lexer.treeBuilder('=BYCOL({1,2,3;4,5,6},LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.CALC);});it('value is error', async () => {let lexerNode = lexer.treeBuilder('=BYCOL(#NAME?,LAMBDA(x,x*2))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=BYCOL({1,2,3},#NAME?)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=BYCOL({1,2,3},1)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);});});diff --git a/packages/engine-formula/src/functions/logical/byrow/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/byrow/__test__/index.spec.tsindex 44eb795aea..6f67ef9e1f 100644--- a/packages/engine-formula/src/functions/logical/byrow/__test__/index.spec.ts+++ b/packages/engine-formula/src/functions/logical/byrow/__test__/index.spec.ts@@ -14,13 +14,16 @@* limitations under the License.*/-import { beforeEach, describe, expect, it } from 'vitest';import type { Injector } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+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 { IFunctionService } from '../../../../services/function.service';import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_META } from '../../../meta/function-names';@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';import { FUNCTION_NAMES_LOGICAL } from '../../function-names';import { Lambda } from '../../lambda';import { Byrow } from '../index';-import type { LexerNode } from '../../../../engine/analysis/lexer-node';-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';describe('Test byrow', () => {// const testFunction = new Byrow(FUNCTION_NAMES_LOGICAL.BYROW);@@ -60,7 +61,7 @@ describe('Test byrow', () => {it('multiply', async () => {let lexerNode = lexer.treeBuilder('=BYROW({1;2;3},LAMBDA(x,x*2))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[2],[4],@@ -69,29 +70,29 @@ describe('Test byrow', () => {lexerNode = lexer.treeBuilder('=BYROW(1,LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(2);lexerNode = lexer.treeBuilder('=BYROW({1,2,3;4,5,6},LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.CALC);});it('value is error', async () => {let lexerNode = lexer.treeBuilder('=BYROW(#NAME?,LAMBDA(x,x*2))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=BYROW({1;2;3},#NAME?)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=BYROW({1;2;3},1)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);});});diff --git a/packages/engine-formula/src/functions/logical/makearray/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/makearray/__test__/index.spec.tsindex 491b17355a..9c62b862ea 100644--- a/packages/engine-formula/src/functions/logical/makearray/__test__/index.spec.ts+++ b/packages/engine-formula/src/functions/logical/makearray/__test__/index.spec.ts@@ -15,14 +15,16 @@*/import type { Injector } from '@univerjs/core';-import { beforeEach, describe, expect, it } from 'vitest';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+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 { Lexer } from '../../../../engine/analysis/lexer';-import type { LexerNode } from '../../../../engine/analysis/lexer-node';import { AstTreeBuilder } from '../../../../engine/analysis/parser';-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';import { Interpreter } from '../../../../engine/interpreter/interpreter';-import type { ArrayValueObject } from '../../../../engine/value-object/array-value-object';+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';import { IFunctionService } from '../../../../services/function.service';import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_META } from '../../../meta/function-names';@@ -30,7 +32,6 @@ import { Multiply } from '../../../meta/multiply';import { FUNCTION_NAMES_LOGICAL } from '../../function-names';import { Lambda } from '../../lambda';import { Makearray } from '../index';-import type { BaseValueObject } from '../../../../engine/value-object/base-value-object';describe('Test makearray', () => {// const testFunction = new Makearray(FUNCTION_NAMES_LOGICAL.MAKEARRAY);@@ -63,7 +64,7 @@ describe('Test makearray', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = await interpreter.executeAsync(astNode as BaseAstNode);+ const result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).toValue()).toStrictEqual([[1, 2, 3, 4],@@ -78,7 +79,7 @@ describe('Test makearray', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = await interpreter.executeAsync(astNode as BaseAstNode);+ const result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(15);});@@ -88,7 +89,7 @@ describe('Test makearray', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = await interpreter.executeAsync(astNode as BaseAstNode);+ const result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).toValue()).toStrictEqual([[1, 2, 3, 4],diff --git a/packages/engine-formula/src/functions/logical/map/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/map/__test__/index.spec.tsindex 2b87ec8c66..2a3b9aaf66 100644--- a/packages/engine-formula/src/functions/logical/map/__test__/index.spec.ts+++ b/packages/engine-formula/src/functions/logical/map/__test__/index.spec.ts@@ -14,13 +14,16 @@* limitations under the License.*/-import { beforeEach, describe, expect, it } from 'vitest';import type { Injector } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+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 { IFunctionService } from '../../../../services/function.service';import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_META } from '../../../meta/function-names';@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';import { FUNCTION_NAMES_LOGICAL } from '../../function-names';import { Lambda } from '../../lambda';import { Map } from '../index';-import type { LexerNode } from '../../../../engine/analysis/lexer-node';-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';describe('Test map', () => {// const testFunction = new Map(FUNCTION_NAMES_LOGICAL.MAP);@@ -60,7 +61,7 @@ describe('Test map', () => {it('multiply', async () => {let lexerNode = lexer.treeBuilder('=MAP({1;2;3},LAMBDA(x,x*2))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[2],[4],@@ -69,12 +70,12 @@ describe('Test map', () => {lexerNode = lexer.treeBuilder('=MAP(1,LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(2);lexerNode = lexer.treeBuilder('=MAP({1,2,3;4,5,6},LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[2, 4, 6],[8, 10, 12],@@ -82,7 +83,7 @@ describe('Test map', () => {lexerNode = lexer.treeBuilder('=MAP({1,2,3;4,5,6},1,LAMBDA(x,y,x*y))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[1, ErrorType.NA, ErrorType.NA],[ErrorType.NA, ErrorType.NA, ErrorType.NA],@@ -90,7 +91,7 @@ describe('Test map', () => {lexerNode = lexer.treeBuilder('=MAP({1,2,3;4,5,6},{1,2},LAMBDA(x,y,x*y))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[1, 4, ErrorType.NA],[ErrorType.NA, ErrorType.NA, ErrorType.NA],@@ -100,17 +101,17 @@ describe('Test map', () => {it('value is error', async () => {let lexerNode = lexer.treeBuilder('=MAP(#NAME?,LAMBDA(x,x*2))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=MAP({1;2;3},#NAME?)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=MAP({1;2;3},1)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);});});diff --git a/packages/engine-formula/src/functions/logical/reduce/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/reduce/__test__/index.spec.tsindex 6ecdb3d779..eeedeca1c7 100644--- a/packages/engine-formula/src/functions/logical/reduce/__test__/index.spec.ts+++ b/packages/engine-formula/src/functions/logical/reduce/__test__/index.spec.ts@@ -14,13 +14,16 @@* limitations under the License.*/-import { beforeEach, describe, expect, it } from 'vitest';import type { Injector } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+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 { IFunctionService } from '../../../../services/function.service';import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_META } from '../../../meta/function-names';@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';import { FUNCTION_NAMES_LOGICAL } from '../../function-names';import { Lambda } from '../../lambda';import { Reduce } from '../index';-import type { LexerNode } from '../../../../engine/analysis/lexer-node';-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';describe('Test reduce', () => {// const testFunction = new Reduce(FUNCTION_NAMES_LOGICAL.REDUCE);@@ -60,17 +61,17 @@ describe('Test reduce', () => {it('multiply', async () => {let lexerNode = lexer.treeBuilder('=REDUCE(1,{1;2;3},LAMBDA(x,y,x*y))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(6);lexerNode = lexer.treeBuilder('=REDUCE(1,{1;2;3},LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);lexerNode = lexer.treeBuilder('=REDUCE({1,a,#NAME?;4,5,6},1,LAMBDA(x,y,x*y))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[1, ErrorType.VALUE, ErrorType.NAME],[4, 5, 6],@@ -80,12 +81,12 @@ describe('Test reduce', () => {it('value is error', async () => {let lexerNode = lexer.treeBuilder('=REDUCE(#NAME?,1,LAMBDA(x,x*2))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=REDUCE({1;2;3},#NAME?,LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[ErrorType.NAME],[ErrorType.NAME],@@ -94,7 +95,7 @@ describe('Test reduce', () => {lexerNode = lexer.treeBuilder('=REDUCE({1;2;3},1,#NAME?)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[ErrorType.NAME],[ErrorType.NAME],@@ -103,7 +104,7 @@ describe('Test reduce', () => {lexerNode = lexer.treeBuilder('=REDUCE(1,1,1)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);});});diff --git a/packages/engine-formula/src/functions/logical/scan/__test__/index.spec.ts b/packages/engine-formula/src/functions/logical/scan/__test__/index.spec.tsindex 95f3086f43..aedfc866e8 100644--- a/packages/engine-formula/src/functions/logical/scan/__test__/index.spec.ts+++ b/packages/engine-formula/src/functions/logical/scan/__test__/index.spec.ts@@ -14,13 +14,16 @@* limitations under the License.*/-import { beforeEach, describe, expect, it } from 'vitest';import type { Injector } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+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 { IFunctionService } from '../../../../services/function.service';import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_META } from '../../../meta/function-names';@@ -28,8 +31,6 @@ import { Multiply } from '../../../meta/multiply';import { FUNCTION_NAMES_LOGICAL } from '../../function-names';import { Lambda } from '../../lambda';import { Scan } from '../index';-import type { LexerNode } from '../../../../engine/analysis/lexer-node';-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';describe('Test scan', () => {// const testFunction = new Scan(FUNCTION_NAMES_LOGICAL.SCAN);@@ -60,7 +61,7 @@ describe('Test scan', () => {it('multiply', async () => {let lexerNode = lexer.treeBuilder('=SCAN(1,{1;2;3},LAMBDA(x,y,x*y))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[1],[2],@@ -69,17 +70,17 @@ describe('Test scan', () => {lexerNode = lexer.treeBuilder('=SCAN(1,1,LAMBDA(x,y,x*y))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(1);lexerNode = lexer.treeBuilder('=SCAN(1,{1;2;3},LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);lexerNode = lexer.treeBuilder('=SCAN("test",{1;2;3},LAMBDA(x,y,x*y))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[ErrorType.VALUE],[ErrorType.VALUE],@@ -88,12 +89,12 @@ describe('Test scan', () => {lexerNode = lexer.treeBuilder('=SCAN({1,a,#NAME?;4,5,6},1,LAMBDA(x,y,x*y))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.CALC);lexerNode = lexer.treeBuilder('=SCAN(1,{1,2,#NAME?;4,5,6},LAMBDA(x,y,x*y))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual([[1, 2, ErrorType.NAME],[ErrorType.NAME, ErrorType.NAME, ErrorType.NAME],@@ -103,22 +104,22 @@ describe('Test scan', () => {it('value is error', async () => {let lexerNode = lexer.treeBuilder('=SCAN(#NAME?,1,LAMBDA(x,x*2))');let astNode = astTreeBuilder.parse(lexerNode as LexerNode);- let result = await interpreter.executeAsync(astNode as BaseAstNode);+ let result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=SCAN({1;2;3},#NAME?,LAMBDA(x,x*2))');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=SCAN(1,1,#NAME?)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.NAME);lexerNode = lexer.treeBuilder('=SCAN({1},1,1)');astNode = astTreeBuilder.parse(lexerNode as LexerNode);- result = await interpreter.executeAsync(astNode as BaseAstNode);+ result = await interpreter.executeAsync(generateExecuteAstNodeData(astNode as BaseAstNode));expect(getObjectValue(result)).toStrictEqual(ErrorType.VALUE);});});diff --git a/packages/engine-formula/src/functions/lookup/column/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/column/__tests__/index.spec.tsindex e84a9c42f2..44cdc6def5 100644--- a/packages/engine-formula/src/functions/lookup/column/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/lookup/column/__tests__/index.spec.ts@@ -25,6 +25,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -91,7 +92,7 @@ describe('Test column', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(1);});@@ -100,7 +101,7 @@ describe('Test column', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).toValue()).toStrictEqual([[3]]);});@@ -109,7 +110,7 @@ describe('Test column', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).toValue()).toStrictEqual([[3, 4, 5, 6]]);});@@ -118,7 +119,7 @@ describe('Test column', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});@@ -127,7 +128,7 @@ describe('Test column', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});@@ -136,7 +137,7 @@ describe('Test column', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});@@ -145,7 +146,7 @@ describe('Test column', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});diff --git a/packages/engine-formula/src/functions/lookup/columns/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/columns/__tests__/index.spec.tsindex 93a4679189..0c4e0da2fe 100644--- a/packages/engine-formula/src/functions/lookup/columns/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/lookup/columns/__tests__/index.spec.ts@@ -24,6 +24,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -90,7 +91,7 @@ describe('Test columns', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});@@ -99,7 +100,7 @@ describe('Test columns', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(4);});@@ -108,7 +109,7 @@ describe('Test columns', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});@@ -117,7 +118,7 @@ describe('Test columns', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});@@ -126,7 +127,7 @@ describe('Test columns', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});@@ -135,7 +136,7 @@ describe('Test columns', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});@@ -144,7 +145,7 @@ describe('Test columns', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});diff --git a/packages/engine-formula/src/functions/lookup/index/__test__/index.spec.ts b/packages/engine-formula/src/functions/lookup/index/__test__/index.spec.tsindex dedfcffe5c..fe2f6675d7 100644--- a/packages/engine-formula/src/functions/lookup/index/__test__/index.spec.ts+++ b/packages/engine-formula/src/functions/lookup/index/__test__/index.spec.ts@@ -24,6 +24,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -196,7 +197,7 @@ describe('Test index', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));return getObjectValue(result);};diff --git a/packages/engine-formula/src/functions/lookup/indirect/__test__/index.spec.ts b/packages/engine-formula/src/functions/lookup/indirect/__test__/index.spec.tsindex 8da095b7d4..653f52f0f6 100644--- a/packages/engine-formula/src/functions/lookup/indirect/__test__/index.spec.ts+++ b/packages/engine-formula/src/functions/lookup/indirect/__test__/index.spec.ts@@ -25,6 +25,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -95,7 +96,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);});@@ -105,7 +106,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);});@@ -115,7 +116,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).toValue()).toStrictEqual([[ErrorType.VALUE, ErrorType.VALUE, ErrorType.VALUE, ErrorType.VALUE],@@ -131,7 +132,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);});@@ -141,7 +142,7 @@ describe('Test indirect', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseReferenceObject).toArrayValueObject().toValue()).toStrictEqual([[4]]);});diff --git a/packages/engine-formula/src/functions/lookup/indirect/index.ts b/packages/engine-formula/src/functions/lookup/indirect/index.tsindex 5e808de115..08a783ef0d 100644--- a/packages/engine-formula/src/functions/lookup/indirect/index.ts+++ b/packages/engine-formula/src/functions/lookup/indirect/index.ts@@ -14,17 +14,17 @@* limitations under the License.*/+import type { BaseReferenceObject } from '../../../engine/reference-object/base-reference-object';+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';import { ErrorType } from '../../../basics/error-type';-import { REFERENCE_REGEX_COLUMN, REFERENCE_REGEX_ROW, REFERENCE_SINGLE_RANGE_REGEX } from '../../../basics/regex';+import { regexTestColumn, regexTestRow, regexTestSingeRange } from '../../../basics/regex';import { operatorToken } from '../../../basics/token';-import type { BaseReferenceObject } from '../../../engine/reference-object/base-reference-object';import { CellReferenceObject } from '../../../engine/reference-object/cell-reference-object';import { ColumnReferenceObject } from '../../../engine/reference-object/column-reference-object';import { RangeReferenceObject } from '../../../engine/reference-object/range-reference-object';import { RowReferenceObject } from '../../../engine/reference-object/row-reference-object';import { deserializeRangeForR1C1 } from '../../../engine/utils/r1c1-reference';-import { deserializeRangeWithSheet } from '../../../engine/utils/reference';-import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';+import { deserializeRangeWithSheetWithCache } from '../../../engine/utils/reference';import { type BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';import { BaseFunction } from '../../base-function';@@ -93,18 +93,18 @@ export class Indirect extends BaseFunction {return this._setDefault(rangeReferenceObject);}- if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(refTextV)) {+ if (regexTestSingeRange(refTextV)) {return this._setDefault(new CellReferenceObject(refTextV));}- if (new RegExp(REFERENCE_REGEX_ROW).test(refTextV)) {+ if (regexTestRow(refTextV)) {return this._setDefault(new RowReferenceObject(refTextV));}- if (new RegExp(REFERENCE_REGEX_COLUMN).test(refTextV)) {+ if (regexTestColumn(refTextV)) {return this._setDefault(new ColumnReferenceObject(refTextV));}- const gridRange = deserializeRangeWithSheet(refTextV);+ const gridRange = deserializeRangeWithSheetWithCache(refTextV);const { range, sheetName, unitId } = gridRange;diff --git a/packages/engine-formula/src/functions/lookup/offset/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/offset/__tests__/index.spec.tsindex 564e072f08..f3f99b92be 100644--- a/packages/engine-formula/src/functions/lookup/offset/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/lookup/offset/__tests__/index.spec.ts@@ -24,6 +24,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -191,7 +192,7 @@ describe('Test offset', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));return getObjectValue(result);};diff --git a/packages/engine-formula/src/functions/lookup/row/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/row/__tests__/index.spec.tsindex 6975346459..e71fe924a7 100644--- a/packages/engine-formula/src/functions/lookup/row/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/lookup/row/__tests__/index.spec.ts@@ -25,6 +25,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -91,7 +92,7 @@ describe('Test row', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toStrictEqual(1);});@@ -100,7 +101,7 @@ describe('Test row', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).toValue()).toStrictEqual([[5]]);});@@ -109,7 +110,7 @@ describe('Test row', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ArrayValueObject).toValue()).toStrictEqual([[5], [6], [7], [8], [9], [10]]);});@@ -118,7 +119,7 @@ describe('Test row', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});@@ -127,7 +128,7 @@ describe('Test row', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});@@ -136,7 +137,7 @@ describe('Test row', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});@@ -145,7 +146,7 @@ describe('Test row', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});diff --git a/packages/engine-formula/src/functions/lookup/rows/__tests__/index.spec.ts b/packages/engine-formula/src/functions/lookup/rows/__tests__/index.spec.tsindex 237dccfcbf..da0986705b 100644--- a/packages/engine-formula/src/functions/lookup/rows/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/lookup/rows/__tests__/index.spec.ts@@ -24,6 +24,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -90,7 +91,7 @@ describe('Test rows', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});@@ -99,7 +100,7 @@ describe('Test rows', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(2);});@@ -108,7 +109,7 @@ describe('Test rows', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as ErrorValueObject).getValue()).toBe(ErrorType.NA);});@@ -117,7 +118,7 @@ describe('Test rows', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});@@ -126,7 +127,7 @@ describe('Test rows', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});@@ -135,7 +136,7 @@ describe('Test rows', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});@@ -144,7 +145,7 @@ describe('Test rows', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));expect((result as BaseValueObject).getValue()).toBe(1);});diff --git a/packages/engine-formula/src/functions/math/subtotal/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/subtotal/__tests__/index.spec.tsindex 66f6e7f489..db9370347b 100644--- a/packages/engine-formula/src/functions/math/subtotal/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/math/subtotal/__tests__/index.spec.ts@@ -26,6 +26,7 @@ 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 { stripErrorMargin } from '../../../../engine/utils/math-kit';import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';@@ -189,7 +190,7 @@ describe('Test subtotal', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));if ((result as ErrorValueObject).isError()) {return (result as ErrorValueObject).getValue();diff --git a/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.tsindex a595fb7a85..5e2a96d5d6 100644--- a/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts@@ -26,6 +26,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -208,7 +209,7 @@ describe('Test isref function', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));if ((result as ErrorValueObject).isError()) {return (result as ErrorValueObject).getValue();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 6adeeb002f..35454d6a93 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@@ -24,6 +24,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -145,7 +146,7 @@ describe('Test rank function', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));return getObjectValue(result);};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 74dbb5884c..ab5d20726a 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@@ -24,6 +24,7 @@ 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 { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';@@ -145,7 +146,7 @@ describe('Test rank function', () => {const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const result = interpreter.execute(astNode as BaseAstNode);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));return getObjectValue(result);};diff --git a/packages/engine-formula/src/services/calculate-formula.service.ts b/packages/engine-formula/src/services/calculate-formula.service.tsindex cc1d4a7c8c..5c9cb5c741 100644--- a/packages/engine-formula/src/services/calculate-formula.service.ts+++ b/packages/engine-formula/src/services/calculate-formula.service.ts@@ -260,11 +260,11 @@ export class CalculateFormulaService extends Disposable {}const tree = treeList[i];- const astNode = tree.node;+ const nodeData = tree.nodeData;const getDirtyData = tree.getDirtyData;let value: FunctionVariantType;- if (astNode == null && getDirtyData == null) {+ if (nodeData == null && getDirtyData == null) {throw new Error('AstNode or executor is null');}@@ -288,11 +288,11 @@ export class CalculateFormulaService extends Disposable {this._runtimeService.setRuntimeFeatureCellData(tree.featureId, runtimeCellData);this._runtimeService.setRuntimeFeatureRange(tree.featureId, dirtyRanges);- } else if (astNode != null) {- if (interpreter.checkAsyncNode(astNode)) {- value = await interpreter.executeAsync(astNode);+ } else if (nodeData != null) {+ if (interpreter.checkAsyncNode(nodeData.node)) {+ value = await interpreter.executeAsync(nodeData);} else {- value = interpreter.execute(astNode);+ value = interpreter.execute(nodeData);}if (tree.formulaId != null) {@@ -327,6 +327,8 @@ export class CalculateFormulaService extends Disposable {this._runtimeService.markedAsNoFunctionsExecuted();}+ this._runtimeService.clearReferenceAndNumberformatCache();+return this._runtimeService.getAllRuntimeData();}diff --git a/packages/engine-formula/src/services/dependency-manager.service.ts b/packages/engine-formula/src/services/dependency-manager.service.tsindex 67751c0425..caef14704f 100644--- a/packages/engine-formula/src/services/dependency-manager.service.ts+++ b/packages/engine-formula/src/services/dependency-manager.service.ts@@ -67,7 +67,7 @@ export interface IDependencyManagerService {searchDependency(search: IUnitRange[]): Map<string, IRTreeItem>;- hasTreeIdInCache(treeId: string): boolean;+ getLastTreeId(): number;clearDependencyAll(): void;@@ -90,14 +90,14 @@ export class DependencyManagerService extends Disposable implements IDependencyMprivate _dependencyRTreeCache: RTree = new RTree();- private _dependencyTreeIdsCache: Set<string> = new Set();+ private _dependencyTreeIdLast: number = 0;override dispose(): void {this._otherFormulaData = {};this._featureFormulaData = {};this._formulaData = {};this._dependencyRTreeCache.dispose();- this._clearTreeIdCache();+ this._restDependencyTreeId();}/**@@ -107,47 +107,60 @@ export class DependencyManagerService extends Disposable implements IDependencyMgetAllTree() {const trees: FormulaDependencyTree[] = [];- Object.values(this._otherFormulaData).forEach((unit) => {- if (unit == null) {- return true;+ const resetAndPush = (item: FormulaDependencyTree) => {+ if (item) {+ item.resetState();+ trees.push(item);}- Object.values(unit).forEach((sheet) => {- Object.values(sheet).forEach((formula) => {- if (formula) {- formula.resetState();- trees.push(formula);+ };++ // _otherFormulaData+ for (const unitKey in this._otherFormulaData) {+ const unit = this._otherFormulaData[unitKey];+ if (!unit) continue;++ for (const sheetKey in unit) {+ const sheet = unit[sheetKey];+ for (const formulaKey in sheet) {+ if (sheet[formulaKey] == null) {+ continue;}- });- });- });-- Object.values(this._featureFormulaData).forEach((unit) => {- if (unit == null) {- return true;+ resetAndPush(sheet[formulaKey]);+ }}- Object.values(unit).forEach((sheet) => {- Object.values(sheet).forEach((feature) => {- if (feature) {- feature.resetState();- trees.push(feature);- }- });- });- });+ }- Object.values(this._formulaData).map((unit) => {- if (unit == null) {- return [];+ // _featureFormulaData+ for (const unitKey in this._featureFormulaData) {+ const unit = this._featureFormulaData[unitKey];+ if (!unit) continue;++ for (const sheetKey in unit) {+ const sheet = unit[sheetKey];+ for (const featureKey in sheet) {+ if (sheet[featureKey] == null) {+ continue;+ }+ resetAndPush(sheet[featureKey]);+ }}- return Object.values(unit).forEach((sheet) => {- return sheet.forValue((row, col, item) => {- if (item) {- item.resetState();- trees.push(item);+ }++ // _formulaData+ for (const unitKey in this._formulaData) {+ const unit = this._formulaData[unitKey];+ if (!unit) continue;++ for (const sheetKey in unit) {+ const sheet = unit[sheetKey];+ sheet.forValue((row, col, item) => {+ if (item == null) {+ return true;}+ resetAndPush(item);});- });- });+ }+ }return trees;}@@ -175,32 +188,27 @@ export class DependencyManagerService extends Disposable implements IDependencyM*/private _buildDependencyTree(allTrees: FormulaDependencyTree[], shouldBeBuildTrees: FormulaDependencyTree[]) {const shouldBeBuildTreeMap = new Map<string, FormulaDependencyTree>();- shouldBeBuildTrees.forEach((tree) => shouldBeBuildTreeMap.set(tree.treeId, tree));+ for (let i = 0; i < shouldBeBuildTrees.length; i++) {+ const tree = shouldBeBuildTrees[i];+ shouldBeBuildTreeMap.set(tree.treeId, tree);+ }- allTrees.forEach((tree) => {+ for (let i = 0; i < allTrees.length; i++) {+ const tree = allTrees[i];const RTreeItem = tree.toRTreeItem();+const searchResults = this._dependencyRTreeCache.search(RTreeItem);- searchResults.forEach((searchResult) => {+ for (let j = 0; j < searchResults.length; j++) {+ const searchResult = searchResults[j];const shouldBeBuildTree = shouldBeBuildTreeMap.get(searchResult.id);- if (shouldBeBuildTree) {- if (tree === shouldBeBuildTree || shouldBeBuildTree.hasChildren(tree)) {- return;- }++ if (shouldBeBuildTree && tree !== shouldBeBuildTree && !shouldBeBuildTree.hasChildren(tree)) {shouldBeBuildTree.pushChildren(tree);}- });-- // shouldBeBuildTrees.forEach((shouldBeBuildTree) => {- // if (tree === shouldBeBuildTree || shouldBeBuildTree.children.includes(tree)) {- // return true;- // }+ }+ }- // if (shouldBeBuildTree.dependency(tree)) {- // shouldBeBuildTree.pushChildren(tree);- // }- // });- });shouldBeBuildTreeMap.clear();}@@ -211,36 +219,29 @@ export class DependencyManagerService extends Disposable implements IDependencyM*/private _buildReverseDependency(allTrees: FormulaDependencyTree[], dependencyTrees: FormulaDependencyTree[]) {const allTreeMap = new Map<string, FormulaDependencyTree>();- allTrees.forEach((tree) => allTreeMap.set(tree.treeId, tree));- dependencyTrees.forEach((tree) => {+ for (let i = 0; i < allTrees.length; i++) {+ const tree = allTrees[i];+ allTreeMap.set(tree.treeId, tree);+ }++ for (let i = 0; i < dependencyTrees.length; i++) {+ const tree = dependencyTrees[i];const RTreeItem = tree.toRTreeItem();+const searchResults = this._dependencyRTreeCache.search(RTreeItem);- searchResults.forEach((searchResult) => {+ for (let j = 0; j < searchResults.length; j++) {+ const searchResult = searchResults[j];const allTree = allTreeMap.get(searchResult.id);- if (allTree) {- if (tree === allTree || allTree.hasChildren(tree)) {- return;- }++ if (allTree && tree !== allTree && !allTree.hasChildren(tree)) {allTree.pushChildren(tree);}- });- });+ }+ }allTreeMap.clear();-- // allTrees.forEach((tree) => {- // dependencyTrees?.forEach((dependencyTree) => {- // if (tree === dependencyTree || tree.children.includes(dependencyTree)) {- // return true;- // }-- // if (tree.dependency(dependencyTree)) {- // tree.pushChildren(dependencyTree);- // }- // });- // });}/**@@ -279,7 +280,7 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._featureFormulaData = {};this._formulaData = {};this._dependencyRTreeCache.clear();- this._clearTreeIdCache();+ this._restDependencyTreeId();}addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: FormulaDependencyTree) {@@ -291,8 +292,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM}this._otherFormulaData[unitId]![sheetId][formulaId] = dependencyTree;-- this._addTreeIdToCache(dependencyTree);}removeOtherFormulaDependency(unitId: string, sheetId: string, formulaIds: string[]) {@@ -302,8 +301,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._removeDependencyRTreeCache(deleteTree);this.clearDependencyForTree(deleteTree);delete this._otherFormulaData[unitId]![sheetId][formulaId];-- this._removeTreeIdFromCache(deleteTree);});}}@@ -321,7 +318,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._removeDependencyRTreeCacheById(unitId, sheetId);Object.values(this._otherFormulaData[unitId]![sheetId]).forEach((formula) => {this.clearDependencyForTree(formula);- this._removeTreeIdFromCache(formula);});this._otherFormulaData[unitId]![sheetId] = {};@@ -334,7 +330,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._removeDependencyRTreeCacheById(unitId, sheetId);Object.values(unitOtherData[sheetId]!).forEach((formula) => {this.clearDependencyForTree(formula);- this._removeTreeIdFromCache(formula);});});@@ -351,8 +346,6 @@ export class DependencyManagerService extends Disposable implements IDependencyM}this._featureFormulaData[unitId]![sheetId][featureId] = dependencyTree;-- this._addTreeIdToCache(dependencyTree);}removeFeatureFormulaDependency(unitId: string, sheetId: string, featureIds: string[]) {@@ -362,8 +355,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._removeDependencyRTreeCache(deleteTree);this.clearDependencyForTree(deleteTree);delete this._featureFormulaData[unitId]![sheetId][featureId];-- this._removeTreeIdFromCache(deleteTree);});}}@@ -374,7 +365,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMObject.values(this._featureFormulaData[unitId]![sheetId]).forEach((feature) => {this._removeDependencyRTreeCache(feature);this.clearDependencyForTree(feature);- this._removeTreeIdFromCache(feature);});this._featureFormulaData[unitId]![sheetId] = {};@@ -387,7 +377,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._removeDependencyRTreeCacheById(unitId, sheetId);Object.values(unitFeatureData[sheetId]!).forEach((feature) => {this.clearDependencyForTree(feature);- this._removeTreeIdFromCache(feature);});});@@ -407,8 +396,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._formulaData[unitId]![sheetId] = new ObjectMatrix<Nullable<FormulaDependencyTree>>();}this._formulaData[unitId]![sheetId].setValue(row, column, dependencyTree);-- this._addTreeIdToCache(dependencyTree);}removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number) {@@ -417,8 +404,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._removeDependencyRTreeCache(deleteTree);this.clearDependencyForTree(deleteTree);this._formulaData[unitId]![sheetId].realDeleteValue(row, column);-- this._removeTreeIdFromCache(deleteTree);}}@@ -427,7 +412,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._removeDependencyRTreeCacheById(unitId, sheetId);this._formulaData[unitId]![sheetId].forValue((row, column, item) => {this.clearDependencyForTree(item);- this._removeTreeIdFromCache(item);});this._formulaData[unitId]![sheetId].reset();@@ -440,7 +424,6 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._removeDependencyRTreeCacheById(unitId, sheetId);unitFormulaData[sheetId].forValue((row, column, item) => {this.clearDependencyForTree(item);- this._removeTreeIdFromCache(item);});});@@ -453,7 +436,7 @@ export class DependencyManagerService extends Disposable implements IDependencyMthis._featureFormulaData = {};this._formulaData = {};this._dependencyRTreeCache.clear();- this._clearTreeIdCache();+ this._restDependencyTreeId();}getFormulaDependency(unitId: string, sheetId: string, row: number, column: number) {@@ -469,23 +452,14 @@ export class DependencyManagerService extends Disposable implements IDependencyM}));}- private _addTreeIdToCache(tree: FormulaDependencyTree) {- this._dependencyTreeIdsCache.add(tree.treeId);- }-- private _removeTreeIdFromCache(tree: Nullable<FormulaDependencyTree>) {- if (tree == null) {- return;- }- this._dependencyTreeIdsCache.delete(tree.treeId);- }-- private _clearTreeIdCache() {- this._dependencyTreeIdsCache.clear();+ private _restDependencyTreeId() {+ this._dependencyTreeIdLast = 0;}- hasTreeIdInCache(treeId: string) {- return this._dependencyTreeIdsCache.has(treeId);+ getLastTreeId() {+ const id = this._dependencyTreeIdLast;+ this._dependencyTreeIdLast++;+ return id;}private _removeDependencyRTreeCacheById(unitId: string, sheetId: string) {@@ -508,11 +482,10 @@ export class DependencyManagerService extends Disposable implements IDependencyMif (this._formulaData[unitId]) {Object.values(this._formulaData[unitId]).forEach((sheet) => {sheet.forValue((row, column, tree) => {- if (tree?.node?.hasDefinedName(definedName)) {+ if (tree?.nodeData?.node.hasDefinedName(definedName)) {this._removeDependencyRTreeCache(tree);this.clearDependencyForTree(tree);sheet.realDeleteValue(row, column);- this._removeTreeIdFromCache(tree);}});});diff --git a/packages/engine-formula/src/services/runtime.service.ts b/packages/engine-formula/src/services/runtime.service.tsindex 82cb58d722..1fc391e581 100644--- a/packages/engine-formula/src/services/runtime.service.ts+++ b/packages/engine-formula/src/services/runtime.service.ts@@ -30,6 +30,8 @@ import { isInDirtyRange } from '../basics/dirty';import { ErrorType } from '../basics/error-type';import { CELL_INVERTED_INDEX_CACHE } from '../basics/inverted-index-cache';import { getRuntimeFeatureCell } from '../engine/utils/get-runtime-feature-cell';+import { clearNumberFormatTypeCache } from '../engine/utils/numfmt-kit';+import { clearReferenceToRangeCache } from '../engine/utils/reference';import { objectValueToCellValue } from '../engine/utils/value-object';import { type BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';import { IFormulaCurrentConfigService } from './current-data.service';@@ -174,6 +176,8 @@ export interface IFormulaRuntimeService {setRuntimeFeatureCellData(featureId: string, featureData: IRuntimeUnitDataType): void;setRuntimeFeatureRange(featureId: string, featureRange: IFeatureDirtyRangeType): void;++ clearReferenceAndNumberformatCache(): void;}export class FormulaRuntimeService extends Disposable implements IFormulaRuntimeService {@@ -253,6 +257,7 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntimethis.reset();this._runtimeFeatureCellData = {};this._runtimeFeatureRange = {};+ this.clearReferenceAndNumberformatCache();}enableCycleDependency() {@@ -363,6 +368,11 @@ export class FormulaRuntimeService extends Disposable implements IFormulaRuntimethis._completedFormulasCount = 0;}+ clearReferenceAndNumberformatCache() {+ clearNumberFormatTypeCache();+ clearReferenceToRangeCache();+ }+setCurrent(row: number, column: number, rowCount: number, columnCount: number, sheetId: string, unitId: string) {this._currentRow = row;this._currentColumn = column;diff --git a/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts b/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.tsindex d81e37dad5..8fca0ef8be 100644--- a/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts+++ b/packages/sheets-ui/src/controllers/render-controllers/sheet.render-controller.ts@@ -15,8 +15,10 @@*/import type { ICommandInfo, IExecutionOptions, IRange, Nullable, Workbook, Worksheet } from '@univerjs/core';+import type { ISetFormulaCalculationNotificationMutation } from '@univerjs/engine-formula';import type { IAfterRender$Info, IBasicFrameInfo, IExtendFrameInfo, IRenderContext, IRenderModule, ISummaryFrameInfo, ITimeMetric, IViewportInfos, Scene } from '@univerjs/engine-render';import { CommandType, ICommandService, IContextService, Inject, Optional, Rectangle, RxDisposable } from '@univerjs/core';+import { SetFormulaCalculationNotificationMutation } from '@univerjs/engine-formula';import {Rect,ScrollBar,@@ -29,8 +31,8 @@ import {} from '@univerjs/engine-render';import { COMMAND_LISTENER_SKELETON_CHANGE, COMMAND_LISTENER_VALUE_CHANGE, MoveRangeMutation, SetRangeValuesMutation, SetWorksheetActiveOperation } from '@univerjs/sheets';import { ITelemetryService } from '@univerjs/telemetry';-import { Subject, withLatestFrom } from 'rxjs';+import { Subject, withLatestFrom } from 'rxjs';import {SHEET_COMPONENT_HEADER_LAYER_INDEX,SHEET_COMPONENT_MAIN_LAYER_INDEX,@@ -424,6 +426,13 @@ export class SheetRenderController extends RxDisposable implements IRenderModuleprivate _markUnitDirty(unitId: string, command: ICommandInfo) {const { mainComponent: spreadsheet, scene } = this._context;+ if (command.id === SetFormulaCalculationNotificationMutation.id) {+ const params = command.params as ISetFormulaCalculationNotificationMutation;+ if (params.stageInfo != null) {+ return;+ }+ }+if (spreadsheet) {spreadsheet.makeDirty(); // refresh spreadsheet}