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

package/dist/browser/modules/excel/xlsx/xform/table/filter-column-xform.d.ts

@@ -0,0 +1,24 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { ListXform } from "@excel/xlsx/xform/list-xform";
+interface FilterColumnModel {
+    colId?: string;
+    filterButton: boolean;
+    customFilters?: any[];
+}
+declare class FilterColumnXform extends BaseXform {
+    map: {
+        [key: string]: ListXform;
+    };
+    parser: any;
+    model: FilterColumnModel;
+    constructor();
+    get tag(): string;
+    prepare(model: FilterColumnModel, options: {
+        index: number;
+    }): void;
+    render(xmlStream: any, model: FilterColumnModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { FilterColumnXform };

package/dist/browser/modules/excel/xlsx/xform/table/filter-column-xform.js

@@ -0,0 +1,87 @@
+import { BaseXform } from "../base-xform.js";
+import { ListXform } from "../list-xform.js";
+import { CustomFilterXform } from "./custom-filter-xform.js";
+import { FilterXform } from "./filter-xform.js";
+class FilterColumnXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            customFilters: new ListXform({
+                tag: "customFilters",
+                count: false,
+                empty: true,
+                childXform: new CustomFilterXform()
+            }),
+            filters: new ListXform({
+                tag: "filters",
+                count: false,
+                empty: true,
+                childXform: new FilterXform()
+            })
+        };
+        this.model = { filterButton: false };
+    }
+    get tag() {
+        return "filterColumn";
+    }
+    prepare(model, options) {
+        model.colId = options.index.toString();
+    }
+    render(xmlStream, model) {
+        if (model.customFilters) {
+            xmlStream.openNode(this.tag, {
+                colId: model.colId,
+                hiddenButton: model.filterButton ? "0" : "1"
+            });
+            this.map.customFilters.render(xmlStream, model.customFilters);
+            xmlStream.closeNode();
+            return;
+        }
+        xmlStream.leafNode(this.tag, {
+            colId: model.colId,
+            hiddenButton: model.filterButton ? "0" : "1"
+        });
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        const { attributes } = node;
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    filterButton: attributes.hiddenButton === "0"
+                };
+                return true;
+            case "dynamicFilter":
+                // Ignore dynamicFilter nodes - we don't need to preserve them for reading
+                return true;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parseOpen(node);
+                    return true;
+                }
+                throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+        }
+    }
+    parseText() { }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                this.model.customFilters = this.map.customFilters.model;
+                return false;
+            default:
+                // could be some unrecognised tags
+                return true;
+        }
+    }
+}
+export { FilterColumnXform };

