@cj-tech-master/excelts 3.1.0 → 4.0.0-canary.20260103013222.0e5d37f

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

@@ -1,132 +0,0 @@
-import { ZipBuilder } from "./zip/zip-builder.js";
-import { StreamBuf } from "./stream-buf.browser.js";
-// 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 StreamBuf();
-        this.zipBuilder = new 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();
-    }
-}
-export { ZipWriter };

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

@@ -1,109 +0,0 @@
-import events from "events";
-import { ZipBuilder } from "./zip/index.js";
-import { StreamBuf } from "./stream-buf.js";
-// =============================================================================
-// 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.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 StreamBuf();
-        this.zipBuilder = new 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);
-    }
-}
-// =============================================================================
-export { ZipWriter };

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

@@ -1,123 +0,0 @@
-import { parseSax } from "../../utils/parse-sax.js";
-import { XmlStream } from "../../utils/xml-stream.js";
-// 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(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/xlsx/xform/book/sheet-xform.js

@@ -1,30 +0,0 @@
-import { xmlDecode } from "../../../utils/utils.js";
-import { BaseXform } from "../base-xform.js";
-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/xlsx/xform/core/content-types-xform.js

@@ -1,128 +0,0 @@
-import { XmlStream } from "../../../utils/xml-stream.js";
-import { BaseXform } from "../base-xform.js";
-// used for rendering the [Content_Types].xml file
-// not used for parsing
-class ContentTypesXform extends BaseXform {
-    render(xmlStream, model) {
-        xmlStream.openXml(XmlStream.StdDocAttributes);
-        xmlStream.openNode("Types", ContentTypesXform.PROPERTY_ATTRIBUTES);
-        const mediaHash = {};
-        (model.media || []).forEach((medium) => {
-            if (medium.type === "image") {
-                const imageType = medium.extension;
-                if (!mediaHash[imageType]) {
-                    mediaHash[imageType] = true;
-                    xmlStream.leafNode("Default", {
-                        Extension: imageType,
-                        ContentType: `image/${imageType}`
-                    });
-                }
-            }
-        });
-        xmlStream.leafNode("Default", {
-            Extension: "rels",
-            ContentType: "application/vnd.openxmlformats-package.relationships+xml"
-        });
-        xmlStream.leafNode("Default", { Extension: "xml", ContentType: "application/xml" });
-        xmlStream.leafNode("Override", {
-            PartName: "/xl/workbook.xml",
-            ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"
-        });
-        model.worksheets.forEach((worksheet, index) => {
-            // Use fileIndex if set, otherwise use sequential index (1-based)
-            const fileIndex = worksheet.fileIndex || index + 1;
-            const name = `/xl/worksheets/sheet${fileIndex}.xml`;
-            xmlStream.leafNode("Override", {
-                PartName: name,
-                ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"
-            });
-        });
-        if ((model.pivotTables || []).length) {
-            // Add content types for pivot cache (definition and records)
-            (model.pivotTables || []).forEach((pivotTable) => {
-                const n = pivotTable.tableNumber;
-                xmlStream.leafNode("Override", {
-                    PartName: `/xl/pivotCache/pivotCacheDefinition${n}.xml`,
-                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"
-                });
-                xmlStream.leafNode("Override", {
-                    PartName: `/xl/pivotCache/pivotCacheRecords${n}.xml`,
-                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"
-                });
-            });
-        }
-        xmlStream.leafNode("Override", {
-            PartName: "/xl/theme/theme1.xml",
-            ContentType: "application/vnd.openxmlformats-officedocument.theme+xml"
-        });
-        xmlStream.leafNode("Override", {
-            PartName: "/xl/styles.xml",
-            ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"
-        });
-        const hasSharedStrings = model.sharedStrings && model.sharedStrings.count;
-        if (hasSharedStrings) {
-            xmlStream.leafNode("Override", {
-                PartName: "/xl/sharedStrings.xml",
-                ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"
-            });
-        }
-        if (model.tables) {
-            model.tables.forEach((table) => {
-                xmlStream.leafNode("Override", {
-                    PartName: `/xl/tables/${table.target}`,
-                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"
-                });
-            });
-        }
-        // Add pivot table overrides after tables (matches Excel order)
-        if ((model.pivotTables || []).length) {
-            (model.pivotTables || []).forEach((pivotTable) => {
-                const n = pivotTable.tableNumber;
-                xmlStream.leafNode("Override", {
-                    PartName: `/xl/pivotTables/pivotTable${n}.xml`,
-                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"
-                });
-            });
-        }
-        if (model.drawings) {
-            model.drawings.forEach((drawing) => {
-                xmlStream.leafNode("Override", {
-                    PartName: `/xl/drawings/${drawing.name}.xml`,
-                    ContentType: "application/vnd.openxmlformats-officedocument.drawing+xml"
-                });
-            });
-        }
-        if (model.commentRefs && model.commentRefs.length) {
-            xmlStream.leafNode("Default", {
-                Extension: "vml",
-                ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"
-            });
-            model.commentRefs.forEach(({ commentName }) => {
-                xmlStream.leafNode("Override", {
-                    PartName: `/xl/${commentName}.xml`,
-                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"
-                });
-            });
-        }
-        xmlStream.leafNode("Override", {
-            PartName: "/docProps/core.xml",
-            ContentType: "application/vnd.openxmlformats-package.core-properties+xml"
-        });
-        xmlStream.leafNode("Override", {
-            PartName: "/docProps/app.xml",
-            ContentType: "application/vnd.openxmlformats-officedocument.extended-properties+xml"
-        });
-        xmlStream.closeNode();
-    }
-    parseOpen() {
-        return false;
-    }
-    parseText() { }
-    parseClose() {
-        return false;
-    }
-}
-ContentTypesXform.PROPERTY_ATTRIBUTES = {
-    xmlns: "http://schemas.openxmlformats.org/package/2006/content-types"
-};
-export { ContentTypesXform };

