@cj-tech-master/excelts 9.2.1 → 9.3.0

package/dist/cjs/modules/pdf/excel-bridge.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.excelToPdf = excelToPdf;
 const enums_1 = require("../excel/enums.js");
 const cell_format_1 = require("../excel/utils/cell-format.js");
+const host_registry_1 = require("../formula/host-registry.js");
 const utils_base_1 = require("../../utils/utils.base.js");
 const pdf_exporter_1 = require("./render/pdf-exporter");
 const types_1 = require("./types");
@@ -37,6 +38,14 @@ const types_1 = require("./types");
  * @returns Promise of PDF file as a Uint8Array
  */
 async function excelToPdf(workbook, options) {
+    // Recalculate all formulas before conversion so that formula results
+    // reflect the latest cell values (fixes stale cached results from XLSX).
+    //
+    // The formula engine is opt-in: callers who import
+    // `@cj-tech-master/excelts/formula` get automatic recalculation here; callers
+    // who don't import it fall back to whatever cached results the XLSX
+    // shipped with (safe for workbooks last saved by Excel itself).
+    (0, host_registry_1.tryInvokeFormulaEngine)(workbook);
     const pdfWorkbook = excelWorkbookToPdf(workbook);
     return (0, pdf_exporter_1.exportPdf)(pdfWorkbook, options);
 }

package/dist/esm/index.browser.js

@@ -16,6 +16,10 @@ export * from "./modules/excel/anchor.js";
 export { Table } from "./modules/excel/table.js";
 export { DataValidations } from "./modules/excel/data-validations.js";
 export { FormCheckbox } from "./modules/excel/form-control.js";
+// Note: the formula engine lives at the `./formula` subpath so it stays
+// out of bundles that only need to read / write XLSX files. Import
+// `@cj-tech-master/excelts/formula` to enable `Workbook.calculateFormulas()`
+// and automatic recalculation in `excelToPdf()`.
 // =============================================================================
 // Enums
 // =============================================================================

package/dist/esm/index.js

@@ -12,6 +12,10 @@ export * from "./modules/excel/anchor.js";
 export { Table } from "./modules/excel/table.js";
 export { DataValidations } from "./modules/excel/data-validations.js";
 export { FormCheckbox } from "./modules/excel/form-control.js";
+// Note: the formula engine lives at the `./formula` subpath so it stays
+// out of bundles that only need to read / write XLSX files. Import
+// `@cj-tech-master/excelts/formula` to enable `Workbook.calculateFormulas()`
+// and automatic recalculation in `excelToPdf()`.
 // =============================================================================
 // Node.js Only: Streaming Classes
 // These can also be accessed via Workbook.createStreamWriter/createStreamReader

package/dist/esm/modules/excel/cell.js

@@ -10,6 +10,51 @@ import { escapeHtml } from "./utils/under-dash.js";
 // empty string, and empty objects `{}`. This is used to prevent an empty `{}`
 // style property on a row from shadowing a real style property on a column.
 const hasOwnKeys = (v) => !!v && (typeof v !== "object" || Object.keys(v).length > 0);
+/**
+ * Flatten a rich-text array into its plain-text representation by
+ * concatenating each run's `text`. Missing/null runs contribute "".
+ */
+function flattenRichText(runs) {
+    let out = "";
+    for (const run of runs) {
+        if (run && typeof run.text === "string") {
+            out += run.text;
+        }
+    }
+    return out;
+}
+/**
+ * Normalize a CellHyperlinkValue so the {@link NormalizedHyperlink} invariants
+ * hold.
+ *
+ * - If the caller supplied `richText` but no `text`, text is derived.
+ * - If the caller supplied `text` but no `richText`, richText stays absent.
+ * - If both are supplied, `richText` wins and `text` is regenerated
+ *   (to keep `text === flatten(richText)`).
+ * - An empty `richText: []` is dropped (treated as "no rich text").
+ */
+function normalizeHyperlinkValue(value) {
+    let text;
+    let richText;
+    if (Array.isArray(value.richText) && value.richText.length > 0) {
+        richText = value.richText;
+        text = flattenRichText(richText);
+    }
+    else {
+        text = typeof value.text === "string" ? value.text : "";
+    }
+    const out = {
+        text,
+        hyperlink: typeof value.hyperlink === "string" ? value.hyperlink : ""
+    };
+    if (richText) {
+        out.richText = richText;
+    }
+    if (typeof value.tooltip === "string" && value.tooltip.length > 0) {
+        out.tooltip = value.tooltip;
+    }
+    return out;
+}
 // Cell requirements
 //  Operate inside a worksheet
 //  Store and retrieve a value with a range of types: text, number, date, hyperlink, reference, formula, etc.
