@cj-tech-master/excelts 1.5.0 → 1.6.1

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

@@ -1,20 +1,48 @@
 import { BaseXform } from "../base-xform.js";
 import { CacheField } from "./cache-field.js";
+import { CacheFieldXform } from "./cache-field-xform.js";
 import { XmlStream } from "../../../utils/xml-stream.js";
 class PivotCacheDefinitionXform extends BaseXform {
     constructor() {
         super();
         this.map = {};
+        this.model = null;
+        this.currentCacheField = null;
+        this.inCacheFields = false;
+        this.inCacheSource = false;
     }
     prepare(_model) {
-        // TK
+        // 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) {
-        const { sourceSheet, cacheFields } = 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;
         xmlStream.openXml(XmlStream.StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
@@ -29,8 +57,8 @@ class PivotCacheDefinitionXform extends BaseXform {
         });
         xmlStream.openNode("cacheSource", { type: "worksheet" });
         xmlStream.leafNode("worksheetSource", {
-            ref: sourceSheet.dimensions.shortRange,
-            sheet: sourceSheet.name
+            ref: source.dimensions.shortRange,
+            sheet: source.name
         });
         xmlStream.closeNode();
         xmlStream.openNode("cacheFields", { count: cacheFields.length });
@@ -39,19 +67,113 @@ class PivotCacheDefinitionXform extends BaseXform {
         xmlStream.closeNode();
         xmlStream.closeNode();
     }
-    parseOpen(_node) {
-        // TK
-        return false;
+    /**
+     * 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",
+            refreshedBy: model.refreshedBy || "Author",
+            refreshedDate: model.refreshedDate || "45125.026046874998",
+            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,
+                    refreshedBy: attributes.refreshedBy,
+                    refreshedDate: attributes.refreshedDate,
+                    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) {
-        // TK
+    parseText(text) {
+        if (this.currentCacheField) {
+            this.currentCacheField.parseText(text);
+        }
     }
-    parseClose(_name) {
-        // TK
-        return false;
+    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) {
-        // TK
+        // No reconciliation needed
     }
 }
 PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES = {

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

@@ -1,79 +1,227 @@
 import { XmlStream } from "../../../utils/xml-stream.js";
+import { xmlEncode, xmlDecode } from "../../../utils/utils.js";
 import { BaseXform } from "../base-xform.js";
 class PivotCacheRecordsXform extends BaseXform {
     constructor() {
         super();
         this.map = {};
+        this.model = null;
+        this.currentRecord = null;
     }
     prepare(_model) {
-        // TK
+        // 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) {
-        const { sourceSheet, cacheFields } = model;
-        const sourceBodyRows = sourceSheet.getSheetValues().slice(2);
+        // 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(renderTable());
+        xmlStream.writeXml(this.renderTableNew(sourceBodyRows, cacheFields));
         xmlStream.closeNode();
-        // Helpers
-        function renderTable() {
-            const rowsInXML = sourceBodyRows.map((row) => {
-                const realRow = row.slice(1);
-                return [...renderRowLines(realRow)].join("");
-            });
-            return rowsInXML.join("");
-        }
-        function* renderRowLines(row) {
-            // PivotCache Record: http://www.datypic.com/sc/ooxml/e-ssml_r-1.html
-            // Note: pretty-printing this for now to ease debugging.
-            yield "\n  <r>";
-            for (const [index, cellValue] of row.entries()) {
-                yield "\n    ";
-                yield renderCell(cellValue, cacheFields[index].sharedItems);
+    }
+    /**
+     * 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));
             }
-            yield "\n  </r>";
+            xmlStream.writeXml("\n  </r>");
         }
-        function renderCell(value, sharedItems) {
-            // no shared items
-            // --------------------------------------------------
-            if (sharedItems === null) {
-                if (Number.isFinite(value)) {
-                    // Numeric value: http://www.datypic.com/sc/ooxml/e-ssml_n-2.html
-                    return `<n v="${value}" />`;
-                }
-                // Character Value: http://www.datypic.com/sc/ooxml/e-ssml_s-2.html
-                return `<s v="${value}" />`;
+        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));
             }
-            // shared items
-            // --------------------------------------------------
-            const sharedItemsIndex = sharedItems.indexOf(value);
-            if (sharedItemsIndex < 0) {
-                throw new Error(`${JSON.stringify(value)} not in sharedItems ${JSON.stringify(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}" />`;
             }
-            // Shared Items Index: http://www.datypic.com/sc/ooxml/e-ssml_x-9.html
-            return `<x v="${sharedItemsIndex}" />`;
+            return `<s v="${xmlEncode(String(value))}" />`;
+        }
+        // shared items
+        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) {
-        // TK
-        return false;
+    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) {
-        // TK
+        // No text content in cache records elements
     }
-    parseClose(_name) {
-        // TK
-        return false;
+    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) {
-        // TK
+        // No reconciliation needed
     }
 }
 PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES = {