@univerjs-pro/engine-formula 0.22.1 → 0.23.0

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

@@ -0,0 +1,220 @@
+import type { IUnitRange } from '@univerjs/core';
+/**
+ * Dependency engine shared type declarations.
+ *
+ * The engine uses numeric node indexes internally and keeps the external
+ * node identity in these public references. `row` and `col` are always
+ * zero-based.
+ */
+export type CellId = number;
+export type CalcNodeIndex = number;
+export type ExternalNodeId = number | string;
+/**
+ * Supported calculation node categories.
+ */
+export declare enum CalcNodeType {
+    CellFormula = 1,
+    OtherFormula = 2,
+    FeatureCalculation = 3
+}
+/**
+ * Public reference for a calculation node.
+ */
+export interface ICalcNodeRef {
+    type: CalcNodeType;
+    id: ExternalNodeId;
+}
+export type DynamicDependencyId = number | string;
+export type DynamicResolveStatus = 'resolved' | 'unknown' | 'error';
+/**
+ * Decoded location for an encoded `CellId`.
+ */
+export interface IDecodedCell {
+    unitId: string;
+    sheetId: string;
+    row: number;
+    col: number;
+}
+/**
+ * Decoded identity for a feature calculation id encoded by the engine.
+ */
+export interface IDecodedFeatureCalculationId {
+    unitId: string;
+    sheetId: string;
+    formulaId: string;
+}
+/**
+ * Decoded identity for an other formula id encoded by the engine.
+ */
+export interface IDecodedOtherFormulaId {
+    unitId: string;
+    sheetId: string;
+    formulaId: string;
+    refOffsetX: number;
+    refOffsetY: number;
+}
+/**
+ * Unit-aware rectangular range.
+ */
+export type IRefRange = IUnitRange;
+/**
+ * Dependency declaration for a calculation node.
+ */
+export interface ICalcNodeDeps {
+    /**
+     * Direct precedent cells.
+     *
+     * If a precedent cell is itself a `CellFormula`, it also becomes a
+     * precedent node in calculation order.
+     */
+    cells?: CellId[];
+    /**
+     * Precedent ranges.
+     *
+     * Formula cells inside these ranges naturally become precedent nodes.
+     */
+    ranges?: IRefRange[];
+    /**
+     * Explicit precedent calculation nodes.
+     *
+     * `FeatureCalculation` and `CellFormula` can be depended on explicitly.
+     * `OtherFormula` cannot be used as a precedent.
+     */
+    nodes?: ICalcNodeRef[];
+    /**
+     * Dynamic dependencies such as OFFSET / INDIRECT.
+     *
+     * `paramDeps` are registered into the static graph so parameter changes
+     * dirty the node. Runtime dependencies are patched later through a
+     * `DynamicResolver`.
+     */
+    dynamics?: IDynamicDependency[];
+}
+export type ICompressedSharedFormulaPattern = {
+    kind: 'cell';
+    unitId: string;
+    sheetId: string;
+    rowDelta: number;
+    colDelta: number;
+} | {
+    kind: 'range';
+    unitId: string;
+    sheetId: string;
+    startRowDelta: number;
+    startColDelta: number;
+    endRowDelta: number;
+    endColDelta: number;
+};
+export interface ICompressedSharedFormulaGroup {
+    groupId: string;
+    fillRange: IRefRange;
+    patterns: ICompressedSharedFormulaPattern[];
+}
+export interface IDynamicDependency {
+    id: DynamicDependencyId;
+    paramDeps: ICalcNodeDeps;
+}
+export interface IDynamicResolveResult {
+    signature: string;
+    cells?: CellId[];
+    ranges?: IRefRange[];
+    nodes?: ICalcNodeRef[];
+    traceCells?: CellId[];
+    status?: DynamicResolveStatus;
+}
+export type IDynamicResolver = (node: ICalcNodeRef, dynamic: IDynamicDependency) => IDynamicResolveResult;
+/**
+ * Construction options for the dependency engine.
+ */
+export interface IDependencyEngineOptions {
+    maxRows: number;
+    maxCols: number;
+    /**
+     * Ranges are indexed by their shorter side until this span is exceeded.
+     * Very large ranges are kept in a fallback list.
+     */
+    maxIndexedSpan?: number;
+    /**
+     * Changed ranges below this cell count are scanned point-by-point against
+     * direct cell dependencies.
+     */
+    pointScanCellLimit?: number;
+    initialNodeCapacity?: number;
+    initialRangeCapacity?: number;
+}
+/**
+ * Result returned when adding or updating a node.
+ */
+export interface ISetNodeResult {
+    nodeIndex: CalcNodeIndex;
+    hasCycle: boolean;
+}
+/**
+ * A single executable item in a dirty calculation plan.
+ */
+export interface ICalculationNodePlanItem {
+    type: 'node';
+    nodeIndex: CalcNodeIndex;
+}
+/**
+ * A compact batch of acyclic dirty nodes.
+ */
+export interface ICalculationNodesPlanItem {
+    type: 'nodes';
+    nodeIndices: CalcNodeIndex[];
+}
+/**
+ * A strongly-connected dirty node group that should be calculated iteratively.
+ */
+export interface ICalculationCyclePlanItem {
+    type: 'cycle';
+    nodeIndices: CalcNodeIndex[];
+}
+export type ICalculationPlanItem = ICalculationNodePlanItem | ICalculationNodesPlanItem | ICalculationCyclePlanItem;
+/**
+ * One independent dirty dependency tree. Trees have no dependency edges between
+ * them and can be scheduled independently by higher layers.
+ */
+export interface ICalculationOrderTree {
+    hasCycle: boolean;
+    plan: ICalculationPlanItem[];
+}
+/**
+ * Dirty-node calculation order.
+ */
+export interface ICalculationOrderResult {
+    hasCycle: boolean;
+    calculationForest: ICalculationOrderTree[];
+}
+/**
+ * Compact dependent list representation. A single dependent is stored as a
+ * number and promoted to an array only when needed.
+ */
+export type DepList = CalcNodeIndex | CalcNodeIndex[];
+/**
+ * Internal range storage strategy.
+ */
+export declare enum RangeKind {
+    RowIndexed = 1,
+    ColIndexed = 2,
+    Large = 3
+}
+/**
+ * Backward-compatible type aliases for older imports.
+ */
+export type CalcNodeRef = ICalcNodeRef;
+export type DecodedCell = IDecodedCell;
+export type DecodedFeatureCalculationId = IDecodedFeatureCalculationId;
+export type DecodedOtherFormulaId = IDecodedOtherFormulaId;
+export type DynamicDependency = IDynamicDependency;
+export type DynamicResolver = IDynamicResolver;
+export type DynamicResolveResult = IDynamicResolveResult;
+export type CompressedSharedFormulaGroup = ICompressedSharedFormulaGroup;
+export type CompressedSharedFormulaPattern = ICompressedSharedFormulaPattern;
+export type RefRange = IRefRange;
+export type CalcNodeDeps = ICalcNodeDeps;
+export type DependencyEngineOptions = IDependencyEngineOptions;
+export type SetNodeResult = ISetNodeResult;
+export type CalculationOrderResult = ICalculationOrderResult;
+export type CalculationPlanItem = ICalculationPlanItem;
+export type CalculationOrderTree = ICalculationOrderTree;

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

