@univerjs-pro/engine-formula-rust 1.0.0-insiders.20260809-70eefdd → 1.0.0

package/lib/cjs/index.cjs

@@ -246,7 +246,7 @@ var import_core2 = require("@univerjs/core");
 
 // src/services/rust-formula-projection.service.ts
 var import_core = require("@univerjs/core");
-var XLSX_WORKBOOK_CALCULATION_RESOURCE = "UNIVER_CLI_XLSX_WORKBOOK_CALCULATION_PLUGIN", EXTERNAL_DATA_RESOURCE = "SHEET_EXTERNAL_DATA_PLUGIN", EXTERNAL_DATA_SIGNATURE = "external_data", RUST_UPSERT_REFERENCE_DATA_MUTATION_ID = "formula.mutation.upsert-reference-data", RUST_UPSERT_PROJECTION_WORKBOOK_MUTATION_ID = "formula.mutation.upsert-projection-workbook", RUST_FORMULA_RELEVANT_MUTATIONS = /* @__PURE__ */ new Set([
+var XLSX_WORKBOOK_CALCULATION_RESOURCE = "UNIVER_CLI_XLSX_WORKBOOK_CALCULATION_PLUGIN", EXTERNAL_DATA_RESOURCE = "SHEET_EXTERNAL_DATA_PLUGIN", EXTERNAL_DATA_SIGNATURE = "external_data", RUST_UPSERT_REFERENCE_DATA_MUTATION_ID = "formula.mutation.upsert-reference-data", RUST_UPSERT_PROJECTION_WORKBOOK_MUTATION_ID = "formula.mutation.upsert-projection-workbook", RUST_SET_SUPER_TABLES_MUTATION_ID = "formula.mutation.set-super-tables", RUST_FORMULA_RELEVANT_MUTATIONS = /* @__PURE__ */ new Set([
   "sheet.mutation.set-range-values",
   "sheet.mutation.insert-row",
   "sheet.mutation.insert-col",
@@ -262,6 +262,11 @@ var XLSX_WORKBOOK_CALCULATION_RESOURCE = "UNIVER_CLI_XLSX_WORKBOOK_CALCULATION_P
   "sheet.mutation.set-col-visible",
   "sheet.mutation.set-row-hidden",
   "sheet.mutation.set-row-visible",
+  "sheet.mutation.set-table-filter",
+  "sheet.mutation.set-filter-range",
+  "sheet.mutation.set-filter-criteria",
+  "sheet.mutation.remove-filter",
+  "sheet.mutation.re-calc-filter",
   "sheet.mutation.set-worksheet-name",
   "sheet.mutation.reorder-range",
   "sheet.mutation.set-worksheet-row-count",
@@ -273,6 +278,7 @@ var XLSX_WORKBOOK_CALCULATION_RESOURCE = "UNIVER_CLI_XLSX_WORKBOOK_CALCULATION_P
   "formula.mutation.set-image-formula-data",
   "formula.mutation.set-other-formula",
   "formula.mutation.set-super-table",
+  RUST_SET_SUPER_TABLES_MUTATION_ID,
   "formula.mutation.set-super-table-option",
   "formula.mutation.remove-defined-name",
   "formula.mutation.remove-feature-calculation",
@@ -334,11 +340,18 @@ function serializeRuntimeWorkbookSnapshots(workbooks) {
 }
 function serializeRuntimeWorkbookSnapshot(input) {
   let { snapshot } = input, sheetOrder = snapshot.sheetOrder?.length > 0 ? snapshot.sheetOrder : Object.keys(snapshot.sheets ?? {}), calculation = serializeCalculation(snapshot), precisionAsDisplayed = calculation?.fullPrecision === !1, sheets = sheetOrder.map(
-    (sheetId) => serializeSheetSnapshot(sheetId, snapshot.sheets?.[sheetId], snapshot.styles, precisionAsDisplayed)
+    (sheetId) => serializeSheetSnapshot(
+      sheetId,
+      snapshot.sheets?.[sheetId],
+      snapshot.styles,
+      precisionAsDisplayed,
+      input.styleResolver
+    )
   ).filter((sheet) => sheet != null);
   return {
     unitId: input.unitId || snapshot.id,
     name: snapshot.name,
+    dateSystem: snapshot.dateSystem,
     sheets,
     ...calculation ? { calculation } : {},
     resources: serializeResources(snapshot),
@@ -406,13 +419,16 @@ function otherFormulaDataToUnitOtherData(otherFormulaData) {
           if (!colMap) return;
           let row = Number(rowKey), rowData = {};
           formulaData[row] = rowData, Object.entries(colMap).forEach(([colKey, value]) => {
-            rowData[Number(colKey)] = [[cellDataFromRustValue(value)]];
+            rowData[Number(colKey)] = otherFormulaResultFromRustValue(value);
           });
         });
       });
     });
   }), unitOtherData;
 }
