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

package/dist/cjs/utils/zip-stream.browser.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipWriter = void 0;
+const zip_builder_1 = require("./zip/zip-builder");
+const stream_buf_browser_1 = require("./stream-buf.browser");
+// Helper function for base64 decoding in browser
+function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+// =============================================================================
+// The ZipWriter class - Browser version without Node.js events dependency
+// Packs streamed data into an output zip stream
+class ZipWriter {
+    constructor(options) {
+        this.finalized = false;
+        this.pendingWrites = [];
+        this.events = new Map();
+        const level = options?.compression === "STORE"
+            ? 0
+            : Math.max(0, Math.min(9, options?.compressionOptions?.level ?? 1));
+        this.stream = new stream_buf_browser_1.StreamBuf();
+        this.zipBuilder = new zip_builder_1.ZipBuilder({ level });
+    }
+    // Event emitter methods
+    on(event, callback) {
+        const callbacks = this.events.get(event) || [];
+        callbacks.push(callback);
+        this.events.set(event, callbacks);
+        return this;
+    }
+    once(event, callback) {
+        const onceCallback = (...args) => {
+            this.off(event, onceCallback);
+            callback(...args);
+        };
+        return this.on(event, onceCallback);
+    }
+    off(event, callback) {
+        const callbacks = this.events.get(event) || [];
+        const index = callbacks.indexOf(callback);
+        if (index !== -1) {
+            callbacks.splice(index, 1);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const callbacks = this.events.get(event) || [];
+        callbacks.forEach(cb => cb(...args));
+        return callbacks.length > 0;
+    }
+    removeListener(event, callback) {
+        return this.off(event, callback);
+    }
+    append(data, options) {
+        let buffer;
+        if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
+            const base64Data = typeof data === "string" ? data : String(data);
+            buffer = base64ToUint8Array(base64Data);
+        }
+        else if (typeof data === "string") {
+            buffer = new TextEncoder().encode(data);
+        }
+        else if (data instanceof Uint8Array) {
+            buffer = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            buffer = new Uint8Array(data);
+        }
+        else {
+            buffer = data;
+        }
+        const writePromise = this.zipBuilder
+            .addFile({ name: options.name, data: buffer })
+            .then(chunks => {
+            for (const chunk of chunks) {
+                this.stream.write(new Uint8Array(chunk));
+            }
+        });
+        this.pendingWrites.push(writePromise);
+    }
+    push(chunk) {
+        return this.stream.push(chunk);
+    }
+    async finalize() {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        await Promise.all(this.pendingWrites);
+        const finalChunks = this.zipBuilder.finalize();
+        for (const chunk of finalChunks) {
+            this.stream.write(new Uint8Array(chunk));
+        }
+        this.stream.end();
+        this.emit("finish");
+    }
+    // ==========================================================================
+    // Stream.Readable interface
+    read(size) {
+        return this.stream.read(size);
+    }
+    setEncoding(encoding) {
+        return this.stream.setEncoding(encoding);
+    }
+    pause() {
+        return this.stream.pause();
+    }
+    resume() {
+        return this.stream.resume();
+    }
+    isPaused() {
+        return this.stream.isPaused();
+    }
+    pipe(destination) {
+        return this.stream.pipe(destination);
+    }
+    unpipe(destination) {
+        return this.stream.unpipe(destination);
+    }
+    unshift() {
+        return this.stream.unshift();
+    }
+    wrap() {
+        return this.stream.wrap();
+    }
+}
+exports.ZipWriter = ZipWriter;

