@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/cjs/modules/excel/xlsx/xform/book/external-link-xform.js

@@ -108,19 +108,21 @@ class ExternalLinkXform extends base_xform_1.BaseXform {
             const sheet = cache[name];
             return sheet && Object.keys(sheet).length > 0;
         });
-        if (hasAnyCache) {
-            xmlStream.openNode("sheetDataSet");
-            // Iterate in sheetNames order so sheetId indices are stable.
-            for (let i = 0; i < model.sheetNames.length; i++) {
-                const sheetName = model.sheetNames[i];
-                const cells = cache[sheetName];
-                if (!cells || Object.keys(cells).length === 0) {
-                    continue;
-                }
+        // Excel requires <sheetDataSet> to be present even when empty —
+        // omitting it causes "file cannot be opened" errors. Each declared
+        // sheet must have a corresponding <sheetData sheetId="N"/> entry.
+        xmlStream.openNode("sheetDataSet");
+        for (let i = 0; i < model.sheetNames.length; i++) {
+            const sheetName = model.sheetNames[i];
+            const cells = hasAnyCache ? cache[sheetName] : undefined;
+            if (cells && Object.keys(cells).length > 0) {
                 renderSheetData(xmlStream, i, cells);
             }
-            xmlStream.closeNode();
+            else {
+                xmlStream.leafNode("sheetData", { sheetId: String(i) });
+            }
         }
+        xmlStream.closeNode();
         xmlStream.closeNode(); // </externalBook>
         xmlStream.closeNode(); // </externalLink>
     }

package/dist/cjs/modules/excel/xlsx/xform/book/workbook-xform.js

@@ -46,7 +46,44 @@ class WorkbookXform extends base_xform_1.BaseXform {
         };
     }
     prepare(model) {
-        model.sheets = model.worksheets;
+        // Build the sheets list preserving the author's chosen sheet order.
+        // Each sheet (worksheet or chartsheet) carries an `orderNo` set
+        // during add / load; we sort the combined list by that field so a
+        // workbook with interleaved `[ws1, cs1, ws2, cs2]` round-trips in
+        // the same order the user authored. The previous implementation
+        // sorted by `sheetNo` — but `sheetNo` is the file-path number
+        // (independent per family), so a workbook where the author added
+        // worksheet A, chartsheet X, worksheet B got reshuffled to
+        // [A(1), X(1), B(2)] → [A, X, B] which is only correct by
+        // accident when worksheet and chartsheet numbering starts at the
+        // same value. `orderNo` is a unified counter and reflects true
+        // insertion / tab order.
+        const worksheets = [...(model.worksheets ?? [])];
+        const chartsheets = [...(model.chartsheets ?? [])];
+        if (chartsheets.length === 0) {
+            model.sheets = worksheets;
+        }
+        else {
+            const combined = [...worksheets, ...chartsheets];
+            const withIndex = combined.map((sheet, originalIndex) => ({ sheet, originalIndex }));
+            withIndex.sort((a, b) => {
+                const aOrder = typeof a.sheet.orderNo === "number"
+                    ? a.sheet.orderNo
+                    : typeof a.sheet.sheetNo === "number"
+                        ? a.sheet.sheetNo
+                        : Infinity;
+                const bOrder = typeof b.sheet.orderNo === "number"
+                    ? b.sheet.orderNo
+                    : typeof b.sheet.sheetNo === "number"
+                        ? b.sheet.sheetNo
+                        : Infinity;
+                if (aOrder !== bOrder) {
+                    return aOrder - bOrder;
+                }
+                return a.originalIndex - b.originalIndex;
+            });
+            model.sheets = withIndex.map(entry => entry.sheet);
+        }
         // collate all the print areas from all of the sheets and add them to the defined names
         const printAreas = [];
         let index = 0; // sheets is sparse array - calc index manually
@@ -105,6 +142,15 @@ class WorkbookXform extends base_xform_1.BaseXform {
         this.map.bookViews.render(xmlStream, model.views);
         this.map.sheets.render(xmlStream, model.sheets);
         this.map.definedNames.render(xmlStream, model.definedNames);
+        // <externalReferences> must appear BEFORE <calcPr> per ECMA-376
+        // CT_Workbook sequence: sheets → definedNames → externalReferences →
+        // calcPr → pivotCaches. Violating this order causes Excel to reject
+        // the file as corrupt.
+        const externalLinks = model.externalLinks ?? [];
+        if (externalLinks.length > 0) {
+            const externalReferenceModels = externalLinks.map((link) => ({ rId: link.rId }));
+            this.map.externalReferences.render(xmlStream, externalReferenceModels);
+        }
         this.map.calcPr.render(xmlStream, model.calcProperties);
         // R9-B6: Deduplicate pivot caches by cacheId before rendering.
         // Multiple pivot tables may share the same cache, but workbook.xml should
@@ -119,15 +165,6 @@ class WorkbookXform extends base_xform_1.BaseXform {
             return true;
         });
         this.map.pivotCaches.render(xmlStream, uniquePivotCaches);
-        // <externalReferences> order matters: one entry per externalLink in
-        // declaration order, each carrying the r:id that resolves (via
-        // workbook.xml.rels) to `xl/externalLinks/externalLink{N}.xml`. The
-        // index inside this list is exactly the `[N]` used in formula strings.
-        const externalLinks = model.externalLinks ?? [];
-        if (externalLinks.length > 0) {
-            const externalReferenceModels = externalLinks.map((link) => ({ rId: link.rId }));
-            this.map.externalReferences.render(xmlStream, externalReferenceModels);
-        }
         xmlStream.closeNode();
     }
     parseOpen(node) {
@@ -192,29 +229,59 @@ class WorkbookXform extends base_xform_1.BaseXform {
             return map;
         }, {});
         // reconcile sheet ids, rIds and names
