@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/cjs/modules/excel/xlsx/xform/sheet/worksheet-xform.js

@@ -204,29 +204,77 @@ class WorkSheetXform extends base_xform_1.BaseXform {
                 vmlDrawing: `vmlDrawing${fileIndex}`
             });
         }
+        // Office 365 threaded comments — a separate rel pointing at the
+        // per-sheet `xl/threadedComments/threadedComment{N}.xml` part.
+        // Excel requires the rel to exist even when the sheet already has
+        // a classic comments rel (the two are independent — legacy VML
+        // carries the fallback text, threaded comments carry the modern
+        // conversation tree).
+        if (model.threadedComments && model.threadedComments.length > 0) {
+            rels.push({
+                Id: nextRid(rels),
+                Type: rel_type_1.RelType.ThreadedComments,
+                Target: `../threadedComments/threadedComment${fileIndex}.xml`
+            });
+        }
         // Handle pre-loaded drawing (from file read) that may contain charts or other non-image content.
-        // Reset anchors and rels so they are rebuilt cleanly from model.media (images) and
-        // model.formControls (shapes) below.  Without this reset, every read-write cycle would
-        // duplicate image anchors because the same images exist in both model.drawing.anchors
-        // (preserved for round-trip) and model.media (the canonical image list).
-        // For chart drawings, rels are preserved because the raw XML passthrough references
-        // original rIds; anchors are still cleared since they are unused for chart drawings.
+        // Chart anchors (with chartNumber from reconcile) are preserved and get fresh rels.
+        // Non-chart anchors are discarded — images are rebuilt from model.media below.
         if (model.drawing && model.drawing.anchors) {
             const drawing = model.drawing;
             drawing.rId = nextRid(rels);
             if (!drawing.name) {
                 drawing.name = `drawing${++options.drawingsCount}`;
             }
-            const hasChartRels = (drawing.rels ?? []).some((rel) => rel.Target && rel.Target.includes("/charts/"));
-            // Anchors are always reset: for chart drawings they are unused (raw XML passthrough),
-            // for normal drawings they are rebuilt from model.media below.
+            // Separate chart anchors from non-chart anchors
+            const chartAnchors = drawing.anchors.filter((a) => a.chartNumber || a.chartExNumber);
+            // Reset anchors — chart anchors will be re-added, image anchors rebuilt below
             drawing.anchors = [];
-            if (!hasChartRels) {
-                // Non-chart drawings: clear rels so image rels are rebuilt from scratch.
-                drawing.rels = [];
+            drawing.rels = [];
+            // Re-add chart anchors and build their rels
+            for (const anchor of chartAnchors) {
+                const chartRId = nextRid(drawing.rels);
+                if (anchor.chartExNumber) {
+                    // Office 2016+ cx chart
+                    drawing.rels.push({
+                        Id: chartRId,
+                        Type: rel_type_1.RelType.ChartEx,
+                        Target: (0, ooxml_paths_1.chartExRelTargetFromDrawing)(anchor.chartExNumber)
+                    });
+                    anchor.graphicFrame = {
+                        ...anchor.graphicFrame,
+                        rId: chartRId,
+                        isChartEx: true,
+                        index: anchor.graphicFrame?.index,
+                        name: anchor.graphicFrame?.name ?? `Chart ${anchor.chartExNumber}`
+                    };
+                    // ChartEx MUST be serialised inside `<mc:AlternateContent>`
+                    // — see TwoCellAnchorXform.render for the full rationale.
+                    // Tag the anchor here so re-saves of files we authored
+                    // ourselves (which load without the wrapper in the current
+                    // codebase) still emit the correct structure on the next
+                    // write. Files that came in already wrapped keep whatever
+                    // requires value the parser captured.
+                    if (!anchor.alternateContent) {
+                        anchor.alternateContent = { requires: "cx1" };
+                    }
+                }
+                else {
+                    // Traditional c: chart
+                    drawing.rels.push({
+                        Id: chartRId,
+                        Type: rel_type_1.RelType.Chart,
+                        Target: (0, ooxml_paths_1.chartRelTargetFromDrawing)(anchor.chartNumber)
+                    });
+                    anchor.graphicFrame = {
+                        ...anchor.graphicFrame,
+                        rId: chartRId,
+                        index: anchor.graphicFrame?.index,
+                        name: anchor.graphicFrame?.name ?? `Chart ${anchor.chartNumber}`
+                    };
+                }
+                drawing.anchors.push(anchor);
             }
-            // Chart drawings keep their original rels intact since the raw drawing XML
-            // references those rIds directly.
             options.drawings.push(drawing);
             rels.push({
                 Id: drawing.rId,
@@ -234,6 +282,115 @@ class WorkSheetXform extends base_xform_1.BaseXform {
                 Target: (0, ooxml_paths_1.drawingRelTargetFromWorksheet)(drawing.name)
             });
         }
+        // Handle programmatic charts (from worksheet.addChart API) that are NOT already
+        // in the drawing. Charts loaded from XLSX are already in drawing.anchors with
+        // chartNumber — only add truly new charts.
+        if (model.charts && model.charts.length > 0) {
+            // Collect chartNumbers already present in the drawing
+            const existingChartNumbers = new Set();
+            const existingChartExNumbers = new Set();
+            if (model.drawing?.anchors) {
+                for (const a of model.drawing.anchors) {
+                    if (a.chartNumber) {
+                        existingChartNumbers.add(a.chartNumber);
+                    }
+                    if (a.chartExNumber) {
+                        existingChartExNumbers.add(a.chartExNumber);
+                    }
+                }
+            }
+            const newCharts = model.charts.filter((c) => {
+                if (c.chartNumber && !existingChartNumbers.has(c.chartNumber)) {
+                    return true;
+                }
+                if (c.chartExNumber && !existingChartExNumbers.has(c.chartExNumber)) {
+                    return true;
+                }
+                return false;
+            });
+            if (newCharts.length > 0) {
+                // Ensure a drawing exists
+                if (!model.drawing) {
+                    model.drawing = {
+                        anchors: [],
+                        rels: [],
+                        rId: nextRid(rels),
+                        name: `drawing${++options.drawingsCount}`
+                    };
+                    options.drawings.push(model.drawing);
+                    rels.push({
+                        Id: model.drawing.rId,
+                        Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+                        Target: (0, ooxml_paths_1.drawingRelTargetFromWorksheet)(model.drawing.name)
+                    });
+                }
+                const drawing = model.drawing;
+                for (const chartAnchor of newCharts) {
+                    // Chart `ChartAnchorModel.range` stores absolute position
+                    // (`pos.x/y`) and extent (`ext.cx/cy`) in EMU — the native
+                    // OOXML unit. The drawing xform pipeline (PosXform,
+                    // ExtXform) expects pixels at 96 dpi (the image convention
+                    // — `ext.width/height`) and multiplies by `EMU_PER_PIXEL_AT_96_DPI`
+                    // on render. Normalise at this boundary: convert the EMU
+                    // values to pixels so downstream xforms re-convert to EMU
+                    // without doubling.
+                    //
+                    // Without this conversion an absolute-anchored chart wrote
+                    // `<xdr:pos x="8709660000" y="8709660000"/>` for a 914400
+                    // EMU position (a 9525× overshoot) and
+                    // `<xdr:ext cx="NaN" cy="NaN"/>` because `ext` carried
+                    // `{ cx, cy }` keys but ExtXform looked for `{ width,
+                    // height }`.
+                    const emuToPixel = 9525; // EMU_PER_PIXEL_AT_96_DPI
+                    const normalizedRange = { ...chartAnchor.range };
+                    if (chartAnchor.range.pos) {
+                        normalizedRange.pos = {
+                            x: chartAnchor.range.pos.x / emuToPixel,
+                            y: chartAnchor.range.pos.y / emuToPixel
+                        };
+                    }
+                    if (chartAnchor.range.ext && chartAnchor.range.ext.cx !== undefined) {
+                        normalizedRange.ext = {
+                            width: chartAnchor.range.ext.cx / emuToPixel,
+                            height: chartAnchor.range.ext.cy / emuToPixel
+                        };
+                    }
+                    const chartRId = nextRid(drawing.rels);
+                    if (chartAnchor.chartExNumber) {
+                        drawing.rels.push({
+                            Id: chartRId,
+                            Type: rel_type_1.RelType.ChartEx,
+                            Target: (0, ooxml_paths_1.chartExRelTargetFromDrawing)(chartAnchor.chartExNumber)
+                        });
+                        drawing.anchors.push({
+                            range: normalizedRange,
+                            chartExNumber: chartAnchor.chartExNumber,
+                            alternateContent: { requires: "cx1" },
+                            graphicFrame: {
+                                rId: chartRId,
+                                isChartEx: true,
+                                name: `Chart ${chartAnchor.chartExNumber}`
+                            }
+                        });
+                    }
+                    else {
+                        drawing.rels.push({
+                            Id: chartRId,
+                            Type: rel_type_1.RelType.Chart,
+                            Target: (0, ooxml_paths_1.chartRelTargetFromDrawing)(chartAnchor.chartNumber)
+                        });
+                        drawing.anchors.push({
+                            range: normalizedRange,
+                            chartNumber: chartAnchor.chartNumber,
+                            graphicFrame: {
+                                rId: chartRId,
+                                name: `Chart ${chartAnchor.chartNumber}`
+                            }
+                        });
+                    }
+                }
+            }
+        }
         // Process background and image media entries
         const backgroundMedia = [];
         const imageMedia = [];
@@ -543,11 +700,26 @@ class WorkSheetXform extends base_xform_1.BaseXform {
         this.map.headerFooter.render(xmlStream, model.headerFooter);
         this.map.rowBreaks.render(xmlStream, model.rowBreaks);
         this.map.colBreaks.render(xmlStream, model.colBreaks);
+        // `ignoredErrors` must precede `drawing` per ECMA-376 §18.3.1.99
+        // CT_Worksheet (… colBreaks, customProperties, cellWatches,
+        // ignoredErrors, smartTags, drawing, legacyDrawing, …). Emitting
+        // it after `controls` produced out-of-order XML that strict
+        // validators reject and some Excel builds repair on open
+        // (dropping the ignoredErrors block entirely). Previously the
+        // comment on this call claimed the opposite order — it was
+        // factually wrong.
+        this.map.ignoredErrors.render(xmlStream, model.ignoredErrors);
         this.map.drawing.render(xmlStream, model.drawing); // Note: must be after rowBreaks/colBreaks
-        this.map.picture.render(xmlStream, model.background); // Note: must be after drawing
+        // ECMA-376 §18.3.1.99 CT_Worksheet child sequence is:
+        //   … drawing → legacyDrawing → legacyDrawingHF → drawingHF → picture → oleObjects → controls →
+        //   webPublishItems → tableParts → extLst
+        // `legacyDrawing` and `legacyDrawingHF` therefore MUST be emitted
+        // before the background `<picture>` element. The previous order here
+        // had picture before legacyDrawing, which validates against strict
+        // OOXML checkers as out-of-order and was the root cause of several
+        // "Excel needs to repair" reports.
         if (model.rels) {
             // Add a <legacyDrawing /> node for each VML drawing relationship (comments and/or form controls).
-            // NOTE: Excel is picky about worksheet child element order; legacyDrawing must come before controls.
             model.rels.forEach(rel => {
                 if (rel.Type === rel_type_1.RelType.VmlDrawing) {
                     // Skip VML rels that are for header images (they use legacyDrawingHF instead)
@@ -562,6 +734,9 @@ class WorkSheetXform extends base_xform_1.BaseXform {
         if (model.headerImage) {
             xmlStream.leafNode("legacyDrawingHF", { "r:id": model.headerImage.vmlRelId });
         }
+        // Background image: must be emitted AFTER drawing/legacyDrawing per
+        // the CT_Worksheet sequence noted above.
+        this.map.picture.render(xmlStream, model.background);
         // Controls section for legacy form controls (checkboxes, etc.)
         // Excel expects <controls> entries that reference ctrlProp relationships.
         if (model.formControls && model.formControls.length > 0) {
@@ -613,9 +788,10 @@ class WorkSheetXform extends base_xform_1.BaseXform {
             xmlStream.leafNode("mc:Fallback");
             xmlStream.closeNode();
         }
-        // ignoredErrors must come after controls, before tableParts (OOXML schema order).
-        this.map.ignoredErrors.render(xmlStream, model.ignoredErrors);
-        // tableParts must come after ignoredErrors.
+        // `ignoredErrors` is rendered earlier (before `drawing`) per
+        // ECMA-376 §18.3.1.99 schema order — see the block above
+        // `this.map.drawing.render(...)`. Only `tableParts` and `extLst`
+        // remain in this tail section.
         this.map.tableParts.render(xmlStream, model.tables);
         // extLst should be the last element in the worksheet.
         this.map.extLst.render(xmlStream, model);

package/dist/cjs/modules/excel/xlsx/xform/table/auto-filter-xform.js

@@ -24,8 +24,23 @@ class AutoFilterXform extends base_xform_1.BaseXform {
         xmlStream.openNode(this.tag, {
             ref: model.autoFilterRef
         });
+        // Only emit `<filterColumn>` for columns that carry actual filter
+        // state. Real Excel only emits the child when a filter is applied
+        // (`customFilters` / `filters` / `dynamicFilter`) or when the
+        // author explicitly set the filter-button visibility (either
+        // `filterButton: true` or `filterButton: false`). Columns that
+        // never touched `filterButton` (i.e. `undefined`) default to
+        // Excel's "show button" behaviour and should emit nothing —
+        // emitting an empty `<filterColumn hiddenButton="1"/>` for
+        // every such column makes Excel reject the table with
+        // "Removed Records: Table from /xl/tables/tableN.xml".
         model.columns.forEach((column) => {
-            this.map.filterColumn.render(xmlStream, column);
+            if (column?.customFilters !== undefined ||
+                column?.filters !== undefined ||
+                column?.dynamicFilter !== undefined ||
+                column?.filterButton !== undefined) {
+                this.map.filterColumn.render(xmlStream, column);
+            }
         });
         xmlStream.closeNode();
     }

package/dist/cjs/modules/excel/xlsx/xform/table/table-column-xform.js

@@ -26,12 +26,27 @@ class TableColumnXform extends base_xform_1.BaseXform {
         };
     }
     render(xmlStream, model) {
-        if (model.calculatedColumnFormula || model.totalsRowFormula) {
+        // `<totalsRowFormula>` is only valid when `totalsRowFunction="custom"`
+        // (or absent entirely, treated as custom). For the built-in
+        // functions — `sum` / `average` / `count` / `countNums` / `max` /
+        // `min` / `stdDev` / `var` — Excel GENERATES the SUBTOTAL formula
+        // itself at open time. Emitting a redundant
+        // `<totalsRowFormula>SUBTOTAL(101,Table[Col])</totalsRowFormula>`
+        // alongside `totalsRowFunction="average"` makes Excel report
+        // "Removed Records: Table from /xl/tables/tableN.xml" because the
+        // schema allows the child only with a custom function. The
+        // library's own `Table` class eagerly populates
+        // `column.totalsRowFormula = getFormula(column)` for every
+        // non-label column so rows render correctly in-memory; we gate
+        // the *emission* here instead of mutating that in-memory cache.
+        const isCustomFn = model.totalsRowFunction === undefined || model.totalsRowFunction === "custom";
+        const emitTotalsFormula = !!model.totalsRowFormula && isCustomFn;
+        if (model.calculatedColumnFormula || emitTotalsFormula) {
             xmlStream.openNode(this.tag, this._renderAttributes(model));
             if (model.calculatedColumnFormula) {
                 xmlStream.leafNode("calculatedColumnFormula", undefined, model.calculatedColumnFormula);
             }
-            if (model.totalsRowFormula) {
+            if (emitTotalsFormula) {
                 xmlStream.leafNode("totalsRowFormula", undefined, model.totalsRowFormula);
             }
             xmlStream.closeNode();

package/dist/cjs/modules/excel/xlsx/xform/xsd-values.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Shared parsers for OOXML / XSD-typed attribute values.
+ *
+ * These helpers are the single source of truth for attribute parsing
+ * across every xform. Multiple xforms used to carry private copies
+ * that drifted on edge cases:
+ *   - chartsheet-xform read `tabSelected="true"` as `false` because it
+ *     only accepted `"1"` (spec permits `"true"` per `xsd:boolean`);
+ *   - some older code accepted `NaN` from `parseFloat` and serialised
+ *     it back as the literal `"NaN"` attribute — an XML Schema
+ *     violation that Excel's strict reader rejects.
+ *
+ * All parsers return `undefined` for missing / unparseable input so
+ * callers distinguish "absent" from "present but invalid" and can
+ * pipe through `?? default` to apply the spec's default value at the
+ * call site (element-specific, so the parser shouldn't bake one in).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXsdBoolean = parseXsdBoolean;
+exports.parseXsdInt = parseXsdInt;
+exports.parseXsdFloat = parseXsdFloat;
+/**
+ * Parse an OOXML boolean attribute (`xsd:boolean`).
+ *
+ * Accepts the four canonical forms — `"1"`, `"0"`, `"true"`, `"false"` —
+ * per the XSD 1.1 spec. Leading / trailing whitespace is stripped
+ * first because XML 1.0 §3.3.3 attribute-value normalisation isn't
+ * guaranteed by every parser, and third-party writers legitimately
+ * emit `" 1 "` / `"0\n"` / etc. Without the trim, those values would
+ * silently downgrade to the schema default (typically `false`),
+ * losing state on round-trip.
+ *
+ * Returns `undefined` for any other value so call sites can
+ * distinguish "attribute absent / unrecognised" from "explicit false"
+ * and apply the element's schema default via `?? true` / `?? false`.
+ */
+function parseXsdBoolean(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed === "1" || trimmed === "true") {
+        return true;
+    }
+    if (trimmed === "0" || trimmed === "false") {
+        return false;
+    }
+    return undefined;
+}
+/**
+ * Parse an OOXML integer attribute (`xsd:int`, bounded at ±2^31-1 per
+ * ECMA-376 / W3C XSD).
+ *
+ * Rejects trailing garbage — `parseInt("100%", 10)` silently returns
+ * `100`, which round-trips back to the wire as a valid-looking
+ * attribute even though the source was corrupt. Gate on a strict
+ * regex so only the lexical space defined by XSD is accepted; the
+ * surrounding trim handles the same third-party-writer whitespace
+ * cases {@link parseXsdBoolean} does.
+ *
+ * Returns `undefined` for missing / empty / non-numeric input rather
+ * than producing `NaN` (which would propagate through the model and
+ * surface as `"NaN"` in the round-trip XML — rejected by strict
+ * readers). Values outside `xsd:int` range are also rejected; callers
+ * that genuinely need 64-bit integers should use a `BigInt` path.
+ */
+function parseXsdInt(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed === "" || !/^[+-]?\d+$/.test(trimmed)) {
+        return undefined;
+    }
+    const n = parseInt(trimmed, 10);
+    if (!Number.isFinite(n)) {
+        return undefined;
+    }
+    if (n > 2147483647 || n < -2147483648) {
+        return undefined;
+    }
+    return n;
+}
+/**
+ * Parse an OOXML floating-point attribute (`xsd:double` / `xsd:float`).
+ * See {@link parseXsdInt} for the rationale — returns `undefined`
+ * instead of `NaN` / `Infinity` so the value never escapes back into
+ * the wire as a schema-invalid attribute.
+ *
+ * Strict lexical-space regex matches `xsd:double` production:
+ * optional sign, integer / decimal, optional exponent. Rejects
+ * trailing garbage for the same reason as {@link parseXsdInt}
+ * (corrupt-source preservation is worse than loud rejection).
+ */
+function parseXsdFloat(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed === "" || !/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(trimmed)) {
+        return undefined;
+    }
+    const n = parseFloat(trimmed);
+    return Number.isFinite(n) ? n : undefined;
+}