@univerjs/engine-formula 0.5.3 → 0.5.4

package/lib/types/engine/utils/generate-ast-node.d.ts

@@ -4,5 +4,7 @@ import { Lexer } from '../analysis/lexer';
 import { AstTreeBuilder } from '../analysis/parser';
 import { AstRootNode } from '../ast-node/ast-root-node';
 import { IFormulaDependencyTree } from '../dependency/dependency-tree';
+import { FormulaAstLRU } from '../../basics/cache-lru';
+export declare const FORMULA_AST_CACHE: FormulaAstLRU<AstRootNode>;
 export declare function generateAstNode(unitId: string, formulaString: string, lexer: Lexer, astTreeBuilder: AstTreeBuilder, currentConfigService: IFormulaCurrentConfigService): AstRootNode;
 export declare function includeDefinedName(tree: IFormulaDependencyTree, node: Nullable<AstRootNode>, currentConfigService: IFormulaCurrentConfigService): boolean;

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

@@ -69,3 +69,7 @@ export declare function isReferenceStrings(refString: string): boolean;
  * @returns Result
  */
 export declare function needsQuoting(name: string): boolean;
+/**
+ * Add quotes to the sheet name
+ */
+export declare function addQuotesBothSides(name: string): string;

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

@@ -2,6 +2,7 @@ import { Nullable } from '@univerjs/core';
 import { BaseAstNode } from '../ast-node/base-ast-node';
 import { Interpreter } from '../interpreter/interpreter';
 import { FunctionVariantType, AsyncObject } from '../reference-object/base-reference-object';