+        //
+        // `worksheets` is indexed positionally across BOTH sheet kinds
+        // (worksheet and chartsheet). OOXML `definedName/@localSheetId`
+        // is a 0-based index into the workbook-level `<sheets>` element,
+        // which mixes both kinds — so a chartsheet occupying position 1
+        // in `<sheets>` shifts every subsequent worksheet's effective
+        // index by one. Compressing to a worksheets-only array (the
+        // previous implementation) made `localSheetId` resolve to the
+        // wrong worksheet whenever chartsheets were interleaved, so
+        // `_xlnm.Print_Area` / `_xlnm.Print_Titles` landed on an
+        // unrelated sheet.
         const worksheets = [];
+        const chartsheetsList = [];
         let worksheet;
-        let index = 0;
+        let sheetPosition = 0;
         (model.sheets ?? []).forEach((sheet) => {
             const rel = rels[sheet.rId];
             if (!rel) {
+                sheetPosition += 1;
+                return;
+            }
+            const target = `xl/${rel.Target.replace(/^(\s|\/xl\/)+/, "")}`;
+            // Check if this is a chartsheet
+            const chartsheetMatch = /xl\/chartsheets\/sheet(\d+)\.xml/.exec(target);
+            if (chartsheetMatch) {
+                const csNo = parseInt(chartsheetMatch[1], 10);
+                const chartsheet = model.chartsheets?.[csNo];
+                if (chartsheet) {
+                    chartsheet.name = sheet.name;
+                    chartsheet.id = sheet.id;
+                    chartsheet.state = sheet.state;
+                    chartsheet.rId = sheet.rId;
+                    chartsheet.orderNo = sheetPosition;
+                    chartsheetsList.push(chartsheet);
+                }
+                sheetPosition += 1;
                 return;
             }
-            // if rel.Target start with `[space]/xl/` or `/xl/` , then it will be replaced with `''` and spliced behind `xl/`,
-            // otherwise it will be spliced directly behind `xl/`. i.g.
-            worksheet = model.worksheetHash[`xl/${rel.Target.replace(/^(\s|\/xl\/)+/, "")}`];
-            // If there are "chartsheets" in the file, rel.Target will
-            // come out as chartsheets/sheet1.xml or similar here, and
-            // that won't be in model.worksheetHash.
-            // As we don't have the infrastructure to support chartsheets,
-            // we will ignore them for now:
+            worksheet = model.worksheetHash[target];
             if (worksheet) {
                 worksheet.name = sheet.name;
                 worksheet.id = sheet.id;
                 worksheet.state = sheet.state;
-                worksheets[index++] = worksheet;
+                worksheet.orderNo = sheetPosition;
+                // Index by the workbook `<sheets>` position — not the
+                // compressed worksheet counter — so `definedName.localSheetId`
+                // resolves correctly when chartsheets are interleaved.
+                worksheets[sheetPosition] = worksheet;
             }
+            sheetPosition += 1;
         });
+        // Store reconciled chartsheets on the model
+        model.chartsheetsList = chartsheetsList;
         // reconcile print areas
         const definedNames = [];
         if (model.definedNames) {
@@ -266,8 +333,15 @@ class WorkbookXform extends base_xform_1.BaseXform {
             });
         }
         model.definedNames = definedNames;
-        // used by sheets to build their image models
-        model.media.forEach((media, i) => {
+        // used by sheets to build their image models.
+        // Matches the `(model.media ?? []).forEach(...)` guard in
+        // `prepare` (line 144): `reconcile` may be called from code paths
+        // where `model.media` was never initialised (e.g. a programmatic
+        // workbook with no images; the xlsx reader populates this array,
+        // but builder-constructed workbooks do not). Without the guard,
+        // the forEach throws `TypeError: Cannot read properties of
+        // undefined (reading 'forEach')` and aborts the load/save cycle.
+        (model.media ?? []).forEach((media, i) => {
             media.index = i;
         });
     }