package/dist/cjs/utils/zip-stream.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipWriter = void 0;
+const events_1 = __importDefault(require("events"));
+const index_1 = require("./zip/index");
+const stream_buf_1 = require("./stream-buf");
+// =============================================================================
+// The ZipWriter class
+// Packs streamed data into an output zip stream
+// Uses native zlib (Node.js) or CompressionStream (browser) for best performance
+class ZipWriter extends events_1.default.EventEmitter {
+    constructor(options) {
+        super();
+        this.finalized = false;
+        this.pendingWrites = [];
+        // Determine compression level:
+        // - STORE mode = 0 (no compression)
+        // - DEFLATE mode = user level or default 1 (fast compression)
+        const level = options?.compression === "STORE"
+            ? 0
+            : Math.max(0, Math.min(9, options?.compressionOptions?.level ?? 1));
+        this.stream = new stream_buf_1.StreamBuf();
+        this.zipBuilder = new index_1.ZipBuilder({ level });
+    }
+    append(data, options) {
+        let buffer;
+        if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
+            // Decode base64 data - Buffer.from works in both Node.js and browser (via polyfill)
+            const base64Data = typeof data === "string" ? data : data.toString();
+            buffer = Buffer.from(base64Data, "base64");
+        }
+        else if (typeof data === "string") {
+            // Convert string to Buffer - works in both environments
+            buffer = Buffer.from(data, "utf8");
+        }
+        else if (Buffer.isBuffer(data)) {
+            // Buffer extends Uint8Array, can use it directly - no copy needed
+            buffer = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            // Handle typed arrays - create view without copy
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            // Handle ArrayBuffer directly
+            buffer = new Uint8Array(data);
+        }
+        else {
+            // Assume it's already a Uint8Array or compatible type
+            buffer = data;
+        }
+        // Add file to zip using native compression
+        // addFile returns chunks that we write to stream immediately
+        const writePromise = this.zipBuilder
+            .addFile({ name: options.name, data: buffer })
+            .then(chunks => {
+            for (const chunk of chunks) {
+                this.stream.write(Buffer.from(chunk));
+            }
+        });
+        this.pendingWrites.push(writePromise);
+    }
+    push(chunk) {
+        return this.stream.push(chunk);
+    }
+    async finalize() {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        // Wait for all pending writes to complete
+        await Promise.all(this.pendingWrites);
+        // Finalize the zip and write central directory
+        const finalChunks = this.zipBuilder.finalize();
+        for (const chunk of finalChunks) {
+            this.stream.write(Buffer.from(chunk));
+        }
+        this.stream.end();
+        this.emit("finish");
+    }
+    // ==========================================================================
+    // Stream.Readable interface
+    read(size) {
+        return this.stream.read(size);
+    }
+    setEncoding(encoding) {
+        return this.stream.setEncoding(encoding);
+    }
+    pause() {
+        return this.stream.pause();
+    }
+    resume() {
+        return this.stream.resume();
+    }
+    isPaused() {
+        return this.stream.isPaused();
+    }
+    pipe(destination, options) {
+        return this.stream.pipe(destination, options);
+    }
+    unpipe(destination) {
+        return this.stream.unpipe(destination);
+    }
+    unshift(chunk) {
+        return this.stream.unshift(chunk);
+    }
+    wrap(stream) {
+        return this.stream.wrap(stream);
+    }
+}
+exports.ZipWriter = ZipWriter;

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_1 = require("../../utils/parse-sax");
+const xml_stream_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_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_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,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinedNamesXform = void 0;
+const base_xform_1 = require("../base-xform");
+const col_cache_1 = require("../../../utils/col-cache");
+class DefinedNamesXform extends base_xform_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;
+// 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 = col_cache_1.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;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorksheetXform = void 0;
+const utils_1 = require("../../../utils/utils");
+const base_xform_1 = require("../base-xform");
+class WorksheetXform extends base_xform_1.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: (0, utils_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_1 = require("../base-xform");
+class WorkbookCalcPropertiesXform extends base_xform_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_1 = require("../base-xform");
+class WorkbookPivotCacheXform extends base_xform_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_1 = require("../base-xform");
+class WorkbookPropertiesXform extends base_xform_1.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;
+    }
+}
+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_1 = require("../base-xform");
+class WorkbookViewXform extends base_xform_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;