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

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

@@ -0,0 +1,333 @@
+import { Range, type RangeInput } from "@excel/range";
+import { Row, type RowModel } from "@excel/row";
+import { Column, type ColumnModel, type ColumnDefn } from "@excel/column";
+import type { Cell, FormulaResult } from "@excel/cell";
+import { Image, type ImageModel } from "@excel/image";
+import { Table, type TableModel } from "@excel/table";
+import { DataValidations } from "@excel/data-validations";
+import { type PivotTable, type PivotTableModel } from "@excel/pivot-table";
+import type { Workbook } from "@excel/workbook";
+import type { AddImageRange, AutoFilter, CellValue, ColBreak, ConditionalFormattingOptions, DataValidation, RowBreak, RowValues, TableProperties, WorksheetProperties, WorksheetView } from "@excel/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/xform/base-xform.d.ts

@@ -0,0 +1,33 @@
+import { XmlStream } from "@excel/utils/xml-stream";
+interface ParseEvent {
+    eventType: string;
+    value: any;
+}
+declare class BaseXform {
+    map?: {
+        [key: string]: any;
+    };
+    model?: any;
+    prepare(_model?: any, _options?: any): void;
+    render(_xmlStream?: XmlStream, _model?: any): void;
+    parseOpen(_node: any): void;
+    parseText(_text: string): void;
+    parseClose(_name: string): boolean;
+    reconcile(_model: any, _options?: any): void;
+    reset(): void;
+    mergeModel(obj: any): void;
+    parse(saxParser: AsyncIterable<ParseEvent[]>): Promise<any>;
+    parseStream(stream: any): Promise<any>;
+    get xml(): string;
+    toXml(model: any): string;
+    static toAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toStringAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toStringValue(attr: any, dflt?: any): any;
+    static toBoolAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toBoolValue(attr: any, dflt?: any): boolean;
+    static toIntAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toIntValue(attr: any, dflt?: any): number;
+    static toFloatAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toFloatValue(attr: any, dflt?: any): number;
+}
+export { BaseXform };