@@ -0,0 +1,8 @@
+export { CellCodec } from './dependency-engine/cell-codec';
+export { DependencyEngine } from './dependency-engine/dependency-engine';
+export { FormulaCellIndex } from './dependency-engine/formula-cell-index';
+export { cellFormulaNode, featureCalculationNode, otherFormulaNode, } from './dependency-engine/node-helpers';
+export { PointSubscriptionIndex } from './dependency-engine/point-subscription-index';
+export { RangeIndex } from './dependency-engine/range-index';
+export type { CalcNodeDeps, CalcNodeIndex, CalcNodeRef, CalculationOrderResult, CalculationOrderTree, CalculationPlanItem, CellId, CompressedSharedFormulaGroup, CompressedSharedFormulaPattern, DecodedCell, DecodedFeatureCalculationId, DecodedOtherFormulaId, DependencyEngineOptions, DynamicDependency, DynamicResolver, DynamicResolveResult, ExternalNodeId, ICalcNodeDeps, ICalcNodeRef, ICalculationOrderResult, ICalculationOrderTree, ICalculationPlanItem, ICompressedSharedFormulaGroup, ICompressedSharedFormulaPattern, IDecodedCell, IDecodedFeatureCalculationId, IDecodedOtherFormulaId, IDependencyEngineOptions, IRefRange, ISetNodeResult, RefRange, SetNodeResult, } from './dependency-engine/types';
+export { CalcNodeType } from './dependency-engine/types';

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

@@ -1,28 +1,90 @@
-import type { Nullable } from '@univerjs/core';
-import type { IFeatureCalculationManagerParam, IFormulaData, IFormulaDataItem, IFormulaDependencyTree, IOtherFormulaData, IUnitData } from '@univerjs/engine-formula';
-import { FormulaDependencyGenerator, FormulaDependencyTree, FormulaDependencyTreeVirtual } from '@univerjs/engine-formula';
+import type { IUnitRange, Nullable } from '@univerjs/core';
+import type { BaseAstNode, IFormulaDataItem, IFormulaDependencyTree, IFormulaDependencyTreeJson, IUnitData } from '@univerjs/engine-formula';
+import type { DynamicResolver } from './dependency-engine';
+import type { ISharedFormulaCompressionMetrics } from './shared-formula-group-analyzer';
+import { FormulaDependencyGenerator, FormulaDependencyTree, FormulaDependencyTreeType } from '@univerjs/engine-formula';
+export interface IFormulaCalculationTree {
+    unitId: string;
+    subUnitId: string;
+    formula: string;
+    row: number;
+    column: number;
+    rowCount: number;
+    columnCount: number;
+    refOffsetX: number;
+    refOffsetY: number;
+    formulaId: Nullable<string>;
+    featureId: Nullable<string>;
+    getDirtyData: IFormulaDependencyTree['getDirtyData'];
+    hasDynamicDeps: boolean;
+    rangeList?: IUnitRange[];
+    type?: FormulaDependencyTreeType;
+}
+export interface IFormulaCalculationNodeData {
+    node: BaseAstNode;
+    refOffsetX: number;
+    refOffsetY: number;
+}
 export declare class FormulaDependencyProGenerator extends FormulaDependencyGenerator {
-    protected _dependencyTreeCache: Map<number, IFormulaDependencyTree>;
+    private readonly _featureFormulaDirtyDependencies;
+    private readonly _calculationTreeCache;
+    private _calculationNodeDataCache;
+    private readonly _forcedRecalculationNodeIndices;
+    private _sharedFormulaCompressionMetrics;
+    private _cacheDependencyTreeModelRangeList;
     dispose(): void;
-    generate(isCalculateTreeModel?: boolean): Promise<(FormulaDependencyTree | FormulaDependencyTreeVirtual)[]>;
-    private _isCyclicUtilMap;
-    protected _checkIsCycleDependency(treeList: IFormulaDependencyTree[]): boolean;
-    protected _getFeatureFormulaTree(featureId: string, treeId: Nullable<number>, params: IFeatureCalculationManagerParam): FormulaDependencyTree;
-    protected _registerOtherFormulas(otherFormulaData: IOtherFormulaData, otherFormulaDataKeys: string[], treeList: IFormulaDependencyTree[]): void;
-    protected _registerFormulas(formulaDataKeys: string[], formulaData: IFormulaData, unitData: IUnitData, treeList: IFormulaDependencyTree[]): void;
-    protected _createFDtree(unitId: string, sheetId: string, row: number, column: number, unitData: IUnitData, formulaDataItem: IFormulaDataItem): FormulaDependencyTree;
+    clearCalculatedDirty(nodeIndices: number[]): void;
+    clearCachedCalculationNodeData(): void;
+    clearCachedCalculationTree(): void;
+    getCachedCalculationNodeData(nodeIndex: number): IFormulaCalculationNodeData | undefined;
+    getCalculationOrder(): import("./dependency-engine").ICalculationOrderResult;
+    getSharedFormulaCompressionMetrics(): ISharedFormulaCompressionMetrics;
+    hasDynamicDepsByIndex(nodeIndex: number): boolean;
+    refreshDynamicDepsByIndex(nodeIndex: number, resolver: DynamicResolver): boolean;
+    hasUncalculatedDirtyPrecedentByIndex(nodeIndex: number, calculatedNodeIndices: ReadonlySet<number>): boolean;
+    getAllDependencyJson(): Promise<IFormulaDependencyTreeJson[]>;
+    generatePro(isCalculateTreeModel?: boolean): Promise<{
+        calculationOrderResult: import("./dependency-engine").ICalculationOrderResult;
+        dependencyTree: Map<number, IFormulaCalculationTree>;
+    }>;
     /**
-     * Build a formula dependency tree based on the dependency relationships.
-     * @param treeList
+     * Generate nodes for the dependency tree, where each node contains all the reference data ranges included in each formula.
+     * @param formulaData
      */
-    protected _getUpdateTreeListAndMakeDependency(): IFormulaDependencyTree[];
-    protected _getTreeById(treeId: number): IFormulaDependencyTree | undefined;
-    protected _getTreeNode(tree: IFormulaDependencyTree): import("@univerjs/engine-formula/engine/ast-node/ast-root-node.js").AstRootNode;
-    private _traverse;
-    protected _calculateRunList(treeList: IFormulaDependencyTree[]): (FormulaDependencyTree | FormulaDependencyTreeVirtual)[];
-    protected _getAllTreeList(): Promise<IFormulaDependencyTree[]>;
-    protected _getDependencyTreeParenIds(tree: IFormulaDependencyTree): Set<number>;
-    protected _getDependencyTreeChildrenIds(tree: IFormulaDependencyTree): Set<number>;
-    protected _startFormulaDependencyTreeModel(): void;
-    protected _endFormulaDependencyTreeModel(): void;
+    private _generateTreeListPro;
+    private _registerFeatureFormulasPro;
+    private _getFeatureFormulaTreePro;
+    private _registerOtherFormulasPro;
+    private _registerFormulasPro;
+    private _createSharedFormulaGroupMap;
+    private _createSharedFormulaGroupId;
+    private _analyzeSharedFormulaCompression;
+    private _getSharedFormulaUnsupportedReason;
+    private _convertSharedFormulaPatterns;
+    private _hasSharedFormulaSelfOverlap;
+    private _computeSharedFormulaSourceCoverage;
+    private _normalizeSharedFormulaRange;
+    private _recordCompressedSharedFormulaGroupMetrics;
+    private _recordExpandedSharedFormulaGroupMetrics;
+    private _markDirtyDependenciesPro;
+    private _markForcedRecalculationNodesPro;
+    private _markDirtyDefinedNameDependenciesPro;
+    private _cacheCalculationTree;
+    private _cacheCompressedVirtualCalculationTree;
+    private _getOffsetRangeList;
+    private _getAllDependencyJsonPro;
+    private _inferDependencyTreeTypePro;
+    private _clearCalculationTreeCache;
+    private _releaseDependencyTree;
+    private _hasDirtyDefinedNames;
+    private _syncForcedRecalculationNodeIndex;
+    private _syncCompressedVirtualForcedRecalculationNodeIndex;
+    private _detectForcedRecalculationNodePro;
+    private _includeDirtyDefinedNamePro;
+    private _ensureTreeInitializedForFeatureDependencies;
+    private _ensureTreeNodeForCalculation;
+    private _getFeatureFormulaDependencyNodes;
+    private _rangesIntersectAny;
+    private _initialAstNodeAndRanges;
+    protected _createFDtree(unitId: string, sheetId: string, row: number, column: number, unitData: IUnitData, formulaDataItem: IFormulaDataItem): FormulaDependencyTree;
 }

