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

package/dist/esm/xlsx/xform/drawing/two-cell-anchor-xform.js

@@ -1,51 +0,0 @@
-import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
-import { StaticXform } from "../static-xform.js";
-import { CellPositionXform } from "./cell-position-xform.js";
-import { PicXform } from "./pic-xform.js";
-class TwoCellAnchorXform extends BaseCellAnchorXform {
-    constructor() {
-        super();
-        this.map = {
-            "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
-            "xdr:to": new CellPositionXform({ tag: "xdr:to" }),
-            "xdr:pic": new PicXform(),
-            "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
-        };
-    }
-    get tag() {
-        return "xdr:twoCellAnchor";
-    }
-    prepare(model, options) {
-        this.map["xdr:pic"].prepare(model.picture, options);
-    }
-    render(xmlStream, model) {
-        xmlStream.openNode(this.tag, { editAs: model.range.editAs || "oneCell" });
-        this.map["xdr:from"].render(xmlStream, model.range.tl);
-        this.map["xdr:to"].render(xmlStream, model.range.br);
-        this.map["xdr:pic"].render(xmlStream, model.picture);
-        this.map["xdr:clientData"].render(xmlStream, {});
-        xmlStream.closeNode();
-    }
-    parseClose(name) {
-        if (this.parser) {
-            if (!this.parser.parseClose(name)) {
-                this.parser = undefined;
-            }
-            return true;
-        }
-        switch (name) {
-            case this.tag:
-                this.model.range.tl = this.map["xdr:from"].model;
-                this.model.range.br = this.map["xdr:to"].model;
-                this.model.picture = this.map["xdr:pic"].model;
-                return false;
-            default:
-                // could be some unrecognised tags
-                return true;
-        }
-    }
-    reconcile(model, options) {
-        model.medium = this.reconcilePicture(model.picture, options);
-    }
-}
-export { TwoCellAnchorXform };

package/dist/esm/xlsx/xform/list-xform.js

@@ -1,89 +0,0 @@
-import { BaseXform } from "./base-xform.js";
-class ListXform extends BaseXform {
-    constructor(options) {
-        super();
-        this.tag = options.tag;
-        this.always = !!options.always;
-        this.count = options.count;
-        this.empty = options.empty;
-        this.$count = options.$count || "count";
-        this.$ = options.$;
-        this.childXform = options.childXform;
-        this.maxItems = options.maxItems;
-    }
-    prepare(model, options) {
-        const { childXform } = this;
-        if (model) {
-            model.forEach((childModel, index) => {
-                options.index = index;
-                childXform.prepare(childModel, options);
-            });
-        }
-    }
-    render(xmlStream, model) {
-        if (this.always || (model && model.length)) {
-            xmlStream.openNode(this.tag, this.$);
-            if (this.count) {
-                xmlStream.addAttribute(this.$count, (model && model.length) || 0);
-            }
-            const { childXform } = this;
-            (model || []).forEach((childModel, index) => {
-                childXform.render(xmlStream, childModel, index);
-            });
-            xmlStream.closeNode();
-        }
-        else if (this.empty) {
-            xmlStream.leafNode(this.tag);
-        }
-    }
-    parseOpen(node) {
-        if (this.parser) {
-            this.parser.parseOpen(node);
-            return true;
-        }
-        switch (node.name) {
-            case this.tag:
-                this.model = [];
-                return true;
-            default:
-                if (this.childXform.parseOpen(node)) {
-                    this.parser = this.childXform;
-                    return true;
-                }
-                return false;
-        }
-    }
-    parseText(text) {
-        if (this.parser) {
-            this.parser.parseText(text);
-        }
-    }
-    parseClose(name) {
-        if (this.parser) {
-            if (!this.parser.parseClose(name)) {
-                this.model.push(this.parser.model);
-                this.parser = undefined;
-                if (this.maxItems && this.model.length > this.maxItems) {
-                    throw new Error(`Max ${this.childXform.tag} count (${this.maxItems}) exceeded`);
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-    reconcile(model, options) {
-        if (model) {
-            const { childXform } = this;
-            model.forEach((childModel) => {
-                childXform.reconcile(childModel, options);
-            });
-        }
-    }
-    reset() {
-        super.reset();
-        if (this.childXform) {
-            this.childXform.reset();
-        }
-    }
-}
-export { ListXform };

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

@@ -1,128 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { xmlDecode } from "../../../utils/utils.js";
-/**
- * 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/xlsx/xform/pivot-table/cache-field.js

@@ -1,78 +0,0 @@
-import { xmlEncode } from "../../../utils/utils.js";
-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/xlsx/xform/pivot-table/pivot-cache-definition-xform.js

@@ -1,179 +0,0 @@
-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 };