@cj-tech-master/excelts 4.0.0 → 4.0.1-canary.20260104072032.0453bbe

package/dist/browser/modules/excel/utils/under-dash.js

@@ -0,0 +1,166 @@
+const escapeHtmlMap = {
+    '"': """,
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;"
+};
+const escapeHtmlRegex = /["&<>]/g;
+export function isEqual(a, b) {
+    // Fast path: identical references or primitives
+    if (a === b) {
+        return true;
+    }
+    if (a == null || b == null) {
+        return a === b;
+    }
+    const aType = typeof a;
+    if (aType !== typeof b) {
+        return false;
+    }
+    // Primitives already handled by ===
+    if (aType !== "object") {
+        return false;
+    }
+    // Arrays
+    const aIsArray = Array.isArray(a);
+    const bIsArray = Array.isArray(b);
+    if (aIsArray !== bIsArray) {
+        return false;
+    }
+    if (aIsArray) {
+        const len = a.length;
+        if (len !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < len; i++) {
+            if (!isEqual(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Objects
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (let i = 0, len = aKeys.length; i < len; i++) {
+        const key = aKeys[i];
+        if (!Object.prototype.hasOwnProperty.call(b, key)) {
+            return false;
+        }
+        if (!isEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+export function escapeHtml(html) {
+    return html.replace(escapeHtmlRegex, char => escapeHtmlMap[char]);
+}
+export function isUndefined(val) {
+    return val === undefined;
+}
+export function isObject(val) {
+    return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+export function deepMerge(...args) {
+    const target = args[0] || {};
+    const len = args.length;
+    for (let i = 1; i < len; i++) {
+        const arg = args[i];
+        if (!arg) {
+            continue;
+        }
+        if (Array.isArray(arg)) {
+            for (let j = 0, jLen = arg.length; j < jLen; j++) {
+                const val = arg[j];
+                if (val === undefined) {
+                    continue;
+                }
+                const src = target[j];
+                if (Array.isArray(val)) {
+                    target[j] = deepMerge(Array.isArray(src) ? src : [], val);
+                }
+                else if (isObject(val)) {
+                    target[j] = deepMerge(isObject(src) ? src : {}, val);
+                }
+                else {
+                    target[j] = val;
+                }
+            }
+        }
+        else {
+            const keys = Object.keys(arg);
+            for (let j = 0, jLen = keys.length; j < jLen; j++) {
+                const key = keys[j];
+                // Prevent prototype pollution
+                if (key === "__proto__" || key === "constructor" || key === "prototype") {
+                    continue;
+                }
+                const val = arg[key];
+                if (val === undefined) {
+                    continue;
+                }
+                const src = target[key];
+                if (Array.isArray(val)) {
+                    target[key] = deepMerge(Array.isArray(src) ? src : [], val);
+                }
+                else if (isObject(val)) {
+                    target[key] = deepMerge(isObject(src) ? src : {}, val);
+                }
+                else {
+                    target[key] = val;
+                }
+            }
+        }
+    }
+    return target;
+}
+export function cloneDeep(obj, preserveUndefined = true) {
+    if (obj === null || typeof obj !== "object") {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        const len = obj.length;
+        const clone = new Array(len);
+        for (let i = 0; i < len; i++) {
+            const value = obj[i];
+            if (value !== undefined) {
+                clone[i] = cloneDeep(value, preserveUndefined);
+            }
+            else if (preserveUndefined) {
+                clone[i] = undefined;
+            }
+        }
+        return clone;
+    }
+    const clone = {};
+    const keys = Object.keys(obj);
+    for (let i = 0, len = keys.length; i < len; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        if (value !== undefined) {
+            clone[key] = cloneDeep(value, preserveUndefined);
+        }
+        else if (preserveUndefined) {
+            clone[key] = undefined;
+        }
+    }
+    return clone;
+}
+export function get(obj, path, defaultValue) {
+    const keys = path.split(".");
+    let result = obj;
+    for (let i = 0, len = keys.length; i < len; i++) {
+        if (result == null) {
+            return defaultValue;
+        }
+        result = result[keys[i]];
+    }
+    return result ?? defaultValue;
+}

package/dist/browser/modules/excel/utils/xml-stream.d.ts

@@ -0,0 +1,34 @@
+interface Attributes {
+    [key: string]: any;
+}
+declare class XmlStream {
+    private _xml;
+    private _chunks;
+    private _stack;
+    private _rollbacks;
+    leaf?: boolean;
+    open?: boolean;
+    constructor();
+    private _consolidate;
+    get tos(): string | undefined;
+    get cursor(): number;
+    openXml(docAttributes?: Attributes): void;
+    openNode(name: string, attributes?: Attributes): void;
+    addAttribute(name: string, value: any): void;
+    addAttributes(attrs: Attributes): void;
+    writeText(text: any): void;
+    writeXml(xml: string): void;
+    closeNode(): void;
+    leafNode(name: string, attributes?: Attributes, text?: any): void;
+    closeAll(): void;
+    addRollback(): number;
+    commit(): void;
+    rollback(): void;
+    get xml(): string;
+    static StdDocAttributes: {
+        version: string;
+        encoding: string;
+        standalone: string;
+    };
+}
+export { XmlStream };

package/dist/browser/modules/excel/utils/xml-stream.js

@@ -0,0 +1,179 @@
+import { xmlEncode } from "../../../utils/utils.browser.js";
+// constants
+const OPEN_ANGLE = "<";
+const CLOSE_ANGLE = ">";
+const OPEN_ANGLE_SLASH = "</";
+const CLOSE_SLASH_ANGLE = "/>";
+// Chunk size for periodic consolidation (reduces final join overhead)
+const CHUNK_SIZE = 10000;
+function pushAttribute(xml, name, value) {
+    xml.push(` ${name}="${xmlEncode(value.toString())}"`);
+}
+function pushAttributes(xml, attributes) {
+    if (attributes) {
+        const tmp = [];
+        for (const name in attributes) {
+            if (!Object.prototype.hasOwnProperty.call(attributes, name)) {
+                continue;
+            }
+            const value = attributes[name];
+            if (value !== undefined) {
+                pushAttribute(tmp, name, value);
+            }
+        }
+        xml.push(tmp.join(""));
+    }
+}
+class XmlStream {
+    constructor() {
+        this._xml = [];
+        this._chunks = [];
+        this._stack = [];
+        this._rollbacks = [];
+        this.leaf = false;
+        this.open = false;
+    }
+    _consolidate() {
+        // Consolidation is not rollback-safe: joining and moving fragments into `_chunks`
+        // cannot be undone. Avoid consolidating while a rollback marker is active.
+        if (this._rollbacks.length > 0) {
+            return;
+        }
+        // Periodically join small strings into larger chunks to reduce final join overhead
+        if (this._xml.length >= CHUNK_SIZE) {
+            this._chunks.push(this._xml.join(""));
+            this._xml.length = 0;
+        }
+    }
+    get tos() {
+        return this._stack.length ? this._stack[this._stack.length - 1] : undefined;
+    }
+    get cursor() {
+        // handy way to track whether anything has been added
+        return this._chunks.length * CHUNK_SIZE + this._xml.length;
+    }
+    openXml(docAttributes) {
+        const xml = this._xml;
+        // <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+        xml.push("<?xml");
+        pushAttributes(xml, docAttributes);
+        xml.push("?>\n");
+    }
+    openNode(name, attributes) {
+        const parent = this.tos;
+        const xml = this._xml;
+        if (parent && this.open) {
+            xml.push(CLOSE_ANGLE);
+        }
+        this._stack.push(name);
+        // start streaming node
+        xml.push(OPEN_ANGLE);
+        xml.push(name);
+        pushAttributes(xml, attributes);
+        this.leaf = true;
+        this.open = true;
+    }
+    addAttribute(name, value) {
+        if (!this.open) {
+            throw new Error("Cannot write attributes to node if it is not open");
+        }
+        if (value !== undefined) {
+            pushAttribute(this._xml, name, value);
+        }
+    }
+    addAttributes(attrs) {
+        if (!this.open) {
+            throw new Error("Cannot write attributes to node if it is not open");
+        }
+        pushAttributes(this._xml, attrs);
+    }
+    writeText(text) {
+        const xml = this._xml;
+        if (this.open) {
+            xml.push(CLOSE_ANGLE);
+            this.open = false;
+        }
+        this.leaf = false;
+        xml.push(xmlEncode(text.toString()));
+    }
+    writeXml(xml) {
+        if (this.open) {
+            this._xml.push(CLOSE_ANGLE);
+            this.open = false;
+        }
+        this.leaf = false;
+        this._xml.push(xml);
+    }
+    closeNode() {
+        const node = this._stack.pop();
+        const xml = this._xml;
+        if (this.leaf) {
+            xml.push(CLOSE_SLASH_ANGLE);
+        }
+        else {
+            xml.push(OPEN_ANGLE_SLASH);
+            xml.push(node);
+            xml.push(CLOSE_ANGLE);
+        }
+        this.open = false;
+        this.leaf = false;
+        this._consolidate();
+    }
+    leafNode(name, attributes, text) {
+        this.openNode(name, attributes);
+        if (text !== undefined) {
+            // zeros need to be written
+            this.writeText(text);
+        }
+        this.closeNode();
+    }
+    closeAll() {
+        while (this._stack.length) {
+            this.closeNode();
+        }
+    }
+    addRollback() {
+        this._rollbacks.push({
+            xml: this._xml.length,
+            stack: this._stack.length,
+            leaf: this.leaf ?? false,
+            open: this.open ?? false,
+            chunksLength: this._chunks.length
+        });
+        return this.cursor;
+    }
+    commit() {
+        this._rollbacks.pop();
+    }
+    rollback() {
+        const r = this._rollbacks.pop();
+        if (this._xml.length > r.xml) {
+            this._xml.length = r.xml;
+        }
+        if (this._stack.length > r.stack) {
+            this._stack.length = r.stack;
+        }
+        if (this._chunks.length > r.chunksLength) {
+            this._chunks.length = r.chunksLength;
+        }
+        this.leaf = r.leaf;
+        this.open = r.open;
+    }
+    get xml() {
+        this.closeAll();
+        // Join chunks first, then remaining xml array
+        if (this._chunks.length === 0) {
+            return this._xml.join("");
+        }
+        if (this._xml.length > 0) {
+            this._chunks.push(this._xml.join(""));
+        }
+        return this._chunks.join("");
+    }
+}
+XmlStream.StdDocAttributes = {
+    version: "1.0",
+    encoding: "UTF-8",
+    standalone: "yes"
+};
+export { XmlStream };

package/dist/browser/modules/excel/workbook.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Workbook - Cross-platform Excel Workbook
+ *
+ * Full functionality:
+ * - xlsx: File/stream/buffer support (file operations Node.js only)
+ * - csv: CSV read/write support (file operations Node.js only)
+ * - streaming: createStreamWriter/createStreamReader for large files
+ *
+ * Note: Browser build uses rolldown aliases to swap in browser-specific
+ * implementations for xlsx, csv, and stream modules.
+ */
+import { Worksheet, type WorksheetModel } from "@excel/worksheet";
+import { DefinedNames, type DefinedNameModel } from "@excel/defined-names";
+import { XLSX } from "@excel/xlsx/xlsx";
+import { CSV } from "@csv/csv";
+import { WorkbookWriter, type WorkbookWriterOptions } from "@excel/stream/workbook-writer";
+import { WorkbookReader, type WorkbookReaderOptions } from "@excel/stream/workbook-reader";
+import type { Readable } from "@stream";
+import type { PivotTable } from "@excel/pivot-table";
+import type { AddWorksheetOptions, CalculationProperties, Image, WorkbookProperties, WorkbookView, Buffer as ExcelBuffer } from "@excel/types";
+/** Internal media type - more flexible than public Media type */
+export interface WorkbookMedia {
+    type: string;
+    extension: string;
+    filename?: string;
+    buffer?: ExcelBuffer | Uint8Array;
+    base64?: string;
+    name?: string;
+}
+/** Internal model type for serialization */
+export interface WorkbookModel {
+    creator?: string;
+    lastModifiedBy?: string;
+    lastPrinted?: Date;
+    created: Date;
+    modified: Date;
+    properties: Partial<WorkbookProperties>;
+    worksheets: WorksheetModel[];
+    sheets?: WorksheetModel[];
+    definedNames: DefinedNameModel[];
+    views: WorkbookView[];
+    company: string;
+    manager: string;
+    title: string;
+    subject: string;
+    keywords: string;
+    category: string;
+    description: string;
+    language?: string;
+    revision?: number;
+    contentStatus?: string;
+    themes?: unknown;
+    media: WorkbookMedia[];
+    pivotTables: PivotTable[];
+    /** Loaded pivot tables from file - used during reconciliation */
+    loadedPivotTables?: any[];
+    calcProperties: Partial<CalculationProperties>;
+}
+declare class Workbook {
+    /**
+     * Streaming workbook writer class for large files.
+     * @example
+     * // Node.js: new Workbook.Writer({ filename: "large.xlsx" })
+     * // Browser: new Workbook.Writer({ stream: writableStream })
+     */
+    static Writer: typeof WorkbookWriter;
+    /**
+     * Streaming workbook reader class for large files.
+     * @example
+     * // Node.js: new Workbook.Reader("large.xlsx")
+     * // Browser: new Workbook.Reader(readableStream)
+     */
+    static Reader: typeof WorkbookReader;
+    category: string;
+    company: string;
+    created: Date;
+    description: string;
+    keywords: string;
+    manager: string;
+    modified: Date;
+    subject: string;
+    title: string;
+    creator?: string;
+    lastModifiedBy?: string;
+    lastPrinted?: Date;
+    language?: string;
+    revision?: number;
+    contentStatus?: string;
+    properties: Partial<WorkbookProperties>;
+    calcProperties: Partial<CalculationProperties>;
+    views: WorkbookView[];
+    media: WorkbookMedia[];
+    pivotTables: PivotTable[];
+    private _worksheets;
+    private _definedNames;
+    private _themes?;
+    private _xlsx?;
+    private _csv?;
+    constructor();
+    /**
+     * xlsx file format operations
+     * Node.js: readFile, writeFile, read (stream), write (stream), load (buffer), writeBuffer
+     * Browser: load (buffer), writeBuffer
+     */
+    get xlsx(): XLSX;
+    /**
+     * csv file format operations
+     * Node.js: readFile, writeFile, read (stream), write (stream)
+     * Browser: load (string/buffer), writeString, writeBuffer
+     */
+    get csv(): CSV;
+    /**
+     * Create a streaming workbook writer for large files.
+     * This is more memory-efficient than using Workbook for large datasets.
+     *
+     * @param options - Options for the workbook writer
+     *   - Node.js: can use { filename } or { stream }
+     *   - Browser: must use { stream }
+     * @returns A new WorkbookWriter instance
+     *
+     * @example
+     * ```ts
+     * // Node.js with filename
+     * const writer = Workbook.createStreamWriter({ filename: "large-file.xlsx" });
+     *
+     * // Browser or Node.js with stream
+     * const writer = Workbook.createStreamWriter({ stream: writableStream });
+     *
+     * const sheet = writer.addWorksheet("Sheet1");
+     * for (let i = 0; i < 1000000; i++) {
+     *   sheet.addRow([i, `Row ${i}`]).commit();
+     * }
+     * await writer.commit();
+     * ```
+     */
+    static createStreamWriter(options?: WorkbookWriterOptions): WorkbookWriter;
+    /**
+     * Create a streaming workbook reader for large files.
+     * This is more memory-efficient than using Workbook.xlsx.readFile for large datasets.
+     *
+     * @param input - File path (Node.js only) or readable stream
+     * @param options - Options for the workbook reader
+     * @returns A new WorkbookReader instance
+     *
+     * @example
+     * ```ts
+     * // Node.js with file path
+     * const reader = Workbook.createStreamReader("large-file.xlsx");
+     *
+     * // Browser or Node.js with stream
+     * const reader = Workbook.createStreamReader(readableStream);
+     *
+     * for await (const event of reader) {
+     *   if (event.eventType === "worksheet") {
+     *     const worksheet = event.value;
+     *     for await (const row of worksheet) {
+     *       console.log(row.values);
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    static createStreamReader(input: string | Readable, options?: WorkbookReaderOptions): WorkbookReader;
+    get nextId(): number;
+    /**
+     * Add a new worksheet and return a reference to it
+     */
+    addWorksheet(name?: string, options?: AddWorksheetOptions): Worksheet;
+    removeWorksheetEx(worksheet: Worksheet): void;
+    removeWorksheet(id: number | string): void;
+    /**
+     * Fetch sheet by name or id
+     */
+    getWorksheet(id?: number | string): Worksheet | undefined;
+    /**
+     * Return a clone of worksheets in order
+     */
+    get worksheets(): Worksheet[];
+    /**
+     * Iterate over all sheets.
+     *
+     * Note: `workbook.worksheets.forEach` will still work but this is better.
+     */
+    eachSheet(callback: (sheet: Worksheet, id: number) => void): void;
+    get definedNames(): DefinedNames;
+    clearThemes(): void;
+    /**
+     * Add Image to Workbook and return the id
+     */
+    addImage(image: Image): number;
+    getImage(id: number | string): WorkbookMedia | undefined;
+    get model(): WorkbookModel;
+    set model(value: WorkbookModel);
+}
+export { Workbook };