@cj-tech-master/excelts 3.0.1-canary.20251230173853.c3c79fa → 3.1.0-canary.20260102041828.82ed571

package/dist/types/modules/excel/xlsx/xform/style/font-xform.d.ts

@@ -0,0 +1,35 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface FontModel {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean | string;
+    charset?: number;
+    color?: any;
+    condense?: boolean;
+    extend?: boolean;
+    family?: number;
+    outline?: boolean;
+    vertAlign?: string;
+    scheme?: string;
+    shadow?: boolean;
+    strike?: boolean;
+    size?: number;
+    name?: string;
+}
+interface FontOptions {
+    tagName: string;
+    fontNameTag: string;
+}
+declare class FontXform extends BaseXform {
+    private options;
+    parser: any;
+    private renderOrder;
+    constructor(options?: FontOptions);
+    get tag(): string;
+    render(xmlStream: any, model: FontModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static OPTIONS: FontOptions;
+}
+export { FontXform };

package/dist/types/modules/excel/xlsx/xform/style/numfmt-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface NumFmtModel {
+    id: number;
+    formatCode: string;
+}
+declare class NumFmtXform extends BaseXform {
+    private id?;
+    private formatCode?;
+    constructor(id?: number, formatCode?: string);
+    get tag(): string;
+    render(xmlStream: any, model: NumFmtModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+    static getDefaultFmtId(formatCode: string): number | undefined;
+    static getDefaultFmtCode(numFmtId: number): string | undefined;
+}
+export { NumFmtXform };

package/dist/types/modules/excel/xlsx/xform/style/protection-xform.d.ts

@@ -0,0 +1,13 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface ProtectionModel {
+    locked?: boolean;
+    hidden?: boolean;
+}
+declare class ProtectionXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: ProtectionModel): void;
+    parseOpen(node: any): void;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { ProtectionXform };

package/dist/types/modules/excel/xlsx/xform/style/style-xform.d.ts

@@ -0,0 +1,30 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { AlignmentXform } from "@excel/xlsx/xform/style/alignment-xform";
+import { ProtectionXform } from "@excel/xlsx/xform/style/protection-xform";
+interface StyleModel {
+    numFmtId?: number;
+    fontId?: number;
+    fillId?: number;
+    borderId?: number;
+    xfId?: number;
+    alignment?: any;
+    protection?: any;
+}
+interface StyleOptions {
+    xfId?: boolean;
+}
+declare class StyleXform extends BaseXform {
+    private xfId;
+    map: {
+        alignment: AlignmentXform;
+        protection: ProtectionXform;
+    };
+    parser: any;
+    constructor(options?: StyleOptions);
+    get tag(): string;
+    render(xmlStream: any, model: StyleModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { StyleXform };

package/dist/types/modules/excel/xlsx/xform/style/styles-xform.d.ts

@@ -0,0 +1,46 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { StaticXform } from "@excel/xlsx/xform/static-xform";
+interface StylesModel {
+    styles?: any[];
+    numFmts?: any[];
+    fonts?: any[];
+    borders?: any[];
+    fills?: any[];
+    dxfs?: any[];
+}
+declare class StylesXform extends BaseXform {
+    private index?;
+    private weakMap?;
+    parser: any;
+    static Mock: typeof StylesXform;
+    constructor(initialise?: boolean);
+    initIndex(): void;
+    init(): void;
+    render(xmlStream: any, model?: StylesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    addStyleModel(model: any, cellType?: number): number;
+    getStyleModel(id: number): any;
+    addDxfStyle(style: any): number;
+    getDxfStyle(id: number): any;
+    _addStyle(style: any): number;
+    _addNumFmtStr(formatCode: string): number;
+    _addFont(font: any): number;
+    _addBorder(border: any): number;
+    _addFill(fill: any): number;
+    static STYLESHEET_ATTRIBUTES: {
+        xmlns: string;
+        "xmlns:mc": string;
+        "mc:Ignorable": string;
+        "xmlns:x14ac": string;
+        "xmlns:x16r2": string;
+    };
+    static STATIC_XFORMS: {
+        cellStyles: StaticXform;
+        dxfs: StaticXform;
+        tableStyles: StaticXform;
+        extLst: StaticXform;
+    };
+}
+export { StylesXform };

package/dist/types/modules/excel/xlsx/xform/style/underline-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+type UnderlineType = boolean | "single" | "double" | "singleAccounting" | "doubleAccounting";
+declare class UnderlineXform extends BaseXform {
+    static Attributes: {
+        [key: string]: any;
+    };
+    constructor(model?: UnderlineType);
+    get tag(): string;
+    render(xmlStream: any, model?: UnderlineType): void;
+    parseOpen(node: any): void;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { UnderlineXform };

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

@@ -0,0 +1,21 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { FilterColumnXform } from "@excel/xlsx/xform/table/filter-column-xform";
+interface AutoFilterModel {
+    autoFilterRef: string;
+    columns: any[];
+}
+declare class AutoFilterXform extends BaseXform {
+    map: {
+        [key: string]: FilterColumnXform;
+    };
+    parser: any;
+    model: AutoFilterModel;
+    constructor();
+    get tag(): string;
+    prepare(model: any): void;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { AutoFilterXform };

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

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

package/dist/types/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/types/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/types/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/types/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/types/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/types/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 };

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

@@ -0,0 +1,24 @@
+/**
+ * XLSX - Node.js version with full functionality
+ *
+ * Extends XLSX with:
+ * - readFile: Read from file path
+ * - writeFile: Write to file path
+ * - Constructor injects readFileAsync for filename-based media loading
+ *
+ * Inherited from XLSX:
+ * - read: Read from stream
+ * - write: Write to stream
+ * - load: Load from buffer
+ * - writeBuffer: Write to buffer (Uint8Array)
+ * - addMedia: Supports buffer, base64, and filename (via readFileAsync)
+ */
+import { XLSX as XLSXBase } from "@excel/xlsx/xlsx.browser";
+declare class XLSX extends XLSXBase {
+    constructor(workbook: any);
+    private static iterateZipEntries;
+    read(stream: any, options?: any): Promise<any>;
+    readFile(filename: string, options?: any): Promise<any>;
+    writeFile(filename: string, options?: any): Promise<void>;
+}
+export { XLSX };

package/dist/types/modules/stream/base-transform.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Base Transform Stream
+ *
+ * Provides a base class for Transform streams.
+ * Works identically in both browser and Node.js environments.
+ */
+import { EventEmitter } from "@stream/event-emitter";
+export interface BaseTransformOptions {
+    /** High water mark for backpressure */
+    highWaterMark?: number;
+    /** Enable object mode (non-binary data) */
+    objectMode?: boolean;
+}
+export type TransformCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
+/**
+ * Browser-compatible Base Transform stream
+ */
+export declare abstract class BaseTransform<TInput = Uint8Array, TOutput = Uint8Array> extends EventEmitter {
+    protected _buffer: TInput[];
+    protected _bufferIndex: number;
+    protected _isProcessing: boolean;
+    protected _isDestroyed: boolean;
+    protected _isFinished: boolean;
+    protected _errorEmitted: boolean;
+    protected _objectMode: boolean;
+    protected _highWaterMark: number;
+    constructor(options?: BaseTransformOptions);
+    /**
+     * Main transform implementation - must be overridden by subclasses
+     */
+    abstract processChunk(chunk: TInput, callback: TransformCallback<TOutput>): void;
+    /**
+     * Optional flush implementation for remaining data
+     */
+    processFlush(callback: TransformCallback<TOutput>): void;
+    /**
+     * Write data to the transform stream
+     */
+    write(chunk: TInput): boolean;
+    /**
+     * Signal end of input
+     */
+    end(chunk?: TInput): void;
+    /**
+     * Destroy the stream
+     */
+    destroy(error?: Error): void;
+    /**
+     * Process next chunk in buffer
+     */
+    private _processNext;
+    /**
+     * Emit error only once
+     */
+    private _emitError;
+    /**
+     * Check if stream is in a valid state
+     */
+    get isValid(): boolean;
+    /**
+     * Check if stream has finished
+     */
+    get isFinished(): boolean;
+    /**
+     * Pipe to another transform or collector
+     */
+    pipe<T extends BaseTransform<TOutput, any>>(destination: T): T;
+}