@cj-tech-master/excelts 4.0.0 → 4.0.1

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

@@ -0,0 +1,179 @@
+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) {
+        // 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/browser/modules/excel/xlsx/xform/pivot-table/pivot-cache-records-xform.d.ts

@@ -0,0 +1,73 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import type { PivotTableSource } from "@excel/pivot-table";
+/**
+ * Model for generating pivot cache records (with live source)
+ */
+interface CacheRecordsModel {
+    source: PivotTableSource;
+    cacheFields: any[];
+}
+/**
+ * Parsed record value - can be:
+ * - { type: 'x', value: number } - Shared item index
+ * - { type: 'n', value: number } - Numeric value
+ * - { type: 's', value: string } - String value
+ * - { type: 'b', value: boolean } - Boolean value
+ * - { type: 'm' } - Missing/null value
+ * - { type: 'd', value: Date } - Date value
+ * - { type: 'e', value: string } - Error value
+ */
+interface RecordValue {
+    type: "x" | "n" | "s" | "b" | "m" | "d" | "e";
+    value?: any;
+}
+/**
+ * Parsed cache records model
+ */
+interface ParsedCacheRecordsModel {
+    records: RecordValue[][];
+    count: number;
+    isLoaded?: boolean;
+}
+declare class PivotCacheRecordsXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    model: ParsedCacheRecordsModel | null;
+    private currentRecord;
+    constructor();
+    prepare(_model: any): void;
+    get tag(): string;
+    reset(): void;
+    /**
+     * Render pivot cache records XML.
+     * Supports both newly created models (with PivotTableSource) and loaded models.
+     */
+    render(xmlStream: any, model: CacheRecordsModel | ParsedCacheRecordsModel): void;
+    /**
+     * Render newly created pivot cache records
+     */
+    private renderNew;
+    /**
+     * Render loaded pivot cache records
+     */
+    private renderLoaded;
+    /**
+     * Render a single record value to XML
+     */
+    private renderRecordValue;
+    private renderTableNew;
+    private renderCellNew;
+    parseOpen(node: any): boolean;
+    parseText(_text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(_model: any, _options: any): void;
+    static PIVOT_CACHE_RECORDS_ATTRIBUTES: {
+        xmlns: string;
+        "xmlns:r": string;
+        "xmlns:mc": string;
+        "mc:Ignorable": string;
+        "xmlns:xr": string;
+    };
+}
+export { PivotCacheRecordsXform, type ParsedCacheRecordsModel };

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

@@ -0,0 +1,234 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { xmlEncode, xmlDecode } from "../../../../../utils/utils.browser.js";
+import { BaseXform } from "../base-xform.js";
+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 };

package/dist/browser/modules/excel/xlsx/xform/pivot-table/pivot-table-xform.d.ts

@@ -0,0 +1,119 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+/**
+ * Model for generating pivot table (with live source)
+ */
+interface PivotTableModel {
+    rows: number[];
+    columns: number[];
+    values: number[];
+    metric: "sum" | "count";
+    cacheFields: any[];
+    cacheId: number;
+    applyWidthHeightFormats: "0" | "1";
+}
+/**
+ * Parsed pivot field
+ */
+interface ParsedPivotField {
+    axis?: "axisRow" | "axisCol" | "axisPage" | "axisValues";
+    dataField?: boolean;
+    items?: number[];
+    compact?: boolean;
+    outline?: boolean;
+    showAll?: boolean;
+    defaultSubtotal?: boolean;
+}
+/**
+ * Parsed data field
+ */
+interface ParsedDataField {
+    name: string;
+    fld: number;
+    baseField?: number;
+    baseItem?: number;
+    subtotal?: "sum" | "count" | "average" | "max" | "min" | "product" | "countNums" | "stdDev" | "stdDevP" | "var" | "varP";
+}
+/**
+ * Parsed pivot table model (loaded from file)
+ */
+interface ParsedPivotTableModel {
+    name?: string;
+    cacheId: number;
+    uid?: string;
+    location?: {
+        ref: string;
+        firstHeaderRow?: number;
+        firstDataRow?: number;
+        firstDataCol?: number;
+    };
+    pivotFields: ParsedPivotField[];
+    rowFields: number[];
+    colFields: number[];
+    dataFields: ParsedDataField[];
+    applyNumberFormats?: string;
+    applyBorderFormats?: string;
+    applyFontFormats?: string;
+    applyPatternFormats?: string;
+    applyAlignmentFormats?: string;
+    applyWidthHeightFormats?: string;
+    dataCaption?: string;
+    styleName?: string;
+    updatedVersion?: string;
+    minRefreshableVersion?: string;
+    createdVersion?: string;
+    useAutoFormatting?: boolean;
+    itemPrintTitles?: boolean;
+    indent?: number;
+    compact?: boolean;
+    compactData?: boolean;
+    multipleFieldFilters?: boolean;
+    rowItems?: any[];
+    colItems?: any[];
+    isLoaded?: boolean;
+    extensions?: any[];
+}
+declare class PivotTableXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    model: ParsedPivotTableModel | null;
+    private inPivotFields;
+    private inRowFields;
+    private inColFields;
+    private inDataFields;
+    private inRowItems;
+    private inColItems;
+    private inLocation;
+    private currentPivotField;
+    private inItems;
+    private inPivotTableStyleInfo;
+    constructor();
+    prepare(_model: any): void;
+    get tag(): string;
+    reset(): void;
+    /**
+     * Render pivot table XML.
+     * Supports both newly created models and loaded models.
+     */
+    render(xmlStream: any, model: PivotTableModel | ParsedPivotTableModel): void;
+    /**
+     * Render newly created pivot table
+     */
+    private renderNew;
+    /**
+     * Render loaded pivot table (preserving original structure)
+     */
+    private renderLoaded;
+    /**
+     * Render a loaded pivot field
+     */
+    private renderPivotFieldLoaded;
+    parseOpen(node: any): boolean;
+    parseText(_text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(_model: any, _options: any): void;
+    static PIVOT_TABLE_ATTRIBUTES: {
+        xmlns: string;
+    };
+}
+export { PivotTableXform, type ParsedPivotTableModel };