package/lib/types/engine/shared-formula-group-analyzer.d.ts

@@ -0,0 +1,45 @@
+import type { IUnitRange } from '@univerjs/core';
+import type { IFormulaData } from '@univerjs/engine-formula';
+export type SharedFormulaFallbackReason = 'small-group' | 'non-rectangular-fill-range' | 'missing-anchor-formula' | 'ambiguous-anchor-formula' | 'unsupported-dynamic-reference' | 'volatile-function' | 'self-overlap' | 'array-formula' | 'spill-formula' | 'external-reference' | 'unsupported-range-pattern';
+export interface ISharedFormulaAnalyzerConfig {
+    minSharedGroupSize?: number;
+}
+export interface ISharedFormulaCellAddress {
+    unitId: string;
+    sheetId: string;
+    row: number;
+    col: number;
+}
+export interface ISharedFormulaGroupSummary {
+    groupId: string;
+    unitId: string;
+    sheetId: string;
+    si: string;
+    anchor?: ISharedFormulaCellAddress;
+    fillRange?: IUnitRange;
+    width: number;
+    height: number;
+    size: number;
+    virtualFormulaCount: number;
+    mode: 'candidate' | 'expanded';
+    fallbackReason?: SharedFormulaFallbackReason;
+}
+export interface ISharedFormulaCompressionMetrics {
+    totalFormulaNodes: number;
+    totalSharedFormulaGroups: number;
+    compressedSharedFormulaGroups: number;
+    compressibleSharedFormulaGroups: number;
+    expandedSharedFormulaGroups: number;
+    totalVirtualFormulaNodesInCompressedGroups: number;
+    totalVirtualFormulaNodesInCompressibleGroups: number;
+    skippedExpandedDependencyRegistrationCount: number;
+    sharedPatternCount: number;
+    sharedSourceCoverageEntryCount: number;
+    fallbackReasonCounts: Partial<Record<SharedFormulaFallbackReason, number>>;
+}
+export interface ISharedFormulaAnalysisResult {
+    groups: ISharedFormulaGroupSummary[];
+    metrics: ISharedFormulaCompressionMetrics;
+}
+export declare function createEmptySharedFormulaCompressionMetrics(): ISharedFormulaCompressionMetrics;
+export declare function analyzeSharedFormulaGroups(formulaData: IFormulaData, config?: ISharedFormulaAnalyzerConfig): ISharedFormulaAnalysisResult;

