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

package/dist/types/xlsx/xform/sheet/ext-lst-xform.d.ts

@@ -0,0 +1,16 @@
+import { CompositeXform } from "../composite-xform";
+declare class ExtLstXform extends CompositeXform {
+    map: {
+        [key: string]: any;
+    };
+    model: any;
+    private ext;
+    constructor();
+    get tag(): string;
+    prepare(model: any, _options?: any): void;
+    hasContent(model: any): boolean;
+    render(xmlStream: any, model: any): void;
+    createNewModel(): any;
+    onParserClose(name: string, parser: any): void;
+}
+export { ExtLstXform };

package/dist/types/xlsx/xform/sheet/header-footer-xform.d.ts

@@ -0,0 +1,20 @@
+import { BaseXform } from "../base-xform";
+interface HeaderFooterModel {
+    differentFirst?: boolean;
+    differentOddEven?: boolean;
+    oddHeader?: string;
+    oddFooter?: string;
+    evenHeader?: string;
+    evenFooter?: string;
+    firstHeader?: string;
+    firstFooter?: string;
+}
+declare class HeaderFooterXform extends BaseXform {
+    private currentNode?;
+    get tag(): string;
+    render(xmlStream: any, model?: HeaderFooterModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { HeaderFooterXform };

package/dist/types/xlsx/xform/sheet/hyperlink-xform.d.ts

@@ -0,0 +1,16 @@
+import { BaseXform } from "../base-xform";
+interface HyperlinkModel {
+    address: string;
+    rId: string;
+    tooltip?: string;
+    target?: string;
+}
+declare class HyperlinkXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: HyperlinkModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+    isInternalLink(model: HyperlinkModel): boolean;
+}
+export { HyperlinkXform };

package/dist/types/xlsx/xform/sheet/merge-cell-xform.d.ts

@@ -0,0 +1,9 @@
+import { BaseXform } from "../base-xform";
+declare class MergeCellXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: string): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { MergeCellXform };

package/dist/types/xlsx/xform/sheet/outline-properties-xform.d.ts

@@ -0,0 +1,13 @@
+import { BaseXform } from "../base-xform";
+interface OutlinePropertiesModel {
+    summaryBelow?: boolean;
+    summaryRight?: boolean;
+}
+declare class OutlinePropertiesXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: OutlinePropertiesModel): boolean;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { OutlinePropertiesXform };

package/dist/types/xlsx/xform/sheet/page-breaks-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "../base-xform";
+/**
+ * Xform for individual page break (brk element)
+ * Used by both RowBreaksXform and ColBreaksXform
+ */
+declare class PageBreaksXform extends BaseXform {
+    model: any;
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PageBreaksXform };

package/dist/types/xlsx/xform/sheet/page-margins-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "../base-xform";
+interface PageMarginsModel {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    header?: number;
+    footer?: number;
+}
+declare class PageMarginsXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: PageMarginsModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PageMarginsXform };

package/dist/types/xlsx/xform/sheet/page-setup-properties-xform.d.ts

@@ -0,0 +1,12 @@
+import { BaseXform } from "../base-xform";
+interface PageSetupPropertiesModel {
+    fitToPage: boolean;
+}
+declare class PageSetupPropertiesXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: PageSetupPropertiesModel): boolean;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PageSetupPropertiesXform };

package/dist/types/xlsx/xform/sheet/page-setup-xform.d.ts

@@ -0,0 +1,27 @@
+import { BaseXform } from "../base-xform";
+interface PageSetupModel {
+    paperSize?: number;
+    orientation?: string;
+    horizontalDpi?: number;
+    verticalDpi?: number;
+    pageOrder?: string;
+    blackAndWhite?: boolean;
+    draft?: boolean;
+    cellComments?: string;
+    errors?: string;
+    scale?: number;
+    fitToWidth?: number;
+    fitToHeight?: number;
+    firstPageNumber?: number;
+    useFirstPageNumber?: boolean;
+    usePrinterDefaults?: boolean;
+    copies?: number;
+}
+declare class PageSetupXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: PageSetupModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PageSetupXform };

package/dist/types/xlsx/xform/sheet/picture-xform.d.ts

@@ -0,0 +1,12 @@
+import { BaseXform } from "../base-xform";
+interface PictureModel {
+    rId: string;
+}
+declare class PictureXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: PictureModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PictureXform };

