@visactor/vtable-sheet 1.20.0-alpha.3 → 1.20.0

package/cjs/managers/formula-manager.js

@@ -4,19 +4,10 @@ Object.defineProperty(exports, "__esModule", {
     value: !0
 }), exports.FormulaManager = void 0;
 
-const hyperformula_1 = require("hyperformula"), formula_range_selector_1 = require("../formula/formula-range-selector"), formula_1 = require("../formula"), DEFAULT_HYPERFORMULA_CONFIG = {
-    licenseKey: "gpl-v3",
-    useColumnIndex: !0,
-    useArrayArithmetic: !1,
-    useStats: !0,
+const formula_engine_1 = require("../formula/formula-engine"), formula_range_selector_1 = require("../formula/formula-range-selector"), formula_1 = require("../formula"), DEFAULT_FORMULA_ENGINE_CONFIG = {
     precisionRounding: 14,
-    nullYear: 30,
-    leapYear1900: !1,
-    smartRounding: !0,
-    functionPlugins: [],
-    ignoreWhiteSpace: "standard",
     caseSensitive: !1,
-    parseDateTime: () => {},
+    ignoreWhiteSpace: "standard",
     nullDate: {
         year: 1899,
         month: 12,
@@ -39,39 +30,26 @@ class FormulaManager {
         this.lastSelectionRangesOfHandling = [], this.inputIsParamMode = null, this.inputingElement = null, 
         this.sheet = sheet, this.cellHighlightManager = new formula_1.CellHighlightManager(sheet), 
         this.formulaRangeSelector = new formula_range_selector_1.FormulaRangeSelector(this), 
-        this.initializeHyperFormula();
+        this.initializeFormulaEngine();
     }
-    initializeHyperFormula() {
+    initializeFormulaEngine() {
         try {
-            this.hyperFormula = hyperformula_1.HyperFormula.buildEmpty(DEFAULT_HYPERFORMULA_CONFIG), 
+            this.formulaEngine = new formula_engine_1.FormulaEngine(DEFAULT_FORMULA_ENGINE_CONFIG), 
             this.isInitialized = !0;
         } catch (error) {
             throw new Error("FormulaManager initialization failed");
         }
     }
     addSheet(sheetKey, normalizedData) {
-        if (this.ensureInitialized(), this.sheetMapping.has(sheetKey)) return this.sheetMapping.get(sheetKey);
+        if (this.ensureInitialized(), this.sheetMapping.has(sheetKey)) {
+            const existingId = this.sheetMapping.get(sheetKey);
+            if (void 0 !== existingId) return existingId;
+        }
         try {
-            let sheetId;
-            if (0 === this.sheetMapping.size) {
-                this.hyperFormula = hyperformula_1.HyperFormula.buildFromArray([ [ "" ] ], DEFAULT_HYPERFORMULA_CONFIG), 
-                sheetId = 0;
-                if (this.hyperFormula.getSheetName(0) !== sheetKey) try {
-                    this.hyperFormula.renameSheet(0, sheetKey);
-                } catch (e) {}
-            } else try {
-                const existingSheetId = this.hyperFormula.getSheetId(sheetKey);
-                if (void 0 !== existingSheetId) sheetId = existingSheetId; else {
-                    const sheetName = this.hyperFormula.addSheet(sheetKey);
-                    sheetId = this.hyperFormula.getSheetId(sheetName);
-                }
-            } catch (error) {
-                const sheetName = this.hyperFormula.addSheet(sheetKey);
-                sheetId = this.hyperFormula.getSheetId(sheetName);
-            }
-            return Array.isArray(normalizedData) && normalizedData.length > 0 && this.hyperFormula.setSheetContent(sheetId, normalizedData), 
-            this.sheetMapping.set(sheetKey, sheetId), this.reverseSheetMapping.set(sheetId, sheetKey), 
-            this.nextSheetId = Math.max(this.nextSheetId, sheetId + 1), sheetId;
+            const wasFirstSheet = 0 === this.sheetMapping.size, sheetId = this.formulaEngine.addSheet(sheetKey, normalizedData);
+            return this.sheetMapping.set(sheetKey, sheetId), this.reverseSheetMapping.set(sheetId, sheetKey), 
+            this.nextSheetId = Math.max(this.nextSheetId, sheetId + 1), wasFirstSheet && this.formulaEngine.setActiveSheet(sheetKey), 
+            sheetId;
         } catch (error) {
             throw new Error(`Failed to add sheet: ${sheetKey}`);
         }
@@ -112,7 +90,7 @@ class FormulaManager {
         const sheetId = this.sheetMapping.get(sheetKey);
         if (void 0 !== sheetId) try {
             if (this.sheetMapping.size <= 1) throw new Error("Cannot remove the last sheet");
-            this.hyperFormula.removeSheet(sheetId), this.sheetMapping.delete(sheetKey), this.reverseSheetMapping.delete(sheetId);
+            this.formulaEngine.removeSheet(sheetKey), this.sheetMapping.delete(sheetKey), this.reverseSheetMapping.delete(sheetId);
         } catch (error) {
             throw new Error(`Failed to remove sheet: ${sheetKey}`);
         }
@@ -121,7 +99,7 @@ class FormulaManager {
         const sheetId = this.sheetMapping.get(oldKey);
         if (void 0 === sheetId) throw new Error(`Sheet not found: ${oldKey}`);
         try {
-            this.hyperFormula.renameSheet(sheetId, newKey), this.sheetMapping.delete(oldKey), 
+            this.formulaEngine.renameSheet(oldKey, newKey), this.sheetMapping.delete(oldKey), 
             this.sheetMapping.set(newKey, sheetId), this.reverseSheetMapping.set(sheetId, newKey);
         } catch (error) {
             throw new Error(`Failed to rename sheet: ${oldKey}`);
@@ -131,26 +109,11 @@ class FormulaManager {
         const sheetId = this.sheetMapping.get(sheetKey);
         return void 0 === sheetId ? this.addSheet(sheetKey) : sheetId;
     }
-    getHasHeader(sheetKey) {
-        var _a, _b, _c;
-        const sheetDefine = this.sheet.getSheetManager().getSheet(sheetKey);
-        return null !== (_c = null !== (_a = null == sheetDefine ? void 0 : sheetDefine.showHeader) && void 0 !== _a ? _a : (null === (_b = null == sheetDefine ? void 0 : sheetDefine.columns) || void 0 === _b ? void 0 : _b.length) > 0) && void 0 !== _c && _c;
-    }
     setCellContent(cell, value) {
         if (this.ensureInitialized(), !cell || void 0 === cell.sheet || void 0 === cell.row || void 0 === cell.col) throw new Error("Invalid cell parameter for setCellContent");
         if (cell.row < 0 || cell.col < 0) throw new Error(`Cell coordinates out of bounds: row=${cell.row}, col=${cell.col}`);
         try {
-            const address = {
-                sheet: this.getSheetId(cell.sheet),
-                row: cell.row,
-                col: cell.col
-            };
-            let processedValue = value;
-            if (null == processedValue && (processedValue = ""), "string" == typeof processedValue && !processedValue.startsWith("=")) {
-                const numericValue = Number(processedValue);
-                isNaN(numericValue) || "" === processedValue.trim() || (processedValue = numericValue);
-            }
-            this.hyperFormula.setCellContents(address, [ [ processedValue ] ]);
+            this.formulaEngine.setCellContent(cell, value);
         } catch (error) {
             throw error instanceof Error ? new Error(`Failed to set cell content at ${cell.sheet}:${cell.row}:${cell.col}. ${error.message}`) : new Error(`Failed to set cell content at ${cell.sheet}:${cell.row}:${cell.col}`);
         }
@@ -158,15 +121,7 @@ class FormulaManager {
     getCellValue(cell) {
         this.ensureInitialized();
         try {
-            const address = {
-                sheet: this.getSheetId(cell.sheet),
-                row: cell.row,
-                col: cell.col
-            }, value = this.hyperFormula.getCellValue(address);
-            return {
-                value: value,
-                error: value instanceof hyperformula_1.CellError ? value : void 0
-            };
+            return this.formulaEngine.getCellValue(cell);
         } catch (error) {
             return {
                 value: null,
@@ -177,12 +132,7 @@ class FormulaManager {
     getCellFormula(cell) {
         this.ensureInitialized();
         try {
-            const address = {
-                sheet: this.getSheetId(cell.sheet),
-                row: cell.row,
-                col: cell.col
-            };
-            return this.hyperFormula.getCellFormula(address);
+            return this.formulaEngine.getCellFormula(cell);
         } catch (error) {
             return;
         }
@@ -190,12 +140,7 @@ class FormulaManager {
     isCellFormula(cell) {
         this.ensureInitialized();
         try {
-            const address = {
-                sheet: this.getSheetId(cell.sheet),
-                row: cell.row,
-                col: cell.col
-            };
-            return this.hyperFormula.doesCellHaveFormula(address);
+            return this.formulaEngine.isCellFormula(cell);
         } catch (error) {
             return !1;
         }
@@ -203,16 +148,7 @@ class FormulaManager {
     getCellDependents(cell) {
         this.ensureInitialized();
         try {
-            const address = {
-                sheet: this.getSheetId(cell.sheet),
-                row: cell.row,
-                col: cell.col
-            };
-            return this.hyperFormula.getCellDependents(address).filter((dep => "sheet" in dep && "row" in dep && "col" in dep)).map((dep => ({
-                sheet: this.reverseSheetMapping.get(dep.sheet) || "",
-                row: dep.row,
-                col: dep.col
-            })));
+            return this.formulaEngine.getCellDependents(cell);
         } catch (error) {
             return [];
         }
@@ -220,16 +156,7 @@ class FormulaManager {
     getCellPrecedents(cell) {
         this.ensureInitialized();
         try {
-            const address = {
-                sheet: this.getSheetId(cell.sheet),
-                row: cell.row,
-                col: cell.col
-            };
-            return this.hyperFormula.getCellPrecedents(address).filter((prec => "sheet" in prec && "row" in prec && "col" in prec)).map((prec => ({
-                sheet: this.reverseSheetMapping.get(prec.sheet) || "",
-                row: prec.row,
-                col: prec.col
-            })));
+            return this.formulaEngine.getCellPrecedents(cell);
         } catch (error) {
             return [];
         }
@@ -237,78 +164,44 @@ class FormulaManager {
     batchUpdate(changes) {
         this.ensureInitialized();
         try {
-            this.hyperFormula.batch((() => {
-                changes.forEach((({cell: cell, value: value}) => {
-                    const address = {
-                        sheet: this.getSheetId(cell.sheet),
-                        row: cell.row,
-                        col: cell.col
-                    };
-                    this.hyperFormula.setCellContents(address, [ [ value ] ]);
-                }));
-            }));
+            for (const {cell: cell, value: value} of changes) this.formulaEngine.setCellContent(cell, value);
         } catch (error) {
             throw new Error("Batch update failed");
         }
     }
-    addRows(sheetKey, rowIndex, numberOfRows = 1) {
+    addRows(_sheetKey, rowIndex, numberOfRows = 1) {
         this.ensureInitialized();
-        try {
-            const sheetId = this.getSheetId(sheetKey);
-            this.hyperFormula.addRows(sheetId, [ rowIndex, numberOfRows ]);
-        } catch (error) {
-            throw new Error(`Failed to add ${numberOfRows} rows at index ${rowIndex}`);
-        }
     }
-    removeRows(sheetKey, rowIndex, numberOfRows = 1) {
+    removeRows(_sheetKey, rowIndex, numberOfRows = 1) {
         this.ensureInitialized();
-        try {
-            const sheetId = this.getSheetId(sheetKey);
-            this.hyperFormula.removeRows(sheetId, [ rowIndex, numberOfRows ]);
-        } catch (error) {
-            throw new Error(`Failed to remove ${numberOfRows} rows at index ${rowIndex}`);
-        }
     }
-    addColumns(sheetKey, columnIndex, numberOfColumns = 1) {
+    addColumns(_sheetKey, columnIndex, numberOfColumns = 1) {
         this.ensureInitialized();
-        try {
-            const sheetId = this.getSheetId(sheetKey);
-            this.hyperFormula.addColumns(sheetId, [ columnIndex, numberOfColumns ]);
-        } catch (error) {
-            throw new Error(`Failed to add ${numberOfColumns} columns at index ${columnIndex}`);
-        }
     }
-    removeColumns(sheetKey, columnIndex, numberOfColumns = 1) {
+    removeColumns(_sheetKey, columnIndex, numberOfColumns = 1) {
         this.ensureInitialized();
-        try {
-            const sheetId = this.getSheetId(sheetKey);
-            this.hyperFormula.removeColumns(sheetId, [ columnIndex, numberOfColumns ]);
-        } catch (error) {
-            throw new Error(`Failed to remove ${numberOfColumns} columns at index ${columnIndex}`);
-        }
     }
     getSheetSerialized(sheetKey) {
         this.ensureInitialized();
         try {
-            const sheetId = this.getSheetId(sheetKey);
-            return this.hyperFormula.getSheetSerialized(sheetId);
+            return [ [] ];
         } catch (error) {
             return [ [] ];
         }
     }
-    setSheetContent(sheetKey, normalizedData) {
-        this.ensureInitialized();
+    sortFormulasByDependency(sheetKey, formulas) {
         try {
-            const sheetId = this.getSheetId(sheetKey);
-            this.hyperFormula.setSheetContent(sheetId, normalizedData);
+            return this.formulaEngine.sortFormulasByDependency(sheetKey, formulas);
         } catch (error) {
-            throw new Error(`Failed to set content for sheet: ${sheetKey}`);
+            return Object.entries(formulas);
         }
     }
+    setSheetContent(sheetKey, _normalizedData) {
+        this.ensureInitialized();
+    }
     hasCircularReference() {
         try {
-            const stats = this.hyperFormula.getStats();
-            return stats && stats.dependencyGraph && stats.dependencyGraph.hasCircularReferences();
+            return !1;
         } catch (error) {
             return !1;
         }
@@ -318,9 +211,7 @@ class FormulaManager {
     }
     validateFormula(formula) {
         try {
-            return this.hyperFormula.validateFormula(formula), {
-                isValid: !0
-            };
+            return this.formulaEngine.validateFormula(formula);
         } catch (error) {
             return {
                 isValid: !1,
@@ -348,11 +239,7 @@ class FormulaManager {
     }
     calculateFormula(formula) {
         try {
-            const result = this.hyperFormula.calculateFormula(formula, 0);
-            return {
-                value: result,
-                error: result instanceof hyperformula_1.CellError ? result.message : void 0
-            };
+            return this.formulaEngine.calculateFormula(formula);
         } catch (error) {
             return {
                 value: null,
@@ -360,31 +247,19 @@ class FormulaManager {
             };
         }
     }
-    suspendEvaluation() {
-        try {
-            this.hyperFormula.suspendEvaluation();
-        } catch (error) {}
-    }
-    resumeEvaluation() {
-        try {
-            this.hyperFormula.resumeEvaluation();
-        } catch (error) {}
-    }
-    rebuildAndRecalculate() {
-        try {
-            this.hyperFormula.rebuildAndRecalculate();
-        } catch (error) {}
-    }
+    suspendEvaluation() {}
+    resumeEvaluation() {}
+    rebuildAndRecalculate() {}
     clearContent() {
         try {
-            this.release(), this.initializeHyperFormula();
+            this.release(), this.initializeFormulaEngine();
         } catch (error) {}
     }
     release() {
         var _a, _b;
         null === (_a = this.formulaRangeSelector) || void 0 === _a || _a.release(), null === (_b = this.cellHighlightManager) || void 0 === _b || _b.release();
         try {
-            this.hyperFormula && this.hyperFormula.destroy();
+            this.formulaEngine && this.formulaEngine.release();
         } catch (error) {} finally {
             this.sheetMapping.clear(), this.reverseSheetMapping.clear(), this.isInitialized = !1, 
             this.nextSheetId = 0, this.formulaRangeSelector = null, this.cellHighlightManager = null;
@@ -395,34 +270,46 @@ class FormulaManager {
             isInitialized: this.isInitialized,
             sheets: Array.from(this.sheetMapping.entries()),
             functions: this.getAvailableFunctions(),
-            stats: this.isInitialized ? this.hyperFormula.getStats() : null
+            stats: null
         };
     }
+    exportFormulas(sheetKey) {
+        this.ensureInitialized();
+        try {
+            return this.formulaEngine.exportFormulas(sheetKey);
+        } catch (error) {
+            return {};
+        }
+    }
     ensureInitialized() {
         if (!this.isInitialized) throw new Error("FormulaManager not initialized");
     }
     getAllSheets() {
-        const sheets = [];
-        for (const [key, id] of this.sheetMapping.entries()) try {
-            const name = this.hyperFormula.getSheetName(id) || key;
-            sheets.push({
-                key: key,
-                id: id,
-                name: name
-            });
+        try {
+            return this.formulaEngine.getAllSheets();
+        } catch (error) {
+            return [];
+        }
+    }
+    setActiveSheet(sheetKey) {
+        this.ensureInitialized();
+        try {
+            this.formulaEngine.setActiveSheet(sheetKey);
+        } catch (error) {
+            throw new Error(`Failed to set active sheet: ${sheetKey}`);
+        }
+    }
+    getActiveSheet() {
+        this.ensureInitialized();
+        try {
+            return this.formulaEngine.getActiveSheet();
         } catch (error) {
-            sheets.push({
-                key: key,
-                id: id,
-                name: key
-            });
+            return null;
         }
-        return sheets;
     }
     copyRange(sourceSheet, sourceRange, targetSheet, targetRow, targetCol) {
         this.ensureInitialized();
         try {
-            this.getSheetId(sourceSheet), this.getSheetId(targetSheet);
             for (let row = sourceRange.startRow; row <= sourceRange.endRow; row++) for (let col = sourceRange.startCol; col <= sourceRange.endCol; col++) {
                 const sourceCell = {
                     sheet: sourceSheet,
@@ -441,4 +328,5 @@ class FormulaManager {
     }
 }
 
-exports.FormulaManager = FormulaManager;
+exports.FormulaManager = FormulaManager;
+//# sourceMappingURL=formula-manager.js.map