+import { PrimitiveValueType } from './primitive-object';
 import { BaseValueObject } from './base-value-object';
 export declare class LambdaValueObjectObject extends BaseValueObject {
     private _lambdaNode;
@@ -13,6 +14,11 @@ export declare class LambdaValueObjectObject extends BaseValueObject {
     dispose(): void;
     isLambda(): boolean;
     execute(...variants: FunctionVariantType[]): BaseValueObject | AsyncObject;
+    /**
+     * Execute custom lambda function, handle basic types
+     * @param variants
+     */
+    executeCustom(...variants: PrimitiveValueType[]): BaseValueObject | AsyncObject;
     private _setLambdaNodeValue;
     private _setLambdaPrivacyValueMap;
     getLambdaPrivacyVarKeys(): string[];

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

@@ -2,7 +2,8 @@ import { FormulaAstLRU } from '../../basics/cache-lru';
 import { compareToken } from '../../basics/token';
 import { BaseValueObject, ErrorValueObject } from './base-value-object';
 export type PrimitiveValueType = string | boolean | number | null;
-export type FormulaFunctionValueType = PrimitiveValueType | PrimitiveValueType[][];
+export type FormulaFunctionValueType = PrimitiveValueType | PrimitiveValueType[][] | BaseValueObject;
+export type FormulaFunctionResultValueType = PrimitiveValueType | PrimitiveValueType[][];
 export declare class NullValueObject extends BaseValueObject {
     private static _instance;
     static create(): NullValueObject;

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

@@ -1,14 +1,38 @@
 import { IDisposable, FBase, ICommandService, IConfigService, Injector } from '@univerjs/core';
-import { FormulaExecutedStateType, IExecutionInProgressParams } from '@univerjs/engine-formula';
+import { FormulaExecutedStateType, IExecutionInProgressParams, ISequenceNode, LexerTreeBuilder } from '@univerjs/engine-formula';
 /**
  * This interface class provides methods to modify the behavior of the operation formula.
  */
 export declare class FFormula extends FBase {
     protected readonly _commandService: ICommandService;
     protected readonly _injector: Injector;
+    private _lexerTreeBuilder;
     protected readonly _configService: IConfigService;
-    constructor(_commandService: ICommandService, _injector: Injector, _configService: IConfigService);
+    constructor(_commandService: ICommandService, _injector: Injector, _lexerTreeBuilder: LexerTreeBuilder, _configService: IConfigService);
     _initialize(): void;
+    /**
+     * The tree builder for formula string.
+     * @type {LexerTreeBuilder}
+     */
+    get lexerTreeBuilder(): LexerTreeBuilder;
+    /**
+     * Offsets the formula
+     * @param {string} formulaString
+     * @param {number} refOffsetX
+     * @param {number} refOffsetY
+     * @param {boolean} [ignoreAbsolute] default is false
+     * @example
+     * const result = moveFormulaRefOffset('sum(a1,b2)',1,1)
+     * // result  is 'sum(b2,c3)'
+     */
+    moveFormulaRefOffset(formulaString: string, refOffsetX: number, refOffsetY: number, ignoreAbsolute?: boolean): string;
+    /**
+     * Resolves the formula string to a 'node' node
+     * @param {string} formulaString
+     * @returns {*}  {((string | ISequenceNode)[])}
+     * @memberof FFormula
+     */
+    sequenceNodesBuilder(formulaString: string): (string | ISequenceNode)[];
     /**
      * Start the calculation of the formula.
      */
@@ -19,15 +43,18 @@ export declare class FFormula extends FBase {
     stopCalculation(): void;
     /**
      * Listening calculation starts.
+     * @param callback
      */
     calculationStart(callback: (forceCalculation: boolean) => void): IDisposable;
     /**
      * Listening calculation ends.
+     * @param callback
      */
     calculationEnd(callback: (functionsExecutedState: FormulaExecutedStateType) => void): IDisposable;
     onCalculationEnd(): Promise<void>;
     /**
      * Listening calculation processing.
+     * @param callback
      */
     calculationProcessing(callback: (stageInfo: IExecutionInProgressParams) => void): IDisposable;
     /**

package/lib/types/functions/base-function.d.ts

@@ -3,7 +3,7 @@ import { IFunctionNames } from '../basics/function';
 import { BaseReferenceObject, FunctionVariantType, NodeValueType } from '../engine/reference-object/base-reference-object';
 import { ArrayBinarySearchType, ArrayOrderSearchType } from '../engine/utils/compare';
 import { ArrayValueObject } from '../engine/value-object/array-value-object';
-import { FormulaFunctionValueType } from '../engine/value-object/primitive-object';
+import { FormulaFunctionResultValueType, FormulaFunctionValueType } from '../engine/value-object/primitive-object';
 import { FormulaDataModel } from '../models/formula-data.model';
 import { IDefinedNameMapItem } from '../services/defined-names.service';
 import { BaseValueObject, ErrorValueObject } from '../engine/value-object/base-value-object';
@@ -87,7 +87,7 @@ export declare class BaseFunction {
     isAddress(): boolean;
     isCustom(): boolean;
     setRefInfo(unitId: string, subUnitId: string, row: number, column: number): void;
-    calculateCustom(...arg: Array<FormulaFunctionValueType>): FormulaFunctionValueType | Promise<FormulaFunctionValueType>;
+    calculateCustom(...arg: Array<FormulaFunctionValueType>): FormulaFunctionResultValueType | Promise<FormulaFunctionResultValueType>;
     calculate(...arg: BaseValueObject[]): NodeValueType;
     checkArrayType(variant: FunctionVariantType): boolean;
     /**

package/lib/types/index.d.ts

@@ -61,7 +61,7 @@ export { handleRefStringInfo } from './engine/utils/reference';
 export { generateStringWithSequence, type ISequenceNode, sequenceNodeType } from './engine/utils/sequence';
 export { ArrayValueObject, ValueObjectFactory } from './engine/value-object/array-value-object';
 export { BaseValueObject, ErrorValueObject } from './engine/value-object/base-value-object';
-export type { FormulaFunctionValueType, PrimitiveValueType } from './engine/value-object/primitive-object';
+export type { FormulaFunctionResultValueType, FormulaFunctionValueType, PrimitiveValueType } from './engine/value-object/primitive-object';
 export { BooleanValueObject, NullValueObject, NumberValueObject, StringValueObject } from './engine/value-object/primitive-object';
 export { functionArray } from './functions/array/function-map';
 export { FUNCTION_NAMES_ARRAY } from './functions/array/function-names';
@@ -115,7 +115,6 @@ export { FormulaExecutedStateType, FormulaExecuteStageType, FormulaRuntimeServic
 export { ISuperTableService } from './services/super-table.service';
 export { SuperTableService } from './services/super-table.service';
 export { deserializeRangeWithSheetWithCache } from './engine/utils/reference-cache';
-export { FFormula } from './facade/f-formula';
 export { FormulaDependencyTree, type IFormulaDependencyTree } from './engine/dependency/dependency-tree';
 export { type IOtherFormulaData } from './basics/common';
 export { FormulaDependencyTreeType } from './engine/dependency/dependency-tree';
@@ -126,3 +125,4 @@ export { DEFAULT_INTERVAL_COUNT } from './services/calculate-formula.service';
 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';
+export { LambdaValueObjectObject } from './engine/value-object/lambda-value-object';

package/lib/umd/facade.js

@@ -1 +1 @@
-(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,this._initialize()}_initialize(){}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"})});
+(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,o){"use strict";var d=Object.defineProperty,m=Object.getOwnPropertyDescriptor,f=(u,e,t,i)=>{for(var r=i>1?void 0:i?m(e,t):e,s=u.length-1,l;s>=0;s--)(l=u[s])&&(r=(i?l(e,t,r):l(r))||r);return i&&r&&d(e,t,r),r},c=(u,e)=>(t,i)=>e(t,i,u);a.FFormula=class extends n.FBase{constructor(e,t,i,r){super(),this._commandService=e,this._injector=t,this._lexerTreeBuilder=i,this._configService=r,this._initialize()}_initialize(){}get lexerTreeBuilder(){return this._lexerTreeBuilder}moveFormulaRefOffset(e,t,i,r){return this._lexerTreeBuilder.moveFormulaRefOffset(e,t,i,r)}sequenceNodesBuilder(e){return this._lexerTreeBuilder.sequenceNodesBuilder(e)||[]}executeCalculation(){this._commandService.executeCommand(o.SetFormulaCalculationStartMutation.id,{commands:[],forceCalculation:!0},{onlyLocal:!0})}stopCalculation(){this._commandService.executeCommand(o.SetFormulaCalculationStopMutation.id,{})}calculationStart(e){return this._commandService.onCommandExecuted(t=>{if(t.id===o.SetFormulaCalculationStartMutation.id){const i=t.params;e(i.forceCalculation)}})}calculationEnd(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==o.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),r=this.calculationEnd(()=>{clearTimeout(i),r.dispose(),e()})})}calculationProcessing(e){return this._commandService.onCommandExecuted(t=>{if(t.id!==o.SetFormulaCalculationNotificationMutation.id)return;const i=t.params;i.stageInfo!==void 0&&e(i.stageInfo)})}setMaxIteration(e){this._configService.setConfig(o.ENGINE_FORMULA_CYCLE_REFERENCE_COUNT,e)}},a.FFormula=f([c(0,n.Inject(n.ICommandService)),c(1,n.Inject(n.Injector)),c(2,n.Inject(o.LexerTreeBuilder)),c(3,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"})});