@@ -234,12 +279,30 @@ class Cell {
     }
     /** @internal */
     _upgradeToHyperlink(hyperlink) {
-        // if this cell is a string, turn it into a Hyperlink
-        if (this.type === Cell.Types.String) {
-            this._value = Value.create(Cell.Types.Hyperlink, this, {
-                text: String(this._value.value),
-                hyperlink
-            });
+        // Upgrade this cell to a Hyperlink while preserving the existing display
+        // text. Supports promotion from both plain String cells and RichText cells.
+        // For RichText cells, the runs are preserved on the new hyperlink value.
+        switch (this.type) {
+            case Cell.Types.String: {
+                this._value = Value.create(Cell.Types.Hyperlink, this, {
+                    text: String(this._value.value),
+                    hyperlink
+                });
+                break;
+            }
+            case Cell.Types.RichText: {
+                const current = this._value.value;
+                const runs = current && Array.isArray(current.richText) ? current.richText : [];
+                this._value = Value.create(Cell.Types.Hyperlink, this, {
+                    text: flattenRichText(runs),
+                    richText: runs.length > 0 ? runs : undefined,
+                    hyperlink
+                });
+                break;
+            }
+            default:
+                // Other cell types (Number, Date, Formula, ...) are not auto-upgraded.
+                break;
         }
     }
     // =========================================================================
@@ -250,6 +313,11 @@ class Cell {
     get result() {
         return this._value.result;
     }
+    set result(value) {
+        if (this.type === Cell.Types.Formula) {
+            this._value.result = value;
+        }
+    }
     get formulaType() {
         return this._value.formulaType ?? Enums.FormulaType.None;
     }
@@ -506,34 +574,95 @@ class HyperlinkValue {
     constructor(cell, value) {
         this.model = {
             address: cell.address,
-            type: Cell.Types.Hyperlink,
-            text: value ? value.text : undefined,
-            hyperlink: value ? value.hyperlink : undefined
+            type: Cell.Types.Hyperlink
         };
-        if (value && value.tooltip) {
-            this.model.tooltip = value.tooltip;
+        if (value) {
+            // Formula + hyperlink: surface as a Hyperlink whose display is the
+            // formula's evaluated result, but persist the formula on the model so
+            // it round-trips on write. The cell value getter ignores the formula
+            // fields, keeping the public Hyperlink shape clean.
+            if ("formula" in value && typeof value.formula === "string") {
+                const fh = value;
+                const display = fh.result === undefined || fh.result === null ? "" : String(fh.result);
+                this.model.text = display;
+                this.model.hyperlink = fh.hyperlink ?? "";
+                if (fh.tooltip !== undefined) {
+                    this.model.tooltip = fh.tooltip;
+                }
+                // Internal-only fields preserved for write-time re-emission.
+                this.model.formula =
+                    fh.formula;
+                if (fh.result !== undefined) {
+                    this.model.result = fh.result;
+                }
+                return;
+            }
+            const normalized = normalizeHyperlinkValue(value);
+            this.model.text = normalized.text;
+            this.model.hyperlink = normalized.hyperlink;
+            if (normalized.richText) {
+                this.model.richText = normalized.richText;
+            }
+            if (normalized.tooltip !== undefined) {
+                this.model.tooltip = normalized.tooltip;
+            }
         }
     }
     get value() {
-        return {
+        const out = {
             text: this.model.text ?? "",
-            hyperlink: this.model.hyperlink ?? "",
-            tooltip: this.model.tooltip
+            hyperlink: this.model.hyperlink ?? ""
         };
+        if (this.model.richText && this.model.richText.length > 0) {
+            out.richText = this.model.richText;
+        }
+        if (this.model.tooltip !== undefined) {
+            out.tooltip = this.model.tooltip;
+        }
+        return out;
     }
     set value(value) {
-        this.model.text = value.text;
-        this.model.hyperlink = value.hyperlink;
-        if (value.tooltip) {
-            this.model.tooltip = value.tooltip;
+        const normalized = normalizeHyperlinkValue(value);
+        this.model.text = normalized.text;
+        this.model.hyperlink = normalized.hyperlink;
+        if (normalized.richText) {
+            this.model.richText = normalized.richText;
+        }
+        else {
+            delete this.model.richText;
+        }
+        if (normalized.tooltip !== undefined) {
+            this.model.tooltip = normalized.tooltip;
+        }
+        else {
+            delete this.model.tooltip;
         }
     }
     get text() {
         return this.model.text;
     }
     set text(value) {
+        // Setting text while richText is present would break the invariant
+        // (text must equal flattenRichText(richText)). Dropping richText is the
+        // only safe resolution.
+        if (this.model.richText) {
+            delete this.model.richText;
+        }
         this.model.text = value;
     }
+    get richText() {
+        return this.model.richText;
+    }
+    set richText(value) {
+        if (Array.isArray(value) && value.length > 0) {
+            this.model.richText = value;
+            this.model.text = flattenRichText(value);
+        }
+        else {
+            delete this.model.richText;
+            // leave model.text untouched — caller may still want the plain text
+        }
+    }
     get hyperlink() {
         return this.model.hyperlink;
     }
@@ -625,7 +754,8 @@ class FormulaValue {
             ref: value ? value.ref : undefined,
             formula: value ? value.formula : undefined,
             sharedFormula: value ? value.sharedFormula : undefined,
-            result: value ? value.result : undefined
+            result: value ? value.result : undefined,
+            isDynamicArray: value ? value.isDynamicArray : undefined
         };
     }
     _copyModel(model) {
@@ -645,6 +775,9 @@ class FormulaValue {
         if (model.sharedFormula) {
             copy.sharedFormula = model.sharedFormula;
         }
+        if (model.isDynamicArray) {
+            copy.isDynamicArray = model.isDynamicArray;
+        }
         return copy;
     }
     get value() {
@@ -666,6 +799,9 @@ class FormulaValue {
         if (value.sharedFormula) {
             this.model.sharedFormula = value.sharedFormula;
         }
+        if (value.isDynamicArray !== undefined) {
+            this.model.isDynamicArray = value.isDynamicArray;
+        }
     }
     validate(value) {
         switch (Value.getType(value)) {
@@ -953,14 +1089,26 @@ const Value = {
             if ("checkbox" in value && typeof value.checkbox === "boolean") {
                 return Cell.Types.Checkbox;
             }
-            if ("text" in value && value.text && "hyperlink" in value && value.hyperlink) {
-                return Cell.Types.Hyperlink;
+            // Hyperlink detection: requires `hyperlink` and either non-empty `text`
+            // or a non-empty `richText` array, OR a formula (formula+hyperlink is
+            // surfaced as a Hyperlink with the formula's result as display).
+            // Checked before RichText/Formula so combined payloads route correctly.
+            if ("hyperlink" in value && typeof value.hyperlink === "string" && value.hyperlink) {
+                const hasText = "text" in value && typeof value.text === "string" && value.text.length > 0;
+                const hasRichText = "richText" in value && Array.isArray(value.richText) && value.richText.length > 0;
+                const hasFormula = "formula" in value && typeof value.formula === "string";
+                if (hasText || hasRichText || hasFormula) {
+                    return Cell.Types.Hyperlink;
+                }
             }
             if (("formula" in value && value.formula) ||
                 ("sharedFormula" in value && value.sharedFormula)) {
                 return Cell.Types.Formula;
             }
-            if ("richText" in value && value.richText) {
+            // RichText only when the runs array is non-empty. An empty `richText: []`
+            // carries no content and falls through to JSON rather than producing a
+            // RichText cell with no runs.
+            if ("richText" in value && Array.isArray(value.richText) && value.richText.length > 0) {
                 return Cell.Types.RichText;
             }
             if ("sharedString" in value && value.sharedString) {