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

package/dist/types/xlsx/xform/style/color-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "../base-xform";
+interface ColorModel {
+    argb?: string;
+    theme?: number;
+    tint?: number;
+    indexed?: number;
+}
+declare class ColorXform extends BaseXform {
+    private name;
+    constructor(name?: string);
+    get tag(): string;
+    render(xmlStream: any, model?: ColorModel): boolean;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { ColorXform };

package/dist/types/xlsx/xform/style/dxf-xform.d.ts

@@ -0,0 +1,23 @@
+import { BaseXform } from "../base-xform";
+interface DxfModel {
+    alignment?: any;
+    border?: any;
+    fill?: any;
+    font?: any;
+    numFmt?: string;
+    numFmtId?: number;
+    protection?: any;
+}
+declare class DxfXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: DxfModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { DxfXform };

package/dist/types/xlsx/xform/style/fill-xform.d.ts

@@ -0,0 +1,85 @@
+import { BaseXform } from "../base-xform";
+import { ColorXform } from "./color-xform";
+interface StopModel {
+    position: number;
+    color: any;
+}
+interface PatternFillModel {
+    type: "pattern";
+    pattern: string;
+    fgColor?: any;
+    bgColor?: any;
+}
+interface GradientFillModel {
+    type: "gradient";
+    gradient: "angle" | "path";
+    degree?: number;
+    center?: {
+        left: number;
+        top: number;
+        right?: number;
+        bottom?: number;
+    };
+    stops: StopModel[];
+}
+type FillModel = PatternFillModel | GradientFillModel;
+declare class StopXform extends BaseXform {
+    map: {
+        color: ColorXform;
+    };
+    parser: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: StopModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+declare class PatternFillXform extends BaseXform {
+    map: {
+        fgColor: ColorXform;
+        bgColor: ColorXform;
+    };
+    parser: any;
+    constructor();
+    get name(): string;
+    get tag(): string;
+    render(xmlStream: any, model: PatternFillModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+declare class GradientFillXform extends BaseXform {
+    map: {
+        stop: StopXform;
+    };
+    parser: any;
+    constructor();
+    get name(): string;
+    get tag(): string;
+    render(xmlStream: any, model: GradientFillModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+declare class FillXform extends BaseXform {
+    map: {
+        patternFill: PatternFillXform;
+        gradientFill: GradientFillXform;
+    };
+    parser: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: FillModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    validStyle(value: string): boolean;
+    static validPatternValues: {
+        [key: string]: boolean;
+    };
+    static StopXform: typeof StopXform;
+    static PatternFillXform: typeof PatternFillXform;
+    static GradientFillXform: typeof GradientFillXform;
+}
+export { FillXform };

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

@@ -0,0 +1,35 @@
+import { BaseXform } from "../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/xlsx/xform/style/numfmt-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "../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/xlsx/xform/style/protection-xform.d.ts

@@ -0,0 +1,13 @@
+import { BaseXform } from "../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/xlsx/xform/style/style-xform.d.ts

@@ -0,0 +1,30 @@
+import { BaseXform } from "../base-xform";
+import { AlignmentXform } from "./alignment-xform";
+import { ProtectionXform } from "./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/xlsx/xform/style/styles-xform.d.ts

@@ -0,0 +1,46 @@
+import { BaseXform } from "../base-xform";
+import { StaticXform } from "../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/xlsx/xform/style/underline-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "../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/xlsx/xform/table/auto-filter-xform.d.ts

@@ -0,0 +1,21 @@
+import { BaseXform } from "../base-xform";
+import { FilterColumnXform } from "./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/xlsx/xform/table/custom-filter-xform.d.ts

@@ -0,0 +1,15 @@
+import { BaseXform } from "../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/xlsx/xform/table/filter-column-xform.d.ts

@@ -0,0 +1,24 @@
+import { BaseXform } from "../base-xform";
+import { ListXform } from "../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/xlsx/xform/table/filter-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "../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/xlsx/xform/table/table-column-xform.d.ts

@@ -0,0 +1,21 @@
+import { BaseXform } from "../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/xlsx/xform/table/table-style-info-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "../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/xlsx/xform/table/table-xform.d.ts

@@ -0,0 +1,33 @@
+import { BaseXform } from "../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/xlsx/xlsx.base.d.ts

@@ -0,0 +1,134 @@
+/**
+ * XLSXBase - 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
+ */
+/**
+ * Interface for stream-like objects used in parsing
+ */
+export interface IParseStream {
+    on(event: string, callback: Function): this;
+    removeListener(event: string, callback: Function): this;
+    pipe(dest: any): any;
+    [Symbol.asyncIterator]?: () => AsyncIterator<any>;
+}
+/**
+ * Interface for StreamBuf-like objects
+ */
+export interface IStreamBuf {
+    write(data: any): void;
+    end(): void;
+    read(): any;
+    toBuffer?(): any;
+    once(event: string, callback: Function): void;
+    on(event: string, callback: Function): void;
+    removeListener(event: string, callback: Function): void;
+    pipe?(dest: any): any;
+}
+/**
+ * Interface for ZipWriter-like objects
+ */
+export interface IZipWriter {
+    append(data: any, options: {
+        name: string;
+        base64?: boolean;
+    }): void;
+    pipe(stream: any): void;
+    on(event: string, callback: Function): void;
+    finalize(): void;
+}
+/**
+ * Abstract base class for XLSX operations
+ */
+declare abstract class XLSXBase {
+    workbook: any;
+    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: any);
+    /**
+     * Create a StreamBuf instance for buffering data
+     */
+    protected abstract createStreamBuf(): IStreamBuf;
+    /**
+     * Create a stream from binary data (for media/themes)
+     */
+    protected abstract createBinaryStream(data: Uint8Array): IParseStream;
+    /**
+     * Create a stream from string content (for XML parsing)
+     */
+    protected abstract createTextStream(content: string): IParseStream;
+    /**
+     * Convert buffer/Uint8Array to string
+     */
+    protected abstract bufferToString(data: any): string;
+    parseRels(stream: any): Promise<any>;
+    parseWorkbook(stream: any): Promise<any>;
+    parseSharedStrings(stream: any): Promise<any>;
+    reconcile(model: any, options?: any): 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: any, model: any, sheetNo: number, options: any, path: string): Promise<void>;
+    _processCommentEntry(stream: any, model: any, name: string): Promise<void>;
+    _processTableEntry(stream: any, model: any, name: string): Promise<void>;
+    _processWorksheetRelsEntry(stream: any, model: any, sheetNo: number): Promise<void>;
+    _processMediaEntry(stream: any, 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: any, model: any, name: string): Promise<void>;
+    _processPivotTableEntry(stream: any, model: any, name: string): Promise<void>;
+    _processPivotTableRelsEntry(stream: any, model: any, name: string): Promise<void>;
+    _processPivotCacheDefinitionEntry(stream: any, model: any, name: string): Promise<void>;
+    _processPivotCacheDefinitionRelsEntry(stream: any, model: any, name: string): Promise<void>;
+    _processPivotCacheRecordsEntry(stream: any, 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: any, model: any, entryName: string): Promise<void>;
+    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 { XLSXBase };

package/dist/types/xlsx/xlsx.browser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * XLSX Browser version - No Node.js dependencies
+ *
+ * Extends XLSXBase with:
+ * - load: Load from buffer/ArrayBuffer/Uint8Array
+ * - writeBuffer: Write to BrowserBuffer (Uint8Array with toString("base64"))
+ *
+ * NOT supported:
+ * - readFile/writeFile (no file system)
+ * - read/write (no streams)
+ */
+import { BrowserBuffer } from "../utils/browser-buffer";
+import { XLSXBase, type IStreamBuf, type IParseStream } from "./xlsx.base";
+declare class XLSX extends XLSXBase {
+    protected createStreamBuf(): IStreamBuf;
+    protected createBinaryStream(data: Uint8Array): IParseStream;
+    protected createTextStream(content: string): IParseStream;
+    protected bufferToString(data: any): string;
+    /**
+     * Load workbook from buffer/ArrayBuffer/Uint8Array
+     * This is the main entry point for browser usage
+     */
+    load(data: any, options?: any): Promise<any>;
+    /**
+     * Write workbook to buffer
+     * Returns a BrowserBuffer which supports toString("base64")
+     */
+    writeBuffer(options?: any): Promise<BrowserBuffer>;
+    addMedia(zip: any, model: any): Promise<void>;
+}
+export { XLSX };

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

@@ -0,0 +1,26 @@
+/**
+ * XLSX - Node.js version with full functionality
+ *
+ * Extends XLSXBase with:
+ * - readFile: Read from file path
+ * - writeFile: Write to file path
+ * - read: Read from stream
+ * - write: Write to stream
+ * - load: Load from buffer
+ * - writeBuffer: Write to buffer
+ */
+import { XLSXBase, type IStreamBuf, type IParseStream } from "./xlsx.base";
+declare class XLSX extends XLSXBase {
+    protected createStreamBuf(): IStreamBuf;
+    protected createBinaryStream(data: Uint8Array): IParseStream;
+    protected createTextStream(content: string): IParseStream;
+    protected bufferToString(data: any): string;
+    readFile(filename: string, options?: any): Promise<any>;
+    writeFile(filename: string, options?: any): Promise<void>;
+    read(stream: any, options?: any): Promise<any>;
+    write(stream: any, options?: any): Promise<XLSX>;
+    load(data: any, options?: any): Promise<any>;
+    writeBuffer(options?: any): Promise<Buffer>;
+    addMedia(zip: any, model: any): Promise<void>;
+}
+export { XLSX };