@univerjs/engine-formula 0.5.4 → 0.5.5-experimental.20250123-34738ff

package/lib/es/facade.js

@@ -1,14 +1,19 @@
-import { Inject as u, ICommandService as f, Injector as _, FBase as C, IConfigService as v, FUniver as m } from "@univerjs/core";
-import { LexerTreeBuilder as x, SetFormulaCalculationStartMutation as l, SetFormulaCalculationStopMutation as p, SetFormulaCalculationNotificationMutation as d, ENGINE_FORMULA_CYCLE_REFERENCE_COUNT as S } from "@univerjs/engine-formula";
-var h = Object.defineProperty, E = Object.getOwnPropertyDescriptor, F = (e, t, r, i) => {
-  for (var n = i > 1 ? void 0 : i ? E(t, r) : t, a = e.length - 1, c; a >= 0; a--)
-    (c = e[a]) && (n = (i ? c(t, r, n) : c(n)) || n);
-  return i && n && h(t, r, n), n;
-}, o = (e, t) => (r, i) => t(r, i, e);
-let s = class extends C {
-  constructor(e, t, r, i) {
-    super(), this._commandService = e, this._injector = t, this._lexerTreeBuilder = r, this._configService = i, this._initialize();
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+import { Inject, ICommandService, Injector, FBase, IConfigService, FUniver } from "@univerjs/core";
+import { LexerTreeBuilder, SetFormulaCalculationStartMutation, SetFormulaCalculationStopMutation, SetFormulaCalculationNotificationMutation, ENGINE_FORMULA_CYCLE_REFERENCE_COUNT } from "@univerjs/engine-formula";
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam"), _a;
+let FFormula = (_a = class extends FBase {
+  constructor(_commandService, _injector, _lexerTreeBuilder, _configService) {
+    super(), this._commandService = _commandService, this._injector = _injector, this._lexerTreeBuilder = _lexerTreeBuilder, this._configService = _configService, this._initialize();
   }
+  /**
+   * @ignore
+   */
   _initialize() {
   }
   /**
@@ -28,8 +33,8 @@ let s = class extends C {
    * const result = moveFormulaRefOffset('sum(a1,b2)',1,1)
    * // result  is 'sum(b2,c3)'
    */
-  moveFormulaRefOffset(e, t, r, i) {
-    return this._lexerTreeBuilder.moveFormulaRefOffset(e, t, r, i);
+  moveFormulaRefOffset(formulaString, refOffsetX, refOffsetY, ignoreAbsolute) {
+    return this._lexerTreeBuilder.moveFormulaRefOffset(formulaString, refOffsetX, refOffsetY, ignoreAbsolute);
   }
   /**
    * Resolves the formula string to a 'node' node
@@ -37,30 +42,30 @@ let s = class extends C {
    * @returns {*}  {((string | ISequenceNode)[])}
    * @memberof FFormula
    */
-  sequenceNodesBuilder(e) {
-    return this._lexerTreeBuilder.sequenceNodesBuilder(e) || [];
+  sequenceNodesBuilder(formulaString) {
+    return this._lexerTreeBuilder.sequenceNodesBuilder(formulaString) || [];
   }
   /**
    * Start the calculation of the formula.
    */
   executeCalculation() {
-    this._commandService.executeCommand(l.id, { commands: [], forceCalculation: !0 }, { onlyLocal: !0 });
+    this._commandService.executeCommand(SetFormulaCalculationStartMutation.id, { commands: [], forceCalculation: !0 }, { onlyLocal: !0 });
   }
   /**
    * Stop the calculation of the formula.
    */
   stopCalculation() {
-    this._commandService.executeCommand(p.id, {});
+    this._commandService.executeCommand(SetFormulaCalculationStopMutation.id, {});
   }
   /**
    * Listening calculation starts.
    * @param callback
    */
-  calculationStart(e) {
-    return this._commandService.onCommandExecuted((t) => {
-      if (t.id === l.id) {
-        const r = t.params;
-        e(r.forceCalculation);
+  calculationStart(callback) {
+    return this._commandService.onCommandExecuted((command) => {
+      if (command.id === SetFormulaCalculationStartMutation.id) {
+        const params = command.params;
+        callback(params.forceCalculation);
       }
     });
   }
@@ -68,20 +73,20 @@ let s = class extends C {
    * Listening calculation ends.
    * @param callback
    */
-  calculationEnd(e) {
-    return this._commandService.onCommandExecuted((t) => {
-      if (t.id !== d.id)
+  calculationEnd(callback) {
+    return this._commandService.onCommandExecuted((command) => {
+      if (command.id !== SetFormulaCalculationNotificationMutation.id)
         return;
-      const r = t.params;
-      r.functionsExecutedState !== void 0 && e(r.functionsExecutedState);
+      const params = command.params;
+      params.functionsExecutedState !== void 0 && callback(params.functionsExecutedState);
     });
   }
   onCalculationEnd() {
-    return new Promise((e, t) => {
-      const r = setTimeout(() => {
-        t(new Error("Calculation end timeout"));
-      }, 3e4), i = this.calculationEnd(() => {
-        clearTimeout(r), i.dispose(), e();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error("Calculation end timeout"));
+      }, 3e4), disposable = this.calculationEnd(() => {
+        clearTimeout(timer), disposable.dispose(), resolve();
       });
     });
   }
@@ -89,12 +94,12 @@ let s = class extends C {
    * Listening calculation processing.
    * @param callback
    */
-  calculationProcessing(e) {
-    return this._commandService.onCommandExecuted((t) => {
-      if (t.id !== d.id)
+  calculationProcessing(callback) {
+    return this._commandService.onCommandExecuted((command) => {
+      if (command.id !== SetFormulaCalculationNotificationMutation.id)
         return;
-      const r = t.params;
-      r.stageInfo !== void 0 && e(r.stageInfo);
+      const params = command.params;
+      params.stageInfo !== void 0 && callback(params.stageInfo);
     });
   }
   /**
@@ -108,22 +113,24 @@ let s = class extends C {
    * formulaEngine.setMaxIteration(5);
    * ```
    */
-  setMaxIteration(e) {
-    this._configService.setConfig(S, e);
+  setMaxIteration(maxIteration) {
+    this._configService.setConfig(ENGINE_FORMULA_CYCLE_REFERENCE_COUNT, maxIteration);
   }
-};
-s = F([
-  o(0, u(f)),
-  o(1, u(_)),
-  o(2, u(x)),
-  o(3, v)
-], s);
-class g extends m {
+}, __name(_a, "FFormula"), _a);
+FFormula = __decorateClass([
+  __decorateParam(0, Inject(ICommandService)),
+  __decorateParam(1, Inject(Injector)),
+  __decorateParam(2, Inject(LexerTreeBuilder)),
+  __decorateParam(3, IConfigService)
+], FFormula);
+const _FUniverEngineFormulaMixin = class _FUniverEngineFormulaMixin extends FUniver {
   getFormula() {
-    return this._injector.createInstance(s);
+    return this._injector.createInstance(FFormula);
   }
-}
-m.extend(g);
+};
+__name(_FUniverEngineFormulaMixin, "FUniverEngineFormulaMixin");
+let FUniverEngineFormulaMixin = _FUniverEngineFormulaMixin;
+FUniver.extend(FUniverEngineFormulaMixin);
 export {
-  s as FFormula
+  FFormula
 };