package/dist/types/xlsx/xform/sheet/print-options-xform.d.ts

@@ -0,0 +1,15 @@
+import { BaseXform } from "../base-xform";
+interface PrintOptionsModel {
+    showRowColHeaders: boolean;
+    showGridLines: boolean;
+    horizontalCentered: boolean;
+    verticalCentered: boolean;
+}
+declare class PrintOptionsXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: PrintOptionsModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { PrintOptionsXform };

package/dist/types/xlsx/xform/sheet/row-breaks-xform.d.ts

@@ -0,0 +1,10 @@
+import { ListXform } from "../list-xform";
+/**
+ * Xform for row page breaks (rowBreaks element in worksheet XML)
+ * Used to define manual page breaks between rows when printing.
+ */
+declare class RowBreaksXform extends ListXform {
+    constructor();
+    render(xmlStream: any, model: any): void;
+}
+export { RowBreaksXform };

package/dist/types/xlsx/xform/sheet/row-xform.d.ts

@@ -0,0 +1,37 @@
+import { BaseXform } from "../base-xform";
+interface RowXformOptions {
+    maxItems?: number;
+}
+interface RowModel {
+    number: number;
+    min?: number;
+    max?: number;
+    cells: any[];
+    styleId?: number;
+    hidden?: boolean;
+    bestFit?: boolean;
+    height?: number;
+    outlineLevel?: number;
+    collapsed?: boolean;
+    style?: any;
+}
+declare class RowXform extends BaseXform {
+    private maxItems?;
+    map: {
+        [key: string]: any;
+    };
+    model: RowModel;
+    parser: any;
+    private numRowsSeen;
+    private lastCellCol;
+    constructor(options?: RowXformOptions);
+    get tag(): string;
+    reset(): void;
+    prepare(model: RowModel, options: any): void;
+    render(xmlStream: any, model?: RowModel, options?: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: RowModel, options: any): void;
+}
+export { RowXform };

package/dist/types/xlsx/xform/sheet/sheet-format-properties-xform.d.ts

@@ -0,0 +1,16 @@
+import { BaseXform } from "../base-xform";
+interface SheetFormatPropertiesModel {
+    defaultRowHeight: number;
+    dyDescent?: number;
+    outlineLevelRow: number;
+    outlineLevelCol: number;
+    defaultColWidth?: number;
+}
+declare class SheetFormatPropertiesXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: SheetFormatPropertiesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { SheetFormatPropertiesXform };

package/dist/types/xlsx/xform/sheet/sheet-properties-xform.d.ts

@@ -0,0 +1,19 @@
+import { BaseXform } from "../base-xform";
+interface SheetPropertiesModel {
+    tabColor?: any;
+    pageSetup?: any;
+    outlineProperties?: any;
+}
+declare class SheetPropertiesXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser?: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model?: SheetPropertiesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): boolean;
+    parseClose(_name: string): boolean;
+}
+export { SheetPropertiesXform };

package/dist/types/xlsx/xform/sheet/sheet-protection-xform.d.ts

@@ -0,0 +1,31 @@
+import { BaseXform } from "../base-xform";
+interface SheetProtectionModel {
+    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;
+}
+declare class SheetProtectionXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: SheetProtectionModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { SheetProtectionXform };

package/dist/types/xlsx/xform/sheet/sheet-view-xform.d.ts

