@univerjs/sheets-formula 0.4.2 → 0.5.0-beta.0

package/lib/es/locale/en-US.js

@@ -0,0 +1,14 @@
+const a = {
+  formula: {
+    progress: {
+      analyzing: "Analyzing",
+      calculating: "Calculating",
+      "array-analysis": "Array Analysis",
+      "array-calculation": "Array Calculation",
+      done: "Done"
+    }
+  }
+};
+export {
+  a as default
+};

package/lib/es/locale/fa-IR.js

@@ -0,0 +1,14 @@
+const a = {
+  formula: {
+    progress: {
+      analyzing: "در حال تحلیل",
+      calculating: "در حال محاسبه",
+      "array-analysis": "تحلیل آرایه",
+      "array-calculation": "محاسبه آرایه",
+      done: "تمام"
+    }
+  }
+};
+export {
+  a as default
+};

package/lib/es/locale/ru-RU.js

@@ -0,0 +1,14 @@
+const a = {
+  formula: {
+    progress: {
+      analyzing: "Анализ",
+      calculating: "Вычисление",
+      "array-analysis": "Анализ массива",
+      "array-calculation": "Вычисление массива",
+      done: "Готово"
+    }
+  }
+};
+export {
+  a as default
+};

package/lib/es/locale/vi-VN.js

@@ -0,0 +1,14 @@
+const a = {
+  formula: {
+    progress: {
+      analyzing: "Đang phân tích",
+      calculating: "Đang tính toán",
+      "array-analysis": "Phân tích mảng",
+      "array-calculation": "Tính toán mảng",
+      done: "Hoàn tất"
+    }
+  }
+};
+export {
+  a as default
+};

package/lib/es/locale/zh-CN.js

@@ -0,0 +1,14 @@
+const a = {
+  formula: {
+    progress: {
+      analyzing: "分析中",
+      calculating: "计算中",
+      "array-analysis": "数组分析",
+      "array-calculation": "数组计算",
+      done: "完成"
+    }
+  }
+};
+export {
+  a as default
+};

package/lib/es/locale/zh-TW.js

@@ -0,0 +1,14 @@
+const a = {
+  formula: {
+    progress: {
+      analyzing: "分析中",
+      calculating: "計算中",
+      "array-analysis": "陣列分析",
+      "array-calculation": "陣列計算",
+      done: "完成"
+    }
+  }
+};
+export {
+  a as default
+};

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

@@ -5,10 +5,28 @@ import { BaseFunction, IFunctionInfo, IFunctionNames } from '@univerjs/engine-fo
  */
 export declare const PLUGIN_CONFIG_KEY_BASE = "sheets-formula.base.config";
 export declare const configSymbolBase: unique symbol;
+export declare enum CalculationMode {
+    /**
+     * Force calculation of all formulas
+     */
+    FORCED = 0,
+    /**
+     * Partial calculation, only cells with formulas but no v values are calculated
+     */
+    WHEN_EMPTY = 1,
+    /**
+     * All formulas are not calculated
+     */
+    NO_CALCULATION = 2
+}
 export interface IUniverSheetsFormulaBaseConfig {
     notExecuteFormula?: boolean;
     description?: IFunctionInfo[];
     function?: Array<[Ctor<BaseFunction>, IFunctionNames]>;
+    /**
+     * Define the calculation mode during initialization, default is `WHEN_EMPTY`
+     */
+    initialFormulaComputing?: CalculationMode;
 }
 export declare const defaultPluginBaseConfig: IUniverSheetsFormulaBaseConfig;
 /**

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

@@ -1,5 +1,6 @@
-import { Disposable, ICommandService } from '@univerjs/core';
-import { IActiveDirtyManagerService } from '@univerjs/engine-formula';
+import { Disposable, ICommandService, IConfigService, ILogService, LocaleService } from '@univerjs/core';
+import { FormulaDataModel, IActiveDirtyManagerService } from '@univerjs/engine-formula';
+import { RegisterOtherFormulaService } from '../services/register-other-formula.service';
 /**
  * This interface is for the progress bar to display the calculation progress.
  */