package/dist/types/modules/excel/xlsx/xform/book/defined-name-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface DefinedNameModel {
+    name: string;
+    ranges: string[];
+    localSheetId?: number;
+}
+declare class DefinedNamesXform extends BaseXform {
+    private _parsedName?;
+    private _parsedLocalSheetId?;
+    private _parsedText;
+    constructor();
+    render(xmlStream: any, model: DefinedNameModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { DefinedNamesXform };

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

@@ -0,0 +1,14 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface SheetModel {
+    id: number;
+    name: string;
+    state?: string;
+    rId: string;
+}
+declare class WorksheetXform extends BaseXform {
+    render(xmlStream: any, model: SheetModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorksheetXform };

package/dist/types/modules/excel/xlsx/xform/book/workbook-calc-properties-xform.d.ts

@@ -0,0 +1,11 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface CalcPropertiesModel {
+    fullCalcOnLoad?: boolean;
+}
+declare class WorkbookCalcPropertiesXform extends BaseXform {
+    render(xmlStream: any, model: CalcPropertiesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookCalcPropertiesXform };

package/dist/types/modules/excel/xlsx/xform/book/workbook-pivot-cache-xform.d.ts

@@ -0,0 +1,12 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface PivotCacheModel {
+    cacheId: string;
+    rId: string;
+}
+declare class WorkbookPivotCacheXform extends BaseXform {
+    render(xmlStream: any, model: PivotCacheModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookPivotCacheXform };

package/dist/types/modules/excel/xlsx/xform/book/workbook-properties-xform.d.ts

@@ -0,0 +1,11 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface WorkbookPropertiesModel {
+    date1904?: boolean;
+}
+declare class WorkbookPropertiesXform extends BaseXform {
+    render(xmlStream: any, model: WorkbookPropertiesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookPropertiesXform };

package/dist/types/modules/excel/xlsx/xform/book/workbook-view-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface WorkbookViewModel {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    firstSheet?: number;
+    activeTab?: number;
+    visibility?: string;
+}
+declare class WorkbookViewXform extends BaseXform {
+    render(xmlStream: any, model: WorkbookViewModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookViewXform };

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

@@ -0,0 +1,23 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { StaticXform } from "@excel/xlsx/xform/static-xform";
+declare class WorkbookXform extends BaseXform {
+    parser: any;
+    constructor();
+    prepare(model: any): void;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: any): void;
+    static WORKBOOK_ATTRIBUTES: {
+        xmlns: string;
+        "xmlns:r": string;
+        "xmlns:mc": string;
+        "mc:Ignorable": string;
+        "xmlns:x15": string;
+    };
+    static STATIC_XFORMS: {
+        fileVersion: StaticXform;
+    };
+}
+export { WorkbookXform };

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

@@ -0,0 +1,28 @@
+import { RichTextXform } from "@excel/xlsx/xform/strings/rich-text-xform";
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface NoteText {
+    font?: any;
+    text: string;
+}
+interface CommentNote {
+    texts: NoteText[];
+}
+interface CommentModel {
+    type: string;
+    note: CommentNote;
+    ref: string;
+    authorId?: number;
+}
+declare class CommentXform extends BaseXform {
+    model: CommentModel;
+    parser: any;
+    private _richTextXform?;
+    constructor(model?: CommentModel);
+    get tag(): string;
+    get richTextXform(): RichTextXform;
+    render(xmlStream: any, model?: CommentModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { CommentXform };

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

@@ -0,0 +1,21 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import { CommentXform } from "@excel/xlsx/xform/comment/comment-xform";
+interface CommentsModel {
+    comments: any[];
+}
+declare class CommentsXform extends BaseXform {
+    map: {
+        [key: string]: CommentXform;
+    };
+    parser: any;
+    model: CommentsModel;
+    constructor();
+    render(xmlStream: any, model?: CommentsModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static COMMENTS_ATTRIBUTES: {
+        xmlns: string;
+    };
+}
+export { CommentsXform };

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

@@ -0,0 +1,16 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+declare class VmlPositionXform extends BaseXform {
+    private _model;
+    model: {
+        [key: string]: boolean;
+    };
+    constructor(model?: {
+        tag?: string;
+    });
+    get tag(): string;
+    render(xmlStream: any, model: string, type?: string[]): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { VmlPositionXform };

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

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

package/dist/types/modules/excel/xlsx/xform/comment/vml-anchor-xform.d.ts

@@ -0,0 +1,27 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface AnchorModel {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+interface RefAddress {
+    col: number;
+    row: number;
+}
+interface RenderModel {
+    anchor?: AnchorModel;
+    refAddress?: RefAddress;
+}
+declare class VmlAnchorXform extends BaseXform {
+    private text;
+    constructor();
+    get tag(): string;
+    getAnchorRect(anchor: AnchorModel): number[];
+    getDefaultRect(ref: RefAddress): number[];
+    render(xmlStream: any, model: RenderModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { VmlAnchorXform };

package/dist/types/modules/excel/xlsx/xform/comment/vml-client-data-xform.d.ts

@@ -0,0 +1,35 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface Protection {
+    locked?: string;
+    lockText?: string;
+}
+interface ClientDataModel {
+    anchor: any;
+    protection: Protection;
+    editAs: string;
+}
+interface RenderModel {
+    note: {
+        protection: Protection;
+        editAs: string;
+    };
+    refAddress: {
+        row: number;
+        col: number;
+    };
+}
+declare class VmlClientDataXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: ClientDataModel;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: RenderModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    normalizeModel(): void;
+}
+export { VmlClientDataXform };

package/dist/types/modules/excel/xlsx/xform/comment/vml-notes-xform.d.ts

@@ -0,0 +1,24 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface VmlNotesModel {
+    comments: any[];
+}
+declare class VmlNotesXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: VmlNotesModel;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model?: VmlNotesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: any, options: any): void;
+    static DRAWING_ATTRIBUTES: {
+        "xmlns:v": string;
+        "xmlns:o": string;
+        "xmlns:x": string;
+    };
+}
+export { VmlNotesXform };

package/dist/types/modules/excel/xlsx/xform/comment/vml-shape-xform.d.ts

@@ -0,0 +1,25 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface ShapeModel {
+    note: {
+        margins?: {
+            insetmode?: string;
+            inset?: number[];
+        };
+    };
+    refAddress?: any;
+}
+declare class VmlShapeXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: ShapeModel, index?: number): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static V_SHAPE_ATTRIBUTES: (model: ShapeModel, index: number) => any;
+}
+export { VmlShapeXform };