@univerjs/engine-formula 1.0.0-alpha.8 → 1.0.0-beta.1

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

@@ -220,6 +220,8 @@ export interface ISuperTable {
      * Sheet tables default to true; Base virtual tables store records from row 0.
      */
     showHeader?: boolean;
+    /** Whether the projected range contains a physical totals row. */
+    showFooter?: boolean;
 }
 export declare enum TableOptionType {
     ALL = "#All",

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

@@ -32,10 +32,10 @@ export declare const REFERENCE_REGEX_SINGLE_ROW = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\
 export declare const REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING: RegExp;
 export declare const REFERENCE_REGEX_SINGLE_COLUMN = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\s*?\\$?[A-Za-z]+$";
 export declare const REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING: RegExp;
-export declare const REFERENCE_TABLE_ALL_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+$";
-export declare const REFERENCE_TABLE_SINGLE_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[((?<!#)[\\s\\S])*\\]|\\[\\[#.+\\]\\s*?,\\s*?\\[((?<!#)[\\s\\S])*\\]\\])+$";
-export declare const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[((?<!#)[\\s\\S])*\\]\\s*?:\\s*?\\[((?<!#)[\\s\\S])*\\]\\])?$|^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[#.+\\]\\s*?,\\s*?\\[((?<!#)[\\s\\S])*\\]\\s*?:\\s*?\\[((?<!#)[\\s\\S])*\\]\\])?$";
-export declare const REFERENCE_TABLE_TITLE_ONLY_ANY_HASH_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+\\[\\s*#([^\\]]+)\\s*\\]$";
+export declare const REFERENCE_TABLE_ALL_COLUMN_REGEX = "^(?:(?:\\[(?:[^\\]]|\\]\\])+\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[(?:[^\\]]|\\]\\])+\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+$";
+export declare const REFERENCE_TABLE_SINGLE_COLUMN_REGEX = "^(?:(?:\\[(?:[^\\]]|\\]\\])+\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[(?:[^\\]]|\\]\\])+\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[[^#]*#?\\]|\\[\\[#.+\\]\\s*?,\\s*?\\[[^#]*#?\\]\\])+$";
+export declare const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX = "^(?:(?:\\[(?:[^\\]]|\\]\\])+\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[(?:[^\\]]|\\]\\])+\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[[^#]*#?\\]\\s*?:\\s*?\\[[^#]*#?\\]\\])?$|^(?:(?:\\[(?:[^\\]]|\\]\\])+\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[(?:[^\\]]|\\]\\])+\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[#.+\\]\\s*?,\\s*?\\[[^#]*#?\\]\\s*?:\\s*?\\[[^#]*#?\\]\\])?$";
+export declare const REFERENCE_TABLE_TITLE_ONLY_ANY_HASH_REGEX = "^(?:(?:\\[(?:[^\\]]|\\]\\])+\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[(?:[^\\]]|\\]\\])+\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+\\[\\s*#([^\\]]+)\\s*\\]$";
 export declare const REFERENCE_TABLE_ALL_COLUMN_REGEX_PRECOMPILING: RegExp;
 export declare const REFERENCE_TABLE_SINGLE_COLUMN_REGEX_PRECOMPILING: RegExp;
 export declare const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX_PRECOMPILING: RegExp;

package/lib/types/controllers/formula-calculation-trigger.controller.d.ts

@@ -15,7 +15,6 @@
  */
 import { Disposable, LifecycleService } from '@univerjs/core';
 import { FormulaCalculationTriggerService } from '../services/formula-calculation-trigger.service';
-import { RegisterOtherFormulaService } from '../services/register-other-formula.service';
 export declare class FormulaCalculationTriggerController extends Disposable {
-    constructor(formulaCalculationTriggerService: FormulaCalculationTriggerService, registerOtherFormulaService: RegisterOtherFormulaService, lifecycleService: LifecycleService);
+    constructor(formulaCalculationTriggerService: FormulaCalculationTriggerService, lifecycleService: LifecycleService);
 }

package/lib/types/controllers/formula.controller.d.ts

@@ -17,7 +17,7 @@ import { Disposable, ICommandService, IConfigService } from '@univerjs/core';
 import { DataSyncPrimaryController } from '@univerjs/rpc';
 import { IFunctionService } from '../services/function.service';
 import { RegisterOtherFormulaService } from '../services/register-other-formula.service';
-type FormulaDataSyncController = Pick<DataSyncPrimaryController, 'registerSyncingMutations' | 'syncUnitMutations'>;
+type FormulaDataSyncController = Pick<DataSyncPrimaryController, 'registerSyncingMutations' | 'syncUnitMutations' | 'waitForPendingMutations'>;
 export declare class FormulaController extends Disposable {
     private readonly _commandService;
     private readonly _functionService;

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

@@ -27,6 +27,9 @@ export declare const FormulaSequenceNodeCache: FormulaAstLRU<(string | ISequence
 interface IInjectDefinedNameParam {
     unitId: Nullable<string>;
     sheetId?: Nullable<string>;
+    refOffsetX: number;
+    refOffsetY: number;
+    hasFunction(functionToken: IFunctionNames): boolean;
     getValueByName(unitId: string, name: string, sheetId?: Nullable<string>): Nullable<IDefinedNamesServiceParam>;
     getDirtyDefinedNameMap(): IDirtyUnitDefinedNameMap;
     getSheetName: (unitId: string, sheetId: string) => string;
@@ -101,6 +104,7 @@ export declare class LexerTreeBuilder extends Disposable {
     nodeMakerTest(formulaString: string): ErrorType.VALUE | (string | LexerNode)[] | undefined;
     treeBuilder(formulaString: string, transformSuffix?: boolean, injectDefinedNameParam?: IInjectDefinedNameParam): ErrorType.VALUE | LexerNode | (string | LexerNode)[] | undefined;
     private _handleDefinedName;
+    private _moveDefinedNameRefOffset;
     private _getHasSheetNameDefinedName;
     private _handleNestedDefinedName;
     private _simpleCheckDefinedName;

package/lib/types/engine/analysis/lexer.d.ts

@@ -17,11 +17,13 @@ import type { Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
 import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IDefinedNamesService } from '../../services/defined-names.service';
+import { IFunctionService } from '../../services/function.service';
 import { LexerTreeBuilder } from './lexer-tree-builder';
 export declare class Lexer extends Disposable {
     private readonly _definedNamesService;
     private readonly _lexerTreeBuilder;
     private readonly _formulaCurrentConfigService;
-    constructor(_definedNamesService: IDefinedNamesService, _lexerTreeBuilder: LexerTreeBuilder, _formulaCurrentConfigService: IFormulaCurrentConfigService);
-    treeBuilder(formulaString: string, transformSuffix?: boolean, unitId?: Nullable<string>): import("../..").ErrorType.VALUE | import("./lexer-node").LexerNode | (string | import("./lexer-node").LexerNode)[] | undefined;
+    private readonly _functionService;
+    constructor(_definedNamesService: IDefinedNamesService, _lexerTreeBuilder: LexerTreeBuilder, _formulaCurrentConfigService: IFormulaCurrentConfigService, _functionService: IFunctionService);
+    treeBuilder(formulaString: string, transformSuffix?: boolean, unitId?: Nullable<string>, refOffsetX?: number, refOffsetY?: number): import("../..").ErrorType.VALUE | import("./lexer-node").LexerNode | (string | import("./lexer-node").LexerNode)[] | undefined;
 }

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

@@ -52,6 +52,7 @@ export declare class BaseAstNode {
     getToken(): string;
     setValue(value: Nullable<FunctionVariantType>): void;
     getValue(): Nullable<FunctionVariantType>;
+    preservesLazyIfReferenceArray(_child: BaseAstNode): boolean;
     isCalculated(): boolean;
     setCalculated(): void;
     execute(): void;

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

@@ -35,6 +35,7 @@ export declare class FunctionNode extends BaseAstNode {
     private _unitReferenceResolver;
     constructor(token: string, _functionExecutor: BaseFunction, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _definedNamesService: IDefinedNamesService, _formulaDataModel: FormulaDataModel, _unitReferenceResolver: IFormulaUnitReferenceResolver);
     get nodeType(): NodeType;
+    preservesLazyIfReferenceArray(child: BaseAstNode): boolean;
     executeAsync(): Promise<AstNodePromiseType>;
     execute(): void;
     private _collectVariants;

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

@@ -13,20 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IFunctionService } from '../../services/function.service';
 import { LexerNode } from '../analysis/lexer-node';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class UnionNode extends BaseAstNode {
-    constructor(operatorString: string);
+    private readonly _currentConfigService;
+    constructor(operatorString: string, _currentConfigService: Pick<IFormulaCurrentConfigService, 'getSheetsInfo'>);
     get nodeType(): NodeType;
     execute(): void;
+    private _createThreeDimensionalReference;
+    private _normalizeSheetName;
+    private _copyReferenceContext;
     private _unionFunction;
 }
 export declare class UnionNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;
-    constructor(_functionService: IFunctionService);
+    private readonly _currentConfigService;
+    constructor(_functionService: IFunctionService, _currentConfigService: IFormulaCurrentConfigService);
     get zIndex(): number;
     create(param: string): BaseAstNode;
     checkAndCreateNodeType(param: LexerNode | string): BaseAstNode | undefined;

package/lib/types/engine/reference-object/base-reference-object.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { ICellData, IRange, Nullable } from '@univerjs/core';
+import type { ICellData, IRange, IUnitRange, Nullable } from '@univerjs/core';
 import type { IArrayFormulaRangeType, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap, IUnitStylesData } from '../../basics/common';
 import type { BaseValueObject } from '../value-object/base-value-object';
 import { ObjectMatrix } from '@univerjs/core';
@@ -146,6 +146,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
         sheetId: string;
         unitId: string;
     };
+    toUnitRanges(): IUnitRange[];
     private _checkIfWorksheetMiss;
     private _getBlankArrayValueObject;
 }

package/lib/types/engine/reference-object/multi-area-reference-object.d.ts

@@ -13,19 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Nullable } from '@univerjs/core';
+import type { IUnitRange, Nullable } from '@univerjs/core';
 import type { ArrayValueObject } from '../value-object/array-value-object';
-import type { BaseValueObject, ErrorValueObject } from '../value-object/base-value-object';
+import type { BaseValueObject } from '../value-object/base-value-object';
+import { ErrorValueObject } from '../value-object/base-value-object';
 import { BaseReferenceObject } from './base-reference-object';
 export type MultiAreaValue = BaseReferenceObject | ErrorValueObject;
+export declare enum MultiAreaArrayMode {
+    FIRST_CELL_GRID = "first-cell-grid",
+    STACK_AREAS = "stack-areas"
+}
 export declare class MultiAreaReferenceObject extends BaseReferenceObject {
+    private readonly _arrayMode;
     /**
      * 2D structure:
      * - First dimension: stored by rows
      * - Second dimension: each AreaValue within that row
      */
     private _areas;
-    constructor(token: string, areas?: MultiAreaValue[][]);
+    constructor(token: string, areas?: MultiAreaValue[][], _arrayMode?: MultiAreaArrayMode);
     dispose(): void;
     getAreas(): MultiAreaValue[][];
     setAreas(areas: MultiAreaValue[][]): void;
@@ -77,11 +83,13 @@ export declare class MultiAreaReferenceObject extends BaseReferenceObject {
      * - inner `_areas[row]` dimension => columns
      */
     toArrayValueObject(): ArrayValueObject;
+    private _stackAreas;
     getRangePosition(): import("@univerjs/core").IRange;
     toUnitRange(): {
         range: import("@univerjs/core").IRange;
         sheetId: string;
         unitId: string;
     };
+    toUnitRanges(): IUnitRange[];
     getRangeData(): import("@univerjs/core").IRange;
 }

package/lib/types/engine/reference-object/table-reference-object.d.ts

@@ -81,7 +81,7 @@ export declare class TableReferenceObject extends BaseReferenceObject {
     private _findCommaAtTopLevel;
     /**
      * Parse Section, compatible with both "[#Data]" and "#Data" inputs
-     * Returns TableOptionType if matched; returns DATA if not (could throw error instead)
+     * Returns TableOptionType if matched; returns undefined when the comma belongs to a column title.
      */
     private _parseSectionMaybeBracketed;
     /**

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

@@ -21,5 +21,5 @@ import type { AstRootNode } from '../ast-node/ast-root-node';
 import type { 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, subUnitId?: string): AstRootNode;
+export declare function generateAstNode(unitId: string, formulaString: string, lexer: Lexer, astTreeBuilder: AstTreeBuilder, currentConfigService: IFormulaCurrentConfigService, subUnitId?: string, definedNameRefOffsetX?: number, definedNameRefOffsetY?: number): AstRootNode;
 export declare function includeDefinedName(tree: IFormulaDependencyTree, node: Nullable<AstRootNode>, currentConfigService: IFormulaCurrentConfigService): boolean;

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

@@ -132,7 +132,7 @@ export declare class ArrayValueObject extends BaseValueObject {
      * the sequential matching approach is only used for special matches in XLOOKUP and XMATCH.
      * For example, when match_mode is set to 1 and -1 for an exact match. If not found, it returns the next smaller item.
      */
-    orderSearch(valueObject: BaseValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, isFuzzyMatching?: boolean): void | {
+    orderSearch(valueObject: BaseValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, isFuzzyMatching?: boolean, keepFirstNearest?: boolean): void | {
         row: number;
         column: number;
     } | null;

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

@@ -76,6 +76,10 @@ export declare class BaseFunction {
      * Whether the function needs unevaluated AST children.
      */
     needsAstChildren: boolean;
+    /**
+     * Arguments that preserve a selected lazy IF branch as a reference array.
+     */
+    lazyIfReferenceArrayArgumentIndexes: readonly number[];
     /**
      * Legacy CSE-style array functions should write only the first result cell
      * when they are used as a top-level normal formula.
@@ -163,11 +167,11 @@ export declare class BaseFunction {
     private _getOneLastByRaw;
     equalSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean): BaseValueObject;
     fuzzySearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean): BaseValueObject;
-    orderSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean): BaseValueObject;
+    orderSearch(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, keepFirstNearest?: boolean): BaseValueObject;
     binarySearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, axis?: number, searchType?: ArrayBinarySearchType, matchType?: ArrayOrderSearchType): ErrorValueObject | ArrayValueObject | undefined;
     equalSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
     fuzzySearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, isFirst?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
-    orderSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, axis?: number): ErrorValueObject | ArrayValueObject | undefined;
+    orderSearchExpand(value: BaseValueObject, searchArray: ArrayValueObject, resultArray: ArrayValueObject, searchType?: ArrayOrderSearchType, isDesc?: boolean, axis?: number, keepFirstNearest?: boolean): ErrorValueObject | ArrayValueObject | undefined;
     flattenArray(variants: BaseValueObject[], ignoreLogicalValuesAndText?: boolean): ArrayValueObject | BaseValueObject;
     private _includingLogicalValuesAndText;
     createReferenceObject(reference: BaseReferenceObject, range: IRange): ErrorValueObject | BaseReferenceObject;

package/lib/types/functions/compatibility/rank/index.d.ts

@@ -20,6 +20,7 @@ export declare class Rank extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(number: FunctionVariantType, ref: FunctionVariantType, order?: FunctionVariantType): BaseValueObject;
     private _checkRefReferenceObject;
 }

package/lib/types/functions/information/isblank/index.d.ts

@@ -13,12 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
 import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
-import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
-import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Isblank extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
+    needsReferenceObject: boolean;
+    calculate(value: FunctionVariantType): import("../../..").BaseValueObject | ArrayValueObject;
 }

package/lib/types/functions/logical/percentof/index.d.ts

@@ -14,14 +14,13 @@
  * limitations under the License.
  */
 import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
-import { ErrorValueObject } from '../../../engine/value-object/base-value-object';
-import { BaseFunction } from '../../base-function';
+import { Sum } from '../../math/sum';
 /**
- * PERCENTOF is an Excel GROUPBY aggregator token. It is evaluated by GROUPBY's
- * AST path, not as a standalone scalar function.
+ * PERCENTOF is logically equivalent to SUM(dataSubset) / SUM(dataAll).
+ * GROUPBY also consumes the function name as an aggregator token through its AST path.
  */
-export declare class Percentof extends BaseFunction {
+export declare class Percentof extends Sum {
     minParams: number;
     maxParams: number;
-    calculate(..._variants: BaseValueObject[]): ErrorValueObject;
+    calculate(dataSubset: BaseValueObject, dataAll: BaseValueObject): BaseValueObject;
 }

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

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class Choose extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     needsReferenceObject: boolean;
     calculate(indexNum: FunctionVariantType, ...variants: FunctionVariantType[]): FunctionVariantType;
 }

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

@@ -13,10 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Anchorarray } from './anchorarray';
 import { Choose } from './choose';
 import { FUNCTION_NAMES_LOOKUP } from './function-names';
 import { Hstack } from './hstack';
+import { Index } from './index/index';
 import { Indirect } from './indirect';
 import { Lookup } from './lookup';
 import { Match } from './match';
-export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Choose)[] | (FUNCTION_NAMES_LOOKUP | typeof Hstack)[] | (FUNCTION_NAMES_LOOKUP | typeof Indirect)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Match)[])[];
+import { Offset } from './offset';
+export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Anchorarray)[] | (FUNCTION_NAMES_LOOKUP | typeof Choose)[] | (FUNCTION_NAMES_LOOKUP | typeof Hstack)[] | (FUNCTION_NAMES_LOOKUP | typeof Index)[] | (FUNCTION_NAMES_LOOKUP | typeof Indirect)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Match)[] | (FUNCTION_NAMES_LOOKUP | typeof Offset)[])[];

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

@@ -19,6 +19,7 @@ import { BaseFunction } from '../../base-function';
 export declare class Match extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(lookupValue: BaseValueObject, lookupArray: ArrayValueObject, matchType?: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
     private _getSearchModeValue;

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

@@ -23,6 +23,10 @@ export declare class Xlookup extends BaseFunction {
     private _legacyImplicitLookupValue;
     private _handleExpandObject;
     private _handleSingleObject;
+    private _exactSearch;
+    private _exactSearchExpand;
+    private _findExactPosition;
+    private _isExactMatch;
     private _blankResultAsZero;
     /**
      * Wildcard matching and binary search cannot appear at the same time

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

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class Sumproduct extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(array1: BaseValueObject, ...variants: BaseValueObject[]): BaseValueObject;
     /**
      * Validate all variants:

package/lib/types/functions/statistical/median/index.d.ts

@@ -18,5 +18,6 @@ import { BaseFunction } from '../../base-function';
 export declare class Median extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(...variants: BaseValueObject[]): BaseValueObject;
 }

package/lib/types/functions/statistical/percentile-exc/index.d.ts

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class PercentileExc extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(array: BaseValueObject, k: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
 }

package/lib/types/functions/statistical/percentile-inc/index.d.ts

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class PercentileInc extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(array: BaseValueObject, k: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
 }

package/lib/types/functions/statistical/rank-avg/index.d.ts

@@ -20,6 +20,7 @@ export declare class RankAvg extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(number: FunctionVariantType, ref: FunctionVariantType, order?: FunctionVariantType): BaseValueObject;
     private _getResult;
     private _checkRefReferenceObject;

package/lib/types/functions/statistical/rank-eq/index.d.ts

@@ -20,6 +20,7 @@ export declare class RankEq extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(number: FunctionVariantType, ref: FunctionVariantType, order?: FunctionVariantType): BaseValueObject;
     private _checkRefReferenceObject;
 }

package/lib/types/functions/text/textjoin/index.d.ts

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class Textjoin extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(delimiter: BaseValueObject, ignoreEmpty: BaseValueObject, ...variants: BaseValueObject[]): BaseValueObject;
     private _handleSingleObject;
     private _getDelimiterValues;

package/lib/types/services/register-other-formula.service.d.ts

@@ -13,11 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { IRange, Nullable } from '@univerjs/core';
+import type { IDisposable, IRange, Nullable } from '@univerjs/core';
 import type { ISetFormulaCalculationResultMutation } from '../commands/mutations/set-formula-calculation.mutation';
 import type { IOtherFormulaResult } from './formula-common';
 import { Disposable, ICommandService, LifecycleService } from '@univerjs/core';
-import { BehaviorSubject } from 'rxjs';
 import { IActiveDirtyManagerService } from './active-dirty-manager.service';
 export declare enum OtherFormulaBizType {
     DEFAULT = "default",
@@ -33,6 +32,7 @@ export declare class RegisterOtherFormulaService extends Disposable {
     private _activeDirtyManagerService;
     private readonly _lifecycleService;
     private _formulaCacheMap;
+    private _mutationSyncHandler?;
     private _formulaChangeWithRange$;
     formulaChangeWithRange$: import("rxjs").Observable<{
         unitId: string;
@@ -45,12 +45,12 @@ export declare class RegisterOtherFormulaService extends Disposable {
     formulaResult$: import("rxjs").Observable<Record<string, Record<string, IOtherFormulaResult[]>>>;
     private _otherFormulaResultApplied$;
     otherFormulaResultApplied$: import("rxjs").Observable<ISetFormulaCalculationResultMutation>;
-    calculateStarted$: BehaviorSubject<boolean>;
     constructor(_commandService: ICommandService, _activeDirtyManagerService: IActiveDirtyManagerService, _lifecycleService: LifecycleService);
     dispose(): void;
     private _ensureCacheMap;
     private _createFormulaId;
     private _initFormulaRegister;
+    setMutationSyncHandler(handler: (unitId: string) => () => Promise<void>): IDisposable;
     private _initFormulaCalculationResultChange;
     registerFormulaWithRange(unitId: string, subUnitId: string, formulaText: string, ranges?: IRange[], extra?: Record<string, any>, bizType?: OtherFormulaBizType, bizId?: string): string;
     getFormulaDirtyMap(unitId: string): Record<string, Record<string, boolean>>;

package/lib/types/services/runtime.service.d.ts

@@ -78,6 +78,7 @@ export interface IFormulaRuntimeService {
     reset(): void;
     setCurrent(row: number, column: number, rowCount: number, columnCount: number, sheetId: string, unitId: string): void;
     setFunctionRefInfoOverride(rowCount: number, columnCount: number): () => void;
+    hasFunctionRefInfoOverride(): boolean;
     registerFunctionDefinitionPrivacyVar(lambdaId: string, lambdaVar: Map<string, Nullable<BaseAstNode>>): void;
     getFunctionDefinitionPrivacyVar(lambdaId: string): Nullable<Map<string, Nullable<BaseAstNode>>>;
     setRuntimeData(functionVariant: FunctionVariantType): void;
@@ -187,6 +188,7 @@ export declare class FormulaRuntimeService extends Disposable implements IFormul
     clearReferenceAndNumberformatCache(): void;
     setCurrent(row: number, column: number, rowCount: number, columnCount: number, sheetId: string, unitId: string): void;
     setFunctionRefInfoOverride(rowCount: number, columnCount: number): () => void;
+    hasFunctionRefInfoOverride(): boolean;
     clearFunctionDefinitionPrivacyVar(): void;
     registerFunctionDefinitionPrivacyVar(lambdaId: string, lambdaVar: Map<string, Nullable<BaseAstNode>>): void;
     getFunctionDefinitionPrivacyVar(lambdaId: string): Nullable<Map<string, Nullable<BaseAstNode>>>;