@cj-tech-master/excelts 4.0.0 → 4.0.1

package/dist/browser/modules/excel/xlsx/xform/drawing/pic-xform.d.ts

@@ -0,0 +1,22 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface PicModel {
+    index?: number;
+    [key: string]: any;
+}
+declare class PicXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: any;
+    constructor();
+    get tag(): string;
+    prepare(model: PicModel, options: {
+        index: number;
+    }): void;
+    render(xmlStream: any, model: PicModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { PicXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/pic-xform.js

@@ -0,0 +1,64 @@
+import { BaseXform } from "../base-xform.js";
+import { StaticXform } from "../static-xform.js";
+import { BlipFillXform } from "./blip-fill-xform.js";
+import { NvPicPrXform } from "./nv-pic-pr-xform.js";
+import { spPrJSON } from "./sp-pr.js";
+class PicXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:nvPicPr": new NvPicPrXform(),
+            "xdr:blipFill": new BlipFillXform(),
+            "xdr:spPr": new StaticXform(spPrJSON)
+        };
+    }
+    get tag() {
+        return "xdr:pic";
+    }
+    prepare(model, options) {
+        model.index = options.index + 1;
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        this.map["xdr:nvPicPr"].render(xmlStream, model);
+        this.map["xdr:blipFill"].render(xmlStream, model);
+        this.map["xdr:spPr"].render(xmlStream, model);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText() { }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.mergeModel(this.parser.model);
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                return false;
+            default:
+                // not quite sure how we get here!
+                return true;
+        }
+    }
+}
+export { PicXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/sp-pr.d.ts

@@ -0,0 +1,32 @@
+export declare const spPrJSON: {
+    tag: string;
+    c: ({
+        tag: string;
+        c: ({
+            tag: string;
+            $: {
+                x: string;
+                y: string;
+                cx?: undefined;
+                cy?: undefined;
+            };
+        } | {
+            tag: string;
+            $: {
+                cx: string;
+                cy: string;
+                x?: undefined;
+                y?: undefined;
+            };
+        })[];
+        $?: undefined;
+    } | {
+        tag: string;
+        $: {
+            prst: string;
+        };
+        c: {
+            tag: string;
+        }[];
+    })[];
+};

package/dist/browser/modules/excel/xlsx/xform/drawing/sp-pr.js

@@ -0,0 +1,17 @@
+export const spPrJSON = {
+    tag: "xdr:spPr",
+    c: [
+        {
+            tag: "a:xfrm",
+            c: [
+                { tag: "a:off", $: { x: "0", y: "0" } },
+                { tag: "a:ext", $: { cx: "0", cy: "0" } }
+            ]
+        },
+        {
+            tag: "a:prstGeom",
+            $: { prst: "rect" },
+            c: [{ tag: "a:avLst" }]
+        }
+    ]
+};

package/dist/browser/modules/excel/xlsx/xform/drawing/two-cell-anchor-xform.d.ts

@@ -0,0 +1,20 @@
+import { BaseCellAnchorXform } from "@excel/xlsx/xform/drawing/base-cell-anchor-xform";
+interface TwoCellModel {
+    range: {
+        editAs?: string;
+        tl: any;
+        br: any;
+    };
+    picture: any;
+}
+declare class TwoCellAnchorXform extends BaseCellAnchorXform {
+    constructor();
+    get tag(): string;
+    prepare(model: TwoCellModel, options: {
+        index: number;
+    }): void;
+    render(xmlStream: any, model: TwoCellModel): void;
+    parseClose(name: string): boolean;
+    reconcile(model: any, options: any): void;
+}
+export { TwoCellAnchorXform };

package/dist/browser/modules/excel/xlsx/xform/drawing/two-cell-anchor-xform.js

@@ -0,0 +1,51 @@
+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/browser/modules/excel/xlsx/xform/list-xform.d.ts

@@ -0,0 +1,32 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface ListXformOptions {
+    tag: string;
+    always?: boolean;
+    count?: boolean;
+    empty?: boolean;
+    $count?: string;
+    $?: any;
+    childXform: any;
+    maxItems?: number;
+}
+declare class ListXform extends BaseXform {
+    protected tag: string;
+    protected always: boolean;
+    protected count?: boolean;
+    protected empty?: boolean;
+    $count: string;
+    $?: any;
+    protected childXform: any;
+    protected maxItems?: number;
+    parser: any;
+    model: any[];
+    constructor(options: ListXformOptions);
+    prepare(model: any[], options: any): void;
+    render(xmlStream: any, model?: any[]): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: any[], options: any): void;
+    reset(): void;
+}
+export { ListXform };

