@univerjs/engine-formula 0.5.1 → 0.5.2

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

@@ -169,6 +169,7 @@ export interface IFormulaDatasetConfig {
     allUnitData?: IUnitData;
     unitStylesData?: IUnitStylesData;
     unitSheetNameMap?: IUnitSheetNameMap;
+    maxIteration?: number;
 }
 export declare enum ConcatenateType {
     FRONT = 0,

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

@@ -2,6 +2,8 @@ import { Ctor } from '@univerjs/core';
 import { IFunctionNames } from '../basics/function';
 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 configSymbol: unique symbol;
 export interface IUniverEngineFormulaConfig {
     notExecuteFormula?: boolean;

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

@@ -40,7 +40,7 @@ export declare class LexerTreeBuilder extends Disposable {
      */
     checkIfAddBracket(formulaString: string): number;
     sequenceNodesBuilder(formulaString: string): (string | ISequenceNode)[] | undefined;
-    convertRefersToAbsolute(formulaString: string, startAbsoluteRefType: AbsoluteRefType, endAbsoluteRefType: AbsoluteRefType): string;
+    convertRefersToAbsolute(formulaString: string, startAbsoluteRefType: AbsoluteRefType, endAbsoluteRefType: AbsoluteRefType, currentSheetName?: string): string;
     moveFormulaRefOffset(formulaString: string, refOffsetX: number, refOffsetY: number, ignoreAbsolute?: boolean): string;
     /**
      * univer-pro/issues/1684

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

@@ -1,7 +1,7 @@
 import { IDirtyUnitSheetNameMap, IFeatureDirtyRangeType, IRuntimeUnitDataType, IUnitExcludedCell } from '../../basics/common';
 import { IFormulaDirtyData } from '../../services/current-data.service';
 import { IAllRuntimeData } from '../../services/runtime.service';
-import { AstRootNode } from '../ast-node';
+import { AstRootNode, FunctionNode } from '../ast-node';
 import { IRange, IUnitRange, Nullable } from '@univerjs/core';
 export declare enum FDtreeStateType {
     DEFAULT = 0,
@@ -38,6 +38,7 @@ export declare class FormulaDependencyTreeVirtual extends FormulaDependencyTreeC
     refOffsetY: number;
     isCache: boolean;
     isDirty: boolean;
+    addressFunctionNodes: FunctionNode[];
     get isVirtual(): boolean;
     get row(): number;
     get column(): number;
@@ -88,6 +89,7 @@ export declare class FormulaDependencyTree extends FormulaDependencyTreeCalculat
     columnCount: number;
     isDirty: boolean;
     node: Nullable<AstRootNode>;
+    addressFunctionNodes: FunctionNode[];
     constructor(treeId: number);
     get isVirtual(): boolean;
     get nodeData(): {

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

@@ -1,6 +1,7 @@
-import { IRange, IUnitRange, Nullable, Disposable } from '@univerjs/core';
+import { IRange, IUnitRange, Nullable, Disposable, RTree } from '@univerjs/core';
 import { IFeatureDirtyRangeType, IFormulaData, IFormulaDataItem, IOtherFormulaData, IUnitData } from '../../basics/common';
 import { IFeatureCalculationManagerParam, IFeatureCalculationManagerService } from '../../services/feature-calculation-manager.service';
+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';
@@ -26,6 +27,7 @@ export declare class FormulaDependencyGenerator extends Disposable {
     protected readonly _lexer: Lexer;
     protected readonly _dependencyManagerService: IDependencyManagerService;
     private _updateRangeFlattenCache;
+    protected _dependencyRTreeCacheForAddressFunction: RTree;
     constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _otherFormulaManagerService: IOtherFormulaManagerService, _featureCalculationManagerService: IFeatureCalculationManagerService, _interpreter: Interpreter, _astTreeBuilder: AstTreeBuilder, _lexer: Lexer, _dependencyManagerService: IDependencyManagerService);
     dispose(): void;
     generate(): Promise<(FormulaDependencyTree | FormulaDependencyTreeVirtual)[]>;
@@ -71,6 +73,23 @@ export declare class FormulaDependencyGenerator extends Disposable {
      * @param node
      */
     protected _getRangeListByNode(nodeData: IExecuteAstNodeData): Promise<IUnitRange[]>;
+    protected _getAddressFunctionNodeList(node: Nullable<BaseAstNode>): FunctionNode[];
+    protected _getTreeNode(tree: IFormulaDependencyTree): import('../ast-node').AstRootNode;
+    protected _buildDirtyRangesByAddressFunction(treeDependencyCache: RTree, tree: IFormulaDependencyTree): Promise<void>;
+    private _executedAddressFunctionNodeIds;
+    protected _calculateListByFunctionRefNode(treeList: IFormulaDependencyTree[]): Promise<void>;
+    private _calculateAddressFunction;
+    private _calculateAddressFunctionRuntimeData;
+    private _buildTreeNodeById;
+    private _searchDependencyByAddressFunction;
+    protected _getTreeById(treeId: number): Nullable<IFormulaDependencyTree>;
+    private _addDependencyTreeByAddressFunction;
+    /**
+     * Calculate the range required for collection in advance,
+     * including references and location functions (such as OFFSET, INDIRECT, INDEX, etc.).
+     * @param node
+     */
+    protected _getRangeListByFunctionRefNode(referenceFunctionList: FunctionNode[], refOffsetX: number, refOffsetY: number): Promise<IUnitRange[]>;
     /**
      * Build a formula dependency tree based on the dependency relationships.
      * @param treeList

package/lib/types/engine/utils/value-object.d.ts

@@ -44,4 +44,3 @@ export declare enum ReferenceObjectType {
 }
 export declare function getReferenceObjectFromCache(trimToken: string, type: ReferenceObjectType): BaseReferenceObject;
 export declare function getRangeReferenceObjectFromCache(variant1: BaseReferenceObject, variant2: BaseReferenceObject): FunctionVariantType;
-export declare function clearReferenceObjectCache(): void;

package/lib/types/facade/f-formula.d.ts

@@ -1,4 +1,4 @@
-import { IDisposable, FBase, ICommandService, Injector } from '@univerjs/core';
+import { IDisposable, FBase, ICommandService, IConfigService, Injector } from '@univerjs/core';
 import { FormulaExecutedStateType, IExecutionInProgressParams } from '@univerjs/engine-formula';
 /**
  * This interface class provides methods to modify the behavior of the operation formula.
@@ -6,7 +6,8 @@ import { FormulaExecutedStateType, IExecutionInProgressParams } from '@univerjs/
 export declare class FFormula extends FBase {
     private readonly _commandService;
     protected readonly _injector: Injector;
-    constructor(_commandService: ICommandService, _injector: Injector);
+    protected readonly _configService: IConfigService;
+    constructor(_commandService: ICommandService, _injector: Injector, _configService: IConfigService);
     /**
      * Start the calculation of the formula.
      */
@@ -28,4 +29,16 @@ export declare class FFormula extends FBase {
      * Listening calculation processing.
      */
     calculationProcessing(callback: (stageInfo: IExecutionInProgressParams) => void): IDisposable;
+    /**
+     * When a formula contains a circular reference, set the maximum number of iterations for the formula calculation.
+     * @param maxIteration The maximum number of iterations. The default value is 1.
+     * @example
+     * ```ts
+     * // Set the maximum number of iterations for the formula calculation to 5.
+     * // The default value is 1.
+     * const formulaEngine = univerAPI.getFormula();
+     * formulaEngine.setMaxIteration(5);
+     * ```
+     */
+    setMaxIteration(maxIteration: number): void;
 }

package/lib/types/functions/lookup/choose/index.d.ts

@@ -4,6 +4,5 @@ export declare class Choose extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
-    isAddress(): boolean;
     calculate(indexNum: FunctionVariantType, ...variants: FunctionVariantType[]): FunctionVariantType;
 }

package/lib/types/functions/math/function-map.d.ts

@@ -1,7 +1,7 @@
 import { Base } from './base';
 import { FUNCTION_NAMES_MATH } from './function-names';
+import { Product } from './product';
 import { Randarray } from './randarray';
 import { Subtotal } from './subtotal';
-import { Sum } from './sum';
 import { Sumifs } from './sumifs';
-export declare const functionMath: ((FUNCTION_NAMES_MATH | typeof Base)[] | (FUNCTION_NAMES_MATH | typeof Randarray)[] | (FUNCTION_NAMES_MATH | typeof Subtotal)[] | (FUNCTION_NAMES_MATH | typeof Sum)[] | (FUNCTION_NAMES_MATH | typeof Sumifs)[])[];
+export declare const functionMath: ((FUNCTION_NAMES_MATH | typeof Base)[] | (FUNCTION_NAMES_MATH | typeof Product)[] | (FUNCTION_NAMES_MATH | typeof Randarray)[] | (FUNCTION_NAMES_MATH | typeof Subtotal)[] | (FUNCTION_NAMES_MATH | typeof Sumifs)[])[];

package/lib/types/functions/math/product/index.d.ts

@@ -4,5 +4,4 @@ export declare class Product extends BaseFunction {
     minParams: number;
     maxParams: number;
     calculate(...variants: BaseValueObject[]): BaseValueObject;
-    private _multiplyArray;
 }

package/lib/types/functions/math/sumifs/index.d.ts

@@ -1,5 +1,5 @@
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Sumifs extends BaseFunction {
     minParams: number;

package/lib/types/index.d.ts

@@ -34,7 +34,6 @@ export { type ISetFormulaDataMutationParams, SetFormulaDataMutation } from './co
 export { type IRemoveOtherFormulaMutationParams, type ISetOtherFormulaMutationParams, RemoveOtherFormulaMutation, SetOtherFormulaMutation } from './commands/mutations/set-other-formula.mutation';
 export { RemoveSuperTableMutation, SetSuperTableMutation, SetSuperTableOptionMutation } from './commands/mutations/set-super-table.mutation';
 export { CalculateController } from './controller/calculate.controller';
-export { SetDefinedNameController } from './controller/set-defined-name.controller';
 export { Lexer } from './engine/analysis/lexer';
 export { LexerNode } from './engine/analysis/lexer-node';
 export { LexerTreeBuilder } from './engine/analysis/lexer-tree-builder';
@@ -124,6 +123,6 @@ export { FormulaDependencyTreeVirtual } from './engine/dependency/dependency-tre
 export { generateAstNode } from './engine/utils/generate-ast-node';
 export { type IFeatureCalculationManagerParam } from './services/feature-calculation-manager.service';
 export { DEFAULT_INTERVAL_COUNT } from './services/calculate-formula.service';
-export { ENGINE_FORMULA_PLUGIN_CONFIG_KEY, type IUniverEngineFormulaConfig } from './controller/config.schema';
+export { ENGINE_FORMULA_CYCLE_REFERENCE_COUNT, ENGINE_FORMULA_PLUGIN_CONFIG_KEY, type IUniverEngineFormulaConfig } from './controller/config.schema';
 export { generateRandomDependencyTreeId } from './engine/dependency/formula-dependency';
 export { DependencyManagerBaseService } from './services/dependency-manager.service';

package/lib/types/services/calculate-formula.service.d.ts

@@ -8,7 +8,6 @@ import { ErrorNode } from '../engine/ast-node/base-ast-node';
 import { IFormulaDependencyGenerator } from '../engine/dependency/formula-dependency';
 import { Interpreter } from '../engine/interpreter/interpreter';
 import { IFormulaCurrentConfigService } from './current-data.service';
-export declare const DEFAULT_CYCLE_REFERENCE_COUNT = 1;
 export declare const DEFAULT_INTERVAL_COUNT = 500;
 export declare const CYCLE_REFERENCE_COUNT = "cycleReferenceCount";
 export declare const EVERY_N_FUNCTION_EXECUTION_PAUSE = 100;

package/lib/types/services/current-data.service.d.ts

@@ -8,6 +8,7 @@ export interface IFormulaDirtyData {
     dirtyUnitFeatureMap: IDirtyUnitFeatureMap;
     dirtyUnitOtherFormulaMap: IDirtyUnitOtherFormulaMap;
     clearDependencyTreeCache: IDirtyUnitSheetNameMap;
+    maxIteration?: number;
 }
 export interface IFormulaCurrentConfigService {
     load(config: IFormulaDatasetConfig): void;

package/lib/umd/facade.js

@@ -1 +1 @@
-(function(i,a){typeof exports=="object"&&typeof module<"u"?a(exports,require("@univerjs/core"),require("@univerjs/engine-formula")):typeof define=="function"&&define.amd?define(["exports","@univerjs/core","@univerjs/engine-formula"],a):(i=typeof globalThis<"u"?globalThis:i||self,a(i.UniverEngineFormulaFacade={},i.UniverCore,i.UniverEngineFormula))})(this,function(i,a,u){"use strict";var m=Object.defineProperty,d=Object.getOwnPropertyDescriptor,f=(r,t,e,n)=>{for(var o=n>1?void 0:n?d(t,e):t,c=r.length-1,s;c>=0;c--)(s=r[c])&&(o=(n?s(t,e,o):s(o))||o);return n&&o&&m(t,e,o),o},l=(r,t)=>(e,n)=>t(e,n,r);i.FFormula=class extends a.FBase{constructor(t,e){super(),this._commandService=t,this._injector=e}executeCalculation(){this._commandService.executeCommand(u.SetFormulaCalculationStartMutation.id,{commands:[],forceCalculation:!0},{onlyLocal:!0})}stopCalculation(){this._commandService.executeCommand(u.SetFormulaCalculationStopMutation.id,{})}calculationStart(t){return this._commandService.onCommandExecuted(e=>{if(e.id===u.SetFormulaCalculationStartMutation.id){const n=e.params;t(n.forceCalculation)}})}calculationEnd(t){return this._commandService.onCommandExecuted(e=>{if(e.id!==u.SetFormulaCalculationNotificationMutation.id)return;const n=e.params;n.functionsExecutedState!==void 0&&t(n.functionsExecutedState)})}onCalculationEnd(){return new Promise((t,e)=>{const n=setTimeout(()=>{e(new Error("Calculation end timeout"))},3e4),o=this.calculationEnd(()=>{clearTimeout(n),o.dispose(),t()})})}calculationProcessing(t){return this._commandService.onCommandExecuted(e=>{if(e.id!==u.SetFormulaCalculationNotificationMutation.id)return;const n=e.params;n.stageInfo!==void 0&&t(n.stageInfo)})}},i.FFormula=f([l(0,a.Inject(a.ICommandService)),l(1,a.Inject(a.Injector))],i.FFormula);class v extends a.FUniver{getFormula(){return this._injector.createInstance(i.FFormula)}}a.FUniver.extend(v),Object.defineProperty(i,Symbol.toStringTag,{value:"Module"})});
+(function(a,n){typeof exports=="object"&&typeof module<"u"?n(exports,require("@univerjs/core"),require("@univerjs/engine-formula")):typeof define=="function"&&define.amd?define(["exports","@univerjs/core","@univerjs/engine-formula"],n):(a=typeof globalThis<"u"?globalThis:a||self,n(a.UniverEngineFormulaFacade={},a.UniverCore,a.UniverEngineFormula))})(this,function(a,n,r){"use strict";var m=Object.defineProperty,d=Object.getOwnPropertyDescriptor,f=(u,e,t,i)=>{for(var o=i>1?void 0:i?d(e,t):e,s=u.length-1,l;s>=0;s--)(l=u[s])&&(o=(i?l(e,t,o):l(o))||o);return i&&o&&m(e,t,o),o},c=(u,e)=>(t,i)=>e(t,i,u);a.FFormula=class extends n.FBase{constructor(e,t,i){super(),this._commandService=e,this._injector=t,this._configService=i}executeCalculation(){this._commandService.executeCommand(r.SetFormulaCalculationStartMutation.id,{commands:[],forceCalculation:!0},{onlyLocal:!0})}stopCalculation(){this._commandService.executeCommand(r.SetFormulaCalculationStopMutation.id,{})}calculationStart(e){return this._commandService.onCommandExecuted(t=>{if(t.id===r.SetFormulaCalculationStartMutation.id){const i=t.params;e(i.forceCalculation)}})}calculationEnd(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==r.SetFormulaCalculationNotificationMutation.id)return;const i=t.params;i.functionsExecutedState!==void 0&&e(i.functionsExecutedState)})}onCalculationEnd(){return new Promise((e,t)=>{const i=setTimeout(()=>{t(new Error("Calculation end timeout"))},3e4),o=this.calculationEnd(()=>{clearTimeout(i),o.dispose(),e()})})}calculationProcessing(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==r.SetFormulaCalculationNotificationMutation.id)return;const i=t.params;i.stageInfo!==void 0&&e(i.stageInfo)})}setMaxIteration(e){this._configService.setConfig(r.ENGINE_FORMULA_CYCLE_REFERENCE_COUNT,e)}},a.FFormula=f([c(0,n.Inject(n.ICommandService)),c(1,n.Inject(n.Injector)),c(2,n.IConfigService)],a.FFormula);class v extends n.FUniver{getFormula(){return this._injector.createInstance(a.FFormula)}}n.FUniver.extend(v),Object.defineProperty(a,Symbol.toStringTag,{value:"Module"})});