@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/cjs/xlsx/xform/sheet/page-breaks-xform.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageBreaksXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class PageBreaksXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "brk";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode("brk", model);
+    }
+    parseOpen(node) {
+        if (node.name === "brk") {
+            this.model = node.attributes.ref;
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.PageBreaksXform = PageBreaksXform;

package/dist/cjs/xlsx/xform/sheet/page-margins-xform.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageMarginsXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class PageMarginsXform extends base_xform_js_1.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;
+    }
+}
+exports.PageMarginsXform = PageMarginsXform;

package/dist/cjs/xlsx/xform/sheet/page-setup-properties-xform.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageSetupPropertiesXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class PageSetupPropertiesXform extends base_xform_js_1.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;
+    }
+}
+exports.PageSetupPropertiesXform = PageSetupPropertiesXform;

package/dist/cjs/xlsx/xform/sheet/page-setup-xform.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageSetupXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+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 base_xform_js_1.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),
+                scale: model.scale,
+                fitToWidth: model.fitToWidth,
+                fitToHeight: model.fitToHeight,
+                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;
+    }
+}
+exports.PageSetupXform = PageSetupXform;

package/dist/cjs/xlsx/xform/sheet/picture-xform.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PictureXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class PictureXform extends base_xform_js_1.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;
+    }
+}
+exports.PictureXform = PictureXform;

package/dist/cjs/xlsx/xform/sheet/print-options-xform.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrintOptionsXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+function booleanToXml(model) {
+    return model ? "1" : undefined;
+}
+class PrintOptionsXform extends base_xform_js_1.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;
+    }
+}
+exports.PrintOptionsXform = PrintOptionsXform;

package/dist/cjs/xlsx/xform/sheet/row-breaks-xform.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowBreaksXform = void 0;
+const page_breaks_xform_js_1 = require("./page-breaks-xform");
+const list_xform_js_1 = require("../list-xform");
+class RowBreaksXform extends list_xform_js_1.ListXform {
+    constructor() {
+        const options = {
+            tag: "rowBreaks",
+            count: true,
+            childXform: new page_breaks_xform_js_1.PageBreaksXform()
+        };
+        super(options);
+    }
+    // get tag() { return 'rowBreaks'; }
+    render(xmlStream, model) {
+        if (model && model.length) {
+            xmlStream.openNode(this.tag, this.$);
+            if (this.count) {
+                xmlStream.addAttribute(this.$count, model.length);
+                xmlStream.addAttribute("manualBreakCount", model.length);
+            }
+            const { childXform } = this;
+            model.forEach((childModel) => {
+                childXform.render(xmlStream, childModel);
+            });
+            xmlStream.closeNode();
+        }
+        else if (this.empty) {
+            xmlStream.leafNode(this.tag);
+        }
+    }
+}
+exports.RowBreaksXform = RowBreaksXform;

