@cj-tech-master/excelts 3.0.1 → 3.1.0-canary.20260102041828.82ed571

package/dist/esm/modules/excel/xlsx/xform/pivot-table/cache-field-xform.js

@@ -0,0 +1,128 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { xmlDecode } from "@utils/utils";
+/**
+ * Xform for parsing individual <cacheField> elements within a pivot cache definition.
+ *
+ * Example XML:
+ * ```xml
+ * <cacheField name="Category" numFmtId="0">
+ *   <sharedItems count="3">
+ *     <s v="A" />
+ *     <s v="B" />
+ *     <s v="C" />
+ *   </sharedItems>
+ * </cacheField>
+ *
+ * <cacheField name="Value" numFmtId="0">
+ *   <sharedItems containsSemiMixedTypes="0" containsString="0"
+ *                containsNumber="1" containsInteger="1" minValue="5" maxValue="45" />
+ * </cacheField>
+ * ```
+ */
+class CacheFieldXform extends BaseXform {
+    constructor() {
+        super();
+        this.model = null;
+        this.inSharedItems = false;
+    }
+    get tag() {
+        return "cacheField";
+    }
+    reset() {
+        this.model = null;
+        this.inSharedItems = false;
+    }
+    parseOpen(node) {
+        const { name, attributes } = node;
+        switch (name) {
+            case "cacheField":
+                // Initialize the model with field name
+                this.model = {
+                    name: xmlDecode(attributes.name || ""),
+                    sharedItems: null
+                };
+                break;
+            case "sharedItems":
+                this.inSharedItems = true;
+                // Store numeric field metadata
+                if (this.model) {
+                    this.model.containsNumber = attributes.containsNumber === "1";
+                    this.model.containsInteger = attributes.containsInteger === "1";
+                    if (attributes.minValue !== undefined) {
+                        this.model.minValue = parseFloat(attributes.minValue);
+                    }
+                    if (attributes.maxValue !== undefined) {
+                        this.model.maxValue = parseFloat(attributes.maxValue);
+                    }
+                    // Initialize sharedItems array if count > 0 (for both string and numeric fields)
+                    const count = parseInt(attributes.count || "0", 10);
+                    if (count > 0) {
+                        this.model.sharedItems = [];
+                    }
+                    else {
+                        // No count means no individual items (pure numeric field)
+                        this.model.sharedItems = null;
+                    }
+                }
+                break;
+            case "s":
+                // String value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    // Decode XML entities in the value
+                    const value = xmlDecode(attributes.v || "");
+                    this.model.sharedItems.push(value);
+                }
+                break;
+            case "n":
+                // Numeric value in sharedItems (less common, but possible)
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    const value = parseFloat(attributes.v || "0");
+                    this.model.sharedItems.push(value);
+                }
+                break;
+            case "b":
+                // Boolean value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    const value = attributes.v === "1";
+                    this.model.sharedItems.push(value);
+                }
+                break;
+            case "e":
+                // Error value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    const value = `#${attributes.v || "ERROR!"}`;
+                    this.model.sharedItems.push(value);
+                }
+                break;
+            case "m":
+                // Missing/null value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    this.model.sharedItems.push(null);
+                }
+                break;
+            case "d":
+                // Date value in sharedItems
+                if (this.inSharedItems && this.model?.sharedItems !== null) {
+                    const value = new Date(attributes.v || "");
+                    this.model.sharedItems.push(value);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(_text) {
+        // No text content in cacheField elements
+    }
+    parseClose(name) {
+        switch (name) {
+            case "cacheField":
+                // End of this cacheField element
+                return false;
+            case "sharedItems":
+                this.inSharedItems = false;
+                break;
+        }
+        return true;
+    }
+}
+export { CacheFieldXform };

package/dist/esm/modules/excel/xlsx/xform/pivot-table/cache-field.js

