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

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/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-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-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/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 };