@@ -0,0 +1,32 @@
+import { BaseXform } from "../base-xform";
+interface SheetViewModel {
+    workbookViewId?: number;
+    rightToLeft?: boolean;
+    tabSelected?: boolean;
+    showRuler?: boolean;
+    showRowColHeaders?: boolean;
+    showGridLines?: boolean;
+    zoomScale?: number;
+    zoomScaleNormal?: number;
+    style?: string;
+    state?: string;
+    xSplit?: number;
+    ySplit?: number;
+    topLeftCell?: string;
+    activePane?: string;
+    activeCell?: string;
+}
+declare class SheetViewXform extends BaseXform {
+    model: SheetViewModel;
+    private sheetView;
+    private pane;
+    private selections;
+    get tag(): string;
+    prepare(model: SheetViewModel): void;
+    render(xmlStream: any, model: SheetViewModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+    reconcile(): void;
+}
+export { SheetViewXform };

package/dist/types/xlsx/xform/sheet/table-part-xform.d.ts

@@ -0,0 +1,12 @@
+import { BaseXform } from "../base-xform";
+interface TablePartModel {
+    rId: string;
+}
+declare class TablePartXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: TablePartModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { TablePartXform };

package/dist/types/xlsx/xform/sheet/worksheet-xform.d.ts

@@ -0,0 +1,21 @@
+import { BaseXform } from "../base-xform";
+declare class WorkSheetXform extends BaseXform {
+    private ignoreNodes;
+    parser: any;
+    private preImageId;
+    static WORKSHEET_ATTRIBUTES: {
+        xmlns: string;
+        "xmlns:r": string;
+        "xmlns:mc": string;
+        "xmlns:x14ac": string;
+        "mc:Ignorable": string;
+    };
+    constructor(options?: any);
+    prepare(model: any, options: any): void;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: any): void;
+    parseClose(name: any): boolean;
+    reconcile(model: any, options: any): void;
+}
+export { WorkSheetXform };

package/dist/types/xlsx/xform/simple/boolean-xform.d.ts

