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

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

@@ -0,0 +1,195 @@
+/**
+ * Workbook - Cross-platform Excel Workbook
+ *
+ * Full functionality:
+ * - xlsx: File/stream/buffer support (file operations Node.js only)
+ * - csv: CSV read/write support (file operations Node.js only)
+ * - streaming: createStreamWriter/createStreamReader for large files
+ *
+ * Note: Browser build uses rolldown aliases to swap in browser-specific
+ * implementations for xlsx, csv, and stream modules.
+ */
+import { Worksheet, type WorksheetModel } from "./worksheet";
+import { DefinedNames, type DefinedNameModel } from "./defined-names";
+import { XLSX } from "./xlsx/xlsx";
+import { CSV } from "../csv/csv";
+import { WorkbookWriter, type WorkbookWriterOptions } from "./stream/workbook-writer";
+import { WorkbookReader, type WorkbookReaderOptions } from "./stream/workbook-reader";
+import type { Readable } from "../stream/index";
+import type { PivotTable } from "./pivot-table";
+import type { AddWorksheetOptions, CalculationProperties, Image, WorkbookProperties, WorkbookView, Buffer as ExcelBuffer } from "./types";
+/** Internal media type - more flexible than public Media type */
+export interface WorkbookMedia {
+    type: string;
+    extension: string;
+    filename?: string;
+    buffer?: ExcelBuffer | Uint8Array;
+    base64?: string;
+    name?: string;
+}
+/** Internal model type for serialization */
+export interface WorkbookModel {
+    creator?: string;
+    lastModifiedBy?: string;
+    lastPrinted?: Date;
+    created: Date;
+    modified: Date;
+    properties: Partial<WorkbookProperties>;
+    worksheets: WorksheetModel[];
+    sheets?: WorksheetModel[];
+    definedNames: DefinedNameModel[];
+    views: WorkbookView[];
+    company: string;
+    manager: string;
+    title: string;
+    subject: string;
+    keywords: string;
+    category: string;
+    description: string;
+    language?: string;
+    revision?: number;
+    contentStatus?: string;
+    themes?: unknown;
+    media: WorkbookMedia[];
+    pivotTables: PivotTable[];
+    /** Loaded pivot tables from file - used during reconciliation */
+    loadedPivotTables?: any[];
+    calcProperties: Partial<CalculationProperties>;
+}
+declare class Workbook {
+    /**
+     * Streaming workbook writer class for large files.
+     * @example
+     * // Node.js: new Workbook.Writer({ filename: "large.xlsx" })
+     * // Browser: new Workbook.Writer({ stream: writableStream })
+     */
+    static Writer: typeof WorkbookWriter;
+    /**
+     * Streaming workbook reader class for large files.
+     * @example
+     * // Node.js: new Workbook.Reader("large.xlsx")
+     * // Browser: new Workbook.Reader(readableStream)
+     */
+    static Reader: typeof WorkbookReader;
+    category: string;
+    company: string;
+    created: Date;
+    description: string;
+    keywords: string;
+    manager: string;
+    modified: Date;
+    subject: string;
+    title: string;
+    creator?: string;
+    lastModifiedBy?: string;
+    lastPrinted?: Date;
+    language?: string;
+    revision?: number;
+    contentStatus?: string;
+    properties: Partial<WorkbookProperties>;
+    calcProperties: Partial<CalculationProperties>;
+    views: WorkbookView[];
+    media: WorkbookMedia[];
+    pivotTables: PivotTable[];
+    private _worksheets;
+    private _definedNames;
+    private _themes?;
+    private _xlsx?;
+    private _csv?;
+    constructor();
+    /**
+     * xlsx file format operations
+     * Node.js: readFile, writeFile, read (stream), write (stream), load (buffer), writeBuffer
+     * Browser: load (buffer), writeBuffer
+     */
+    get xlsx(): XLSX;
+    /**
+     * csv file format operations
+     * Node.js: readFile, writeFile, read (stream), write (stream)
+     * Browser: load (string/buffer), writeString, writeBuffer
+     */
+    get csv(): CSV;
+    /**
+     * Create a streaming workbook writer for large files.
+     * This is more memory-efficient than using Workbook for large datasets.
+     *
+     * @param options - Options for the workbook writer
+     *   - Node.js: can use { filename } or { stream }
+     *   - Browser: must use { stream }
+     * @returns A new WorkbookWriter instance
+     *
+     * @example
+     * ```ts
+     * // Node.js with filename
+     * const writer = Workbook.createStreamWriter({ filename: "large-file.xlsx" });
+     *
+     * // Browser or Node.js with stream
+     * const writer = Workbook.createStreamWriter({ stream: writableStream });
+     *
+     * const sheet = writer.addWorksheet("Sheet1");
+     * for (let i = 0; i < 1000000; i++) {
+     *   sheet.addRow([i, `Row ${i}`]).commit();
+     * }
+     * await writer.commit();
+     * ```
+     */
+    static createStreamWriter(options?: WorkbookWriterOptions): WorkbookWriter;
+    /**
+     * Create a streaming workbook reader for large files.
+     * This is more memory-efficient than using Workbook.xlsx.readFile for large datasets.
+     *
+     * @param input - File path (Node.js only) or readable stream
+     * @param options - Options for the workbook reader
+     * @returns A new WorkbookReader instance
+     *
+     * @example
+     * ```ts
+     * // Node.js with file path
+     * const reader = Workbook.createStreamReader("large-file.xlsx");
+     *
+     * // Browser or Node.js with stream
+     * const reader = Workbook.createStreamReader(readableStream);
+     *
+     * for await (const event of reader) {
+     *   if (event.eventType === "worksheet") {
+     *     const worksheet = event.value;
+     *     for await (const row of worksheet) {
+     *       console.log(row.values);
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    static createStreamReader(input: string | Readable, options?: WorkbookReaderOptions): WorkbookReader;
+    get nextId(): number;
+    /**
+     * Add a new worksheet and return a reference to it
+     */
+    addWorksheet(name?: string, options?: AddWorksheetOptions): Worksheet;
+    removeWorksheetEx(worksheet: Worksheet): void;
+    removeWorksheet(id: number | string): void;
+    /**
+     * Fetch sheet by name or id
+     */
+    getWorksheet(id?: number | string): Worksheet | undefined;
+    /**
+     * Return a clone of worksheets in order
+     */
+    get worksheets(): Worksheet[];
+    /**
+     * Iterate over all sheets.
+     *
+     * Note: `workbook.worksheets.forEach` will still work but this is better.
+     */
+    eachSheet(callback: (sheet: Worksheet, id: number) => void): void;
+    get definedNames(): DefinedNames;
+    clearThemes(): void;
+    /**
+     * Add Image to Workbook and return the id
+     */
+    addImage(image: Image): number;
+    getImage(id: number | string): WorkbookMedia | undefined;
+    get model(): WorkbookModel;
+    set model(value: WorkbookModel);
+}
+export { Workbook };

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