package/dist/cjs/xlsx/xform/sheet/row-xform.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const cell_xform_js_1 = require("./cell-xform");
+const utils_js_1 = require("../../../utils/utils");
+class RowXform extends base_xform_js_1.BaseXform {
+    constructor(options) {
+        super();
+        this.maxItems = options && options.maxItems;
+        this.map = {
+            c: new cell_xform_js_1.CellXform()
+        };
+    }
+    get tag() {
+        return "row";
+    }
+    prepare(model, options) {
+        const styleId = options.styles.addStyleModel(model.style);
+        if (styleId) {
+            model.styleId = styleId;
+        }
+        const cellXform = this.map.c;
+        model.cells.forEach((cellModel) => {
+            cellXform.prepare(cellModel, options);
+        });
+    }
+    render(xmlStream, model, options) {
+        if (!model) {
+            return;
+        }
+        xmlStream.openNode("row");
+        xmlStream.addAttribute("r", model.number);
+        if (model.height) {
+            xmlStream.addAttribute("ht", model.height);
+            xmlStream.addAttribute("customHeight", "1");
+        }
+        if (model.hidden) {
+            xmlStream.addAttribute("hidden", "1");
+        }
+        if (model.min > 0 && model.max > 0 && model.min <= model.max) {
+            xmlStream.addAttribute("spans", `${model.min}:${model.max}`);
+        }
+        if (model.styleId) {
+            xmlStream.addAttribute("s", model.styleId);
+            xmlStream.addAttribute("customFormat", "1");
+        }
+        xmlStream.addAttribute("x14ac:dyDescent", "0.25");
+        if (model.outlineLevel) {
+            xmlStream.addAttribute("outlineLevel", model.outlineLevel);
+        }
+        if (model.collapsed) {
+            xmlStream.addAttribute("collapsed", "1");
+        }
+        const cellXform = this.map.c;
+        model.cells.forEach((cellModel) => {
+            cellXform.render(xmlStream, cellModel, options);
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        if (node.name === "row") {
+            this.numRowsSeen += 1;
+            const spans = node.attributes.spans
+                ? node.attributes.spans.split(":").map((span) => parseInt(span, 10))
+                : [undefined, undefined];
+            const model = (this.model = {
+                number: parseInt(node.attributes.r, 10),
+                min: spans[0],
+                max: spans[1],
+                cells: []
+            });
+            if (node.attributes.s) {
+                model.styleId = parseInt(node.attributes.s, 10);
+            }
+            if ((0, utils_js_1.parseBoolean)(node.attributes.hidden)) {
+                model.hidden = true;
+            }
+            if ((0, utils_js_1.parseBoolean)(node.attributes.bestFit)) {
+                model.bestFit = true;
+            }
+            if (node.attributes.ht) {
+                model.height = parseFloat(node.attributes.ht);
+            }
+            if (node.attributes.outlineLevel) {
+                model.outlineLevel = parseInt(node.attributes.outlineLevel, 10);
+            }
+            if ((0, utils_js_1.parseBoolean)(node.attributes.collapsed)) {
+                model.collapsed = true;
+            }
+            return true;
+        }
+        this.parser = this.map[node.name];
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            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.cells.push(this.parser.model);
+                if (this.maxItems && this.model.cells.length > this.maxItems) {
+                    throw new Error(`Max column count (${this.maxItems}) exceeded`);
+                }
+                this.parser = undefined;
+            }
+            return true;
+        }
+        return false;
+    }
+    reconcile(model, options) {
+        model.style = model.styleId ? options.styles.getStyleModel(model.styleId) : {};
+        if (model.styleId !== undefined) {
+            model.styleId = undefined;
+        }
+        const cellXform = this.map.c;
+        model.cells.forEach((cellModel) => {
+            cellXform.reconcile(cellModel, options);
+        });
+    }
+}
+exports.RowXform = RowXform;

package/dist/cjs/xlsx/xform/sheet/sheet-format-properties-xform.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SheetFormatPropertiesXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class SheetFormatPropertiesXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "sheetFormatPr";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            const attributes = {
+                defaultRowHeight: model.defaultRowHeight,
+                outlineLevelRow: model.outlineLevelRow,
+                outlineLevelCol: model.outlineLevelCol,
+                "x14ac:dyDescent": model.dyDescent
+            };
+            if (model.defaultColWidth) {
+                attributes.defaultColWidth = model.defaultColWidth;
+            }
+            // default value for 'defaultRowHeight' is 15, this should not be 'custom'
+            if (!model.defaultRowHeight || model.defaultRowHeight !== 15) {
+                attributes.customHeight = "1";
+            }
+            if (Object.values(attributes).some((value) => value !== undefined)) {
+                xmlStream.leafNode("sheetFormatPr", attributes);
+            }
+        }
+    }
+    parseOpen(node) {
+        if (node.name === "sheetFormatPr") {
+            this.model = {
+                defaultRowHeight: parseFloat(node.attributes.defaultRowHeight || "0"),
+                dyDescent: parseFloat(node.attributes["x14ac:dyDescent"] || "0"),
+                outlineLevelRow: parseInt(node.attributes.outlineLevelRow || "0", 10),
+                outlineLevelCol: parseInt(node.attributes.outlineLevelCol || "0", 10)
+            };
+            if (node.attributes.defaultColWidth) {
+                this.model.defaultColWidth = parseFloat(node.attributes.defaultColWidth);
+            }
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.SheetFormatPropertiesXform = SheetFormatPropertiesXform;

package/dist/cjs/xlsx/xform/sheet/sheet-properties-xform.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SheetPropertiesXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const color_xform_js_1 = require("../style/color-xform");
+const page_setup_properties_xform_js_1 = require("./page-setup-properties-xform");
+const outline_properties_xform_js_1 = require("./outline-properties-xform");
+class SheetPropertiesXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            tabColor: new color_xform_js_1.ColorXform("tabColor"),
+            pageSetUpPr: new page_setup_properties_xform_js_1.PageSetupPropertiesXform(),
+            outlinePr: new outline_properties_xform_js_1.OutlinePropertiesXform()
+        };
+    }
+    get tag() {
+        return "sheetPr";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            xmlStream.addRollback();
+            xmlStream.openNode("sheetPr");
+            let inner = false;
+            inner = this.map.tabColor.render(xmlStream, model.tabColor) || inner;
+            inner = this.map.pageSetUpPr.render(xmlStream, model.pageSetup) || inner;
+            inner = this.map.outlinePr.render(xmlStream, model.outlineProperties) || inner;
+            if (inner) {
+                xmlStream.closeNode();
+                xmlStream.commit();
+            }
+            else {
+                xmlStream.rollback();
+            }
+        }
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        if (node.name === this.tag) {
+            this.reset();
+            return true;
+        }
+        if (this.map[node.name]) {
+            this.parser = this.map[node.name];
+            this.parser.parseOpen(node);
+            return true;
+        }
+        return false;
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+            return true;
+        }
+        return false;
+    }
+    parseClose(_name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(_name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        if (this.map.tabColor.model || this.map.pageSetUpPr.model || this.map.outlinePr.model) {
+            this.model = {};
+            if (this.map.tabColor.model) {
+                this.model.tabColor = this.map.tabColor.model;
+            }
+            if (this.map.pageSetUpPr.model) {
+                this.model.pageSetup = this.map.pageSetUpPr.model;
+            }
+            if (this.map.outlinePr.model) {
+                this.model.outlineProperties = this.map.outlinePr.model;
+            }
+        }
+        else {
+            this.model = null;
+        }
+        return false;
+    }
+}
+exports.SheetPropertiesXform = SheetPropertiesXform;