+function otherFormulaResultFromRustValue(value) {
+  return Array.isArray(value) ? value.map((row) => (Array.isArray(row) ? row : [row]).map((cell) => cellDataFromRustValue(cell))) : [[cellDataFromRustValue(value)]];
+}
 function createFormulaProjectionDesyncSignal(reason, error, mutationId) {
   return {
     reason,
@@ -508,13 +524,26 @@ var RustFormulaProjectionService = class {
   }
 };
 function normalizeRustEngineMutation(mutation) {
-  let params = mutation.id === "formula.mutation.set-super-table" ? normalizeSetSuperTableMutationParams(mutation.params) : mutation.params ?? {};
+  let params = mutation.id === "formula.mutation.set-super-table" ? normalizeSetSuperTableMutationParams(mutation.params) : mutation.id === RUST_SET_SUPER_TABLES_MUTATION_ID ? normalizeSetSuperTablesMutationParams(mutation.params) : mutation.params ?? {};
   return {
     id: mutation.id,
     params,
     dirtyRanges: Array.isArray(mutation.dirtyRanges) ? mutation.dirtyRanges : []
   };
 }
+function normalizeSetSuperTablesMutationParams(params) {
+  return !isRecord(params) || typeof params.unitId != "string" || !Array.isArray(params.tables) ? params ?? {} : {
+    ...params,
+    tables: params.tables.map((entry) => {
+      let normalized = normalizeSetSuperTableMutationParams(
+        isRecord(entry) ? { ...entry, unitId: params.unitId } : entry
+      );
+      if (!isRecord(normalized)) return normalized;
+      let { unitId: _unitId, ...table } = normalized;
+      return table;
+    })
+  };
+}
 function normalizeSetSuperTableMutationParams(params) {
   if (!isRecord(params) || !isRecord(params.reference))
     return params ?? {};
@@ -933,19 +962,19 @@ function extractDefinedNames(snapshot) {
   }
   return {};
 }
-function serializeSheetSnapshot(sheetId, sheet, styles, precisionAsDisplayed) {
+function serializeSheetSnapshot(sheetId, sheet, styles, precisionAsDisplayed, styleResolver) {
   return sheet ? {
     sheetId: sheet.id ?? sheetId,
     name: sheet.name,
     rowCount: sheet.rowCount ?? 0,
     columnCount: sheet.columnCount ?? 0,
     transitionEvaluation: sheet.transitionEvaluation === !0,
-    cellData: serializeCellData(sheet.cellData, styles, precisionAsDisplayed),
+    cellData: serializeCellData(sheet.cellData, styles, precisionAsDisplayed, styleResolver),
     rowData: serializeVisibilityData(sheet.rowData),
     columnData: serializeVisibilityData(sheet.columnData)
   } : null;
 }
-function serializeCellData(cellData = {}, styles, precisionAsDisplayed = !1) {
+function serializeCellData(cellData = {}, styles, precisionAsDisplayed = !1, styleResolver) {
   let result = {}, rawCellData = cellData instanceof import_core.ObjectMatrix ? cellData.getMatrix() : cellData;
   for (let [rowKey, row] of Object.entries(rawCellData ?? {})) {
     if (!row)
@@ -954,13 +983,15 @@ function serializeCellData(cellData = {}, styles, precisionAsDisplayed = !1) {
     for (let [colKey, cell] of Object.entries(row)) {
       if (!cell || typeof cell != "object")
         continue;
-      let cellRecord = cell, value = {};
-      if ("v" in cellRecord && (value.v = cellRecord.v), typeof cellRecord.t == "number" && (value.t = cellRecord.t), "p" in cellRecord && (value.p = cellRecord.p), typeof cellRecord.f == "string" && (value.f = cellRecord.f), typeof cellRecord.si == "string" && (value.si = cellRecord.si), typeof cellRecord.ref == "string") {
+      let cellRecord = cell, resolvedStyle = styleResolver?.getStyleByCell(cell), value = {};
+      if ("v" in cellRecord && (value.v = cellRecord.v), typeof cellRecord.t == "number" && (value.t = cellRecord.t), "p" in cellRecord && (value.p = cellRecord.p), typeof cellRecord.f == "string" && (value.f = cellRecord.f), typeof cellRecord.ft == "number" && (value.ft = cellRecord.ft), (cellRecord.fd === import_core.BooleanNumber.FALSE || cellRecord.fd === import_core.BooleanNumber.TRUE) && (value.fd = cellRecord.fd), typeof cellRecord.si == "string" && (value.si = cellRecord.si), typeof cellRecord.ref == "string") {
         let hasFormula = typeof cellRecord.f == "string" && cellRecord.f.length > 0;
         typeof cellRecord.si == "string" || hasFormula && isLegacyArrayFormulaCell(cellRecord) ? value.ref = cellRecord.ref : hasFormula && (value.dynamicArrayRef = cellRecord.ref);
       }
-      if (typeof cellRecord.xf == "string" && (value.xf = cellRecord.xf), "s" in cellRecord && (value.s = cellRecord.s), precisionAsDisplayed && typeof cellRecord.f == "string") {
-        let displayPrecision = inferDisplayPrecision(cellRecord.s, styles);
+      typeof cellRecord.xf == "string" && (value.xf = cellRecord.xf), "s" in cellRecord && (value.s = cellRecord.s);
+      let numberFormat = resolveNumberFormatPattern(cellRecord.s, styles, resolvedStyle);
+      if (numberFormat !== void 0 && (value.numberFormat = numberFormat), precisionAsDisplayed && typeof cellRecord.f == "string") {
+        let displayPrecision = inferDisplayPrecision(cellRecord.s, styles, resolvedStyle);
         displayPrecision !== void 0 && (value.displayPrecision = displayPrecision);
       }
       Object.keys(value).length > 0 && (serializedRow[Number(colKey)] = value);
@@ -983,23 +1014,19 @@ function serializeCellDataInRanges(cellData, ranges) {
   return result;
 }
 function isLegacyArrayFormulaCell(cell) {
-  let custom = cell.custom;
-  if (!custom || typeof custom != "object")
-    return !1;
-  let xlsx = custom._xlsx;
-  return xlsx != null && typeof xlsx == "object" && xlsx.legacyArrayFormula === !0;
+  return cell.ft === import_core.FormulaType.ARRAY && cell.fd !== import_core.BooleanNumber.TRUE;
 }
-function inferDisplayPrecision(styleId, styles) {
-  if (typeof styleId != "string" || !styles || typeof styles != "object")
-    return;
-  let style = styles[styleId];
-  if (!style || typeof style != "object")
-    return;
+function inferDisplayPrecision(styleId, styles, resolvedStyle) {
+  let pattern = resolveNumberFormatPattern(styleId, styles, resolvedStyle);
+  return pattern === void 0 ? void 0 : inferFixedNumberFormatPrecision(pattern);
+}
+function resolveNumberFormatPattern(styleRef, styles, resolvedStyle) {
+  let style = resolvedStyle ?? (typeof styleRef == "string" && styles && typeof styles == "object" ? styles[styleRef] : styleRef);
+  if (!style || typeof style != "object") return;
   let numberFormat = style.n;
-  if (!numberFormat || typeof numberFormat != "object")
-    return;
+  if (!numberFormat || typeof numberFormat != "object") return;
   let pattern = numberFormat.pattern;
-  return typeof pattern == "string" ? inferFixedNumberFormatPrecision(pattern) : void 0;
+  return typeof pattern == "string" ? pattern : void 0;
 }
 function inferFixedNumberFormatPrecision(pattern) {
   let cleaned = (pattern.split(";")[0] ?? pattern).replace(/"[^"]*"/gu, "").replace(/\\./gu, "").replace(/_.|\*./gu, "");
@@ -1082,6 +1109,7 @@ var RustEngineSyncController = class extends import_core2.Disposable {
   _nativeReady = !1;
   _snapshotLoaded = !1;
   _projectionLoadPromise = null;
+  _projectionDeltaBarrier = Promise.resolve();
   _pendingMutations = [];
   _projectionManagedTableUnits = /* @__PURE__ */ new Set();
   _initialize() {
@@ -1102,6 +1130,13 @@ var RustEngineSyncController = class extends import_core2.Disposable {
   }
   async waitForProjectionLoad() {
     await this._projectionLoadPromise;
+    let barrier;
+    do
+      barrier = this._projectionDeltaBarrier, await barrier;
+    while (barrier !== this._projectionDeltaBarrier);
+  }
+  setProjectionDeltaBarrier(barrier) {
+    this._projectionDeltaBarrier = barrier;
   }
   async _loadProjection(workbooks) {
     await loadNativeBinding(), this._nativeReady = !0;
@@ -1133,7 +1168,7 @@ var RustEngineSyncController = class extends import_core2.Disposable {
       }
   }
   dispose() {
-    if (super.dispose(), this._pendingMutations.length = 0, this._projectionManagedTableUnits.clear(), this._projectionLoadPromise = null, !this._nativeReady) {
+    if (super.dispose(), this._pendingMutations.length = 0, this._projectionManagedTableUnits.clear(), this._projectionLoadPromise = null, this._projectionDeltaBarrier = Promise.resolve(), !this._nativeReady) {
       this._snapshotLoaded = !1;
       return;
     }
@@ -1267,7 +1302,7 @@ async function analyzeNumberFormatBatch(input) {
 var import_core5 = require("@univerjs/core"), import_engine_formula4 = require("@univerjs/engine-formula"), import_engine_formula5 = require("@univerjs-pro/engine-formula");
 
 // package.json
-var name = "@univerjs-pro/engine-formula-rust", version = "1.0.0-insiders.20260809-70eefdd";
+var name = "@univerjs-pro/engine-formula-rust", version = "1.0.0";
 
 // src/controllers/rust-same-runtime-projection.controller.ts
 var import_core3 = require("@univerjs/core"), import_engine_formula = require("@univerjs/engine-formula");
@@ -1290,18 +1325,20 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
   _activeDirtyManagerService;
   _initialProjectionLoad = Promise.resolve();
   _projectionDeltaQueue = Promise.resolve();
+  _baseProjectionStructures = /* @__PURE__ */ new Map();
   _initialize() {
     for (let base of this._univerInstanceService.getAllUnitsForType(
       import_core3.UniverInstanceType.UNIVER_BASE
     ))
-      this._rustEngineSyncController.setProjectionManagedTableUnit(base.getUnitId());
+      this._rustEngineSyncController.setProjectionManagedTableUnit(base.getUnitId()), this._rememberBaseProjectionStructure(base.getSnapshot());
     this._initialProjectionLoad = this._loadAllWorkbookProjections(), this.disposeWithMe(
       (0, import_core3.toDisposable)(
         this._univerInstanceService.getTypeOfUnitAdded$(import_core3.UniverInstanceType.UNIVER_SHEET).subscribe(({ unit }) => {
           this._enqueueProjectionDelta(() => {
             this._rustEngineSyncController.upsertProjectionWorkbook({
               unitId: unit.getUnitId(),
-              snapshot: unit.getSnapshot()
+              snapshot: unit.getSnapshot(),
+              styleResolver: unit.getStyles()
             });
           });
         })
@@ -1309,7 +1346,7 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
     ), this.disposeWithMe(
       (0, import_core3.toDisposable)(
         this._univerInstanceService.getTypeOfUnitAdded$(import_core3.UniverInstanceType.UNIVER_BASE).subscribe(({ unit }) => {
-          this._rustEngineSyncController.setProjectionManagedTableUnit(unit.getUnitId()), this._enqueueProjectionDelta(() => this._upsertBaseProjection(unit.getUnitId()));
+          this._rustEngineSyncController.setProjectionManagedTableUnit(unit.getUnitId()), this._rememberBaseProjectionStructure(unit.getSnapshot()), this._enqueueProjectionDelta(() => this._upsertBaseProjection(unit.getUnitId()));
         })
       )
     ), this.disposeWithMe(
@@ -1319,7 +1356,7 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
     ), this.disposeWithMe(
       (0, import_core3.toDisposable)(
         this._univerInstanceService.getTypeOfUnitDisposed$(import_core3.UniverInstanceType.UNIVER_BASE).subscribe((base) => {
-          this._rustEngineSyncController.unsetProjectionManagedTableUnit(base.getUnitId()), this._enqueueProjectionDelta(
+          this._baseProjectionStructures.delete(base.getUnitId()), this._rustEngineSyncController.unsetProjectionManagedTableUnit(base.getUnitId()), this._enqueueProjectionDelta(
             () => this._rustEngineSyncController.disposeProjectionWorkbook(base.getUnitId())
           );
         })
@@ -1343,7 +1380,7 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
       if (!this._disposed)
         return task();
     }).catch(() => {
-    });
+    }), this._rustEngineSyncController.setProjectionDeltaBarrier(this._projectionDeltaQueue);
   }
   async _syncBaseMutation(command) {
     if (!hasUnitId2(command.params)) return;
@@ -1352,7 +1389,65 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
       this._applyBaseDirtyRanges(unitId, dirtyRanges);
       return;
     }
-    await this._upsertBaseProjection(unitId);
+    hasStructureInvalidation && this._isBaseProjectionStructureUnchanged(unitId) || hasStructureInvalidation && this._applyBaseFieldInsertion(unitId, dirtyRanges) || await this._upsertBaseProjection(unitId);
+  }
+  _applyBaseFieldInsertion(unitId, dirtyRanges) {
+    let base = this._univerInstanceService.getUnit(unitId, import_core3.UniverInstanceType.UNIVER_BASE), previous = this._baseProjectionStructures.get(unitId);
+    if (!base || !previous) return !1;
+    let snapshot = base.getSnapshot(), insertion = findSingleBaseFieldInsertion(previous, snapshot);
+    if (!insertion) return !1;
+    let projectionData = this._getBaseProjectionData(unitId), sheet = projectionData?.calculationData.allUnitData[unitId]?.[insertion.tableId];
+    if (!projectionData || !sheet) return !1;
+    let formulaData = projectionData.formulaData[unitId]?.[insertion.tableId], cellValue = {};
+    for (let row = 0; row < sheet.rowCount; row++) {
+      let value = sheet.cellData.getValue(row, insertion.column), formula = formulaData?.[row]?.[insertion.column];
+      cellValue[row] = {
+        [insertion.column]: formula ? { ...value, ...formula } : value ?? null
+      };
+    }
+    let insertedRange = {
+      startRow: 0,
+      endRow: Math.max(0, sheet.rowCount - 1),
+      startColumn: insertion.column,
+      endColumn: insertion.column
+    };
+    return this._rustEngineSyncController.applyProjectionMutation({
+      id: "sheet.mutation.insert-col",
+      params: {
+        unitId,
+        subUnitId: insertion.tableId,
+        range: insertedRange
+      },
+      dirtyRanges: []
+    }), this._rustEngineSyncController.applyProjectionMutation({
+      id: "sheet.mutation.set-range-values",
+      params: {
+        unitId,
+        subUnitId: insertion.tableId,
+        cellValue
+      },
+      dirtyRanges: [
+        {
+          unitId,
+          sheetId: insertion.tableId,
+          range: insertedRange
+        }
+      ]
+    }), this._rustEngineSyncController.applyProjectionMutation({
+      id: RUST_SET_SUPER_TABLES_MUTATION_ID,
+      params: {
+        unitId,
+        tables: this._getBaseTableEntries(
+          insertion.tableId,
+          snapshot,
+          (0, import_core3.createBaseFormulaTableNameMap)(snapshot)
+        ).map(([tableName, reference]) => ({
+          tableName,
+          reference
+        }))
+      },
+      dirtyRanges: []
+    }), dirtyRanges.length > 0 && this._applyBaseDirtyRanges(unitId, dirtyRanges), this._rememberBaseProjectionStructure(snapshot), !0;
   }
   _applyBaseDirtyRanges(unitId, dirtyRanges) {
     let projectionData = this._getBaseProjectionData(unitId);
@@ -1394,6 +1489,15 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
       formulaData
     );
     workbook && this._rustEngineSyncController.upsertProjectionWorkbook(workbook);
+    let base = this._univerInstanceService.getUnit(unitId, import_core3.UniverInstanceType.UNIVER_BASE);
+    base && this._rememberBaseProjectionStructure(base.getSnapshot());
+  }
+  _rememberBaseProjectionStructure(snapshot) {
+    this._baseProjectionStructures.set(snapshot.id, createBaseProjectionStructure(snapshot));
+  }
+  _isBaseProjectionStructureUnchanged(unitId) {
+    let base = this._univerInstanceService.getUnit(unitId, import_core3.UniverInstanceType.UNIVER_BASE), previous = this._baseProjectionStructures.get(unitId);
+    return !!(base && previous && isSameBaseProjectionStructure(previous, createBaseProjectionStructure(base.getSnapshot())));
   }
   _getBaseProjectionData(unitId) {
     let base = this._univerInstanceService.getUnit(unitId, import_core3.UniverInstanceType.UNIVER_BASE);
@@ -1403,9 +1507,9 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
         name: snapshot.name,
         unitType: import_core3.UniverInstanceType.UNIVER_BASE
       }
-    }, formulaData = { [unitId]: {} };
+    }, formulaData = { [unitId]: {} }, formulaTableNames = (0, import_core3.createBaseFormulaTableNameMap)(snapshot), normalizeFormulaTableReferences = (0, import_core3.createBaseFormulaTableReferenceNormalizer)(snapshot, formulaTableNames);
     for (let table of Object.values(snapshot.tables)) {
-      let fieldOrder = table.fieldOrder.filter((fieldId) => table.fields[fieldId] != null);
+      let fieldOrder = table.fieldOrder;
       allUnitData[unitId][table.id] = {
         cellData: new import_core3.ObjectMatrix(
           buildBaseRuntimeCellData(table)
@@ -1414,18 +1518,25 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
         columnCount: fieldOrder.length,
         rowData: {},
         columnData: {}
-      }, unitSheetNameMap[unitId][table.name] = table.id;
-      let tableFormulaData = {}, recordOrder = baseRecordOrder(table);
+      }, unitSheetNameMap[unitId][formulaTableNames.get(table.id)] = table.id;
+      let tableFormulaData = {}, normalizedFormulaByFieldId = /* @__PURE__ */ new Map(), recordOrder = baseRecordOrder(table);
       for (let row = 0; row < recordOrder.length; row++)
         if (table.records[recordOrder[row]])
           for (let column = 0; column < fieldOrder.length; column++) {
             let field = table.fields[fieldOrder[column]];
             if (!field || field.type !== "formula") continue;
             let formula = String(field.config?.formula ?? "").trim();
-            formula && ((tableFormulaData[row] ??= {})[column] = {
-              f: normalizeBaseFormulaForEngine(formula, table, snapshot),
+            if (!formula) continue;
+            let normalizedFormula = normalizedFormulaByFieldId.get(field.id);
+            normalizedFormula == null && (normalizedFormula = normalizeBaseFormulaForEngine(
+              formula,
+              table,
+              formulaTableNames,
+              normalizeFormulaTableReferences
+            ), normalizedFormulaByFieldId.set(field.id, normalizedFormula)), (tableFormulaData[row] ??= {})[column] = {
+              f: normalizedFormula,
               si: field.id
-            });
+            };
           }
       formulaData[unitId][table.id] = tableFormulaData;
     }
@@ -1441,7 +1552,8 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
   async _loadAllWorkbookProjections() {
     let workbooks = this._univerInstanceService.getAllUnitsForType(import_core3.UniverInstanceType.UNIVER_SHEET).map((workbook) => ({
       unitId: workbook.getUnitId(),
-      snapshot: workbook.getSnapshot()
+      snapshot: workbook.getSnapshot(),
+      styleResolver: workbook.getStyles()
     })), calculationData = this._formulaDataModel.getCalculateData(), formulaData = this._formulaDataModel.getFormulaData(), baseWorkbooks = this._univerInstanceService.getAllUnitsForType(import_core3.UniverInstanceType.UNIVER_BASE).map(
       (base) => this._createBaseWorkbookProjection(
         base.getUnitId(),
@@ -1494,25 +1606,17 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
   _createBaseTableResource(unitId) {
     let base = this._univerInstanceService.getUnit(unitId, import_core3.UniverInstanceType.UNIVER_BASE);
     if (base) {
-      let snapshot = base.getSnapshot(), tables = Object.values(snapshot.tables), data2 = {};
-      for (let table of tables) {
-        let recordCount = baseRecordOrder(table).length, fieldOrder = table.fieldOrder.filter((fieldId) => table.fields[fieldId] != null), tableNames = /* @__PURE__ */ new Set([table.id, getEngineBaseTableName(table, snapshot)]);
-        isUniqueBaseTableName(table, snapshot) && tableNames.add(table.name);
-        for (let name2 of tableNames)
+      let snapshot = base.getSnapshot(), tables = Object.values(snapshot.tables), formulaTableNames = (0, import_core3.createBaseFormulaTableNameMap)(snapshot), data2 = {};
+      for (let table of tables)
+        for (let [name2, reference] of this._getBaseTableEntries(table.id, snapshot, formulaTableNames)) {
+          let columns = Array.from(reference.titleMap.entries()).toSorted((left, right) => left[1] - right[1]).map(([displayName]) => ({ displayName }));
           (data2[table.id] ??= { tables: [] }).tables.push({
             name: name2,
-            range: {
-              startRow: 0,
-              endRow: Math.max(0, recordCount - 1),
-              startColumn: 0,
-              endColumn: Math.max(0, fieldOrder.length - 1)
-            },
-            columns: fieldOrder.map((fieldId) => ({
-              displayName: table.fields[fieldId]?.name ?? fieldId
-            })),
-            options: { showHeader: !1 }
+            range: reference.range,
+            columns,
+            options: { showHeader: reference.showHeader !== !1 }
           });
-      }
+        }
       return [
         {
           name: "SHEET_TABLE_PLUGIN",
@@ -1539,6 +1643,22 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
       }
     ];
   }
+  _getBaseTableEntries(tableId, snapshot, formulaTableNames) {
+    let table = snapshot.tables[tableId];
+    if (!table) return [];
+    let recordCount = baseRecordOrder(table).length, fieldOrder = table.fieldOrder, reference = {
+      sheetId: table.id,
+      range: {
+        startRow: 0,
+        endRow: Math.max(0, recordCount - 1),
+        startColumn: 0,
+        endColumn: Math.max(0, fieldOrder.length - 1)
+      },
+      titleMap: new Map(fieldOrder.map((fieldId, index) => [table.fields[fieldId]?.name ?? fieldId, index])),
+      showHeader: !1
+    };
+    return [[formulaTableNames.get(table.id), reference]];
+  }
   _rawCellData(cellData) {
     let raw = cellData.getMatrix(), result = {};
     for (let [row, values] of Object.entries(raw ?? {})) {
@@ -1549,16 +1669,58 @@ var RustSameRuntimeProjectionController = class extends import_core3.Disposable
     }
     return result;
   }
-}, BASE_LEGACY_FIELD_REF_PATTERN = /\{([^}]+)\}/g, BASE_TABLE_REFERENCE_PREFIX = /\b[A-Z_][\w.]*\[/gi, BASE_SCOPED_FIELD_REF_PATTERN = /(^|[^\w[])\[\[\s*#(This Row|Data)\s*\],\s*\[([^\]]+)\]\]/gi, BASE_CURRENT_ROW_FIELD_REF_PATTERN = /(^|[^\w[])\[@\[([^\]]+)\]\](?!\])/g, BASE_BRACKET_FIELD_REF_PATTERN = /(^|[^A-Za-z0-9_[\]])\[([^\]]+)\]/g, BASE_EXTERNAL_A1_REF_PATTERN = /(?:'\[[^\]]+\](?:[^']|'')+'|\[[^\]]+\][^\s'!]+)!\$?[A-Z]{1,3}\$?\d+(?::\$?[A-Z]{1,3}\$?\d+)?/gi, BASE_EXTERNAL_STRUCTURED_REFERENCE_PREFIX = /(?:'((?:[^']|'')+)'|\[[^\]]+\]|[A-Za-z0-9_.-]+)![^\s![\]]+\[/g;
-function normalizeBaseFormulaForEngine(formula, currentTable, snapshot) {
-  let references = [], hold = (reference) => `__BASE_FORMULA_REF_${references.push(reference) - 1}__`;
-  return protectBaseTableReferences(protectBaseExternalReferences(formula, hold), hold).replace(
+};
+function createBaseProjectionStructure(snapshot) {
+  let formulaTableNames = (0, import_core3.createBaseFormulaTableNameMap)(snapshot);
+  return {
+    unitName: snapshot.name,
+    tables: Object.fromEntries(
+      Object.values(snapshot.tables).map((table) => [
+        table.id,
+        {
+          formulaName: formulaTableNames.get(table.id),
+          fieldOrder: [...table.fieldOrder],
+          recordOrder: baseRecordOrder(table),
+          fieldSignatures: Object.fromEntries(
+            Object.entries(table.fields).map(([fieldId, field]) => [fieldId, JSON.stringify(field)])
+          )
+        }
+      ])
+    )
+  };
+}
+function isSameBaseProjectionStructure(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function findSingleBaseFieldInsertion(previous, snapshot) {
+  let current = createBaseProjectionStructure(snapshot), previousTableIds = Object.keys(previous.tables).toSorted(), currentTableIds = Object.keys(current.tables).toSorted();
+  if (JSON.stringify(previousTableIds) !== JSON.stringify(currentTableIds)) return null;
+  let insertion = null;
+  for (let tableId of currentTableIds) {
+    let before = previous.tables[tableId], after = current.tables[tableId];
+    if (!before || !after || before.formulaName !== after.formulaName || JSON.stringify(before.recordOrder) !== JSON.stringify(after.recordOrder)) return null;
+    for (let fieldId of before.fieldOrder)
+      if (before.fieldSignatures[fieldId] !== after.fieldSignatures[fieldId]) return null;
+    if (JSON.stringify(before.fieldOrder) === JSON.stringify(after.fieldOrder)) continue;
+    if (insertion || after.fieldOrder.length !== before.fieldOrder.length + 1) return null;
+    let column = after.fieldOrder.findIndex((fieldId, index) => fieldId !== before.fieldOrder[index]);
+    if (column < 0) return null;
+    let withoutInserted = after.fieldOrder.filter((_, index) => index !== column);
+    if (JSON.stringify(withoutInserted) !== JSON.stringify(before.fieldOrder)) return null;
+    insertion = { tableId, column };
+  }
+  return insertion;
+}
+var BASE_LEGACY_FIELD_REF_PATTERN = /\{([^}]+)\}/g, BASE_TABLE_REFERENCE_PREFIX = /\b[A-Z_][\w.]*\[/gi, BASE_SCOPED_FIELD_REF_PATTERN = /(^|[^\w[])\[\[\s*#(This Row|Data)\s*\],\s*\[([^\]]+)\]\]/gi, BASE_CURRENT_ROW_FIELD_REF_PATTERN = /(^|[^\w[])\[@\[([^\]]+)\]\](?!\])/g, BASE_BRACKET_FIELD_REF_PATTERN = /(^|[^A-Za-z0-9_[\]])\[([^\]]+)\]/g, BASE_EXTERNAL_A1_REF_PATTERN = /(?:'\[[^\]]+\](?:[^']|'')+'|\[[^\]]+\][^\s'!]+)!\$?[A-Z]{1,3}\$?\d+(?::\$?[A-Z]{1,3}\$?\d+)?/gi, BASE_EXTERNAL_STRUCTURED_REFERENCE_PREFIX = /(?:'((?:[^']|'')+)'|\[[^\]]+\]|[A-Za-z0-9_.-]+)![^\s![\]]+\[/g;
+function normalizeBaseFormulaForEngine(formula, currentTable, formulaTableNames, normalizeFormulaTableReferences) {
+  let canonicalFormula = normalizeFormulaTableReferences(formula), references = [], hold = (reference) => `__BASE_FORMULA_REF_${references.push(reference) - 1}__`;
+  return protectBaseTableReferences(protectBaseExternalReferences(canonicalFormula, hold), hold).replace(
     BASE_LEGACY_FIELD_REF_PATTERN,
-    (_match, fieldName) => hold(createEngineThisRowRef(currentTable, fieldName, snapshot))
+    (_match, fieldName) => hold(createEngineThisRowRef(currentTable, fieldName, formulaTableNames))
   ).replace(BASE_SCOPED_FIELD_REF_PATTERN, (_match, prefix, scope, fieldName) => {
-    let tableName = getEngineBaseTableName(currentTable, snapshot);
+    let tableName = formulaTableNames.get(currentTable.id) ?? currentTable.name;
     return `${prefix}${hold(`${tableName}[[#${scope}],[${fieldName}]]`)}`;
-  }).replace(BASE_CURRENT_ROW_FIELD_REF_PATTERN, (_match, prefix, fieldName) => `${prefix}${hold(createEngineThisRowRef(currentTable, fieldName, snapshot))}`).replace(BASE_BRACKET_FIELD_REF_PATTERN, (_match, prefix, fieldName) => `${prefix}${hold(createEngineThisRowRef(currentTable, fieldName, snapshot))}`).replace(
+  }).replace(BASE_CURRENT_ROW_FIELD_REF_PATTERN, (_match, prefix, fieldName) => `${prefix}${hold(createEngineThisRowRef(currentTable, fieldName, formulaTableNames))}`).replace(BASE_BRACKET_FIELD_REF_PATTERN, (_match, prefix, fieldName) => `${prefix}${hold(createEngineThisRowRef(currentTable, fieldName, formulaTableNames))}`).replace(
     /__BASE_FORMULA_REF_(\d+)__/g,
     (_match, index) => references[Number(index)] ?? ""
   );
@@ -1607,37 +1769,21 @@ function isInsideBaseFormulaString(formula, position) {
     }
   return inString;
 }
-function createEngineThisRowRef(table, fieldName, snapshot) {
-  return `${getEngineBaseTableName(table, snapshot)}[[#This Row],[${fieldName}]]`;
-}
-function getEngineBaseTableName(table, snapshot) {
-  return isUniqueBaseTableName(table, snapshot) && isExcelTableName(table.name) ? table.name : createStableExcelTableName(table.id);
-}
-function isUniqueBaseTableName(table, snapshot) {
-  let normalizedName = table.name.trim().toLowerCase();
-  return Object.values(snapshot.tables).filter((candidate) => candidate.name.trim().toLowerCase() === normalizedName).length === 1;
-}
-function isExcelTableName(name2) {
-  return name2.length === 0 || name2.length > 255 || !/^[A-Za-z_][A-Za-z0-9_.]*$/.test(name2) ? !1 : !/^[RC]$/i.test(name2) && !/^[A-Za-z]{1,3}[1-9]\d*$/.test(name2) && !/^R(?:\d+)?C(?:\d+)?$/i.test(name2);
-}
-function createStableExcelTableName(tableId) {
-  return `_T_${Array.from(
-    tableId,
-    (character) => /[A-Za-z0-9]/.test(character) ? character : `_x${character.codePointAt(0)?.toString(16) ?? "0"}_`
-  ).join("")}`;
+function createEngineThisRowRef(table, fieldName, formulaTableNames) {
+  return `${formulaTableNames.get(table.id) ?? table.name}[[#This Row],[${fieldName}]]`;
 }
 function baseRecordOrder(table) {
   return table.recordOrder ? table.recordOrder.filter((recordId) => table.records[recordId] != null) : Object.values(table.records ?? {}).toSorted((left, right) => left.orderKey.localeCompare(right.orderKey)).map((record) => record.id);
 }
 function buildBaseRuntimeCellData(table) {
-  let cellData = { ...table.cellData }, fieldOrder = table.fieldOrder.filter((fieldId) => table.fields[fieldId] != null), recordOrder = baseRecordOrder(table);
+  let cellData = { ...table.cellData }, fieldOrder = table.fieldOrder, recordOrder = baseRecordOrder(table);
   for (let row = 0; row < recordOrder.length; row++) {
     let record = table.records[recordOrder[row]];
     if (record) {
       cellData[row] = { ...cellData[row] };
       for (let column = 0; column < fieldOrder.length; column++) {
         let fieldId = fieldOrder[column];
-        Object.prototype.hasOwnProperty.call(record.values ?? {}, fieldId) && (cellData[row][column] = toBaseRuntimeCellData(record.values[fieldId], table.fields[fieldId]));
+        table.fields[fieldId] && Object.prototype.hasOwnProperty.call(record.values ?? {}, fieldId) && (cellData[row][column] = toBaseRuntimeCellData(record.values[fieldId], table.fields[fieldId]));
       }
     }
   }
@@ -1723,7 +1869,7 @@ function resultBatchSheetCounts(output) {
   return counts;
 }
 var RustCalculateFormulaService = class extends import_core4.Disposable {
-  constructor(_configService, _currentConfigService, _runtimeService, _formulaDependencyGenerator, _featureCalculationManagerService, _otherFormulaManagerService, _commandService, _rustEngineSyncController, _formulaDataModel, _formulaReferenceDataService, _excelExternalReferenceModel, _superTableService) {
+  constructor(_configService, _currentConfigService, _runtimeService, _formulaDependencyGenerator, _featureCalculationManagerService, _otherFormulaManagerService, _commandService, _rustEngineSyncController, _formulaDataModel, _formulaReferenceDataService, _excelExternalReferenceModel, _superTableService, _definedNamesService) {
     super();
     this._configService = _configService;
     this._currentConfigService = _currentConfigService;
@@ -1737,6 +1883,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     this._formulaReferenceDataService = _formulaReferenceDataService;
     this._excelExternalReferenceModel = _excelExternalReferenceModel;
     this._superTableService = _superTableService;
+    this._definedNamesService = _definedNamesService;
     this._commandService.hasCommand(import_engine_formula2.SetFormulaCalculationResultMutation.id) || this.disposeWithMe(this._commandService.registerCommand(import_engine_formula2.SetFormulaCalculationResultMutation)), this._commandService.hasCommand(import_engine_formula2.SetArrayFormulaDataMutation.id) || this.disposeWithMe(this._commandService.registerCommand(import_engine_formula2.SetArrayFormulaDataMutation));
   }
   _configService;
@@ -1751,6 +1898,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
   _formulaReferenceDataService;
   _excelExternalReferenceModel;
   _superTableService;
+  _definedNamesService;
   _executionInProgressListener$ = new import_rxjs.Subject();
   executionInProgressListener$ = this._executionInProgressListener$.asObservable();
   _executionCompleteListener$ = new import_rxjs.Subject();
@@ -2248,16 +2396,23 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     if (!unitData) return result;
     for (let [unitId, sheets] of Object.entries(unitData)) {
       result[unitId] = {};
+      let styles = this._currentConfigService.getUnitStylesData()[unitId], sheetNames = Object.fromEntries(
+        Object.entries(this._currentConfigService.getSheetNameMap()[unitId] ?? {}).map(([name2, id]) => [
+          id,
+          name2
+        ])
+      );
       for (let [sheetId, sheet] of Object.entries(sheets))
         result[unitId][sheetId] = {
-          cellData: this._serializeCellData(sheet.cellData),
+          name: sheetNames[sheetId],
+          cellData: this._serializeCellData(sheet.cellData, styles),
           rowCount: sheet.rowCount ?? 0,
           columnCount: sheet.columnCount ?? 0
         };
     }
     return result;
   }
-  _serializeCellData(cellData) {
+  _serializeCellData(cellData, styles) {
     let result = {};
     if (!cellData || typeof cellData != "object") return result;
     let data = typeof cellData.getMatrix == "function" ? cellData.getMatrix() : cellData;
@@ -2267,13 +2422,23 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
         result[row] = {};
         for (let [colStr, cell] of Object.entries(cols)) {
           let col = Number(colStr);
-          Number.isFinite(col) && (result[row][col] = {
+          if (!Number.isFinite(col))
+            continue;
+          result[row][col] = {
             v: cell?.v ?? null,
             t: cell?.t ?? void 0,
             p: cell?.p ?? void 0,
             f: cell?.f ?? void 0,
             s: cell?.s ?? void 0
-          });
+          };
+          let style = styles?.getStyleByCell(cell);
+          if (style && typeof style == "object") {
+            let numberFormat = style.n;
+            if (numberFormat && typeof numberFormat == "object") {
+              let pattern = numberFormat.pattern;
+              typeof pattern == "string" && (result[row][col].numberFormat = pattern);
+            }
+          }
         }
       }
     }
@@ -2282,7 +2447,9 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
   _applyRustOutput(_output) {
   }
   async _applyRustDependencyOutput(output) {
-    let convertStartedAt = performance.now(), patch = rustExecutionOutputToFormulaCalculationPatch(output), convertMs = performance.now() - convertStartedAt, commandStartedAt = performance.now();
+    let convertStartedAt = performance.now(), patch = rustExecutionOutputToFormulaCalculationPatch(output);
+    this._mergeRuntimeUnitData(patch.unitData);
+    let convertMs = performance.now() - convertStartedAt, commandStartedAt = performance.now();
     return (patch.arrayFormulaRange || patch.arrayFormulaCellData) && (this._formulaDataModel.setArrayFormulaRange(patch.arrayFormulaRange ?? {}), this._formulaDataModel.setArrayFormulaCellData(patch.arrayFormulaCellData ?? {}), await this._commandService.executeCommand(
       import_engine_formula2.SetArrayFormulaDataMutation.id,
       {
@@ -2309,6 +2476,20 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
       commandMs: performance.now() - commandStartedAt
     };
   }
+  _mergeRuntimeUnitData(unitData) {
+    let runtimeUnitData = this._runtimeService.getUnitData();
+    Object.entries(unitData).forEach(([unitId, sheetMap]) => {
+      if (!sheetMap) return;
+      let runtimeSheetMap = runtimeUnitData[unitId] ??= {};
+      Object.entries(sheetMap).forEach(([sheetId, cellData]) => {
+        if (!cellData) return;
+        let runtimeMatrix = runtimeSheetMap[sheetId] ??= new import_core4.ObjectMatrix();
+        new import_core4.ObjectMatrix(cellData).forValue((row, column, cell) => {
+          runtimeMatrix.setValue(row, column, cell);
+        });
+      });
+    });
+  }
   async calculate(formulaString) {
     this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0);
     let unitId = "__rust_formula_calculate__", sheetId = "__sheet__", input = {
@@ -2336,13 +2517,25 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
   }
   async executeFormulas(formulas, rowData) {
     this._nativeLoaded || (await loadNativeBinding(), this._nativeLoaded = !0), this._currentConfigService.loadDataLite(rowData);
-    let unitData = this._currentConfigService.getUnitData(), formulaData = this._formulaStringMapToFormulaData(formulas), input = {
+    let unitData = this._currentConfigService.getUnitData(), definedNames = {};
+    for (let [unitId, names] of Object.entries(this._definedNamesService.getAllDefinedNames()))
+      for (let [id, name2] of Object.entries(names))
+        definedNames[JSON.stringify([unitId, id])] = {
+          unitId,
+          localSheetId: name2.localSheetId === "AllDefaultWorkbook" ? void 0 : name2.localSheetId,
+          name: name2.name,
+          formula: name2.formulaOrRefString
+        };
+    let input = {
       config: { maxIteration: 1, intervalCount: DEFAULT_INTERVAL_COUNT },
-      formulaData,
+      formulaData: {},
+      queryFormulas: this._formulaStringMapToQueryData(formulas),
       unitData: this._serializeUnitData(unitData),
       dirtyRanges: [],
-      definedNames: {}
+      definedNames
     }, output = JSON.parse(executeOnRust(JSON.stringify(input)));
+    if (!output.queryResults)
+      throw new Error("Native formula binding does not support independent formula queries");
     return this._formulaExecutionOutputToResultMap(formulas, output);
   }
   async getAllDependencyJson(_rowData) {
@@ -2385,7 +2578,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
     ]);
     return { dependents, inRanges };
   }
-  _formulaStringMapToFormulaData(formulas) {
+  _formulaStringMapToQueryData(formulas) {
     let formulaData = {};
     return Object.entries(formulas).forEach(([unitId, sheetMap]) => {
       sheetMap && (formulaData[unitId] = {}, Object.entries(sheetMap).forEach(([sheetId, rowMap]) => {
@@ -2393,8 +2586,7 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
           if (!colMap) return;
           let row = Number(rowKey);
           formulaData[unitId][sheetId][row] = {}, Object.entries(colMap).forEach(([colKey, formulaList]) => {
-            let formula = Array.isArray(formulaList) ? formulaList[0] : void 0;
-            typeof formula == "string" && (formulaData[unitId][sheetId][row][Number(colKey)] = formula);
+            Array.isArray(formulaList) && (formulaData[unitId][sheetId][row][Number(colKey)] = formulaList);
           });
         }));
       }));
@@ -2408,10 +2600,13 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
           if (!colMap) return;
           let row = Number(rowKey);
           result[unitId][sheetId][row] = {}, Object.entries(colMap).forEach(([colKey, formulaList]) => {
-            let col = Number(colKey), formulasForCell = Array.isArray(formulaList) ? formulaList : [], value = normalizeFormulaResultValue(
-              output.runtimeData?.[unitId]?.[sheetId]?.[row]?.[col]
-            );
-            result[unitId][sheetId][row][col] = formulasForCell.map((formula) => ({ formula, value }));
+            let col = Number(colKey), formulasForCell = Array.isArray(formulaList) ? formulaList : [];
+            result[unitId][sheetId][row][col] = formulasForCell.map((formula, index) => ({
+              formula,
+              value: normalizeFormulaResultValue(
+                output.queryResults?.[unitId]?.[sheetId]?.[row]?.[col]?.[index]?.value
+              )
+            }));
           });
         }));
       }));
@@ -2530,7 +2725,8 @@ var RustCalculateFormulaService = class extends import_core4.Disposable {
   import_engine_formula2.FormulaDataModel,
   import_engine_formula3.IFormulaReferenceDataService,
   import_engine_formula3.ExternalReferenceModel,
-  import_engine_formula2.ISuperTableService
+  import_engine_formula2.ISuperTableService,
+  import_engine_formula2.IDefinedNamesService
 ]);
 function createRustProductExternalSyntheticUnitId(hostUnitId, referenceId) {
   return `external:product:${encodeURIComponent(hostUnitId)}:${encodeURIComponent(referenceId)}`;