package/dist/esm/xlsx/xform/pivot-table/cache-field-xform.js

@@ -1,128 +0,0 @@
-import { BaseXform } from "../base-xform.js";
-import { xmlDecode } from "../../../utils/utils.js";
-/**
- * Xform for parsing individual <cacheField> elements within a pivot cache definition.
- *
- * Example XML:
- * ```xml
- * <cacheField name="Category" numFmtId="0">
- *   <sharedItems count="3">
- *     <s v="A" />
- *     <s v="B" />
- *     <s v="C" />
- *   </sharedItems>
- * </cacheField>
- *
- * <cacheField name="Value" numFmtId="0">
- *   <sharedItems containsSemiMixedTypes="0" containsString="0"
- *                containsNumber="1" containsInteger="1" minValue="5" maxValue="45" />
- * </cacheField>
- * ```
- */
-class CacheFieldXform extends BaseXform {
-    constructor() {
-        super();
-        this.model = null;
-        this.inSharedItems = false;
-    }
-    get tag() {
-        return "cacheField";
-    }
-    reset() {
-        this.model = null;
-        this.inSharedItems = false;
-    }
-    parseOpen(node) {
-        const { name, attributes } = node;
-        switch (name) {
-            case "cacheField":
-                // Initialize the model with field name
-                this.model = {
-                    name: xmlDecode(attributes.name || ""),
-                    sharedItems: null
-                };
-                break;
-            case "sharedItems":
-                this.inSharedItems = true;
-                // Store numeric field metadata
-                if (this.model) {
-                    this.model.containsNumber = attributes.containsNumber === "1";
-                    this.model.containsInteger = attributes.containsInteger === "1";
-                    if (attributes.minValue !== undefined) {
-                        this.model.minValue = parseFloat(attributes.minValue);
-                    }
-                    if (attributes.maxValue !== undefined) {
-                        this.model.maxValue = parseFloat(attributes.maxValue);
-                    }
-                    // Initialize sharedItems array if count > 0 (for both string and numeric fields)
-                    const count = parseInt(attributes.count || "0", 10);
-                    if (count > 0) {
-                        this.model.sharedItems = [];
-                    }
-                    else {
-                        // No count means no individual items (pure numeric field)
-                        this.model.sharedItems = null;
-                    }
-                }
-                break;
-            case "s":
-                // String value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    // Decode XML entities in the value
-                    const value = xmlDecode(attributes.v || "");
-                    this.model.sharedItems.push(value);
-                }
-                break;
-            case "n":
-                // Numeric value in sharedItems (less common, but possible)
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    const value = parseFloat(attributes.v || "0");
-                    this.model.sharedItems.push(value);
-                }
-                break;
-            case "b":
-                // Boolean value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    const value = attributes.v === "1";
-                    this.model.sharedItems.push(value);
-                }
-                break;
-            case "e":
-                // Error value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    const value = `#${attributes.v || "ERROR!"}`;
-                    this.model.sharedItems.push(value);
-                }
-                break;
-            case "m":
-                // Missing/null value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    this.model.sharedItems.push(null);
-                }
-                break;
-            case "d":
-                // Date value in sharedItems
-                if (this.inSharedItems && this.model?.sharedItems !== null) {
-                    const value = new Date(attributes.v || "");
-                    this.model.sharedItems.push(value);
-                }
-                break;
-        }
-        return true;
-    }
-    parseText(_text) {
-        // No text content in cacheField elements
-    }
-    parseClose(name) {
-        switch (name) {
-            case "cacheField":
-                // End of this cacheField element
-                return false;
-            case "sharedItems":
-                this.inSharedItems = false;
-                break;
-        }
-        return true;
-    }
-}
-export { CacheFieldXform };