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

package/dist/browser/modules/excel/stream/worksheet-reader.js

@@ -0,0 +1,367 @@
+/**
+ * WorksheetReader - Cross-Platform Streaming Worksheet Reader
+ *
+ * Works in both Node.js and Browser.
+ */
+import { EventEmitter } from "../../stream/index.browser.js";
+import { parseSax } from "../utils/parse-sax.js";
+import { xmlDecode, isDateFmt, excelToDate } from "../../../utils/utils.browser.js";
+import { colCache } from "../utils/col-cache.js";
+import { Dimensions } from "../range.js";
+import { Row } from "../row.js";
+import { Column } from "../column.js";
+class WorksheetReader extends EventEmitter {
+    constructor({ workbook, id, iterator, options }) {
+        super();
+        this.workbook = workbook;
+        this.id = id;
+        this.sheetNo = typeof id === "number" ? id : parseInt(String(id), 10);
+        this.iterator = iterator;
+        this.options = options || {};
+        // and a name
+        this.name = `Sheet${this.id}`;
+        // column definitions
+        this._columns = null;
+        this._keys = Object.create(null);
+        // keep a record of dimensions
+        this._dimensions = new Dimensions();
+    }
+    // destroy - not a valid operation for a streaming writer
+    // even though some streamers might be able to, it's a bad idea.
+    destroy() {
+        throw new Error("Invalid Operation: destroy");
+    }
+    // return the current dimensions of the reader
+    get dimensions() {
+        return this._dimensions;
+    }
+    // =========================================================================
+    // Columns
+    // get the current columns array.
+    get columns() {
+        return this._columns;
+    }
+    // get a single column by col number. If it doesn't exist, it and any gaps before it
+    // are created.
+    getColumn(c) {
+        if (typeof c === "string") {
+            // if it matches a key'd column, return that
+            const col = this._keys[c];
+            if (col) {
+                return col;
+            }
+            // otherwise, assume letter
+            c = colCache.l2n(c);
+        }
+        if (!this._columns) {
+            this._columns = [];
+        }
+        if (c > this._columns.length) {
+            let n = this._columns.length + 1;
+            while (n <= c) {
+                this._columns.push(new Column(this, n++));
+            }
+        }
+        return this._columns[c - 1];
+    }
+    getColumnKey(key) {
+        return this._keys[key];
+    }
+    setColumnKey(key, value) {
+        this._keys[key] = value;
+    }
+    deleteColumnKey(key) {
+        delete this._keys[key];
+    }
+    eachColumnKey(f) {
+        const keys = this._keys;
+        for (const key in keys) {
+            f(keys[key], key);
+        }
+    }
+    async read() {
+        try {
+            for await (const events of this.parse()) {
+                for (let i = 0; i < events.length; i++) {
+                    const event = events[i];
+                    this.emit(event.eventType, event.value);
+                }
+            }
+            this.emit("finished");
+        }
+        catch (error) {
+            this.emit("error", error);
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (const events of this.parse()) {
+            for (let i = 0; i < events.length; i++) {
+                const event = events[i];
+                if (event.eventType === "row") {
+                    yield event.value;
+                }
+            }
+        }
+    }
+    async *parse() {
+        const { iterator, options } = this;
+        let emitSheet = false;
+        let emitHyperlinks = false;
+        let hyperlinks = null;
+        switch (options.worksheets) {
+            case "emit":
+                emitSheet = true;
+                break;
+            case "prep":
+                break;
+            default:
+                break;
+        }
+        switch (options.hyperlinks) {
+            case "emit":
+                emitHyperlinks = true;
+                break;
+            case "cache":
+                this.hyperlinks = hyperlinks = Object.create(null);
+                break;
+            default:
+                break;
+        }
+        if (!emitSheet && !emitHyperlinks && !hyperlinks) {
+            return;
+        }
+        const shouldHandleHyperlinks = emitHyperlinks || hyperlinks !== null;
+        // references
+        const { sharedStrings, styles, properties } = this.workbook;
+        // xml position
+        let inCols = false;
+        let inRows = false;
+        let inHyperlinks = false;
+        // parse state
+        let cols = null;
+        let row = null;
+        let c = null;
+        let current = null;
+        for await (const events of parseSax(iterator)) {
+            let worksheetEvents = null;
+            for (let i = 0; i < events.length; i++) {
+                const evt = events[i];
+                const eventType = evt.eventType;
+                const value = evt.value;
+                if (eventType === "opentag") {
+                    const node = value;
+                    if (emitSheet) {
+                        switch (node.name) {
+                            case "cols":
+                                inCols = true;
+                                cols = [];
+                                break;
+                            case "sheetData":
+                                inRows = true;
+                                break;
+                            case "col":
+                                if (inCols) {
+                                    cols.push({
+                                        min: parseInt(node.attributes.min, 10),
+                                        max: parseInt(node.attributes.max, 10),
+                                        width: parseFloat(node.attributes.width),
+                                        styleId: parseInt(node.attributes.style || "0", 10)
+                                    });
+                                }
+                                break;
+                            case "row":
+                                if (inRows) {
+                                    const r = parseInt(node.attributes.r, 10);
+                                    row = new Row(this, r);
+                                    if (node.attributes.ht) {
+                                        row.height = parseFloat(node.attributes.ht);
+                                    }
+                                    if (node.attributes.s) {
+                                        const styleId = parseInt(node.attributes.s, 10);
+                                        const style = styles.getStyleModel(styleId);
+                                        if (style) {
+                                            row.style = style;
+                                        }
+                                    }
+                                }
+                                break;
+                            case "c":
+                                if (row) {
+                                    const styleAttr = node.attributes.s;
+                                    c = {
+                                        ref: node.attributes.r,
+                                        s: styleAttr ? parseInt(styleAttr, 10) : 0,
+                                        t: node.attributes.t
+                                    };
+                                }
+                                break;
+                            case "f":
+                                if (c) {
+                                    current = c.f = { text: "" };
+                                }
+                                break;
+                            case "v":
+                                if (c) {
+                                    current = c.v = { text: "" };
+                                }
+                                break;
+                            case "is":
+                            case "t":
+                                if (c) {
+                                    current = c.v = { text: "" };
+                                }
+                                break;
+                            case "mergeCell":
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    // =================================================================
+                    //
+                    if (shouldHandleHyperlinks) {
+                        switch (node.name) {
+                            case "hyperlinks":
+                                inHyperlinks = true;
+                                break;
+                            case "hyperlink":
+                                if (inHyperlinks) {
+                                    const hyperlink = {
+                                        ref: node.attributes.ref,
+                                        rId: node.attributes["r:id"]
+                                    };
+                                    if (emitHyperlinks) {
+                                        (worksheetEvents || (worksheetEvents = [])).push({ eventType: "hyperlink", value: hyperlink });
+                                    }
+                                    else {
+                                        hyperlinks[hyperlink.ref] = hyperlink;
+                                    }
+                                }
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+                else if (eventType === "text") {
+                    // only text data is for sheet values
+                    if (emitSheet) {
+                        if (current) {
+                            current.text += value;
+                        }
+                    }
+                }
+                else if (eventType === "closetag") {
+                    const node = value;
+                    if (emitSheet) {
+                        switch (node.name) {
+                            case "cols":
+                                inCols = false;
+                                this._columns = Column.fromModel(cols);
+                                break;
+                            case "sheetData":
+                                inRows = false;
+                                break;
+                            case "row":
+                                if (row) {
+                                    this._dimensions.expandRow(row);
+                                    (worksheetEvents || (worksheetEvents = [])).push({ eventType: "row", value: row });
+                                }
+                                row = null;
+                                break;
+                            case "c":
+                                if (row && c) {
+                                    const address = colCache.decodeAddress(c.ref);
+                                    const cell = row.getCell(address.col);
+                                    if (c.s) {
+                                        const style = styles.getStyleModel(c.s);
+                                        if (style) {
+                                            cell.style = style;
+                                        }
+                                    }
+                                    if (c.f) {
+                                        const cellValue = {
+                                            formula: c.f.text
+                                        };
+                                        if (c.v) {
+                                            if (c.t === "str") {
+                                                cellValue.result = xmlDecode(c.v.text);
+                                            }
+                                            else {
+                                                cellValue.result = parseFloat(c.v.text);
+                                            }
+                                        }
+                                        cell.value = cellValue;
+                                    }
+                                    else if (c.v) {
+                                        switch (c.t) {
+                                            case "s": {
+                                                const index = parseInt(c.v.text, 10);
+                                                if (sharedStrings) {
+                                                    cell.value = sharedStrings[index];
+                                                }
+                                                else {
+                                                    // Streaming format - unresolved shared string reference
+                                                    cell.value = {
+                                                        sharedString: index
+                                                    };
+                                                }
+                                                break;
+                                            }
+                                            case "inlineStr":
+                                            case "str":
+                                                cell.value = xmlDecode(c.v.text);
+                                                break;
+                                            case "e":
+                                                cell.value = { error: c.v.text };
+                                                break;
+                                            case "b":
+                                                cell.value = parseInt(c.v.text, 10) !== 0;
+                                                break;
+                                            default: {
+                                                const numFmtStr = typeof cell.numFmt === "string" ? cell.numFmt : cell.numFmt?.formatCode;
+                                                if (numFmtStr && isDateFmt(numFmtStr)) {
+                                                    cell.value = excelToDate(parseFloat(c.v.text), properties?.model?.date1904);
+                                                }
+                                                else {
+                                                    cell.value = parseFloat(c.v.text);
+                                                }
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    if (hyperlinks) {
+                                        const hyperlink = hyperlinks[c.ref];
+                                        if (hyperlink) {
+                                            // Streaming-specific: assign text and hyperlink for further processing
+                                            cell.text = cell.value;
+                                            cell.value = undefined;
+                                            cell.hyperlink = hyperlink;
+                                        }
+                                    }
+                                    c = null;
+                                    current = null;
+                                }
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                    if (shouldHandleHyperlinks) {
+                        switch (node.name) {
+                            case "hyperlinks":
+                                inHyperlinks = false;
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+            }
+            if (worksheetEvents && worksheetEvents.length > 0) {
+                yield worksheetEvents;
+            }
+        }
+    }
+}
+export { WorksheetReader };

package/dist/browser/modules/excel/stream/worksheet-writer.d.ts

@@ -0,0 +1,140 @@
+import { Dimensions } from "@excel/range";
+import { StringBuf } from "@excel/utils/string-buf";
+import { Row } from "@excel/row";
+import { Column } from "@excel/column";
+import { SheetRelsWriter } from "@excel/stream/sheet-rels-writer";
+import { SheetCommentsWriter } from "@excel/stream/sheet-comments-writer";
+import { DataValidations } from "@excel/data-validations";
+import type { StreamBuf } from "@excel/utils/stream-buf";
+import type { RowBreak, ColBreak, PageSetup, HeaderFooter, WorksheetProperties, WorksheetView, WorksheetState, AutoFilter, WorksheetProtection, ConditionalFormattingOptions } from "@excel/types";
+interface WorksheetWriterOptions {
+    id: number;
+    name?: string;
+    workbook: any;
+    useSharedStrings?: boolean;
+    properties?: Partial<WorksheetProperties>;
+    state?: WorksheetState;
+    pageSetup?: Partial<PageSetup>;
+    views?: Partial<WorksheetView>[];
+    autoFilter?: AutoFilter;
+    headerFooter?: Partial<HeaderFooter>;
+}
+declare class WorksheetWriter {
+    id: number;
+    name: string;
+    state: WorksheetState;
+    /** Rows stored while being worked on. Set to null after commit. */
+    _rows: Row[] | null;
+    /** Column definitions */
+    _columns: Column[] | null;
+    /** Column keys mapping: key => Column */
+    _keys: {
+        [key: string]: Column;
+    };
+    /** Merged cell ranges */
+    _merges: Dimensions[];
+    _sheetRelsWriter: SheetRelsWriter;
+    _sheetCommentsWriter: SheetCommentsWriter;
+    _dimensions: Dimensions;
+    _rowZero: number;
+    _rowOffset: number;
+    committed: boolean;
+    dataValidations: DataValidations;
+    /** Shared formulae by address */
+    _formulae: {
+        [key: string]: unknown;
+    };
+    _siFormulae: number;
+    conditionalFormatting: ConditionalFormattingOptions[];
+    rowBreaks: RowBreak[];
+    colBreaks: ColBreak[];
+    properties: Partial<WorksheetProperties> & {
+        defaultRowHeight: number;
+        dyDescent?: number;
+        outlineLevelCol: number;
+        outlineLevelRow: number;
+    };
+    headerFooter: Partial<HeaderFooter>;
+    pageSetup: Partial<PageSetup> & {
+        margins: PageSetup["margins"];
+    };
+    useSharedStrings: boolean;
+    _workbook: any;
+    hasComments: boolean;
+    _views: Partial<WorksheetView>[];
+    autoFilter: AutoFilter | null;
+    _media: unknown[];
+    sheetProtection: {
+        sheet?: boolean;
+        algorithmName?: string;
+        saltValue?: string;
+        spinCount?: number;
+        hashValue?: string;
+        [key: string]: unknown;
+    } | null;
+    _stream?: InstanceType<typeof StreamBuf>;
+    startedData: boolean;
+    _background?: {
+        imageId?: number;
+        rId?: string;
+    };
+    _headerRowCount?: number;
+    /** Relationship Id - assigned by WorkbookWriter */
+    rId?: string;
+    constructor(options: WorksheetWriterOptions);
+    get workbook(): any;
+    get stream(): any;
+    destroy(): void;
+    commit(): void;
+    get dimensions(): Dimensions;
+    get views(): Partial<WorksheetView>[];
+    get columns(): Column[] | null;
+    set columns(value: Partial<Column>[]);
+    getColumnKey(key: string): Column | undefined;
+    setColumnKey(key: string, value: Column): void;
+    deleteColumnKey(key: string): void;
+    eachColumnKey(f: (column: Column, key: string) => void): void;
+    getColumn(c: string | number): Column;
+    get _nextRow(): number;
+    eachRow(options: {
+        includeEmpty?: boolean;
+    } | ((row: Row, rowNumber: number) => void), iteratee?: (row: Row, rowNumber: number) => void): void;
+    _commitRow(cRow: Row): void;
+    get lastRow(): Row | undefined;
+    findRow(rowNumber: number): Row | undefined;
+    getRow(rowNumber: number): Row;
+    addRow(value: any[] | Record<string, any>): Row;
+    findCell(r: string | number, c?: number): any;
+    getCell(r: string | number, c?: number): any;
+    mergeCells(...cells: (string | number)[]): void;
+    addConditionalFormatting(cf: ConditionalFormattingOptions): void;
+    removeConditionalFormatting(filter?: number | ((cf: ConditionalFormattingOptions) => boolean)): void;
+    addBackgroundImage(imageId: number): void;
+    getBackgroundImageId(): number | undefined;
+    protect(password?: string, options?: Partial<WorksheetProtection>): Promise<void>;
+    unprotect(): void;
+    _write(text: string): void;
+    _writeSheetProperties(xmlBuf: StringBuf, properties: Partial<WorksheetProperties> | undefined, pageSetup: Partial<PageSetup> | undefined): void;
+    _writeSheetFormatProperties(xmlBuf: StringBuf, properties: Partial<WorksheetProperties> | undefined): void;
+    _writeOpenWorksheet(): void;
+    _writeColumns(): void;
+    _writeOpenSheetData(): void;
+    _writeRow(row: any): void;
+    _writeCloseSheetData(): void;
+    _writeMergeCells(): void;
+    _writeHyperlinks(): void;
+    _writeConditionalFormatting(): void;
+    _writeRowBreaks(): void;
+    _writeColBreaks(): void;
+    _writeDataValidations(): void;
+    _writeSheetProtection(): void;
+    _writePageMargins(): void;
+    _writePageSetup(): void;
+    _writeHeaderFooter(): void;
+    _writeAutoFilter(): void;
+    _writeBackground(): void;
+    _writeLegacyData(): void;
+    _writeDimensions(): void;
+    _writeCloseWorksheet(): void;
+}
+export { WorksheetWriter };