package/dist/cjs/xlsx/xform/sheet/sheet-protection-xform.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SheetProtectionXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+function booleanToXml(model, value) {
+    return model ? value : undefined;
+}
+function xmlToBoolean(value, equals) {
+    return value === equals ? true : undefined;
+}
+class SheetProtectionXform extends base_xform_js_1.BaseXform {
+    get tag() {
+        return "sheetProtection";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            const attributes = {
+                sheet: booleanToXml(model.sheet, "1"),
+                selectLockedCells: model.selectLockedCells === false ? "1" : undefined,
+                selectUnlockedCells: model.selectUnlockedCells === false ? "1" : undefined,
+                formatCells: booleanToXml(model.formatCells, "0"),
+                formatColumns: booleanToXml(model.formatColumns, "0"),
+                formatRows: booleanToXml(model.formatRows, "0"),
+                insertColumns: booleanToXml(model.insertColumns, "0"),
+                insertRows: booleanToXml(model.insertRows, "0"),
+                insertHyperlinks: booleanToXml(model.insertHyperlinks, "0"),
+                deleteColumns: booleanToXml(model.deleteColumns, "0"),
+                deleteRows: booleanToXml(model.deleteRows, "0"),
+                sort: booleanToXml(model.sort, "0"),
+                autoFilter: booleanToXml(model.autoFilter, "0"),
+                pivotTables: booleanToXml(model.pivotTables, "0")
+            };
+            if (model.sheet) {
+                attributes.algorithmName = model.algorithmName;
+                attributes.hashValue = model.hashValue;
+                attributes.saltValue = model.saltValue;
+                attributes.spinCount = model.spinCount;
+                attributes.objects = booleanToXml(model.objects === false, "1");
+                attributes.scenarios = booleanToXml(model.scenarios === false, "1");
+            }
+            if (Object.values(attributes).some((value) => value !== undefined)) {
+                xmlStream.leafNode(this.tag, attributes);
+            }
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    sheet: xmlToBoolean(node.attributes.sheet, "1"),
+                    objects: node.attributes.objects === "1" ? false : undefined,
+                    scenarios: node.attributes.scenarios === "1" ? false : undefined,
+                    selectLockedCells: node.attributes.selectLockedCells === "1" ? false : undefined,
+                    selectUnlockedCells: node.attributes.selectUnlockedCells === "1" ? false : undefined,
+                    formatCells: xmlToBoolean(node.attributes.formatCells, "0"),
+                    formatColumns: xmlToBoolean(node.attributes.formatColumns, "0"),
+                    formatRows: xmlToBoolean(node.attributes.formatRows, "0"),
+                    insertColumns: xmlToBoolean(node.attributes.insertColumns, "0"),
+                    insertRows: xmlToBoolean(node.attributes.insertRows, "0"),
+                    insertHyperlinks: xmlToBoolean(node.attributes.insertHyperlinks, "0"),
+                    deleteColumns: xmlToBoolean(node.attributes.deleteColumns, "0"),
+                    deleteRows: xmlToBoolean(node.attributes.deleteRows, "0"),
+                    sort: xmlToBoolean(node.attributes.sort, "0"),
+                    autoFilter: xmlToBoolean(node.attributes.autoFilter, "0"),
+                    pivotTables: xmlToBoolean(node.attributes.pivotTables, "0")
+                };
+                if (node.attributes.algorithmName) {
+                    this.model.algorithmName = node.attributes.algorithmName;
+                    this.model.hashValue = node.attributes.hashValue;
+                    this.model.saltValue = node.attributes.saltValue;
+                    this.model.spinCount = parseInt(node.attributes.spinCount, 10);
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.SheetProtectionXform = SheetProtectionXform;