package/lib/types/index.d.ts

@@ -1,3 +1,2 @@
-export { LexerTreeProBuilder } from './engine/lexer-tree-builder';
 export { UniverProFormulaEnginePlugin } from './plugin';
 export * from '@univerjs/engine-formula';

package/lib/types/plugin.d.ts

@@ -1,8 +1,6 @@
 import { UniverFormulaEnginePlugin } from '@univerjs/engine-formula';
-export declare const BUILD_TIMESTAMP: number;
 export declare class UniverProFormulaEnginePlugin extends UniverFormulaEnginePlugin {
     static packageName: string;
     static version: string;
     protected _initializeWithOverride(): void;
-    private _initLicenseValid;
 }

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

@@ -1,4 +1,21 @@
+import type { IFormulaDatasetConfig } from '@univerjs/engine-formula';
+import type { CalcNodeIndex, DynamicResolver, ICalculationOrderResult } from '../engine/dependency-engine';
+import type { IFormulaCalculationTree } from '../engine/formula-dependency';
 import { CalculateFormulaService } from '@univerjs/engine-formula';
 export declare class CalculateFormulaProService extends CalculateFormulaService {
-    protected _apply(isArrayFormulaState?: boolean): Promise<import("@univerjs/engine-formula").IAllRuntimeData | undefined>;
+    private _dynamicRuntimeRanges;
+    execute(formulaDatasetConfig: IFormulaDatasetConfig): Promise<void>;
+    protected _executeStep(cycleReferenceCount?: number): Promise<true | undefined>;
+    protected _apply(isArrayFormulaState?: boolean, cycleReferenceCount?: number): Promise<import("@univerjs/engine-formula").IAllRuntimeData | undefined>;
+    private _shouldRescheduleAfterDynamicChange;
+    protected _forEachCalculationPlanTree(calculationOrderResult: Pick<ICalculationOrderResult, 'calculationForest'>, dependencyTree: Map<CalcNodeIndex, IFormulaCalculationTree>, cycleReferenceCount: number, visitor: (tree: IFormulaCalculationTree, nodeIndex: CalcNodeIndex, cycleIndex?: number) => Promise<boolean | void>): Promise<void>;
+    protected _getCalculationPlanTreeCount(calculationOrderResult: Pick<ICalculationOrderResult, 'calculationForest'>, dependencyTree: Map<CalcNodeIndex, IFormulaCalculationTree>, cycleReferenceCount: number): number;
+    protected _getDynamicResolver(): DynamicResolver | undefined;
+    private _refreshDynamicDepsAfterCalculate;
+    private _collectAddressFunctionRuntimeRanges;
+    private _collectAddressFunctionRuntimeRangesInternal;
+    private _getRangeSignature;
+    private _waitForExecutionSlot;
+    private _calculateDependencyTree;
+    private _getCalculationNodeData;
 }

