@cj-tech-master/excelts 4.0.0 → 4.0.1-canary.20260104072032.0453bbe

package/dist/browser/modules/excel/xlsx/xform/sheet/hyperlink-xform.js

@@ -0,0 +1,47 @@
+import { BaseXform } from "../base-xform.js";
+class HyperlinkXform extends BaseXform {
+    get tag() {
+        return "hyperlink";
+    }
+    render(xmlStream, model) {
+        if (this.isInternalLink(model)) {
+            xmlStream.leafNode("hyperlink", {
+                ref: model.address,
+                "r:id": model.rId,
+                tooltip: model.tooltip,
+                location: model.target
+            });
+        }
+        else {
+            xmlStream.leafNode("hyperlink", {
+                ref: model.address,
+                "r:id": model.rId,
+                tooltip: model.tooltip
+            });
+        }
+    }
+    parseOpen(node) {
+        if (node.name === "hyperlink") {
+            this.model = {
+                address: node.attributes.ref,
+                rId: node.attributes["r:id"],
+                tooltip: node.attributes.tooltip
+            };
+            // This is an internal link
+            if (node.attributes.location) {
+                this.model.target = node.attributes.location;
+            }
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+    isInternalLink(model) {
+        // @example: Sheet2!D3, return true
+        return !!(model.target && /^[^!]+![a-zA-Z]+[\d]+$/.test(model.target));
+    }
+}
+export { HyperlinkXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/merge-cell-xform.d.ts

@@ -0,0 +1,9 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare class MergeCellXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: string): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { MergeCellXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/merge-cell-xform.js

@@ -0,0 +1,21 @@
+import { BaseXform } from "../base-xform.js";
+class MergeCellXform extends BaseXform {
+    get tag() {
+        return "mergeCell";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode("mergeCell", { ref: model });
+    }
+    parseOpen(node) {
+        if (node.name === "mergeCell") {
+            this.model = node.attributes.ref;
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { MergeCellXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/merges.d.ts

@@ -0,0 +1,14 @@
+interface MergeData {
+    address: string;
+    master: string;
+}
+declare class Merges {
+    private merges;
+    private hash?;
+    constructor();
+    add(merge: MergeData): void;
+    get mergeCells(): string[];
+    reconcile(mergeCells: string[], rows: any[]): void;
+    getMasterAddress(address: string): string | undefined;
+}
+export { Merges };

package/dist/browser/modules/excel/xlsx/xform/sheet/merges.js

@@ -0,0 +1,50 @@
+import { Range } from "../../../range.js";
+import { colCache } from "../../../utils/col-cache.js";
+import { Enums } from "../../../enums.js";
+class Merges {
+    constructor() {
+        // optional mergeCells is array of ranges (like the xml)
+        this.merges = {};
+    }
+    add(merge) {
+        // merge is {address, master}
+        if (this.merges[merge.master]) {
+            this.merges[merge.master].expandToAddress(merge.address);
+        }
+        else {
+            const range = `${merge.master}:${merge.address}`;
+            this.merges[merge.master] = new Range(range);
+        }
+    }
+    get mergeCells() {
+        return Object.values(this.merges).map((merge) => merge.range);
+    }
+    reconcile(mergeCells, rows) {
+        // reconcile merge list with merge cells
+        mergeCells.forEach((merge) => {
+            const dimensions = colCache.decode(merge);
+            for (let i = dimensions.top; i <= dimensions.bottom; i++) {
+                const row = rows[i - 1];
+                for (let j = dimensions.left; j <= dimensions.right; j++) {
+                    const cell = row.cells[j - 1];
+                    if (!cell) {
+                        // nulls are not included in document - so if master cell has no value - add a null one here
+                        row.cells[j] = {
+                            type: Enums.ValueType.Null,
+                            address: colCache.encodeAddress(i, j)
+                        };
+                    }
+                    else if (cell.type === Enums.ValueType.Merge) {
+                        cell.master = dimensions.tl;
+                    }
+                }
+            }
+        });
+    }
+    getMasterAddress(address) {
+        // if address has been merged, return its master's address. Assumes reconcile has been called
+        const range = this.hash[address];
+        return range && range.tl;
+    }
+}
+export { Merges };

package/dist/browser/modules/excel/xlsx/xform/sheet/outline-properties-xform.d.ts

@@ -0,0 +1,13 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface OutlinePropertiesModel {
+    summaryBelow?: boolean;
+    summaryRight?: boolean;
+}
+declare class OutlinePropertiesXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: OutlinePropertiesModel): boolean;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { OutlinePropertiesXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/outline-properties-xform.js

@@ -0,0 +1,36 @@
+import { BaseXform } from "../base-xform.js";
+const isDefined = (attr) => typeof attr !== "undefined";
+class OutlinePropertiesXform extends BaseXform {
+    get tag() {
+        return "outlinePr";
+    }
+    render(xmlStream, model) {
+        if (model && (isDefined(model.summaryBelow) || isDefined(model.summaryRight))) {
+            xmlStream.leafNode(this.tag, {
+                summaryBelow: isDefined(model.summaryBelow) ? Number(model.summaryBelow) : undefined,
+                summaryRight: isDefined(model.summaryRight) ? Number(model.summaryRight) : undefined
+            });
+            return true;
+        }
+        return false;
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            this.model = {
+                summaryBelow: isDefined(node.attributes.summaryBelow)
+                    ? Boolean(Number(node.attributes.summaryBelow))
+                    : undefined,
+                summaryRight: isDefined(node.attributes.summaryRight)
+                    ? Boolean(Number(node.attributes.summaryRight))
+                    : undefined
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { OutlinePropertiesXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/page-breaks-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+/**
+ * Xform for individual page break (brk element)
+ * Used by both RowBreaksXform and ColBreaksXform
+ */
+declare class PageBreaksXform extends BaseXform {
+    model: any;
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PageBreaksXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/page-breaks-xform.js

@@ -0,0 +1,33 @@
+import { BaseXform } from "../base-xform.js";
+/**
+ * Xform for individual page break (brk element)
+ * Used by both RowBreaksXform and ColBreaksXform
+ */
+class PageBreaksXform extends BaseXform {
+    get tag() {
+        return "brk";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode("brk", model);
+    }
+    parseOpen(node) {
+        if (node.name === "brk") {
+            const { id, max, man, min } = node.attributes;
+            this.model = {
+                id: +id,
+                max: +max,
+                man: +man
+            };
+            if (min !== undefined) {
+                this.model.min = +min;
+            }
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { PageBreaksXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/page-margins-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface PageMarginsModel {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    header?: number;
+    footer?: number;
+}
+declare class PageMarginsXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: PageMarginsModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PageMarginsXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/page-margins-xform.js

@@ -0,0 +1,42 @@
+import { BaseXform } from "../base-xform.js";
+class PageMarginsXform extends BaseXform {
+    get tag() {
+        return "pageMargins";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            const attributes = {
+                left: model.left,
+                right: model.right,
+                top: model.top,
+                bottom: model.bottom,
+                header: model.header,
+                footer: model.footer
+            };
+            if (Object.values(attributes).some((value) => value !== undefined)) {
+                xmlStream.leafNode(this.tag, attributes);
+            }
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    left: parseFloat(node.attributes.left || 0.7),
+                    right: parseFloat(node.attributes.right || 0.7),
+                    top: parseFloat(node.attributes.top || 0.75),
+                    bottom: parseFloat(node.attributes.bottom || 0.75),
+                    header: parseFloat(node.attributes.header || 0.3),
+                    footer: parseFloat(node.attributes.footer || 0.3)
+                };
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { PageMarginsXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/page-setup-properties-xform.d.ts

@@ -0,0 +1,12 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface PageSetupPropertiesModel {
+    fitToPage: boolean;
+}
+declare class PageSetupPropertiesXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: PageSetupPropertiesModel): boolean;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PageSetupPropertiesXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/page-setup-properties-xform.js

@@ -0,0 +1,29 @@
+import { BaseXform } from "../base-xform.js";
+class PageSetupPropertiesXform extends BaseXform {
+    get tag() {
+        return "pageSetUpPr";
+    }
+    render(xmlStream, model) {
+        if (model && model.fitToPage) {
+            xmlStream.leafNode(this.tag, {
+                fitToPage: model.fitToPage ? "1" : undefined
+            });
+            return true;
+        }
+        return false;
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            this.model = {
+                fitToPage: node.attributes.fitToPage === "1"
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { PageSetupPropertiesXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/page-setup-xform.d.ts

@@ -0,0 +1,27 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface PageSetupModel {
+    paperSize?: number;
+    orientation?: string;
+    horizontalDpi?: number;
+    verticalDpi?: number;
+    pageOrder?: string;
+    blackAndWhite?: boolean;
+    draft?: boolean;
+    cellComments?: string;
+    errors?: string;
+    scale?: number;
+    fitToWidth?: number;
+    fitToHeight?: number;
+    firstPageNumber?: number;
+    useFirstPageNumber?: boolean;
+    usePrinterDefaults?: boolean;
+    copies?: number;
+}
+declare class PageSetupXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: PageSetupModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PageSetupXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/page-setup-xform.js

@@ -0,0 +1,96 @@
+import { BaseXform } from "../base-xform.js";
+function booleanToXml(model) {
+    return model ? "1" : undefined;
+}
+function pageOrderToXml(model) {
+    switch (model) {
+        case "overThenDown":
+            return model;
+        default:
+            return undefined;
+    }
+}
+function cellCommentsToXml(model) {
+    switch (model) {
+        case "atEnd":
+        case "asDisplyed":
+            return model;
+        default:
+            return undefined;
+    }
+}
+function errorsToXml(model) {
+    switch (model) {
+        case "dash":
+        case "blank":
+        case "NA":
+            return model;
+        default:
+            return undefined;
+    }
+}
+function pageSizeToModel(value) {
+    return value !== undefined ? parseInt(value, 10) : undefined;
+}
+class PageSetupXform extends BaseXform {
+    get tag() {
+        return "pageSetup";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            const attributes = {
+                paperSize: model.paperSize,
+                orientation: model.orientation,
+                horizontalDpi: model.horizontalDpi,
+                verticalDpi: model.verticalDpi,
+                pageOrder: pageOrderToXml(model.pageOrder),
+                blackAndWhite: booleanToXml(model.blackAndWhite),
+                draft: booleanToXml(model.draft),
+                cellComments: cellCommentsToXml(model.cellComments),
+                errors: errorsToXml(model.errors),
+                // Only output non-default values (matches Excel behavior)
+                scale: model.scale !== 100 ? model.scale : undefined,
+                fitToWidth: model.fitToWidth !== 1 ? model.fitToWidth : undefined,
+                fitToHeight: model.fitToHeight !== 1 ? model.fitToHeight : undefined,
+                firstPageNumber: model.firstPageNumber,
+                useFirstPageNumber: booleanToXml(!!model.firstPageNumber),
+                usePrinterDefaults: booleanToXml(model.usePrinterDefaults),
+                copies: model.copies
+            };
+            if (Object.values(attributes).some((value) => value !== undefined)) {
+                xmlStream.leafNode(this.tag, attributes);
+            }
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    paperSize: pageSizeToModel(node.attributes.paperSize),
+                    orientation: node.attributes.orientation || "portrait",
+                    horizontalDpi: parseInt(node.attributes.horizontalDpi || "4294967295", 10),
+                    verticalDpi: parseInt(node.attributes.verticalDpi || "4294967295", 10),
+                    pageOrder: node.attributes.pageOrder || "downThenOver",
+                    blackAndWhite: node.attributes.blackAndWhite === "1",
+                    draft: node.attributes.draft === "1",
+                    cellComments: node.attributes.cellComments || "None",
+                    errors: node.attributes.errors || "displayed",
+                    scale: parseInt(node.attributes.scale || "100", 10),
+                    fitToWidth: parseInt(node.attributes.fitToWidth || "1", 10),
+                    fitToHeight: parseInt(node.attributes.fitToHeight || "1", 10),
+                    firstPageNumber: parseInt(node.attributes.firstPageNumber || "1", 10),
+                    useFirstPageNumber: node.attributes.useFirstPageNumber === "1",
+                    usePrinterDefaults: node.attributes.usePrinterDefaults === "1",
+                    copies: parseInt(node.attributes.copies || "1", 10)
+                };
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { PageSetupXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/picture-xform.d.ts

@@ -0,0 +1,12 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface PictureModel {
+    rId: string;
+}
+declare class PictureXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: PictureModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PictureXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/picture-xform.js

@@ -0,0 +1,27 @@
+import { BaseXform } from "../base-xform.js";
+class PictureXform extends BaseXform {
+    get tag() {
+        return "picture";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            xmlStream.leafNode(this.tag, { "r:id": model.rId });
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    rId: node.attributes["r:id"]
+                };
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { PictureXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/print-options-xform.d.ts

@@ -0,0 +1,15 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface PrintOptionsModel {
+    showRowColHeaders: boolean;
+    showGridLines: boolean;
+    horizontalCentered: boolean;
+    verticalCentered: boolean;
+}
+declare class PrintOptionsXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: PrintOptionsModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PrintOptionsXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/print-options-xform.js

@@ -0,0 +1,41 @@
+import { BaseXform } from "../base-xform.js";
+function booleanToXml(model) {
+    return model ? "1" : undefined;
+}
+class PrintOptionsXform extends BaseXform {
+    get tag() {
+        return "printOptions";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            const attributes = {
+                headings: booleanToXml(model.showRowColHeaders),
+                gridLines: booleanToXml(model.showGridLines),
+                horizontalCentered: booleanToXml(model.horizontalCentered),
+                verticalCentered: booleanToXml(model.verticalCentered)
+            };
+            if (Object.values(attributes).some((value) => value !== undefined)) {
+                xmlStream.leafNode(this.tag, attributes);
+            }
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    showRowColHeaders: node.attributes.headings === "1",
+                    showGridLines: node.attributes.gridLines === "1",
+                    horizontalCentered: node.attributes.horizontalCentered === "1",
+                    verticalCentered: node.attributes.verticalCentered === "1"
+                };
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { PrintOptionsXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/row-breaks-xform.d.ts

@@ -0,0 +1,10 @@
+import { ListXform } from "@excel/xlsx/xform/list-xform";
+/**
+ * Xform for row page breaks (rowBreaks element in worksheet XML)
+ * Used to define manual page breaks between rows when printing.
+ */
+declare class RowBreaksXform extends ListXform {
+    constructor();
+    render(xmlStream: any, model: any): void;
+}
+export { RowBreaksXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/row-breaks-xform.js

@@ -0,0 +1,29 @@
+import { PageBreaksXform } from "./page-breaks-xform.js";
+import { ListXform } from "../list-xform.js";
+/**
+ * Xform for row page breaks (rowBreaks element in worksheet XML)
+ * Used to define manual page breaks between rows when printing.
+ */
+class RowBreaksXform extends ListXform {
+    constructor() {
+        super({
+            tag: "rowBreaks",
+            count: true,
+            childXform: new PageBreaksXform()
+        });
+    }
+    // Override to add manualBreakCount attribute required by Excel
+    render(xmlStream, model) {
+        if (model && model.length) {
+            xmlStream.openNode(this.tag, this.$);
+            xmlStream.addAttribute(this.$count, model.length);
+            xmlStream.addAttribute("manualBreakCount", model.length);
+            const { childXform } = this;
+            for (const childModel of model) {
+                childXform.render(xmlStream, childModel);
+            }
+            xmlStream.closeNode();
+        }
+    }
+}
+export { RowBreaksXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/row-xform.d.ts

@@ -0,0 +1,37 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface RowXformOptions {
+    maxItems?: number;
+}
+interface RowModel {
+    number: number;
+    min?: number;
+    max?: number;
+    cells: any[];
+    styleId?: number;
+    hidden?: boolean;
+    bestFit?: boolean;
+    height?: number;
+    outlineLevel?: number;
+    collapsed?: boolean;
+    style?: any;
+}
+declare class RowXform extends BaseXform {
+    private maxItems?;
+    map: {
+        [key: string]: any;
+    };
+    model: RowModel;
+    parser: any;
+    private numRowsSeen;
+    private lastCellCol;
+    constructor(options?: RowXformOptions);
+    get tag(): string;
+    reset(): void;
+    prepare(model: RowModel, options: any): void;
+    render(xmlStream: any, model?: RowModel, options?: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: RowModel, options: any): void;
+}
+export { RowXform };