package/dist/browser/modules/excel/xlsx/xform/list-xform.js

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

@@ -0,0 +1,42 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+/**
+ * Parsed cache field model containing name and shared items (if any)
+ */
+interface CacheFieldModel {
+    name: string;
+    sharedItems: any[] | null;
+    containsNumber?: boolean;
+    containsInteger?: boolean;
+    minValue?: number;
+    maxValue?: number;
+}
+/**
+ * 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>
+ * ```
+ */
+declare class CacheFieldXform extends BaseXform {
+    model: CacheFieldModel | null;
+    private inSharedItems;
+    constructor();
+    get tag(): string;
+    reset(): void;
+    parseOpen(node: any): boolean;
+    parseText(_text: string): void;
+    parseClose(name: string): boolean;
+}
+export { CacheFieldXform, type CacheFieldModel };

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

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

@@ -0,0 +1,15 @@
+interface CacheFieldConfig {
+    name: string;
+    sharedItems: any[] | null;
+    minValue?: number;
+    maxValue?: number;
+}
+declare class CacheField {
+    private name;
+    private sharedItems;
+    private minValue?;
+    private maxValue?;
+    constructor({ name, sharedItems, minValue, maxValue }: CacheFieldConfig);
+    render(): string;
+}
+export { CacheField };

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

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

@@ -0,0 +1,60 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { type CacheFieldModel } from "@excel/xlsx/xform/pivot-table/cache-field-xform";
+import type { PivotTableSource } from "@excel/pivot-table";
+/**
+ * Model for parsed pivot cache definition
+ */
+interface ParsedCacheDefinitionModel {
+    sourceRef?: string;
+    sourceSheet?: string;
+    cacheFields: CacheFieldModel[];
+    recordCount?: number;
+    rId?: string;
+    refreshOnLoad?: string;
+    createdVersion?: string;
+    refreshedVersion?: string;
+    minRefreshableVersion?: string;
+    isLoaded?: boolean;
+}
+/**
+ * Model for generating pivot cache definition (with live source)
+ */
+interface CacheDefinitionModel {
+    source: PivotTableSource;
+    cacheFields: any[];
+}
+declare class PivotCacheDefinitionXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    model: ParsedCacheDefinitionModel | null;
+    private currentCacheField;
+    private inCacheFields;
+    private inCacheSource;
+    constructor();
+    prepare(_model: any): void;
+    get tag(): string;
+    reset(): void;
+    /**
+     * Render pivot cache definition XML.
+     * Supports both newly created models (with PivotTableSource) and loaded models.
+     */
+    render(xmlStream: any, model: CacheDefinitionModel | ParsedCacheDefinitionModel): void;
+    /**
+     * Render newly created pivot cache definition
+     */
+    private renderNew;
+    /**
+     * Render loaded pivot cache definition (preserving original structure)
+     */
+    private renderLoaded;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(_model: any, _options: any): void;
+    static PIVOT_CACHE_DEFINITION_ATTRIBUTES: {
+        xmlns: string;
+        "xmlns:r": string;
+    };
+}
+export { PivotCacheDefinitionXform, type ParsedCacheDefinitionModel };