@@ -0,0 +1,15 @@
+import { BaseXform } from "../base-xform";
+interface BooleanXformOptions {
+    tag: string;
+    attr: string;
+}
+declare class BooleanXform extends BaseXform {
+    private tag;
+    private attr;
+    constructor(options: BooleanXformOptions);
+    render(xmlStream: any, model?: boolean): void;
+    parseOpen(node: any): void;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { BooleanXform };

package/dist/types/xlsx/xform/simple/date-xform.d.ts

@@ -0,0 +1,22 @@
+import { BaseXform } from "../base-xform";
+interface DateXformOptions {
+    tag: string;
+    attr?: string;
+    attrs?: any;
+    format?: (dt: Date) => string;
+    parse?: (str: string) => Date;
+}
+declare class DateXform extends BaseXform {
+    private tag;
+    private attr?;
+    private attrs?;
+    private text;
+    private _format;
+    private _parse;
+    constructor(options: DateXformOptions);
+    render(xmlStream: any, model?: Date): void;
+    parseOpen(node: any): void;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { DateXform };

package/dist/types/xlsx/xform/simple/float-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "../base-xform";
+interface FloatXformOptions {
+    tag: string;
+    attr?: string;
+    attrs?: any;
+}
+declare class FloatXform extends BaseXform {
+    private tag;
+    private attr?;
+    private attrs?;
+    private text;
+    constructor(options: FloatXformOptions);
+    render(xmlStream: any, model?: number): void;
+    parseOpen(node: any): void;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { FloatXform };

package/dist/types/xlsx/xform/simple/integer-xform.d.ts

@@ -0,0 +1,20 @@
+import { BaseXform } from "../base-xform";
+interface IntegerXformOptions {
+    tag: string;
+    attr?: string;
+    attrs?: any;
+    zero?: boolean;
+}
+declare class IntegerXform extends BaseXform {
+    private tag;
+    private attr?;
+    private attrs?;
+    private zero?;
+    private text;
+    constructor(options: IntegerXformOptions);
+    render(xmlStream: any, model?: number): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { IntegerXform };

package/dist/types/xlsx/xform/simple/string-xform.d.ts

@@ -0,0 +1,18 @@
+import { BaseXform } from "../base-xform";
+interface StringXformOptions {
+    tag: string;
+    attr?: string;
+    attrs?: any;
+}
+declare class StringXform extends BaseXform {
+    private tag;
+    private attr?;
+    private attrs?;
+    private text;
+    constructor(options: StringXformOptions);
+    render(xmlStream: any, model?: string): void;
+    parseOpen(node: any): void;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { StringXform };

package/dist/types/xlsx/xform/static-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "./base-xform";
+interface StaticModel {
+    tag: string;
+    $?: any;
+    c?: StaticModel[];
+    t?: string;
+}
+declare class StaticXform extends BaseXform {
+    private _model;
+    private _xml?;
+    constructor(model: StaticModel);
+    render(xmlStream: any): void;
+    parseOpen(): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { StaticXform };

package/dist/types/xlsx/xform/strings/phonetic-text-xform.d.ts

@@ -0,0 +1,20 @@
+import { BaseXform } from "../base-xform";
+interface PhoneticTextModel {
+    sb: number;
+    eb: number;
+    text?: string;
+    richText?: any[];
+}
+declare class PhoneticTextXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: PhoneticTextModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { PhoneticTextXform };

package/dist/types/xlsx/xform/strings/rich-text-xform.d.ts

@@ -0,0 +1,25 @@
+import { TextXform } from "./text-xform";
+import { FontXform } from "../style/font-xform";
+import { BaseXform } from "../base-xform";
+interface RichTextModel {
+    font?: any;
+    text: string;
+}
+declare class RichTextXform extends BaseXform {
+    private _textXform?;
+    private _fontXform?;
+    parser: any;
+    constructor(model?: RichTextModel);
+    get tag(): string;
+    get textXform(): TextXform;
+    get fontXform(): FontXform;
+    render(xmlStream: any, model?: RichTextModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static FONT_OPTIONS: {
+        tagName: string;
+        fontNameTag: string;
+    };
+}
+export { RichTextXform };

package/dist/types/xlsx/xform/strings/shared-string-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "../base-xform";
+type SharedStringModel = string | {
+    richText: any[];
+};
+declare class SharedStringXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    constructor(model?: SharedStringModel);
+    get tag(): string;
+    render(xmlStream: any, model?: SharedStringModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { SharedStringXform };

package/dist/types/xlsx/xform/strings/shared-strings-xform.d.ts

@@ -0,0 +1,27 @@
+import { BaseXform } from "../base-xform";
+import { SharedStringXform } from "./shared-string-xform";
+interface SharedStringsModel {
+    values: any[];
+    count: number;
+}
+declare class SharedStringsXform extends BaseXform {
+    private hash;
+    private rich;
+    parser: any;
+    private _sharedStringXform?;
+    private _values?;
+    constructor(model?: SharedStringsModel);
+    get sharedStringXform(): SharedStringXform;
+    get values(): any[];
+    get uniqueCount(): number;
+    get count(): number;
+    getString(index: number): any;
+    add(value: any): number;
+    addText(value: string): number;
+    addRichText(value: any): number;
+    render(xmlStream: any, model?: SharedStringsModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { SharedStringsXform };

package/dist/types/xlsx/xform/strings/text-xform.d.ts

@@ -0,0 +1,10 @@
+import { BaseXform } from "../base-xform";
+declare class TextXform extends BaseXform {
+    private _text;
+    get tag(): string;
+    render(xmlStream: any, model: string): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { TextXform };

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

@@ -0,0 +1,18 @@
+import { BaseXform } from "../base-xform";
+interface AlignmentModel {
+    horizontal?: string;
+    vertical?: string;
+    wrapText?: boolean;
+    shrinkToFit?: boolean;
+    indent?: number;
+    textRotation?: number | "vertical";
+    readingOrder?: "ltr" | "rtl";
+}
+declare class AlignmentXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model: AlignmentModel): void;
+    parseOpen(node: any): void;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { AlignmentXform };

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

@@ -0,0 +1,49 @@
+import { BaseXform } from "../base-xform";
+import { ColorXform } from "./color-xform";
+interface EdgeModel {
+    style?: string;
+    color?: any;
+}
+interface BorderModel {
+    top?: EdgeModel;
+    left?: EdgeModel;
+    bottom?: EdgeModel;
+    right?: EdgeModel;
+    diagonal?: EdgeModel & {
+        up?: boolean;
+        down?: boolean;
+    };
+    color?: any;
+}
+declare class EdgeXform extends BaseXform {
+    private name;
+    map: {
+        color: ColorXform;
+    };
+    private defaultColor;
+    parser: any;
+    constructor(name: string);
+    get tag(): string;
+    render(xmlStream: any, model?: EdgeModel, defaultColor?: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    validStyle(value: string): boolean;
+    static validStyleValues: {
+        [key: string]: boolean;
+    };
+}
+declare class BorderXform extends BaseXform {
+    map: {
+        [key: string]: EdgeXform;
+    };
+    parser: any;
+    private diagonalUp;
+    private diagonalDown;
+    constructor();
+    render(xmlStream: any, model: BorderModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { BorderXform };