@@ -8,10 +9,17 @@ export interface ICalculationProgress {
     done: number;
     /** The total number of formulas need to calculate. */
     count: number;
+    /** The label of the calculation progress. */
+    label?: string;
 }
 export declare class TriggerCalculationController extends Disposable {
     private readonly _commandService;
     private readonly _activeDirtyManagerService;
+    private readonly _logService;
+    private readonly _configService;
+    private readonly _formulaDataModel;
+    private readonly _localeService;
+    private readonly _registerOtherFormulaService;
     private _waitingCommandQueue;
     private _executingDirtyData;
     private _setTimeoutKey;
@@ -20,6 +28,7 @@ export declare class TriggerCalculationController extends Disposable {
     private _doneCalculationTaskCount;
     private _executionInProgressParams;
     private _restartCalculation;
+    private _calculationMode;
     /**
      * The mark of forced calculation. If a new mutation triggers dirty area calculation during the forced calculation process, forced calculation is still required.
      */
@@ -28,16 +37,24 @@ export declare class TriggerCalculationController extends Disposable {
     readonly progress$: import('rxjs').Observable<ICalculationProgress>;
     private _emitProgress;
     private _startProgress;
+    private _calculateProgress;
     private _completeProgress;
     clearProgress(): void;
-    constructor(_commandService: ICommandService, _activeDirtyManagerService: IActiveDirtyManagerService);
+    constructor(_commandService: ICommandService, _activeDirtyManagerService: IActiveDirtyManagerService, _logService: ILogService, _configService: IConfigService, _formulaDataModel: FormulaDataModel, _localeService: LocaleService, _registerOtherFormulaService: RegisterOtherFormulaService);
     dispose(): void;
     private _commandExecutedListener;
     private _generateDirty;
     private _mergeDirty;
+    /**
+     * dirtyRanges may overlap with the ranges in allDirtyRanges and need to be deduplicated
+     * @param allDirtyRanges
+     * @param dirtyRanges
+     */
+    private _mergeDirtyRanges;
     private _mergeDirtyNameMap;
     private _mergeDirtyUnitFeatureOrOtherFormulaMap;
     private _initialExecuteFormulaProcessListener;
     private _resetExecutingDirtyData;
     private _initialExecuteFormula;
+    private _getDiryDataByCalculationMode;
 }

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

@@ -1,4 +1,4 @@
-import { Disposable, ICommandService, Injector, IUniverInstanceService } from '@univerjs/core';
+import { Disposable, ICommandService, IConfigService, Injector, IUniverInstanceService } from '@univerjs/core';
 import { FormulaDataModel, IDefinedNamesService, LexerTreeBuilder } from '@univerjs/engine-formula';
 import { SheetInterceptorService } from '@univerjs/sheets';
 /**
@@ -19,13 +19,15 @@ export declare class UpdateFormulaController extends Disposable {
     private readonly _formulaDataModel;
     private _sheetInterceptorService;
     private readonly _definedNamesService;
+    private readonly _configService;
     readonly _injector: Injector;
-    constructor(_univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _lexerTreeBuilder: LexerTreeBuilder, _formulaDataModel: FormulaDataModel, _sheetInterceptorService: SheetInterceptorService, _definedNamesService: IDefinedNamesService, _injector: Injector);
+    constructor(_univerInstanceService: IUniverInstanceService, _commandService: ICommandService, _lexerTreeBuilder: LexerTreeBuilder, _formulaDataModel: FormulaDataModel, _sheetInterceptorService: SheetInterceptorService, _definedNamesService: IDefinedNamesService, _configService: IConfigService, _injector: Injector);
     private _commandExecutedListener;
     private _handleSetRangeValuesMutation;
     private _handleWorkbookDisposed;
     private _handleInsertSheetMutation;
     private _handleWorkbookAdded;
+    private _getDiryDataByCalculationMode;
     private _getUpdateFormula;
     private _getFormulaReferenceMoveInfo;
 }

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

@@ -0,0 +1,14 @@
+import { CalculationMode } from '@univerjs/sheets-formula';
+interface IFFormulaSheetsMixin {
+    /**
+     * Update the calculation mode of the formula.
+     * @param calculationMode
+     * @returns
+     */
+    setInitialFormulaComputing(calculationMode: CalculationMode): void;
+}
+declare module '@univerjs/engine-formula' {
+    interface FFormula extends IFFormulaSheetsMixin {
+    }
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { IDisposable } from '@univerjs/core';
+import { IRegisterFunctionParams } from '@univerjs/sheets-formula';
+interface IFUniverSheetsFormulaMixin {
+    /**
+     * Register a function to the spreadsheet.
+     *
+     * @param {IRegisterFunctionParams} config The configuration of the function.
+     * @returns {IDisposable} The disposable instance.
+     */
+    registerFunction(config: IRegisterFunctionParams): IDisposable;
+}
+declare module '@univerjs/core' {
+    interface FUniver extends IFUniverSheetsFormulaMixin {
+    }
+}
+export {};

package/lib/types/facade/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import './f-univer';
+import './f-formula';

package/lib/types/index.d.ts

@@ -17,6 +17,7 @@ export { type IInsertFunction, type IInsertFunctionCommandParams, InsertFunction
 export { OtherFormulaMarkDirty } from './commands/mutations/formula.mutation';
 export { UpdateDefinedNameController } from './controllers/update-defined-name.controller';
 export { TriggerCalculationController } from './controllers/trigger-calculation.controller';
+export { CalculationMode, type IUniverSheetsFormulaBaseConfig, PLUGIN_CONFIG_KEY_BASE } from './controllers/config.schema';
 export { UpdateFormulaController } from './controllers/update-formula.controller';
 export { DescriptionService, IDescriptionService, type ISearchItem } from './services/description.service';
 export type { IFormulaInfo, IOtherFormulaResult } from './services/formula-common';

package/lib/types/locale/en-US.d.ts

@@ -0,0 +1,3 @@
+import { default as zhCN } from './zh-CN';
+declare const locale: typeof zhCN;
+export default locale;

package/lib/types/locale/fa-IR.d.ts

@@ -0,0 +1,3 @@
+import { default as zhCN } from './zh-CN';
+declare const locale: typeof zhCN;
+export default locale;

package/lib/types/locale/ru-RU.d.ts

@@ -0,0 +1,3 @@
+import { default as zhCN } from './zh-CN';
+declare const locale: typeof zhCN;
+export default locale;

package/lib/types/locale/vi-VN.d.ts

@@ -0,0 +1,3 @@
+import { default as zhCN } from './zh-CN';
+declare const locale: typeof zhCN;
+export default locale;

package/lib/types/locale/zh-CN.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+declare const locale: {
+    formula: {
+        progress: {
+            analyzing: string;
+            calculating: string;
+            'array-analysis': string;
+            'array-calculation': string;
+            done: string;
+        };
+    };
+};
+export default locale;

package/lib/types/locale/zh-TW.d.ts

@@ -0,0 +1,3 @@
+import { default as zhCN } from './zh-CN';
+declare const locale: typeof zhCN;
+export default locale;

package/lib/types/services/__test__/util.d.ts

@@ -0,0 +1,7 @@
+import { Dependency, IWorkbookData, Workbook, Injector, Univer } from '@univerjs/core';
+export interface ITestBed {
+    univer: Univer;
+    get: Injector['get'];
+    sheet: Workbook;
+}
+export declare function createCommandTestBed(workbookData?: IWorkbookData, dependencies?: Dependency[]): ITestBed;

package/lib/types/services/formula-common.d.ts

@@ -1,4 +1,4 @@
-import { ICellData, Nullable } from '@univerjs/core';
+import { ICellData, IObjectMatrixPrimitiveType, Nullable } from '@univerjs/core';
 export declare enum FormulaResultStatus {
     NOT_REGISTER = 1,
     SUCCESS = 2,
@@ -6,10 +6,10 @@ export declare enum FormulaResultStatus {
     ERROR = 4
 }
 export interface IOtherFormulaResult {
-    result?: Nullable<ICellData>[][];
+    result?: IObjectMatrixPrimitiveType<Nullable<ICellData>[][]>;
     status: FormulaResultStatus;
     formulaId: string;
-    callbacks: Set<(value: Nullable<ICellData>[][]) => void>;
+    callbacks: Set<(value: IObjectMatrixPrimitiveType<Nullable<ICellData>[][]>) => void>;
     extra?: Record<string, any>;
 }
 export interface IFormulaInfo {

package/lib/types/services/formula-ref-range.service.d.ts

@@ -1,4 +1,4 @@
-import { IDisposable, IMutationInfo, IRange, Disposable, IUniverInstanceService } from '@univerjs/core';
+import { IDisposable, IMutationInfo, IRange, Disposable, Injector, IUniverInstanceService } from '@univerjs/core';
 import { EffectRefRangeParams, RefRangeService } from '@univerjs/sheets';
 import { LexerTreeBuilder } from '@univerjs/engine-formula';
 export type FormulaChangeMap = Record<string, Record<string, Record<string, string>>>;
@@ -6,8 +6,8 @@ export type FormulaChangeCallback = (formulaString: string) => {
     redos: IMutationInfo[];
     undos: IMutationInfo[];
 };
-export type RangeFormulaChangeCallback = (formulas: {
-    formulaString: string;
+export type RangeFormulaChangeCallback = (infos: {
+    formulas: string[];
     ranges: IRange[];
 }[]) => {
     redos: IMutationInfo[];
@@ -17,7 +17,10 @@ export declare class FormulaRefRangeService extends Disposable {
     private readonly _refRangeService;
     private readonly _lexerTreeBuilder;
     private readonly _univerInstanceService;
-    constructor(_refRangeService: RefRangeService, _lexerTreeBuilder: LexerTreeBuilder, _univerInstanceService: IUniverInstanceService);
+    private readonly _injector;
+    constructor(_refRangeService: RefRangeService, _lexerTreeBuilder: LexerTreeBuilder, _univerInstanceService: IUniverInstanceService, _injector: Injector);
     transformFormulaByEffectCommand(unitId: string, subUnitId: string, formula: string, params: EffectRefRangeParams): string;
     registerFormula(unitId: string, subUnitId: string, formula: string, callback: FormulaChangeCallback): IDisposable;
+    private _getFormulaDependcy;
+    registerRangeFormula(unitId: string, subUnitId: string, oldRanges: IRange[], formulas: string[], callback: RangeFormulaChangeCallback): IDisposable;
 }

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

@@ -1,26 +1,30 @@
-import { Nullable, Disposable, ICommandService } from '@univerjs/core';
+import { IRange, Nullable, Disposable, ICommandService, LifecycleService } from '@univerjs/core';
 import { IActiveDirtyManagerService } from '@univerjs/engine-formula';
+import { BehaviorSubject } from 'rxjs';
 import { IOtherFormulaResult } from './formula-common';
 export declare class RegisterOtherFormulaService extends Disposable {
     private readonly _commandService;
     private _activeDirtyManagerService;
+    private readonly _lifecycleService;
     private _formulaCacheMap;
-    private _formulaChange$;
-    formulaChange$: import('rxjs').Observable<{
+    private _formulaChangeWithRange$;
+    formulaChangeWithRange$: import('rxjs').Observable<{
         unitId: string;
         subUnitId: string;
         formulaText: string;
         formulaId: string;
+        ranges: IRange[];
     }>;
     private _formulaResult$;
     formulaResult$: import('rxjs').Observable<Record<string, Record<string, IOtherFormulaResult[]>>>;
-    constructor(_commandService: ICommandService, _activeDirtyManagerService: IActiveDirtyManagerService);
+    calculateStarted$: BehaviorSubject<boolean>;
+    constructor(_commandService: ICommandService, _activeDirtyManagerService: IActiveDirtyManagerService, _lifecycleService: LifecycleService);
     dispose(): void;
     private _ensureCacheMap;
     private _createFormulaId;
     private _initFormulaRegister;
     private _initFormulaCalculationResultChange;
-    registerFormula(unitId: string, subUnitId: string, formulaText: string, extra?: Record<string, any>): string;
+    registerFormulaWithRange(unitId: string, subUnitId: string, formulaText: string, ranges?: IRange[], extra?: Record<string, any>): string;
     deleteFormula(unitId: string, subUnitId: string, formulaIdList: string[]): void;
     getFormulaValue(unitId: string, subUnitId: string, formulaId: string): Promise<Nullable<IOtherFormulaResult>>;
     getFormulaValueSync(unitId: string, subUnitId: string, formulaId: string): Nullable<IOtherFormulaResult>;

package/lib/umd/facade.js

@@ -0,0 +1 @@
+(function(e,i){typeof exports=="object"&&typeof module<"u"?i(require("@univerjs/core"),require("@univerjs/engine-formula"),require("@univerjs/sheets-formula")):typeof define=="function"&&define.amd?define(["@univerjs/core","@univerjs/engine-formula","@univerjs/sheets-formula"],i):(e=typeof globalThis<"u"?globalThis:e||self,i(e.UniverCore,e.UniverEngineFormula,e.UniverSheetsFormula))})(this,function(e,i,t){"use strict";class s extends e.FUniver{_initialize(){this._debouncedFormulaCalculation=e.debounce(()=>{this._commandService.executeCommand(i.SetFormulaCalculationStartMutation.id,{commands:[],forceCalculation:!0},{onlyLocal:!0})},10)}registerFunction(r){let n=this._injector.get(t.IRegisterFunctionService);n||(this._injector.add([t.IRegisterFunctionService,{useClass:t.RegisterFunctionService}]),n=this._injector.get(t.IRegisterFunctionService));const c=n.registerFunctions(r);return this._debouncedFormulaCalculation(),c}}e.FUniver.extend(s);class u extends i.FFormula{setInitialFormulaComputing(r){const c=this._injector.get(e.LifecycleService).stage,a=this._injector.get(e.ILogService),f=this._injector.get(e.IConfigService);c>e.LifecycleStages.Starting&&a.warn("[FFormula]","CalculationMode is called after the Starting lifecycle and will take effect the next time the Univer Sheet is constructed. If you want it to take effect when the Univer Sheet is initialized this time, consider calling it before the Ready lifecycle or using configuration.");const o=f.getConfig(t.PLUGIN_CONFIG_KEY_BASE);o&&(o.initialFormulaComputing=r)}}i.FFormula.extend(u)});