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

package/dist/esm/modules/excel/xlsx/xform/base-xform.js

@@ -1,135 +0,0 @@
-import { parseSax } from "@excel/utils/parse-sax";
-import { XmlStream } from "@excel/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) {
-        // IMPORTANT:
-        // Do not return early once parsing is "done".
-        // In true streaming scenarios, `parseSax(stream)` is backed by a Node.js
-        // Readable async iterator. Returning early would close the iterator, which
-        // destroys the underlying stream and can surface as AbortError (ABORT_ERR).
-        let done = false;
-        let finalModel;
-        for await (const events of saxParser) {
-            if (done) {
-                continue;
-            }
-            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)) {
-                        done = true;
-                        finalModel = this.model;
-                        break;
-                    }
-                }
-            }
-        }
-        return done ? finalModel : this.model;
-    }
-    async parseStream(stream) {
-        return this.parse(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 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);
-    }
-}
-export { BaseXform };

package/dist/esm/modules/excel/xlsx/xform/book/defined-name-xform.js

@@ -1,124 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-import { colCache } from "@excel/utils/col-cache";
-class DefinedNamesXform extends 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;
-    }
-}
-// Regex to validate cell range format:
-// - Cell: $A$1 or A1
-// - Range: $A$1:$B$10 or A1:B10
-// - Row range: $1:$2 (for print titles)
-// - Column range: $A:$B (for print titles)
-const cellRangeRegexp = /^[$]?[A-Za-z]{1,3}[$]?\d+(:[$]?[A-Za-z]{1,3}[$]?\d+)?$/;
-const rowRangeRegexp = /^[$]?\d+:[$]?\d+$/;
-const colRangeRegexp = /^[$]?[A-Za-z]{1,3}:[$]?[A-Za-z]{1,3}$/;
-function isValidRange(range) {
-    // Skip array constants wrapped in {} - these are not valid cell ranges
-    // e.g., {"'Sheet1'!$A$1:$B$10"} or {#N/A,#N/A,FALSE,"text"}
-    if (range.startsWith("{") || range.endsWith("}")) {
-        return false;
-    }
-    // Extract the cell reference part (after the sheet name if present)
-    const cellRef = range.split("!").pop() || "";
-    // Must match one of the valid patterns
-    if (!cellRangeRegexp.test(cellRef) &&
-        !rowRangeRegexp.test(cellRef) &&
-        !colRangeRegexp.test(cellRef)) {
-        return false;
-    }
-    try {
-        const decoded = colCache.decodeEx(range);
-        // For cell ranges: row/col or top/bottom/left/right should be valid numbers
-        // For row ranges ($1:$2): top/bottom are numbers, left/right are null
-        // For column ranges ($A:$B): left/right are numbers, top/bottom are null
-        if (("row" in decoded && typeof decoded.row === "number") ||
-            ("top" in decoded && typeof decoded.top === "number") ||
-            ("left" in decoded && typeof decoded.left === "number")) {
-            return true;
-        }
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
-function extractRanges(parsedText) {
-    // Skip if the entire text is wrapped in {} (array constant)
-    const trimmed = parsedText.trim();
-    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-        return [];
-    }
-    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;
-}
-export { DefinedNamesXform };

package/dist/esm/modules/excel/xlsx/xform/book/sheet-xform.js

@@ -1,30 +0,0 @@
-import { xmlDecode } from "@utils/utils";
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-class WorksheetXform extends BaseXform {
-    render(xmlStream, model) {
-        xmlStream.leafNode("sheet", {
-            name: model.name,
-            sheetId: model.id,
-            // Excel doesn't output state when it's 'visible' (default)
-            state: model.state === "visible" ? undefined : model.state,
-            "r:id": model.rId
-        });
-    }
-    parseOpen(node) {
-        if (node.name === "sheet") {
-            this.model = {
-                name: 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;
-    }
-}
-export { WorksheetXform };

package/dist/esm/modules/excel/xlsx/xform/book/workbook-calc-properties-xform.js

@@ -1,21 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-class WorkbookCalcPropertiesXform extends 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;
-    }
-}
-export { WorkbookCalcPropertiesXform };

package/dist/esm/modules/excel/xlsx/xform/book/workbook-pivot-cache-xform.js

@@ -1,24 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-class WorkbookPivotCacheXform extends 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;
-    }
-}
-export { WorkbookPivotCacheXform };

package/dist/esm/modules/excel/xlsx/xform/book/workbook-properties-xform.js

@@ -1,24 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-class WorkbookPropertiesXform extends BaseXform {
-    render(xmlStream, model) {
-        xmlStream.leafNode("workbookPr", {
-            date1904: model.date1904 ? 1 : undefined,
-            // Excel doesn't output defaultThemeVersion
-            filterPrivacy: 1
-        });
-    }
-    parseOpen(node) {
-        if (node.name === "workbookPr") {
-            this.model = {
-                date1904: node.attributes.date1904 === "1"
-            };
-            return true;
-        }
-        return false;
-    }
-    parseText() { }
-    parseClose() {
-        return false;
-    }
-}
-export { WorkbookPropertiesXform };

package/dist/esm/modules/excel/xlsx/xform/book/workbook-view-xform.js

@@ -1,46 +0,0 @@
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-class WorkbookViewXform extends 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;
-    }
-}
-export { WorkbookViewXform };

package/dist/esm/modules/excel/xlsx/xform/book/workbook-xform.js

@@ -1,234 +0,0 @@
-import { colCache } from "@excel/utils/col-cache";
-import { XmlStream } from "@excel/utils/xml-stream";
-import { BaseXform } from "@excel/xlsx/xform/base-xform";
-import { StaticXform } from "@excel/xlsx/xform/static-xform";
-import { ListXform } from "@excel/xlsx/xform/list-xform";
-import { DefinedNamesXform } from "@excel/xlsx/xform/book/defined-name-xform";
-import { WorksheetXform } from "@excel/xlsx/xform/book/sheet-xform";
-import { WorkbookViewXform } from "@excel/xlsx/xform/book/workbook-view-xform";
-import { WorkbookPropertiesXform } from "@excel/xlsx/xform/book/workbook-properties-xform";
-import { WorkbookCalcPropertiesXform } from "@excel/xlsx/xform/book/workbook-calc-properties-xform";
-import { WorkbookPivotCacheXform } from "@excel/xlsx/xform/book/workbook-pivot-cache-xform";
-class WorkbookXform extends BaseXform {
-    constructor() {
-        super();
-        this.map = {
-            fileVersion: WorkbookXform.STATIC_XFORMS.fileVersion,
-            workbookPr: new WorkbookPropertiesXform(),
-            bookViews: new ListXform({
-                tag: "bookViews",
-                count: false,
-                childXform: new WorkbookViewXform()
-            }),
-            sheets: new ListXform({ tag: "sheets", count: false, childXform: new WorksheetXform() }),
-            definedNames: new ListXform({
-                tag: "definedNames",
-                count: false,
-                childXform: new DefinedNamesXform()
-            }),
-            calcPr: new WorkbookCalcPropertiesXform(),
-            pivotCaches: new ListXform({
-                tag: "pivotCaches",
-                count: false,
-                childXform: new 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(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;
-                }
-                if (this.map.pivotCaches.model && this.map.pivotCaches.model.length > 0) {
-                    this.model.pivotCaches = this.map.pivotCaches.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 = 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;
-        });
-    }
-}
-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 StaticXform({
-        tag: "fileVersion",
-        $: { appName: "xl", lastEdited: 5, lowestEdited: 5, rupBuild: 9303 }
-    })
-};
-export { WorkbookXform };