package/lib/types/services/dependency-manager.service.d.ts

@@ -1,24 +1,49 @@
-import type { IRange, Nullable } from '@univerjs/core';
-import type { FormulaDependencyTree, IFormulaDependencyTree } from '@univerjs/engine-formula';
-import { RTree } from '@univerjs/core';
+import type { IUnitRange } from '@univerjs/core';
+import type { FormulaDependencyTree, IDirtyUnitFeatureMap, IDirtyUnitOtherFormulaMap, IDirtyUnitSheetNameMap, IFormulaDependencyTree } from '@univerjs/engine-formula';
+import type { DynamicResolver, ICalcNodeRef, ICompressedSharedFormulaGroup } from '../engine/dependency-engine';
 import { DependencyManagerBaseService } from '@univerjs/engine-formula';
 export declare class DependencyManagerProService extends DependencyManagerBaseService {
-    protected _allTreeMap: Map<number, Map<string, Map<string, IRange>>>;
-    protected _dependencyRTreeCache: RTree;
+    private _dependencyEngineCache;
     reset(): void;
-    addOtherFormulaDependency(unitId: string, sheetId: string, formulaId: string, dependencyTree: IFormulaDependencyTree): void;
+    private _getCellIdsAndRanges;
+    private _getDynamicDeps;
+    addOtherFormulaDependencyPro(unitId: string, sheetId: string, formulaId: string, dependencyTree: IFormulaDependencyTree, featureNodes?: ICalcNodeRef[], mode?: 'replace' | 'merge'): number;
     removeOtherFormulaDependency(unitId: string, sheetId: string, formulaIds: string[]): void;
     clearOtherFormulaDependency(unitId: string, sheetId?: string): void;
-    addFeatureFormulaDependency(unitId: string, sheetId: string, featureId: string, dependencyTree: FormulaDependencyTree): void;
+    getOtherFormulaDependencyPro(unitId: string, sheetId: string, formulaId: string, refOffsetX: number, refOffsetY: number): number | undefined;
+    addFeatureFormulaDependencyPro(unitId: string, sheetId: string, featureId: string, dependencyTree: FormulaDependencyTree): number;
     removeFeatureFormulaDependency(unitId: string, sheetId: string, featureIds: string[]): void;
     clearFeatureFormulaDependency(unitId: string, sheetId?: string): void;
-    addFormulaDependency(unitId: string, sheetId: string, row: number, column: number, dependencyTree: IFormulaDependencyTree): void;
+    getFeatureFormulaDependencyPro(unitId: string, sheetId: string, featureId: string): number | undefined;
+    getFeatureFormulaDependencyNodePro(unitId: string, sheetId: string, featureId: string): ICalcNodeRef;
+    addFormulaDependencyPro(unitId: string, sheetId: string, row: number, column: number, dependencyTree: IFormulaDependencyTree, featureNodes?: ICalcNodeRef[], mode?: 'replace' | 'merge'): number;
+    addFormulaDependencyNodeOnlyPro(unitId: string, sheetId: string, row: number, column: number): number;
+    registerCompressedSharedFormulaGroup(group: ICompressedSharedFormulaGroup): void;
+    clearCompressedSharedFormulaGroups(unitId?: string, sheetId?: string): void;
     removeFormulaDependency(unitId: string, sheetId: string, row: number, column: number): void;
     clearFormulaDependency(unitId: string, sheetId?: string): void;
-    private _removeDependencyRTreeCache;
-    removeFormulaDependencyByDefinedName(unitId: string, definedName: string): void;
-    openKdTree(): void;
-    closeKdTree(): void;
-    protected _removeAllTreeMap(treeId: Nullable<number>): void;
-    protected _addAllTreeMap(tree: IFormulaDependencyTree): void;
+    getFormulaDependencyPro(unitId: string, sheetId: string, row: number, column: number): number | undefined;
+    markIndicesChanged(indices: number[], options?: {
+        onlySelf?: boolean;
+    }): void;
+    markRangesChanged(ranges: IUnitRange[], options?: {
+        includeFormulaCells?: boolean;
+        coalesce?: boolean;
+    }): void;
+    markDirtyFeatureCalculations(dirtyFeatureMap: IDirtyUnitFeatureMap): void;
+    markDirtyOtherFormulas(dirtyOtherFormulaMap: IDirtyUnitOtherFormulaMap): void;
+    markDirtySheetNames(dirtyNameMap: IDirtyUnitSheetNameMap): void;
+    markAllDirty(): void;
+    clearCalculatedDirty(indices: number[]): void;
+    hasDynamicDeps(node: ICalcNodeRef): boolean;
+    hasDynamicDepsByIndex(nodeIndex: number): boolean;
+    refreshDynamicDeps(node: ICalcNodeRef, resolver: DynamicResolver): boolean;
+    refreshDynamicDepsByIndex(nodeIndex: number, resolver: DynamicResolver): boolean;
+    hasUncalculatedDirtyPrecedentByIndex(nodeIndex: number, calculatedNodeIndices: ReadonlySet<number>): boolean;
+    forEachPrecedentNodeByIndex(nodeIndex: number, cb: (precedentNodeIndex: number) => void): void;
+    forEachDependentNodeByIndex(nodeIndex: number, cb: (dependentNodeIndex: number) => void): void;
+    prepareDynamicDependencies(resolver: DynamicResolver): boolean;
+    getCalculationOrder(options?: {
+        detectCycles?: boolean;
+    }): import("../engine/dependency-engine").ICalculationOrderResult;
 }

