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

package/dist/cjs/xlsx/xform/base-xform.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseXform = void 0;
+const parse_sax_js_1 = require("../../utils/parse-sax");
+const xml_stream_js_1 = require("../../utils/xml-stream");
+// Base class for Xforms
+class BaseXform {
+    // ============================================================
+    // Virtual Interface
+    prepare(_model, _options) {
+        // optional preparation (mutation) of model so it is ready for write
+    }
+    render(_xmlStream, _model) {
+        // convert model to xml
+    }
+    parseOpen(_node) {
+        // XML node opened
+    }
+    parseText(_text) {
+        // chunk of text encountered for current node
+    }
+    parseClose(_name) {
+        // XML node closed
+        return false;
+    }
+    reconcile(_model, _options) {
+        // optional post-parse step (opposite to prepare)
+    }
+    // ============================================================
+    reset() {
+        // to make sure parses don't bleed to next iteration
+        this.model = null;
+        // if we have a map - reset them too
+        if (this.map) {
+            Object.values(this.map).forEach(xform => {
+                if (xform instanceof BaseXform) {
+                    xform.reset();
+                }
+                else if (xform.xform) {
+                    xform.xform.reset();
+                }
+            });
+        }
+    }
+    mergeModel(obj) {
+        // set obj's props to this.model
+        this.model = Object.assign(this.model || {}, obj);
+    }
+    async parse(saxParser) {
+        for await (const events of saxParser) {
+            for (const { eventType, value } of events) {
+                if (eventType === "opentag") {
+                    this.parseOpen(value);
+                }
+                else if (eventType === "text") {
+                    this.parseText(value);
+                }
+                else if (eventType === "closetag") {
+                    if (!this.parseClose(value.name)) {
+                        return this.model;
+                    }
+                }
+            }
+        }
+        return this.model;
+    }
+    async parseStream(stream) {
+        return this.parse((0, parse_sax_js_1.parseSax)(stream));
+    }
+    get xml() {
+        // convenience function to get the xml of this.model
+        // useful for manager types that are built during the prepare phase
+        return this.toXml(this.model);
+    }
+    toXml(model) {
+        const xmlStream = new xml_stream_js_1.XmlStream();
+        this.render(xmlStream, model);
+        return xmlStream.xml;
+    }
+    // ============================================================
+    // Useful Utilities
+    static toAttribute(value, dflt, always = false) {
+        if (value === undefined) {
+            if (always) {
+                return dflt;
+            }
+        }
+        else if (always || value !== dflt) {
+            return value.toString();
+        }
+        return undefined;
+    }
+    static toStringAttribute(value, dflt, always = false) {
+        return BaseXform.toAttribute(value, dflt, always);
+    }
+    static toStringValue(attr, dflt) {
+        return attr === undefined ? dflt : attr;
+    }
+    static toBoolAttribute(value, dflt, always = false) {
+        if (value === undefined) {
+            if (always) {
+                return dflt;
+            }
+        }
+        else if (always || value !== dflt) {
+            return value ? "1" : "0";
+        }
+        return undefined;
+    }
+    static toBoolValue(attr, dflt) {
+        return attr === undefined ? dflt : attr === "1";
+    }
+    static toIntAttribute(value, dflt, always = false) {
+        return BaseXform.toAttribute(value, dflt, always);
+    }
+    static toIntValue(attr, dflt) {
+        return attr === undefined ? dflt : parseInt(attr, 10);
+    }
+    static toFloatAttribute(value, dflt, always = false) {
+        return BaseXform.toAttribute(value, dflt, always);
+    }
+    static toFloatValue(attr, dflt) {
+        return attr === undefined ? dflt : parseFloat(attr);
+    }
+}
+exports.BaseXform = BaseXform;