@@ -0,0 +1,333 @@
+import { Range, type RangeInput } from "./range";
+import { Row, type RowModel } from "./row";
+import { Column, type ColumnModel, type ColumnDefn } from "./column";
+import type { Cell, FormulaResult } from "./cell";
+import { Image, type ImageModel } from "./image";
+import { Table, type TableModel } from "./table";
+import { DataValidations } from "./data-validations";
+import { type PivotTable, type PivotTableModel } from "./pivot-table";
+import type { Workbook } from "./workbook";
+import type { AddImageRange, AutoFilter, CellValue, ColBreak, ConditionalFormattingOptions, DataValidation, RowBreak, RowValues, TableProperties, WorksheetProperties, WorksheetView } from "./types";
+type DataValidationModel = {
+    [address: string]: DataValidation | undefined;
+};
+interface SheetProtection {
+    sheet?: boolean;
+    objects?: boolean;
+    scenarios?: boolean;
+    selectLockedCells?: boolean;
+    selectUnlockedCells?: boolean;
+    formatCells?: boolean;
+    formatColumns?: boolean;
+    formatRows?: boolean;
+    insertColumns?: boolean;
+    insertRows?: boolean;
+    insertHyperlinks?: boolean;
+    deleteColumns?: boolean;
+    deleteRows?: boolean;
+    sort?: boolean;
+    autoFilter?: boolean;
+    pivotTables?: boolean;
+    algorithmName?: string;
+    hashValue?: string;
+    saltValue?: string;
+    spinCount?: number;
+}
+interface WorksheetOptions {
+    workbook?: Workbook;
+    id?: number;
+    orderNo?: number;
+    name?: string;
+    state?: string;
+    properties?: Partial<WorksheetProperties>;
+    pageSetup?: Partial<PageSetup>;
+    headerFooter?: Partial<HeaderFooter>;
+    views?: Partial<WorksheetView>[];
+    autoFilter?: AutoFilter | null;
+}
+interface PageSetupMargins {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    header: number;
+    footer: number;
+}
+interface PageSetup {
+    margins: PageSetupMargins;
+    orientation: string;
+    horizontalDpi: number;
+    verticalDpi: number;
+    fitToPage: boolean;
+    pageOrder: string;
+    blackAndWhite: boolean;
+    draft: boolean;
+    cellComments: string;
+    errors: string;
+    scale: number;
+    fitToWidth: number;
+    fitToHeight: number;
+    paperSize?: number;
+    showRowColHeaders: boolean;
+    showGridLines: boolean;
+    firstPageNumber?: number;
+    horizontalCentered: boolean;
+    verticalCentered: boolean;
+    rowBreaks: RowBreak[];
+    printTitlesRow?: string;
+    printTitlesColumn?: string;
+}
+interface HeaderFooter {
+    differentFirst: boolean;
+    differentOddEven: boolean;
+    oddHeader: string | null;
+    oddFooter: string | null;
+    evenHeader: string | null;
+    evenFooter: string | null;
+    firstHeader: string | null;
+    firstFooter: string | null;
+}
+interface WorksheetModel {
+    id: number;
+    name: string;
+    dataValidations: DataValidationModel;
+    properties: Partial<WorksheetProperties>;
+    state: string;
+    pageSetup: PageSetup;
+    headerFooter: HeaderFooter;
+    rowBreaks: RowBreak[];
+    colBreaks: ColBreak[];
+    views: Partial<WorksheetView>[];
+    autoFilter: AutoFilter | null;
+    media: ImageModel[];
+    sheetProtection: SheetProtection | null;
+    tables: TableModel[];
+    pivotTables: PivotTable[];
+    conditionalFormattings: ConditionalFormattingOptions[];
+    cols?: ColumnModel[];
+    rows?: RowModel[];
+    dimensions?: Range;
+    merges?: string[];
+    mergeCells?: string[];
+}
+declare class Worksheet {
+    private _workbook;
+    id: number;
+    orderNo: number;
+    private _name;
+    state: string;
+    private _rows;
+    private _columns;
+    private _keys;
+    private _merges;
+    rowBreaks: RowBreak[];
+    colBreaks: ColBreak[];
+    properties: Partial<WorksheetProperties>;
+    pageSetup: PageSetup;
+    headerFooter: HeaderFooter;
+    dataValidations: DataValidations;
+    views: Partial<WorksheetView>[];
+    autoFilter: AutoFilter | null;
+    private _media;
+    sheetProtection: SheetProtection | null;
+    tables: {
+        [key: string]: Table;
+    };
+    pivotTables: PivotTable[];
+    conditionalFormattings: ConditionalFormattingOptions[];
+    private _headerRowCount?;
+    constructor(options: WorksheetOptions);
+    get name(): string;
+    set name(name: string | undefined);
+    /**
+     * The workbook that contains this worksheet
+     */
+    get workbook(): Workbook;
+    /**
+     * When you're done with this worksheet, call this to remove from workbook
+     */
+    destroy(): void;
+    /**
+     * Get the bounding range of the cells in this worksheet
+     */
+    get dimensions(): Range;
+    /**
+     * Get the current columns array
+     */
+    get columns(): Column[];
+    /**
+     * Add column headers and define column keys and widths.
+     *
+     * Note: these column structures are a workbook-building convenience only,
+     * apart from the column width, they will not be fully persisted.
+     */
+    set columns(value: ColumnDefn[]);
+    getColumnKey(key: string): Column | undefined;
+    setColumnKey(key: string, value: Column): void;
+    deleteColumnKey(key: string): void;
+    eachColumnKey(f: (column: Column, key: string) => void): void;
+    /**
+     * Access an individual column by key, letter and 1-based column number
+     */
+    getColumn(c: string | number): Column;
+    /**
+     * Cut one or more columns (columns to the right are shifted left)
+     * and optionally insert more
+     *
+     * If column properties have been defined, they will be cut or moved accordingly
+     *
+     * Known limitation: If a splice causes any merged cells to move, the results may be unpredictable
+     *
+     * Also: If the worksheet has more rows than values in the column inserts,
+     * the rows will still be shifted as if the values existed
+     */
+    spliceColumns(start: number, count: number, ...inserts: CellValue[][]): void;
+    /**
+     * Get the last column in a worksheet
+     */
+    get lastColumn(): Column;
+    /**
+     * The total column size of the document. Equal to the maximum cell count from all of the rows
+     */
+    get columnCount(): number;
+    /**
+     * A count of the number of columns that have values
+     */
+    get actualColumnCount(): number;
+    _commitRow(row: Row): void;
+    get _lastRowNumber(): number;
+    get _nextRow(): number;
+    /**
+     * Get the last editable row in a worksheet (or undefined if there are none)
+     */
+    get lastRow(): Row | undefined;
+    /**
+     * Tries to find and return row for row number, else undefined
+     *
+     * @param r - The 1-indexed row number
+     */
+    findRow(r: number): Row | undefined;
+    /**
+     * Tries to find and return rows for row number start and length, else undefined
+     *
+     * @param start - The 1-indexed starting row number
+     * @param length - The length of the expected array
+     */
+    findRows(start: number, length: number): (Row | undefined)[];
+    /**
+     * The total row size of the document. Equal to the row number of the last row that has values.
+     */
+    get rowCount(): number;
+    /**
+     * A count of the number of rows that have values. If a mid-document row is empty, it will not be included in the count.
+     */
+    get actualRowCount(): number;
+    getRow(r: number): any;
+    getRows(start: number, length: number): any[] | undefined;
+    addRow(value: any, style?: string): any;
+    addRows(value: any[], style?: string): any[];
+    insertRow(pos: number, value: any, style?: string): any;
+    insertRows(pos: number, values: any[], style?: string): Row[] | undefined;
+    _setStyleOption(pos: number, style?: string): void;
+    _copyStyle(src: number, dest: number, styleEmpty?: boolean): void;
+    /**
+     * Duplicate rows and insert new rows
+     */
+    duplicateRow(rowNum: number, count: number, insert?: boolean): void;
+    /**
+     * Cut one or more rows (rows below are shifted up)
+     * and optionally insert more
+     *
+     * Known limitation: If a splice causes any merged cells to move, the results may be unpredictable
+     */
+    spliceRows(start: number, count: number, ...inserts: RowValues[]): void;
+    /**
+     * Iterate over all rows that have values in a worksheet
+     */
+    eachRow(callback: (row: Row, rowNumber: number) => void): void;
+    /**
+     * Iterate over all rows (including empty rows) in a worksheet
+     */
+    eachRow(opt: {
+        includeEmpty?: boolean;
+    }, callback: (row: Row, rowNumber: number) => void): void;
+    /**
+     * Return all rows as sparse array
+     */
+    getSheetValues(): CellValue[][];
+    /**
+     * Returns the cell at [r,c] or address given by r. If not found, return undefined
+     */
+    findCell(r: number | string, c?: number): Cell | undefined;
+    /**
+     * Get or create cell at [r,c] or address given by r
+     */
+    getCell(r: number | string, c?: number): Cell;
+    /**
+     * Merge cells, either:
+     *
+     * tlbr string, e.g. `'A4:B5'`
+     *
+     * tl string, br string, e.g. `'G10', 'H11'`
+     *
+     * t, l, b, r numbers, e.g. `10,11,12,13`
+     */
+    mergeCells(...cells: RangeInput[]): void;
+    mergeCellsWithoutStyle(...cells: RangeInput[]): void;
+    _mergeCellsInternal(dimensions: Range, ignoreStyle?: boolean): void;
+    _unMergeMaster(master: Cell): void;
+    get hasMerges(): boolean;
+    /**
+     * Scan the range and if any cell is part of a merge, un-merge the group.
+     * Note this function can affect multiple merges and merge-blocks are
+     * atomic - either they're all merged or all un-merged.
+     */
+    unMergeCells(...cells: RangeInput[]): void;
+    fillFormula(range: string, formula: string, results?: FormulaResult[][] | FormulaResult[] | ((row: number, col: number) => FormulaResult | undefined), shareType?: string): void;
+    /**
+     * Using the image id from `Workbook.addImage`,
+     * embed an image within the worksheet to cover a range
+     */
+    addImage(imageId: string | number, range: AddImageRange): void;
+    getImages(): Image[];
+    /**
+     * Using the image id from `Workbook.addImage`, set the background to the worksheet
+     */
+    addBackgroundImage(imageId: string | number): void;
+    getBackgroundImageId(): string | undefined;
+    /**
+     * Protect the worksheet with optional password and options
+     */
+    protect(password?: string, options?: Partial<SheetProtection>): Promise<void>;
+    unprotect(): void;
+    /**
+     * Add a new table and return a reference to it
+     */
+    addTable(model: TableProperties): Table;
+    /**
+     * Fetch table by name
+     */
+    getTable(name: string): Table;
+    /**
+     * Delete table by name
+     */
+    removeTable(name: string): void;
+    /**
+     * Fetch all tables in the worksheet
+     */
+    getTables(): Table[];
+    addPivotTable(model: PivotTableModel): PivotTable;
+    /**
+     * Add conditional formatting rules
+     */
+    addConditionalFormatting(cf: ConditionalFormattingOptions): void;
+    /**
+     * Delete conditional formatting rules
+     */
+    removeConditionalFormatting(filter: number | ((value: ConditionalFormattingOptions, index: number, array: ConditionalFormattingOptions[]) => boolean)): void;
+    get model(): WorksheetModel;
+    _parseRows(model: WorksheetModel): void;
+    _parseMergeCells(model: WorksheetModel): void;
+    set model(value: WorksheetModel);
+}
+export { Worksheet, type WorksheetModel };

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

