@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

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

@@ -0,0 +1,20 @@
+import { BaseXform } from "../base-xform.js";
+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.js";
+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.js";
+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.js";
+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.js";
+import { FontXform } from "../style/font-xform.js";
+import { BaseXform } from "../base-xform.js";
+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.js";
+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.js";
+import { SharedStringXform } from "./shared-string-xform.js";
+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.js";
+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.js";
+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.js";
+import { ColorXform } from "./color-xform.js";
+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 };

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

@@ -0,0 +1,17 @@
+import { BaseXform } from "../base-xform.js";
+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.js";
+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.js";
+import { ColorXform } from "./color-xform.js";
+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,34 @@
+import { BaseXform } from "../base-xform.js";
+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;
+    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.js";
+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.js";
+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.js";
+import { AlignmentXform } from "./alignment-xform.js";
+import { ProtectionXform } from "./protection-xform.js";
+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.js";
+import { StaticXform } from "../static-xform.js";
+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.js";
+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.js";
+import { FilterColumnXform } from "./filter-column-xform.js";
+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.js";
+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.js";
+import { ListXform } from "../list-xform.js";
+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.js";
+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.js";
+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.js";
+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,37 @@
+import { BaseXform } from "../base-xform.js";
+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;
+        "xmlns:mc": string;
+        "mc:Ignorable": string;
+        "xmlns:xr": string;
+        "xmlns:xr3": string;
+    };
+}
+export { TableXform };