@@ -0,0 +1,78 @@
+import { xmlEncode } from "@utils/utils";
+class CacheField {
+    constructor({ name, sharedItems, minValue, maxValue }) {
+        // string type
+        //
+        // {
+        //   'name': 'A',
+        //   'sharedItems': ['a1', 'a2', 'a3']
+        // }
+        //
+        // or
+        //
+        // integer type (no sharedItems)
+        //
+        // {
+        //   'name': 'D',
+        //   'sharedItems': null,
+        //   'minValue': 5,
+        //   'maxValue': 45
+        // }
+        //
+        // or
+        //
+        // numeric type with shared items (used as both row/column and value field)
+        //
+        // {
+        //   'name': 'C',
+        //   'sharedItems': [5, 24, 35, 45]
+        // }
+        this.name = name;
+        this.sharedItems = sharedItems;
+        this.minValue = minValue;
+        this.maxValue = maxValue;
+    }
+    render() {
+        // PivotCache Field: http://www.datypic.com/sc/ooxml/e-ssml_cacheField-1.html
+        // Shared Items: http://www.datypic.com/sc/ooxml/e-ssml_sharedItems-1.html
+        // Escape XML special characters in name attribute
+        const escapedName = xmlEncode(this.name);
+        // No shared items - field not used for rows/columns
+        if (this.sharedItems === null) {
+            // If no minValue/maxValue, this is an unused field - use empty sharedItems like Excel does
+            if (this.minValue === undefined || this.maxValue === undefined) {
+                return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems />
+    </cacheField>`;
+            }
+            // Numeric field used only for values (not rows/columns) - include min/max
+            return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" minValue="${this.minValue}" maxValue="${this.maxValue}" />
+    </cacheField>`;
+        }
+        // Shared items exist - check if all values are numeric
+        // Note: empty array returns true for every(), so check length first
+        const allNumeric = this.sharedItems.length > 0 &&
+            this.sharedItems.every(item => typeof item === "number" && Number.isFinite(item));
+        const allInteger = allNumeric && this.sharedItems.every(item => Number.isInteger(item));
+        if (allNumeric) {
+            // Numeric shared items - used when field is both a row/column field AND a value field
+            // This allows Excel to both group by unique values AND perform aggregation
+            const minValue = Math.min(...this.sharedItems);
+            const maxValue = Math.max(...this.sharedItems);
+            const integerAttr = allInteger ? ' containsInteger="1"' : "";
+            return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1"${integerAttr} minValue="${minValue}" maxValue="${maxValue}" count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<n v="${item}" />`).join("")}
+      </sharedItems>
+    </cacheField>`;
+        }
+        // String shared items - escape XML special characters in each value
+        return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<s v="${xmlEncode(String(item))}" />`).join("")}
+      </sharedItems>
+    </cacheField>`;
+    }
+}
+export { CacheField };

package/dist/esm/modules/excel/xlsx/xform/pivot-table/pivot-cache-definition-xform.js

@@ -0,0 +1,179 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { CacheField } from "@excel/xlsx/xform/pivot-table/cache-field";
+import { CacheFieldXform } from "@excel/xlsx/xform/pivot-table/cache-field-xform";
+import { XmlStream } from "@excel/utils/xml-stream";
+class PivotCacheDefinitionXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {};
+        this.model = null;
+        this.currentCacheField = null;
+        this.inCacheFields = false;
+        this.inCacheSource = false;
+    }
+    prepare(_model) {
+        // No preparation needed for writing
+    }
+    get tag() {
+        // http://www.datypic.com/sc/ooxml/e-ssml_pivotCacheDefinition.html
+        return "pivotCacheDefinition";
+    }
+    reset() {
+        this.model = null;
+        this.currentCacheField = null;
+        this.inCacheFields = false;
+        this.inCacheSource = false;
+    }
+    /**
+     * Render pivot cache definition XML.
+     * Supports both newly created models (with PivotTableSource) and loaded models.
+     */
+    render(xmlStream, model) {
+        // Check if this is a loaded model (has isLoaded flag or no source property)
+        const isLoaded = model.isLoaded || !("source" in model);
+        if (isLoaded) {
+            this.renderLoaded(xmlStream, model);
+        }
+        else {
+            this.renderNew(xmlStream, model);
+        }
+    }
+    /**
+     * Render newly created pivot cache definition
+     */
+    renderNew(xmlStream, model) {
+        const { source, cacheFields } = model;
+        // Record count = number of data rows (excluding header row)
+        const recordCount = source.getSheetValues().slice(2).length;
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, {
+            ...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
+            "r:id": "rId1",
+            refreshOnLoad: "1", // important for our implementation to work
+            createdVersion: "8",
+            refreshedVersion: "8",
+            minRefreshableVersion: "3",
+            recordCount
+        });
+        xmlStream.openNode("cacheSource", { type: "worksheet" });
+        xmlStream.leafNode("worksheetSource", {
+            ref: source.dimensions.shortRange,
+            sheet: source.name
+        });
+        xmlStream.closeNode();
+        xmlStream.openNode("cacheFields", { count: cacheFields.length });
+        // Note: keeping this pretty-printed for now to ease debugging.
+        xmlStream.writeXml(cacheFields.map((cacheField) => new CacheField(cacheField).render()).join("\n    "));
+        xmlStream.closeNode();
+        xmlStream.closeNode();
+    }
+    /**
+     * Render loaded pivot cache definition (preserving original structure)
+     */
+    renderLoaded(xmlStream, model) {
+        const { cacheFields, sourceRef, sourceSheet, recordCount } = model;
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, {
+            ...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
+            "r:id": model.rId || "rId1",
+            refreshOnLoad: model.refreshOnLoad || "1",
+            createdVersion: model.createdVersion || "8",
+            refreshedVersion: model.refreshedVersion || "8",
+            minRefreshableVersion: model.minRefreshableVersion || "3",
+            recordCount: recordCount || cacheFields.length + 1
+        });
+        xmlStream.openNode("cacheSource", { type: "worksheet" });
+        xmlStream.leafNode("worksheetSource", {
+            ref: sourceRef,
+            sheet: sourceSheet
+        });
+        xmlStream.closeNode();
+        xmlStream.openNode("cacheFields", { count: cacheFields.length });
+        xmlStream.writeXml(cacheFields
+            .map((cacheField) => new CacheField(cacheField).render())
+            .join("\n    "));
+        xmlStream.closeNode();
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        const { name, attributes } = node;
+        // Delegate to current cacheField parser if active
+        if (this.currentCacheField) {
+            this.currentCacheField.parseOpen(node);
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                // pivotCacheDefinition root element
+                this.reset();
+                this.model = {
+                    cacheFields: [],
+                    rId: attributes["r:id"],
+                    refreshOnLoad: attributes.refreshOnLoad,
+                    createdVersion: attributes.createdVersion,
+                    refreshedVersion: attributes.refreshedVersion,
+                    minRefreshableVersion: attributes.minRefreshableVersion,
+                    recordCount: attributes.recordCount ? parseInt(attributes.recordCount, 10) : undefined,
+                    isLoaded: true
+                };
+                break;
+            case "cacheSource":
+                this.inCacheSource = true;
+                break;
+            case "worksheetSource":
+                if (this.inCacheSource && this.model) {
+                    this.model.sourceRef = attributes.ref;
+                    this.model.sourceSheet = attributes.sheet;
+                }
+                break;
+            case "cacheFields":
+                this.inCacheFields = true;
+                break;
+            case "cacheField":
+                if (this.inCacheFields) {
+                    this.currentCacheField = new CacheFieldXform();
+                    this.currentCacheField.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(text) {
+        if (this.currentCacheField) {
+            this.currentCacheField.parseText(text);
+        }
+    }
+    parseClose(name) {
+        // Delegate to current cacheField parser if active
+        if (this.currentCacheField) {
+            if (!this.currentCacheField.parseClose(name)) {
+                // cacheField parsing complete, add to model
+                if (this.model && this.currentCacheField.model) {
+                    this.model.cacheFields.push(this.currentCacheField.model);
+                }
+                this.currentCacheField = null;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                // End of pivotCacheDefinition
+                return false;
+            case "cacheSource":
+                this.inCacheSource = false;
+                break;
+            case "cacheFields":
+                this.inCacheFields = false;
+                break;
+        }
+        return true;
+    }
+    reconcile(_model, _options) {
+        // No reconciliation needed
+    }
+}
+PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES = {
+    xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+};
+export { PivotCacheDefinitionXform };

package/dist/esm/modules/excel/xlsx/xform/pivot-table/pivot-cache-records-xform.js

@@ -0,0 +1,234 @@
+import { XmlStream } from "@excel/utils/xml-stream";
+import { xmlEncode, xmlDecode } from "@utils/utils";
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+class PivotCacheRecordsXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {};
+        this.model = null;
+        this.currentRecord = null;
+    }
+    prepare(_model) {
+        // No preparation needed
+    }
+    get tag() {
+        // http://www.datypic.com/sc/ooxml/e-ssml_pivotCacheRecords.html
+        return "pivotCacheRecords";
+    }
+    reset() {
+        this.model = null;
+        this.currentRecord = null;
+    }
+    /**
+     * Render pivot cache records XML.
+     * Supports both newly created models (with PivotTableSource) and loaded models.
+     */
+    render(xmlStream, model) {
+        // Check if this is a loaded model
+        const isLoaded = model.isLoaded || !("source" in model);
+        if (isLoaded) {
+            this.renderLoaded(xmlStream, model);
+        }
+        else {
+            this.renderNew(xmlStream, model);
+        }
+    }
+    /**
+     * Render newly created pivot cache records
+     */
+    renderNew(xmlStream, model) {
+        const { source, cacheFields } = model;
+        const sourceBodyRows = source.getSheetValues().slice(2);
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, {
+            ...PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES,
+            count: sourceBodyRows.length
+        });
+        xmlStream.writeXml(this.renderTableNew(sourceBodyRows, cacheFields));
+        xmlStream.closeNode();
+    }
+    /**
+     * Render loaded pivot cache records
+     */
+    renderLoaded(xmlStream, model) {
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, {
+            ...PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES,
+            count: model.count
+        });
+        // Render each record
+        for (const record of model.records) {
+            xmlStream.writeXml("\n  <r>");
+            for (const value of record) {
+                xmlStream.writeXml("\n    ");
+                xmlStream.writeXml(this.renderRecordValue(value));
+            }
+            xmlStream.writeXml("\n  </r>");
+        }
+        xmlStream.closeNode();
+    }
+    /**
+     * Render a single record value to XML
+     */
+    renderRecordValue(value) {
+        switch (value.type) {
+            case "x":
+                return `<x v="${value.value}" />`;
+            case "n":
+                return `<n v="${value.value}" />`;
+            case "s":
+                return `<s v="${xmlEncode(String(value.value))}" />`;
+            case "b":
+                return `<b v="${value.value ? "1" : "0"}" />`;
+            case "m":
+                return "<m />";
+            case "d":
+                return `<d v="${value.value.toISOString()}" />`;
+            case "e":
+                return `<e v="${value.value}" />`;
+            default:
+                return "<m />";
+        }
+    }
+    // Helper methods for rendering new records
+    renderTableNew(sourceBodyRows, cacheFields) {
+        const parts = [];
+        for (const row of sourceBodyRows) {
+            const realRow = row.slice(1);
+            parts.push("\n  <r>");
+            for (let i = 0; i < realRow.length; i++) {
+                parts.push("\n    ");
+                parts.push(this.renderCellNew(realRow[i], cacheFields[i].sharedItems));
+            }
+            parts.push("\n  </r>");
+        }
+        return parts.join("");
+    }
+    renderCellNew(value, sharedItems) {
+        // Handle null/undefined values first
+        if (value === null || value === undefined) {
+            return "<m />";
+        }
+        // no shared items
+        if (sharedItems === null) {
+            if (Number.isFinite(value)) {
+                return `<n v="${value}" />`;
+            }
+            return `<s v="${xmlEncode(String(value))}" />`;
+        }
+        // shared items - use indexOf for value lookup (works for both string and numeric)
+        const sharedItemsIndex = sharedItems.indexOf(value);
+        if (sharedItemsIndex < 0) {
+            throw new Error(`${JSON.stringify(value)} not in sharedItems ${JSON.stringify(sharedItems)}`);
+        }
+        return `<x v="${sharedItemsIndex}" />`;
+    }
+    parseOpen(node) {
+        const { name, attributes } = node;
+        switch (name) {
+            case this.tag:
+                // pivotCacheRecords root element
+                this.reset();
+                this.model = {
+                    records: [],
+                    count: parseInt(attributes.count || "0", 10),
+                    isLoaded: true
+                };
+                break;
+            case "r":
+                // Start of a new record
+                this.currentRecord = [];
+                break;
+            case "x":
+                // Shared item index
+                if (this.currentRecord) {
+                    this.currentRecord.push({
+                        type: "x",
+                        value: parseInt(attributes.v || "0", 10)
+                    });
+                }
+                break;
+            case "n":
+                // Numeric value
+                if (this.currentRecord) {
+                    this.currentRecord.push({
+                        type: "n",
+                        value: parseFloat(attributes.v || "0")
+                    });
+                }
+                break;
+            case "s":
+                // String value
+                if (this.currentRecord) {
+                    this.currentRecord.push({
+                        type: "s",
+                        value: xmlDecode(attributes.v || "")
+                    });
+                }
+                break;
+            case "b":
+                // Boolean value
+                if (this.currentRecord) {
+                    this.currentRecord.push({
+                        type: "b",
+                        value: attributes.v === "1"
+                    });
+                }
+                break;
+            case "m":
+                // Missing/null value
+                if (this.currentRecord) {
+                    this.currentRecord.push({ type: "m" });
+                }
+                break;
+            case "d":
+                // Date value
+                if (this.currentRecord) {
+                    this.currentRecord.push({
+                        type: "d",
+                        value: new Date(attributes.v || "")
+                    });
+                }
+                break;
+            case "e":
+                // Error value
+                if (this.currentRecord) {
+                    this.currentRecord.push({
+                        type: "e",
+                        value: attributes.v || ""
+                    });
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(_text) {
+        // No text content in cache records elements
+    }
+    parseClose(name) {
+        switch (name) {
+            case this.tag:
+                // End of pivotCacheRecords
+                return false;
+            case "r":
+                // End of record - add to model
+                if (this.model && this.currentRecord) {
+                    this.model.records.push(this.currentRecord);
+                    this.currentRecord = null;
+                }
+                break;
+        }
+        return true;
+    }
+    reconcile(_model, _options) {
+        // No reconciliation needed
+    }
+}
+PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES = {
+    xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+    "mc:Ignorable": "xr",
+    "xmlns:xr": "http://schemas.microsoft.com/office/spreadsheetml/2014/revision"
+};
+export { PivotCacheRecordsXform };