@@ -0,0 +1,12 @@
+interface NumFormat {
+    f?: string;
+    "zh-tw"?: string;
+    "zh-cn"?: string;
+    "ja-jp"?: string;
+    "ko-kr"?: string;
+    "th-th"?: string;
+}
+declare const defaultNumFormats: {
+    [key: number]: NumFormat;
+};
+export { defaultNumFormats };

package/dist/types/modules/excel/xlsx/rel-type.d.ts

@@ -0,0 +1,19 @@
+declare const 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;
+};
+export { RelType };

package/dist/types/modules/excel/xlsx/xform/drawing/sp-pr.d.ts

@@ -0,0 +1,32 @@
+export declare const spPrJSON: {
+    tag: string;
+    c: ({
+        tag: string;
+        c: ({
+            tag: string;
+            $: {
+                x: string;
+                y: string;
+                cx?: undefined;
+                cy?: undefined;
+            };
+        } | {
+            tag: string;
+            $: {
+                cx: string;
+                cy: string;
+                x?: undefined;
+                y?: undefined;
+            };
+        })[];
+        $?: undefined;
+    } | {
+        tag: string;
+        $: {
+            prst: string;
+        };
+        c: {
+            tag: string;
+        }[];
+    })[];
+};

package/dist/types/modules/excel/xlsx/xform/pivot-table/cache-field.d.ts