package/lib/umd/facade.js

@@ -1 +1 @@
-(function(_0x19859c,_0x4341f7){var _0x213b25=_0x14de,_0x10f7fd=_0x19859c();while(!![]){try{var _0x211fb4=parseInt(_0x213b25(0x162))/0x1*(parseInt(_0x213b25(0x161))/0x2)+parseInt(_0x213b25(0x15f))/0x3+parseInt(_0x213b25(0x152))/0x4+parseInt(_0x213b25(0x15a))/0x5*(-parseInt(_0x213b25(0x159))/0x6)+parseInt(_0x213b25(0x15c))/0x7+parseInt(_0x213b25(0x154))/0x8+parseInt(_0x213b25(0x158))/0x9*(-parseInt(_0x213b25(0x156))/0xa);if(_0x211fb4===_0x4341f7)break;else _0x10f7fd['push'](_0x10f7fd['shift']());}catch(_0x30505d){_0x10f7fd['push'](_0x10f7fd['shift']());}}}(_0x5ae6,0x60342),function(_0x137eaf,_0x38664e){var _0x20ebef=_0x14de;typeof exports=='object'&&typeof module<'u'?_0x38664e(exports,require(`@univerjs/engine-formula/facade`)):typeof define==_0x20ebef(0x15e)&&define[_0x20ebef(0x15b)]?define(['exports',_0x20ebef(0x153)],_0x38664e):(_0x137eaf=typeof globalThis<'u'?globalThis:_0x137eaf||self,_0x38664e(_0x137eaf[_0x20ebef(0x15d)]={},_0x137eaf[_0x20ebef(0x163)]));}(this,function(_0x1b5240,_0x3dd8d3){var _0x34202b=_0x14de;Object[_0x34202b(0x160)](_0x1b5240,Symbol[_0x34202b(0x155)],{'value':'Module'}),Object[_0x34202b(0x160)](_0x1b5240,_0x34202b(0x157),{'enumerable':!0x0,'get':function(){return _0x3dd8d3['FFormula'];}});}));function _0x14de(_0x7b697c,_0x5b0451){_0x7b697c=_0x7b697c-0x152;var _0x5ae6e0=_0x5ae6();var _0x14dece=_0x5ae6e0[_0x7b697c];return _0x14dece;}function _0x5ae6(){var _0x1068c1=['UniverEngineFormulaFacade','1529632NHtYaz','@univerjs/engine-formula/facade','689592MrKKrM','toStringTag','10FpPAtd','FFormula','12431754ZevmIl','6maaMeS','2923940wkEMmK','amd','4424875SWLpFg','UniverProEngineFormulaFacade','function','1455126PJrkKc','defineProperty','734aWLILx','2110QwujPP'];_0x5ae6=function(){return _0x1068c1;};return _0x5ae6();}
+(function(_0x38069a,_0x509152){var _0x4f947d=_0x5925,_0x14bcc2=_0x38069a();while(!![]){try{var _0x3c70da=parseInt(_0x4f947d(0x1c8))/0x1+parseInt(_0x4f947d(0x1c3))/0x2+-parseInt(_0x4f947d(0x1c9))/0x3*(parseInt(_0x4f947d(0x1cd))/0x4)+parseInt(_0x4f947d(0x1c2))/0x5*(parseInt(_0x4f947d(0x1c4))/0x6)+-parseInt(_0x4f947d(0x1ca))/0x7*(parseInt(_0x4f947d(0x1c7))/0x8)+parseInt(_0x4f947d(0x1c0))/0x9+-parseInt(_0x4f947d(0x1cb))/0xa*(-parseInt(_0x4f947d(0x1be))/0xb);if(_0x3c70da===_0x509152)break;else _0x14bcc2['push'](_0x14bcc2['shift']());}catch(_0x2604ab){_0x14bcc2['push'](_0x14bcc2['shift']());}}}(_0x5823,0x7ced9),function(_0x1e400c,_0x483446){var _0x5e7a57=_0x5925;typeof exports==_0x5e7a57(0x1bf)&&typeof module<'u'?_0x483446(exports,require(`@univerjs/engine-formula/facade`)):typeof define==_0x5e7a57(0x1cc)&&define['amd']?define([_0x5e7a57(0x1c6),_0x5e7a57(0x1c1)],_0x483446):(_0x1e400c=typeof globalThis<'u'?globalThis:_0x1e400c||self,_0x483446(_0x1e400c['UniverProEngineFormulaFacade']={},_0x1e400c[_0x5e7a57(0x1ce)]));}(this,function(_0x4743d2,_0x4fd6b1){var _0x8572ea=_0x5925;Object[_0x8572ea(0x1cf)](_0x4743d2,Symbol['toStringTag'],{'value':_0x8572ea(0x1bd)}),Object[_0x8572ea(0x1cf)](_0x4743d2,'FFormula',{'enumerable':!0x0,'get':function(){var _0x538da3=_0x8572ea;return _0x4fd6b1[_0x538da3(0x1c5)];}});}));function _0x5925(_0x5274ec,_0x54580f){_0x5274ec=_0x5274ec-0x1bd;var _0x58230f=_0x5823();var _0x5925f4=_0x58230f[_0x5274ec];return _0x5925f4;}function _0x5823(){var _0x5a0757=['3vgXjgB','7dQQJpY','760jABVXV','function','3066056taTkdH','UniverEngineFormulaFacade','defineProperty','Module','72952kRdKTc','object','4980987IpBEfM','@univerjs/engine-formula/facade','607465obAUrd','44626wzXAuA','48oZPayL','FFormula','exports','7706728KEQUhI','189828RkdLYK'];_0x5823=function(){return _0x5a0757;};return _0x5823();}