package/dist/browser/modules/excel/xlsx/xform/table/filter-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface FilterModel {
+    val: string;
+}
+declare class FilterXform extends BaseXform {
+    model: FilterModel;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: FilterModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { FilterXform };

package/dist/browser/modules/excel/xlsx/xform/table/filter-xform.js

@@ -0,0 +1,29 @@
+import { BaseXform } from "../base-xform.js";
+class FilterXform extends BaseXform {
+    constructor() {
+        super();
+        this.model = { val: "" };
+    }
+    get tag() {
+        return "filter";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, {
+            val: model.val
+        });
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            this.model = {
+                val: node.attributes.val
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { FilterXform };

package/dist/browser/modules/excel/xlsx/xform/table/table-column-xform.d.ts

@@ -0,0 +1,21 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface TableColumnModel {
+    id?: number;
+    name: string;
+    totalsRowLabel?: string;
+    totalsRowFunction?: string;
+    dxfId?: string;
+}
+declare class TableColumnXform extends BaseXform {
+    model: TableColumnModel;
+    constructor();
+    get tag(): string;
+    prepare(model: TableColumnModel, options: {
+        index: number;
+    }): void;
+    render(xmlStream: any, model: TableColumnModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { TableColumnXform };

package/dist/browser/modules/excel/xlsx/xform/table/table-column-xform.js

@@ -0,0 +1,41 @@
+import { BaseXform } from "../base-xform.js";
+class TableColumnXform extends BaseXform {
+    constructor() {
+        super();
+        this.model = { name: "" };
+    }
+    get tag() {
+        return "tableColumn";
+    }
+    prepare(model, options) {
+        model.id = options.index + 1;
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, {
+            id: model.id.toString(),
+            name: model.name,
+            totalsRowLabel: model.totalsRowLabel,
+            // Excel doesn't output totalsRowFunction when value is 'none'
+            totalsRowFunction: model.totalsRowFunction === "none" ? undefined : model.totalsRowFunction,
+            dxfId: model.dxfId
+        });
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            const { attributes } = node;
+            this.model = {
+                name: attributes.name,
+                totalsRowLabel: attributes.totalsRowLabel,
+                totalsRowFunction: attributes.totalsRowFunction,
+                dxfId: attributes.dxfId
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { TableColumnXform };

package/dist/browser/modules/excel/xlsx/xform/table/table-style-info-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface TableStyleModel {
+    theme?: string | null;
+    showFirstColumn: boolean;
+    showLastColumn: boolean;
+    showRowStripes: boolean;
+    showColumnStripes: boolean;
+}
+declare class TableStyleInfoXform extends BaseXform {
+    model: TableStyleModel;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: TableStyleModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { TableStyleInfoXform };

package/dist/browser/modules/excel/xlsx/xform/table/table-style-info-xform.js

@@ -0,0 +1,44 @@
+import { BaseXform } from "../base-xform.js";
+class TableStyleInfoXform extends BaseXform {
+    constructor() {
+        super();
+        this.model = {
+            theme: null,
+            showFirstColumn: false,
+            showLastColumn: false,
+            showRowStripes: false,
+            showColumnStripes: false
+        };
+    }
+    get tag() {
+        return "tableStyleInfo";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, {
+            name: model.theme ? model.theme : undefined,
+            showFirstColumn: model.showFirstColumn ? "1" : "0",
+            showLastColumn: model.showLastColumn ? "1" : "0",
+            showRowStripes: model.showRowStripes ? "1" : "0",
+            showColumnStripes: model.showColumnStripes ? "1" : "0"
+        });
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            const { attributes } = node;
+            this.model = {
+                theme: attributes.name ? attributes.name : null,
+                showFirstColumn: attributes.showFirstColumn === "1",
+                showLastColumn: attributes.showLastColumn === "1",
+                showRowStripes: attributes.showRowStripes === "1",
+                showColumnStripes: attributes.showColumnStripes === "1"
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { TableStyleInfoXform };

package/dist/browser/modules/excel/xlsx/xform/table/table-xform.d.ts

@@ -0,0 +1,33 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface TableModel {
+    id?: number;
+    name: string;
+    displayName?: string;
+    ref?: string;
+    tableRef: string;
+    totalsRow?: boolean;
+    headerRow?: boolean;
+    columns?: any[];
+    rows?: any[];
+    autoFilterRef?: string;
+    style?: any;
+}
+declare class TableXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: TableModel;
+    constructor();
+    prepare(model: TableModel, options: any): void;
+    get tag(): string;
+    render(xmlStream: any, model: TableModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: TableModel, options: any): void;
+    static TABLE_ATTRIBUTES: {
+        xmlns: string;
+    };
+}
+export { TableXform };

package/dist/browser/modules/excel/xlsx/xform/table/table-xform.js

@@ -0,0 +1,126 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
+import { BaseXform } from "../base-xform.js";
+import { ListXform } from "../list-xform.js";
+import { AutoFilterXform } from "./auto-filter-xform.js";
+import { TableColumnXform } from "./table-column-xform.js";
+import { TableStyleInfoXform } from "./table-style-info-xform.js";
+class TableXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            autoFilter: new AutoFilterXform(),
+            tableColumns: new ListXform({
+                tag: "tableColumns",
+                count: true,
+                empty: true,
+                childXform: new TableColumnXform()
+            }),
+            tableStyleInfo: new TableStyleInfoXform()
+        };
+        this.model = {
+            id: 0,
+            name: "",
+            tableRef: "",
+            columns: []
+        };
+    }
+    prepare(model, options) {
+        this.map.autoFilter.prepare(model);
+        this.map.tableColumns.prepare(model.columns, options);
+    }
+    get tag() {
+        return "table";
+    }
+    render(xmlStream, model) {
+        xmlStream.openXml(XmlStream.StdDocAttributes);
+        xmlStream.openNode(this.tag, {
+            ...TableXform.TABLE_ATTRIBUTES,
+            id: model.id,
+            name: model.name,
+            displayName: model.displayName || model.name,
+            ref: model.tableRef,
+            totalsRowCount: model.totalsRow ? "1" : undefined,
+            // Excel doesn't output headerRowCount when it's 1 (default) or when there's a header row
+            headerRowCount: model.headerRow ? undefined : "0"
+        });
+        this.map.autoFilter.render(xmlStream, model);
+        this.map.tableColumns.render(xmlStream, model.columns);
+        this.map.tableStyleInfo.render(xmlStream, model.style);
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        const { name, attributes } = node;
+        switch (name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    name: attributes.name,
+                    displayName: attributes.displayName || attributes.name,
+                    tableRef: attributes.ref,
+                    totalsRow: attributes.totalsRowCount === "1",
+                    // ECMA-376: headerRowCount defaults to 1, so missing attribute means has header
+                    headerRow: attributes.headerRowCount !== "0"
+                };
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        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 this.tag:
+                this.model.columns = this.map.tableColumns.model;
+                if (this.map.autoFilter.model) {
+                    this.model.autoFilterRef = this.map.autoFilter.model.autoFilterRef;
+                    this.map.autoFilter.model.columns.forEach((column, index) => {
+                        this.model.columns[index].filterButton = column.filterButton;
+                    });
+                }
+                this.model.style = this.map.tableStyleInfo.model;
+                return false;
+            default:
+                // could be some unrecognised tags
+                return true;
+        }
+    }
+    reconcile(model, options) {
+        // Map tableRef to ref for Table constructor compatibility
+        if (model.tableRef && !model.ref) {
+            model.ref = model.tableRef;
+        }
+        // Add empty rows array if not present (tables loaded from file don't have row data)
+        if (!model.rows) {
+            model.rows = [];
+        }
+        // fetch the dfxs from styles
+        model.columns.forEach(column => {
+            if (column.dxfId !== undefined) {
+                column.style = options.styles.getDxfStyle(column.dxfId);
+            }
+        });
+    }
+}
+TableXform.TABLE_ATTRIBUTES = {
+    xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+};
+export { TableXform };

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

@@ -0,0 +1,208 @@
+/**
+ * XLSX - Abstract base class for XLSX operations
+ *
+ * Contains all platform-agnostic logic shared between Node.js and Browser versions:
+ * - reconcile: Reconcile model after parsing
+ * - _process*Entry: Process individual ZIP entries
+ * - add*: Add content to ZIP during writing
+ * - prepareModel: Prepare model for writing
+ * - loadFromFiles: Load from pre-extracted ZIP data
+ */
+import { type IEventEmitter } from "@stream";
+import type { Workbook } from "@excel/workbook";
+import type { ZipTimestampMode } from "@archive/utils/timestamps";
+type StreamListener = Parameters<IEventEmitter["on"]>[1];
+interface EmitterLike {
+    on(event: string, listener: StreamListener): this;
+    once(event: string, listener: StreamListener): this;
+    off(event: string, listener: StreamListener): this;
+}
+export interface IParseStream extends EmitterLike {
+    pipe(dest: any): any;
+    [Symbol.asyncIterator]?: () => AsyncIterator<Uint8Array | string>;
+}
+export interface IStreamBuf extends EmitterLike {
+    write(data: any): void;
+    end(): void;
+    read(): any;
+    toBuffer?(): any;
+    pipe?(dest: any): any;
+}
+export interface IZipWriter extends EmitterLike {
+    append(data: any, options: {
+        name: string;
+        base64?: boolean;
+    }): void;
+    pipe(stream: any): void;
+    finalize(): void;
+}
+export interface XlsxReadOptions {
+    base64?: boolean;
+    [key: string]: unknown;
+}
+export interface ZipWriterOptions {
+    level?: number;
+    /** ZIP entry modification time (optional). If omitted, defaults to current time. */
+    modTime?: Date;
+    /** Timestamp writing strategy for ZIP entry metadata (optional). */
+    timestamps?: ZipTimestampMode;
+}
+export interface XlsxWriteOptions {
+    zip?: ZipWriterOptions;
+    [key: string]: unknown;
+}
+export type XlsxOptions = XlsxReadOptions & XlsxWriteOptions;
+export interface WorkbookMediaLike {
+    type: string;
+    extension: string;
+    name?: string;
+    filename?: string;
+    buffer?: Uint8Array;
+    base64?: string;
+}
+export interface MediaModel {
+    media: WorkbookMediaLike[];
+}
+interface ZipEntryLike {
+    name: string;
+    type: "Directory" | "File";
+    stream: IParseStream;
+    drain: () => Promise<void>;
+}
+/**
+ * XLSX class - handles Excel file operations
+ * Works in both Node.js and Browser environments
+ */
+declare class XLSX {
+    workbook: Workbook;
+    static RelType: {
+        OfficeDocument: string;
+        Worksheet: string;
+        CalcChain: string;
+        SharedStrings: string;
+        Styles: string;
+        Theme: string;
+        Hyperlink: string;
+        Image: string;
+        CoreProperties: string;
+        ExtenderProperties: string;
+        Comments: string;
+        VmlDrawing: string;
+        Table: string;
+        PivotCacheDefinition: string;
+        PivotCacheRecords: string;
+        PivotTable: string;
+    };
+    constructor(workbook: Workbook);
+    /**
+     * Create a stream from binary data (for media/themes)
+     */
+    protected createBinaryStream(data: Uint8Array): IParseStream;
+    /**
+     * Create a stream from string content (for XML parsing)
+     */
+    protected createTextStream(content: string): IParseStream;
+    /**
+     * Create a StreamBuf instance for buffering data
+     */
+    protected createStreamBuf(): IStreamBuf;
+    /**
+     * Convert buffer/Uint8Array to string
+     */
+    protected bufferToString(data: string | ArrayBuffer | Uint8Array): string;
+    /**
+     * Create a ZIP writer adapter.
+     * Can be overridden by subclasses for platform-specific implementations.
+     */
+    protected createZipWriter(options?: XlsxWriteOptions["zip"]): IZipWriter;
+    /**
+     * Write all workbook content to a ZIP writer
+     * Shared by both Node.js write() and browser writeBuffer()
+     */
+    protected writeToZip(zip: IZipWriter, options?: XlsxWriteOptions): Promise<void>;
+    /**
+     * Read workbook from a stream
+     */
+    read(stream: IParseStream, options?: XlsxReadOptions): Promise<any>;
+    /**
+     * Write workbook to a stream
+     */
+    write(stream: any, options?: XlsxWriteOptions): Promise<XLSX>;
+    /**
+     * Load workbook from buffer/ArrayBuffer/Uint8Array
+     */
+    load(data: any, options?: XlsxReadOptions): Promise<any>;
+    /**
+     * Internal: Load from Uint8Array buffer
+     */
+    protected loadBuffer(buffer: Uint8Array, options?: XlsxReadOptions): Promise<any>;
+    /**
+     * Internal: Load workbook from an async stream of ZIP entries.
+     *
+     * This is the foundation for TRUE streaming reads on platforms that have a
+     * streaming ZIP parser (e.g. Node.js `modules/archive` Parse).
+     */
+    protected loadFromZipEntries(entries: AsyncIterable<ZipEntryLike>, options?: XlsxOptions): Promise<any>;
+    /**
+     * Write workbook to buffer
+     */
+    writeBuffer(options?: XlsxWriteOptions): Promise<Uint8Array>;
+    /**
+     * Add media files to ZIP
+     * Supports buffer, base64, and filename (if readFileAsync is provided)
+     */
+    addMedia(zip: IZipWriter, model: MediaModel): Promise<void>;
+    /**
+     * Optional file reader - can be overridden by subclasses (e.g., Node.js version)
+     */
+    protected readFileAsync?: (filename: string) => Promise<Uint8Array>;
+    parseRels(stream: IParseStream): Promise<any>;
+    parseWorkbook(stream: IParseStream): Promise<any>;
+    parseSharedStrings(stream: IParseStream): Promise<any>;
+    reconcile(model: any, options?: XlsxOptions): void;
+    /**
+     * Reconcile pivot tables by linking them to worksheets and their cache data.
+     */
+    protected _reconcilePivotTables(model: any): void;
+    protected _extractTableNumber(name: string): number;
+    protected _buildCacheIdMap(model: any): Map<string, number>;
+    protected _buildDefinitionToCacheIdMap(model: any): Map<string, number>;
+    protected _determineMetric(dataFields: Array<{
+        subtotal?: string;
+    }>): "sum" | "count";
+    _processWorksheetEntry(stream: IParseStream, model: any, sheetNo: number, options: XlsxOptions | undefined, path: string): Promise<void>;
+    _processCommentEntry(stream: IParseStream, model: any, name: string): Promise<void>;
+    _processTableEntry(stream: IParseStream, model: any, name: string): Promise<void>;
+    _processWorksheetRelsEntry(stream: IParseStream, model: any, sheetNo: number): Promise<void>;
+    _processMediaEntry(stream: IParseStream, model: any, filename: string): Promise<void>;
+    _processDrawingEntry(entry: any, model: any, name: string): Promise<void>;
+    _processDrawingRelsEntry(entry: any, model: any, name: string): Promise<void>;
+    _processVmlDrawingEntry(entry: any, model: any, name: string): Promise<void>;
+    _processThemeEntry(stream: IParseStream, model: any, name: string): Promise<void>;
+    _processPivotTableEntry(stream: IParseStream, model: any, name: string): Promise<void>;
+    _processPivotTableRelsEntry(stream: IParseStream, model: any, name: string): Promise<void>;
+    _processPivotCacheDefinitionEntry(stream: IParseStream, model: any, name: string): Promise<void>;
+    _processPivotCacheDefinitionRelsEntry(stream: IParseStream, model: any, name: string): Promise<void>;
+    _processPivotCacheRecordsEntry(stream: IParseStream, model: any, name: string): Promise<void>;
+    loadFromFiles(zipData: Record<string, Uint8Array>, options?: any): Promise<any>;
+    /**
+     * Process default entries (drawings, comments, tables, etc.)
+     */
+    protected _processDefaultEntry(stream: IParseStream, model: any, entryName: string): Promise<boolean>;
+    addContentTypes(zip: IZipWriter, model: any): Promise<void>;
+    addApp(zip: IZipWriter, model: any): Promise<void>;
+    addCore(zip: IZipWriter, model: any): Promise<void>;
+    addThemes(zip: IZipWriter, model: any): Promise<void>;
+    addOfficeRels(zip: IZipWriter, _model: any): Promise<void>;
+    addWorkbookRels(zip: IZipWriter, model: any): Promise<void>;
+    addSharedStrings(zip: IZipWriter, model: any): Promise<void>;
+    addStyles(zip: IZipWriter, model: any): Promise<void>;
+    addWorkbook(zip: IZipWriter, model: any): Promise<void>;
+    addWorksheets(zip: IZipWriter, model: any): Promise<void>;
+    addDrawings(zip: IZipWriter, model: any): void;
+    addTables(zip: IZipWriter, model: any): void;
+    addPivotTables(zip: IZipWriter, model: any): void;
+    _finalize(zip: IZipWriter): Promise<this>;
+    prepareModel(model: any, options: any): void;
+}
+export { XLSX };