@@ -0,0 +1,15 @@
+interface CacheFieldConfig {
+    name: string;
+    sharedItems: any[] | null;
+    minValue?: number;
+    maxValue?: number;
+}
+declare class CacheField {
+    private name;
+    private sharedItems;
+    private minValue?;
+    private maxValue?;
+    constructor({ name, sharedItems, minValue, maxValue }: CacheFieldConfig);
+    render(): string;
+}
+export { CacheField };

package/dist/types/modules/excel/xlsx/xform/pivot-table/pivot-cache-definition-xform.d.ts

@@ -0,0 +1,60 @@
+import { BaseXform } from "../base-xform";
+import { type CacheFieldModel } from "./cache-field-xform";
+import type { PivotTableSource } from "../../../pivot-table";
+/**
+ * Model for parsed pivot cache definition
+ */
+interface ParsedCacheDefinitionModel {
+    sourceRef?: string;
+    sourceSheet?: string;
+    cacheFields: CacheFieldModel[];
+    recordCount?: number;
+    rId?: string;
+    refreshOnLoad?: string;
+    createdVersion?: string;
+    refreshedVersion?: string;
+    minRefreshableVersion?: string;
+    isLoaded?: boolean;
+}
+/**
+ * Model for generating pivot cache definition (with live source)
+ */
+interface CacheDefinitionModel {
+    source: PivotTableSource;
+    cacheFields: any[];
+}
+declare class PivotCacheDefinitionXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    model: ParsedCacheDefinitionModel | null;
+    private currentCacheField;
+    private inCacheFields;
+    private inCacheSource;
+    constructor();
+    prepare(_model: any): void;
+    get tag(): string;
+    reset(): void;
+    /**
+     * Render pivot cache definition XML.
+     * Supports both newly created models (with PivotTableSource) and loaded models.
+     */
+    render(xmlStream: any, model: CacheDefinitionModel | ParsedCacheDefinitionModel): void;
+    /**
+     * Render newly created pivot cache definition
+     */
+    private renderNew;
+    /**
+     * Render loaded pivot cache definition (preserving original structure)
+     */
+    private renderLoaded;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(_model: any, _options: any): void;
+    static PIVOT_CACHE_DEFINITION_ATTRIBUTES: {
+        xmlns: string;
+        "xmlns:r": string;
+    };
+}
+export { PivotCacheDefinitionXform, type ParsedCacheDefinitionModel };