package/dist/cjs/xlsx/xform/book/defined-name-xform.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinedNamesXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+const col_cache_js_1 = require("../../../utils/col-cache");
+class DefinedNamesXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this._parsedText = [];
+    }
+    render(xmlStream, model) {
+        // <definedNames>
+        //   <definedName name="name">name.ranges.join(',')</definedName>
+        //   <definedName name="_xlnm.Print_Area" localSheetId="0">name.ranges.join(',')</definedName>
+        // </definedNames>
+        xmlStream.openNode("definedName", {
+            name: model.name,
+            localSheetId: model.localSheetId
+        });
+        xmlStream.writeText(model.ranges.join(","));
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "definedName":
+                this._parsedName = node.attributes.name;
+                this._parsedLocalSheetId = node.attributes.localSheetId;
+                this._parsedText = [];
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText(text) {
+        this._parsedText.push(text);
+    }
+    parseClose() {
+        this.model = {
+            name: this._parsedName,
+            ranges: extractRanges(this._parsedText.join(""))
+        };
+        if (this._parsedLocalSheetId !== undefined) {
+            this.model.localSheetId = parseInt(this._parsedLocalSheetId, 10);
+        }
+        return false;
+    }
+}
+exports.DefinedNamesXform = DefinedNamesXform;
+function isValidRange(range) {
+    try {
+        col_cache_js_1.colCache.decodeEx(range);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function extractRanges(parsedText) {
+    const ranges = [];
+    let quotesOpened = false;
+    let last = "";
+    parsedText.split(",").forEach(item => {
+        if (!item) {
+            return;
+        }
+        const quotes = (item.match(/'/g) || []).length;
+        if (!quotes) {
+            if (quotesOpened) {
+                last += `${item},`;
+            }
+            else if (isValidRange(item)) {
+                ranges.push(item);
+            }
+            return;
+        }
+        const quotesEven = quotes % 2 === 0;
+        if (!quotesOpened && quotesEven && isValidRange(item)) {
+            ranges.push(item);
+        }
+        else if (quotesOpened && !quotesEven) {
+            quotesOpened = false;
+            if (isValidRange(last + item)) {
+                ranges.push(last + item);
+            }
+            last = "";
+        }
+        else {
+            quotesOpened = true;
+            last += `${item},`;
+        }
+    });
+    return ranges;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorksheetXform = void 0;
+const utils_js_1 = require("../../../utils/utils");
+const base_xform_js_1 = require("../base-xform");
+class WorksheetXform extends base_xform_js_1.BaseXform {
+    render(xmlStream, model) {
+        xmlStream.leafNode("sheet", {
+            sheetId: model.id,
+            name: model.name,
+            state: model.state,
+            "r:id": model.rId
+        });
+    }
+    parseOpen(node) {
+        if (node.name === "sheet") {
+            this.model = {
+                name: (0, utils_js_1.xmlDecode)(node.attributes.name),
+                id: parseInt(node.attributes.sheetId, 10),
+                state: node.attributes.state,
+                rId: node.attributes["r:id"]
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.WorksheetXform = WorksheetXform;

package/dist/cjs/xlsx/xform/book/workbook-calc-properties-xform.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbookCalcPropertiesXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class WorkbookCalcPropertiesXform extends base_xform_js_1.BaseXform {
+    render(xmlStream, model) {
+        xmlStream.leafNode("calcPr", {
+            calcId: 171027,
+            fullCalcOnLoad: model.fullCalcOnLoad ? 1 : undefined
+        });
+    }
+    parseOpen(node) {
+        if (node.name === "calcPr") {
+            this.model = {};
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.WorkbookCalcPropertiesXform = WorkbookCalcPropertiesXform;

package/dist/cjs/xlsx/xform/book/workbook-pivot-cache-xform.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbookPivotCacheXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class WorkbookPivotCacheXform extends base_xform_js_1.BaseXform {
+    render(xmlStream, model) {
+        xmlStream.leafNode("pivotCache", {
+            cacheId: model.cacheId,
+            "r:id": model.rId
+        });
+    }
+    parseOpen(node) {
+        if (node.name === "pivotCache") {
+            this.model = {
+                cacheId: node.attributes.cacheId,
+                rId: node.attributes["r:id"]
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.WorkbookPivotCacheXform = WorkbookPivotCacheXform;

package/dist/cjs/xlsx/xform/book/workbook-properties-xform.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbookPropertiesXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class WorkbookPropertiesXform extends base_xform_js_1.BaseXform {
+    render(xmlStream, model) {
+        xmlStream.leafNode("workbookPr", {
+            date1904: model.date1904 ? 1 : undefined,
+            defaultThemeVersion: 164011,
+            filterPrivacy: 1
+        });
+    }
+    parseOpen(node) {
+        if (node.name === "workbookPr") {
+            this.model = {
+                date1904: node.attributes.date1904 === "1"
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.WorkbookPropertiesXform = WorkbookPropertiesXform;

package/dist/cjs/xlsx/xform/book/workbook-view-xform.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbookViewXform = void 0;
+const base_xform_js_1 = require("../base-xform");
+class WorkbookViewXform extends base_xform_js_1.BaseXform {
+    render(xmlStream, model) {
+        const attributes = {
+            xWindow: model.x || 0,
+            yWindow: model.y || 0,
+            windowWidth: model.width || 12000,
+            windowHeight: model.height || 24000,
+            firstSheet: model.firstSheet,
+            activeTab: model.activeTab
+        };
+        if (model.visibility && model.visibility !== "visible") {
+            attributes.visibility = model.visibility;
+        }
+        xmlStream.leafNode("workbookView", attributes);
+    }
+    parseOpen(node) {
+        if (node.name === "workbookView") {
+            const model = (this.model = {});
+            const addS = function (name, value, dflt) {
+                const s = value !== undefined ? value : dflt;
+                model[name] = s;
+            };
+            const addN = function (name, value, dflt) {
+                const n = value !== undefined ? parseInt(value, 10) : dflt;
+                if (n !== undefined) {
+                    model[name] = n;
+                }
+            };
+            addN("x", node.attributes.xWindow, 0);
+            addN("y", node.attributes.yWindow, 0);
+            addN("width", node.attributes.windowWidth, 25000);
+            addN("height", node.attributes.windowHeight, 10000);
+            addS("visibility", node.attributes.visibility, "visible");
+            addN("activeTab", node.attributes.activeTab, undefined);
+            addN("firstSheet", node.attributes.firstSheet, undefined);
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+exports.WorkbookViewXform = WorkbookViewXform;

package/dist/cjs/xlsx/xform/book/workbook-xform.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbookXform = void 0;
+const col_cache_js_1 = require("../../../utils/col-cache");
+const xml_stream_js_1 = require("../../../utils/xml-stream");
+const base_xform_js_1 = require("../base-xform");
+const static_xform_js_1 = require("../static-xform");
+const list_xform_js_1 = require("../list-xform");
+const defined_name_xform_js_1 = require("./defined-name-xform");
+const sheet_xform_js_1 = require("./sheet-xform");
+const workbook_view_xform_js_1 = require("./workbook-view-xform");
+const workbook_properties_xform_js_1 = require("./workbook-properties-xform");
+const workbook_calc_properties_xform_js_1 = require("./workbook-calc-properties-xform");
+const workbook_pivot_cache_xform_js_1 = require("./workbook-pivot-cache-xform");
+class WorkbookXform extends base_xform_js_1.BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            fileVersion: WorkbookXform.STATIC_XFORMS.fileVersion,
+            workbookPr: new workbook_properties_xform_js_1.WorkbookPropertiesXform(),
+            bookViews: new list_xform_js_1.ListXform({
+                tag: "bookViews",
+                count: false,
+                childXform: new workbook_view_xform_js_1.WorkbookViewXform()
+            }),
+            sheets: new list_xform_js_1.ListXform({ tag: "sheets", count: false, childXform: new sheet_xform_js_1.WorksheetXform() }),
+            definedNames: new list_xform_js_1.ListXform({
+                tag: "definedNames",
+                count: false,
+                childXform: new defined_name_xform_js_1.DefinedNamesXform()
+            }),
+            calcPr: new workbook_calc_properties_xform_js_1.WorkbookCalcPropertiesXform(),
+            pivotCaches: new list_xform_js_1.ListXform({
+                tag: "pivotCaches",
+                count: false,
+                childXform: new workbook_pivot_cache_xform_js_1.WorkbookPivotCacheXform()
+            })
+        };
+    }
+    prepare(model) {
+        model.sheets = model.worksheets;
+        // collate all the print areas from all of the sheets and add them to the defined names
+        const printAreas = [];
+        let index = 0; // sheets is sparse array - calc index manually
+        model.sheets.forEach((sheet) => {
+            if (sheet.pageSetup && sheet.pageSetup.printArea) {
+                sheet.pageSetup.printArea.split("&&").forEach((printArea) => {
+                    const printAreaComponents = printArea.split(":");
+                    const definedName = {
+                        name: "_xlnm.Print_Area",
+                        ranges: [`'${sheet.name}'!$${printAreaComponents[0]}:$${printAreaComponents[1]}`],
+                        localSheetId: index
+                    };
+                    printAreas.push(definedName);
+                });
+            }
+            if (sheet.pageSetup &&
+                (sheet.pageSetup.printTitlesRow || sheet.pageSetup.printTitlesColumn)) {
+                const ranges = [];
+                if (sheet.pageSetup.printTitlesColumn) {
+                    const titlesColumns = sheet.pageSetup.printTitlesColumn.split(":");
+                    ranges.push(`'${sheet.name}'!$${titlesColumns[0]}:$${titlesColumns[1]}`);
+                }
+                if (sheet.pageSetup.printTitlesRow) {
+                    const titlesRows = sheet.pageSetup.printTitlesRow.split(":");
+                    ranges.push(`'${sheet.name}'!$${titlesRows[0]}:$${titlesRows[1]}`);
+                }
+                const definedName = {
+                    name: "_xlnm.Print_Titles",
+                    ranges,
+                    localSheetId: index
+                };
+                printAreas.push(definedName);
+            }
+            index++;
+        });
+        if (printAreas.length) {
+            model.definedNames = model.definedNames.concat(printAreas);
+        }
+        (model.media || []).forEach((medium, i) => {
+            // assign name
+            medium.name = medium.type + (i + 1);
+        });
+    }
+    render(xmlStream, model) {
+        xmlStream.openXml(xml_stream_js_1.XmlStream.StdDocAttributes);
+        xmlStream.openNode("workbook", WorkbookXform.WORKBOOK_ATTRIBUTES);
+        this.map.fileVersion.render(xmlStream);
+        this.map.workbookPr.render(xmlStream, model.properties);
+        this.map.bookViews.render(xmlStream, model.views);
+        this.map.sheets.render(xmlStream, model.sheets);
+        this.map.definedNames.render(xmlStream, model.definedNames);
+        this.map.calcPr.render(xmlStream, model.calcProperties);
+        this.map.pivotCaches.render(xmlStream, model.pivotTables);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case "workbook":
+                return true;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                return true;
+        }
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case "workbook":
+                this.model = {
+                    sheets: this.map.sheets.model,
+                    properties: this.map.workbookPr.model || {},
+                    views: this.map.bookViews.model,
+                    calcProperties: {}
+                };
+                if (this.map.definedNames.model) {
+                    this.model.definedNames = this.map.definedNames.model;
+                }
+                return false;
+            default:
+                // not quite sure how we get here!
+                return true;
+        }
+    }
+    reconcile(model) {
+        const rels = (model.workbookRels || []).reduce((map, rel) => {
+            map[rel.Id] = rel;
+            return map;
+        }, {});
+        // reconcile sheet ids, rIds and names
+        const worksheets = [];
+        let worksheet;
+        let index = 0;
+        (model.sheets || []).forEach((sheet) => {
+            const rel = rels[sheet.rId];
+            if (!rel) {
+                return;
+            }
+            // if rel.Target start with `[space]/xl/` or `/xl/` , then it will be replaced with `''` and spliced behind `xl/`,
+            // otherwise it will be spliced directly behind `xl/`. i.g.
+            worksheet = model.worksheetHash[`xl/${rel.Target.replace(/^(\s|\/xl\/)+/, "")}`];
+            // If there are "chartsheets" in the file, rel.Target will
+            // come out as chartsheets/sheet1.xml or similar here, and
+            // that won't be in model.worksheetHash.
+            // As we don't have the infrastructure to support chartsheets,
+            // we will ignore them for now:
+            if (worksheet) {
+                worksheet.name = sheet.name;
+                worksheet.id = sheet.id;
+                worksheet.state = sheet.state;
+                worksheets[index++] = worksheet;
+            }
+        });
+        // reconcile print areas
+        const definedNames = [];
+        if (model.definedNames) {
+            model.definedNames.forEach((definedName) => {
+                if (definedName.name === "_xlnm.Print_Area") {
+                    worksheet = worksheets[definedName.localSheetId];
+                    if (worksheet) {
+                        if (!worksheet.pageSetup) {
+                            worksheet.pageSetup = {};
+                        }
+                        const range = col_cache_js_1.colCache.decodeEx(definedName.ranges[0]);
+                        worksheet.pageSetup.printArea = worksheet.pageSetup.printArea
+                            ? `${worksheet.pageSetup.printArea}&&${range.dimensions}`
+                            : range.dimensions;
+                    }
+                }
+                else if (definedName.name === "_xlnm.Print_Titles") {
+                    worksheet = worksheets[definedName.localSheetId];
+                    if (worksheet) {
+                        if (!worksheet.pageSetup) {
+                            worksheet.pageSetup = {};
+                        }
+                        const rangeString = definedName.ranges.join(",");
+                        const dollarRegex = /\$/g;
+                        const rowRangeRegex = /\$\d+:\$\d+/;
+                        const rowRangeMatches = rangeString.match(rowRangeRegex);
+                        if (rowRangeMatches && rowRangeMatches.length) {
+                            const range = rowRangeMatches[0];
+                            worksheet.pageSetup.printTitlesRow = range.replace(dollarRegex, "");
+                        }
+                        const columnRangeRegex = /\$[A-Z]+:\$[A-Z]+/;
+                        const columnRangeMatches = rangeString.match(columnRangeRegex);
+                        if (columnRangeMatches && columnRangeMatches.length) {
+                            const range = columnRangeMatches[0];
+                            worksheet.pageSetup.printTitlesColumn = range.replace(dollarRegex, "");
+                        }
+                    }
+                }
+                else {
+                    definedNames.push(definedName);
+                }
+            });
+        }
+        model.definedNames = definedNames;
+        // used by sheets to build their image models
+        model.media.forEach((media, i) => {
+            media.index = i;
+        });
+    }
+}
+exports.WorkbookXform = WorkbookXform;
+WorkbookXform.WORKBOOK_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": "x15",
+    "xmlns:x15": "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main"
+};
+WorkbookXform.STATIC_XFORMS = {
+    fileVersion: new static_xform_js_1.StaticXform({
+        tag: "fileVersion",
+        $: { appName: "xl", lastEdited: 5, lowestEdited: 5, rupBuild: 9303 }
+    })
+};