@univerjs/engine-formula 0.12.4 → 0.13.0-insiders.20251215-64041bb

package/lib/types/basics/common.d.ts

@@ -1,4 +1,5 @@
 import { ICellData, IColumnData, IObjectArrayPrimitiveType, IObjectMatrixPrimitiveType, IRange, IRowData, IUnitRange, Nullable, ObjectMatrix, Styles } from '@univerjs/core';
+import { sequenceNodeType } from '../engine/utils/sequence';
 import { IImageFormulaInfo } from '../engine/value-object/primitive-object';
 export declare const ERROR_VALUE_OBJECT_CLASS_TYPE = "errorValueObject";
 export declare const ASYNC_OBJECT_CLASS_TYPE = "asyncObject";
@@ -126,6 +127,20 @@ export interface IFormulaIdMap {
     r: number;
     c: number;
 }
+export interface IFormulaStringMap {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IObjectMatrixPrimitiveType<string[]>;
+    }>;
+}
+export interface IFormulaExecuteResultItem {
+    value: Nullable<number | string | boolean | Array<Array<number | string | boolean | null>>>;
+    formula: string;
+}
+export interface IFormulaExecuteResultMap {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IObjectMatrixPrimitiveType<IFormulaExecuteResultItem[]>;
+    }>;
+}
 export interface IFormulaIdMapData {
     [unitId: string]: Nullable<{
         [subUnitId: string]: Nullable<{
@@ -192,9 +207,15 @@ export interface IFormulaDatasetConfig {
     unitStylesData?: IUnitStylesData;
     unitSheetNameMap?: IUnitSheetNameMap;
     maxIteration?: number;
+    isCalculateTreeModel?: boolean;
     rowData?: IUnitRowData;
 }
 export declare enum ConcatenateType {
     FRONT = 0,
     BACK = 1
 }
+export interface IExprTreeNode {
+    value: string;
+    children: IExprTreeNode[];
+    type?: sequenceNodeType;
+}

package/lib/types/basics/date.d.ts

@@ -33,7 +33,6 @@ export declare function formatDateDefault(date: Date): string;
  */
 export declare function isValidDateStr(dateStr: string): boolean;
 export declare function parseFormattedDate(value: string): numfmt.ParseData | null;
-export declare function parseFormattedValue(value: string): numfmt.ParseData | null;
 export declare function parseFormattedTime(value: string): numfmt.ParseData | null;
 export declare function isDate(format: string): boolean;
 export declare function isValidWeekend(weekend: number | string): boolean;

package/lib/types/basics/match-token.d.ts

@@ -1,5 +1,5 @@
 import { compareToken, matchToken, operatorToken, prefixToken, suffixToken } from './token';
-export declare const FORMULA_LEXER_TOKENS: (operatorToken | suffixToken | compareToken | matchToken | prefixToken)[];
+export declare const FORMULA_LEXER_TOKENS: (operatorToken | suffixToken | compareToken | prefixToken | matchToken)[];
 export declare function isFormulaLexerToken(str: string): boolean;
 export declare function includeFormulaLexerToken(str: string): boolean;
 export declare function normalizeSheetName(sheetName: string): string;

package/lib/types/commands/mutations/set-formula-calculation.mutation.d.ts

@@ -1,15 +1,46 @@
-import { IExecutionOptions, IMutation, Nullable } from '@univerjs/core';
-import { IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
+import { IExecutionOptions, IMutation, IUnitRange, Nullable } from '@univerjs/core';
+import { IFormulaExecuteResultMap, IFormulaStringMap, IRuntimeOtherUnitDataType, IRuntimeUnitDataPrimitiveType } from '../../basics/common';
+import { IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson } from '../../engine/dependency/dependency-tree';
 import { IFormulaDirtyData } from '../../services/current-data.service';
 import { FormulaExecutedStateType, IExecutionInProgressParams } from '../../services/runtime.service';
 export interface ISetFormulaCalculationStartMutation extends IFormulaDirtyData {
     options: Nullable<IExecutionOptions>;
 }
+export interface ISetFormulaStringBatchCalculationMutation {
+    formulas: IFormulaStringMap;
+}
+export interface ISetFormulaStringBatchCalculationResultMutation {
+    result: IFormulaExecuteResultMap;
+}
+export interface ISetFormulaStringBatchCalculationResultMutation {
+    result: IFormulaExecuteResultMap;
+}
+export interface ISetFormulaDependencyCalculationMutation {
+    unitId: string;
+    sheetId: string;
+    row: number;
+    column: number;
+}
+export interface ISetFormulaDependencyCalculationResultMutation {
+    result: IFormulaDependencyTreeJson[];
+}
+export interface ISetCellFormulaDependencyCalculationResultMutation {
+    result: IFormulaDependencyTreeFullJson | undefined;
+}
+export interface ISetQueryFormulaDependencyMutation {
+    unitRanges: IUnitRange[];
+    isInRange?: boolean;
+}
+export interface ISetQueryFormulaDependencyResultMutation {
+    result: IFormulaDependencyTreeJson[];
+}
 /**
  * TODO: @DR-Univer
  * Trigger the calculation of the formula and stop the formula
  */
 export declare const SetFormulaCalculationStartMutation: IMutation<ISetFormulaCalculationStartMutation>;
+export declare const SetFormulaStringBatchCalculationMutation: IMutation<ISetFormulaStringBatchCalculationMutation>;
+export declare const SetFormulaStringBatchCalculationResultMutation: IMutation<ISetFormulaStringBatchCalculationResultMutation>;
 export interface ISetFormulaCalculationStopMutation {
 }
 export declare const SetFormulaCalculationStopMutation: IMutation<ISetFormulaCalculationStopMutation>;
@@ -23,3 +54,9 @@ export interface ISetFormulaCalculationResultMutation {
     unitOtherData: IRuntimeOtherUnitDataType;
 }
 export declare const SetFormulaCalculationResultMutation: IMutation<ISetFormulaCalculationResultMutation>;
+export declare const SetFormulaDependencyCalculationMutation: IMutation<{}>;
+export declare const SetFormulaDependencyCalculationResultMutation: IMutation<ISetFormulaDependencyCalculationResultMutation>;
+export declare const SetCellFormulaDependencyCalculationMutation: IMutation<ISetFormulaDependencyCalculationMutation>;
+export declare const SetCellFormulaDependencyCalculationResultMutation: IMutation<ISetCellFormulaDependencyCalculationResultMutation>;
+export declare const SetQueryFormulaDependencyMutation: IMutation<ISetQueryFormulaDependencyMutation>;
+export declare const SetQueryFormulaDependencyResultMutation: IMutation<ISetQueryFormulaDependencyResultMutation>;

package/lib/types/controller/calculate.controller.d.ts

@@ -9,6 +9,10 @@ export declare class CalculateController extends Disposable {
     private _initialize;
     private _commandExecutedListener;
     private _calculate;
+    private _queryFormulaDependencyJson;
+    private _generateAllDependencyTreeJson;
+    private _generateCellDependencyTreeJson;
+    private _calculateFormulaString;
     private _initialExecuteFormulaListener;
     private _applyResult;
 }

package/lib/types/controller/config.schema.d.ts

@@ -4,6 +4,7 @@ import { BaseFunction } from '../functions/base-function';
 export declare const ENGINE_FORMULA_PLUGIN_CONFIG_KEY = "engine-formula.config";
 export declare const DEFAULT_CYCLE_REFERENCE_COUNT = 1;
 export declare const ENGINE_FORMULA_CYCLE_REFERENCE_COUNT = "CYCLE_REFERENCE_COUNT";
+export declare const ENGINE_FORMULA_RETURN_DEPENDENCY_TREE = "RETURN_DEPENDENCY_TREE";
 export declare const configSymbol: unique symbol;
 export interface IUniverEngineFormulaConfig {
     notExecuteFormula?: boolean;

package/lib/types/engine/analysis/lexer-tree-builder.d.ts

@@ -1,5 +1,5 @@
 import { Nullable, AbsoluteRefType, Disposable } from '@univerjs/core';
-import { IDirtyUnitSheetDefinedNameMap } from '../../basics/common';
+import { IDirtyUnitSheetDefinedNameMap, IExprTreeNode, ISuperTable } from '../../basics/common';
 import { IFunctionNames } from '../../basics/function';
 import { IDefinedNamesServiceParam } from '../../services/defined-names.service';
 import { ISequenceArray, ISequenceNode } from '../utils/sequence';
@@ -145,5 +145,6 @@ export declare class LexerTreeBuilder extends Disposable {
     private _isScientificNotation;
     private _addSequenceArray;
     getNewFormulaWithPrefix(formulaString: string, hasFunction: (functionToken: IFunctionNames) => boolean): string | null;
+    getFormulaExprTree(formulaString: string, unitId: string, hasFunction: (functionToken: IFunctionNames) => boolean, getDefinedNameName: (unitId: string, name: string) => Nullable<IDefinedNamesServiceParam>, getTable: (unitId: string, tableName: string) => Nullable<ISuperTable>): IExprTreeNode | null;
 }
 export {};

package/lib/types/engine/ast-node/reference-node.d.ts

@@ -36,7 +36,6 @@ export declare class ReferenceNodeFactory extends BaseAstNodeFactory {
     private _getTableMap;
     private _getNode;
     private _getTableReferenceNode;
-    private _splitTableStructuredRef;
     private _checkTokenIsTableReference;
     private _checkParentIsUnionOperator;
 }

package/lib/types/engine/dependency/dependency-tree.d.ts

@@ -115,4 +115,43 @@ export declare class FormulaDependencyTree extends FormulaDependencyTreeCalculat
     shouldBePushRangeList(): boolean;
     toRTreeItem(): IUnitRange[];
 }
+interface IFormulaDependencyTreeJsonBase {
+    treeId: number;
+    formula: string;
+    row: number;
+    column: number;
+    unitId: string;
+    subUnitId: string;
+    refOffsetX: number;
+    refOffsetY: number;
+    rangeList: IUnitRange[];
+    refTreeId: number | undefined;
+}
+export interface IFormulaDependencyTreeJson extends IFormulaDependencyTreeJsonBase {
+    children: number[];
+    parents: number[];
+}
+export interface IFormulaDependencyTreeFullJson extends IFormulaDependencyTreeJsonBase {
+    children: IFormulaDependencyTreeJson[];
+    parents: IFormulaDependencyTreeJson[];
+}
+export declare class FormulaDependencyTreeModel {
+    children: Set<FormulaDependencyTreeModel>;
+    parents: Set<FormulaDependencyTreeModel>;
+    treeId: number;
+    formula: string;
+    refOffsetX: number;
+    refOffsetY: number;
+    row: number;
+    column: number;
+    unitId: string;
+    subUnitId: string;
+    rangeList: IUnitRange[];
+    refTreeId: number | undefined;
+    constructor(tree: IFormulaDependencyTree);
+    toJson(): IFormulaDependencyTreeJson;
+    toFullJson(): IFormulaDependencyTreeFullJson;
+    addParent(parent: FormulaDependencyTreeModel): void;
+    addChild(child: FormulaDependencyTreeModel): void;
+}
 export {};

package/lib/types/engine/dependency/formula-dependency.d.ts

@@ -4,17 +4,22 @@ import { IFeatureCalculationManagerParam, IFeatureCalculationManagerService } fr
 import { FunctionNode } from '../ast-node';
 import { BaseAstNode } from '../ast-node/base-ast-node';
 import { IExecuteAstNodeData } from '../utils/ast-node-tool';
-import { IFormulaDependencyTree, FormulaDependencyTree, FormulaDependencyTreeVirtual } from './dependency-tree';
+import { IFormulaDependencyTree, IFormulaDependencyTreeFullJson, IFormulaDependencyTreeJson, FormulaDependencyTree, FormulaDependencyTreeModel, FormulaDependencyTreeVirtual } from './dependency-tree';
 import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IDependencyManagerService } from '../../services/dependency-manager.service';
 import { IOtherFormulaManagerService } from '../../services/other-formula-manager.service';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
 import { Lexer } from '../analysis/lexer';
+import { LexerTreeBuilder } from '../analysis/lexer-tree-builder';
 import { AstTreeBuilder } from '../analysis/parser';
 import { Interpreter } from '../interpreter/interpreter';
 export declare function generateRandomDependencyTreeId(dependencyManagerService: IDependencyManagerService): number;
 export interface IFormulaDependencyGenerator {
-    generate(): Promise<IFormulaDependencyTree[]>;
+    generate(isCalculateTreeModel?: boolean): Promise<IFormulaDependencyTree[]>;
+    getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
+    getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
 }
 export declare const IFormulaDependencyGenerator: import('@wendellhu/redi').IdentifierDecorator<IFormulaDependencyGenerator>;
 export declare class FormulaDependencyGenerator extends Disposable {
@@ -26,11 +31,12 @@ export declare class FormulaDependencyGenerator extends Disposable {
     protected readonly _astTreeBuilder: AstTreeBuilder;
     protected readonly _lexer: Lexer;
     protected readonly _dependencyManagerService: IDependencyManagerService;
+    protected readonly _lexerTreeBuilder: LexerTreeBuilder;
     private _updateRangeFlattenCache;
     protected _dependencyRTreeCacheForAddressFunction: RTree;
-    constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _otherFormulaManagerService: IOtherFormulaManagerService, _featureCalculationManagerService: IFeatureCalculationManagerService, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder, _lexer: Lexer, _dependencyManagerService: IDependencyManagerService);
+    constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _otherFormulaManagerService: IOtherFormulaManagerService, _featureCalculationManagerService: IFeatureCalculationManagerService, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder, _lexer: Lexer, _dependencyManagerService: IDependencyManagerService, _lexerTreeBuilder: LexerTreeBuilder);
     dispose(): void;
-    generate(): Promise<(FormulaDependencyTree | FormulaDependencyTreeVirtual)[]>;
+    generate(isCalculateTreeModel?: boolean): Promise<(FormulaDependencyTree | FormulaDependencyTreeVirtual)[]>;
     private _dependencyFeatureCalculation;
     private _clearFeatureCalculationNode;
     /**
@@ -110,4 +116,19 @@ export declare class FormulaDependencyGenerator extends Disposable {
      * @param treeList
      */
     protected _calculateRunList(treeList: IFormulaDependencyTree[]): (FormulaDependencyTree | FormulaDependencyTreeVirtual)[];
+    protected _initializeGenerateTreeList(): Promise<IFormulaDependencyTree[]>;
+    protected _getAllTreeList(): Promise<IFormulaDependencyTree[]>;
+    protected _formulaDependencyTreeModel: Map<number, FormulaDependencyTreeModel>;
+    protected _getTreeModel(treeId: number): FormulaDependencyTreeModel;
+    protected _getDependencyTreeParenIds(tree: IFormulaDependencyTree): Set<number>;
+    protected _getDependencyTreeChildrenIds(tree: IFormulaDependencyTree): Set<number>;
+    protected _getFormulaDependencyTreeModel(tree: IFormulaDependencyTree): FormulaDependencyTreeModel;
+    protected _endFormulaDependencyTreeModel(): void;
+    protected _startFormulaDependencyTreeModel(): void;
+    protected _getAllDependencyJson(treeList: IFormulaDependencyTree[]): IFormulaDependencyTreeJson[];
+    getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
+    protected _setRealFormulaString(treeModel: FormulaDependencyTreeModel): void;
+    getCellDependencyJson(unitId: string, sheetId: string, row: number, column: number): Promise<IFormulaDependencyTreeFullJson | undefined>;
+    getRangeDependents(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
+    getInRangeFormulas(unitRanges: IUnitRange[]): Promise<IFormulaDependencyTreeJson[]>;
 }

package/lib/types/engine/utils/reference.d.ts

@@ -85,3 +85,12 @@ export declare function quoteSheetName(name: string): string;
  * @returns Unquoted name
  */
 export declare function unquoteSheetName(name: string): string;
+export declare function splitTableStructuredRef(ref: string): {
+    tableName: string;
+    struct: string;
+    columnStruct?: undefined;
+} | {
+    tableName: string;
+    columnStruct: string;
+    struct?: undefined;
+};

package/lib/types/engine/utils/sequence.d.ts

@@ -6,7 +6,8 @@ export declare enum sequenceNodeType {
     FUNCTION = 3,
     REFERENCE = 4,
     ARRAY = 5,
-    DEFINED_NAME = 6
+    DEFINED_NAME = 6,
+    TABLE = 7
 }
 export interface ISequenceNode {
     nodeType: sequenceNodeType;