@cj-tech-master/excelts 1.6.1 → 1.6.2-canary.20251223042922.400f6d0

package/dist/esm/stream/xlsx/worksheet-reader.js

@@ -25,7 +25,7 @@ class WorksheetReader extends EventEmitter {
     destroy() {
         throw new Error("Invalid Operation: destroy");
     }
-    // return the current dimensions of the writer
+    // return the current dimensions of the reader
     get dimensions() {
         return this._dimensions;
     }
@@ -44,7 +44,7 @@ class WorksheetReader extends EventEmitter {
             if (col) {
                 return col;
             }
-            // otherise, assume letter
+            // otherwise, assume letter
             c = colCache.l2n(c);
         }
         if (!this._columns) {
@@ -85,9 +85,9 @@ class WorksheetReader extends EventEmitter {
     }
     async *[Symbol.asyncIterator]() {
         for await (const events of this.parse()) {
-            for (const { eventType, value } of events) {
-                if (eventType === "row") {
-                    yield value;
+            for (const event of events) {
+                if (event.eventType === "row") {
+                    yield event.value;
                 }
             }
         }
@@ -283,6 +283,7 @@ class WorksheetReader extends EventEmitter {
                                                     cell.value = sharedStrings[index];
                                                 }
                                                 else {
+                                                    // Streaming format - unresolved shared string reference
                                                     cell.value = {
                                                         sharedString: index
                                                     };
@@ -299,19 +300,22 @@ class WorksheetReader extends EventEmitter {
                                             case "b":
                                                 cell.value = parseInt(c.v.text, 10) !== 0;
                                                 break;
-                                            default:
-                                                if (isDateFmt(cell.numFmt)) {
-                                                    cell.value = excelToDate(parseFloat(c.v.text), properties.model && properties.model.date1904);
+                                            default: {
+                                                const numFmtStr = typeof cell.numFmt === "string" ? cell.numFmt : cell.numFmt?.formatCode;
+                                                if (numFmtStr && isDateFmt(numFmtStr)) {
+                                                    cell.value = excelToDate(parseFloat(c.v.text), properties?.model?.date1904);
                                                 }
                                                 else {
                                                     cell.value = parseFloat(c.v.text);
                                                 }
                                                 break;
+                                            }
                                         }
                                     }
                                     if (hyperlinks) {
                                         const hyperlink = hyperlinks[c.ref];
                                         if (hyperlink) {
+                                            // Streaming-specific: assign text and hyperlink for further processing
                                             cell.text = cell.value;
                                             cell.value = undefined;
                                             cell.hyperlink = hyperlink;

package/dist/esm/stream/xlsx/worksheet-writer.js

@@ -275,20 +275,26 @@ class WorksheetWriter {
     }
     // iterate over every uncommitted row in the worksheet, including maybe empty rows
     eachRow(options, iteratee) {
-        if (!iteratee) {
-            iteratee = options;
-            options = undefined;
+        let callback;
+        let opts;
+        if (typeof options === "function") {
+            callback = options;
+            opts = undefined;
         }
-        if (options && options.includeEmpty) {
+        else {
+            callback = iteratee;
+            opts = options;
+        }
+        if (opts && opts.includeEmpty) {
             const n = this._nextRow;
             for (let i = this._rowZero; i < n; i++) {
-                iteratee(this.getRow(i), i);
+                callback(this.getRow(i), i);
             }
         }
         else {
             this._rows.forEach(row => {
                 if (row.hasValues) {
-                    iteratee(row, row.number);
+                    callback(row, row.number);
                 }
             });
         }

package/dist/types/doc/table.d.ts

@@ -67,8 +67,8 @@ declare class Table {
     set headerRow(value: boolean | undefined);
     get totalsRow(): boolean | undefined;
     set totalsRow(value: boolean | undefined);
-    get theme(): string | undefined;
-    set theme(value: string | undefined);
+    get theme(): TableStyleProperties["theme"];
+    set theme(value: TableStyleProperties["theme"]);
     get showFirstColumn(): boolean | undefined;
     set showFirstColumn(value: boolean | undefined);
     get showLastColumn(): boolean | undefined;

package/dist/types/doc/worksheet.d.ts

@@ -220,33 +220,12 @@ declare class Worksheet {
      * 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;
-    /**
-     * Get or create row by 1-based index
-     */
-    getRow(r: number): Row;
-    /**
-     * Get or create rows by 1-based index
-     */
-    getRows(start: number, length: number): Row[] | undefined;
-    /**
-     * Add a couple of Rows by key-value, after the last current row, using the column keys,
-     * or add a row by contiguous Array (assign to columns A, B & C)
-     */
-    addRow(value: RowValues, style?: string): Row;
-    /**
-     * Add multiple rows by providing an array of arrays or key-value pairs
-     */
-    addRows(value: RowValues[], style?: string): Row[];
-    /**
-     * Insert a Row by key-value, at the position (shifting down all rows from position),
-     * using the column keys, or add a row by contiguous Array (assign to columns A, B & C)
-     */
-    insertRow(pos: number, value: RowValues, style?: string): Row;
-    /**
-     * Insert multiple rows at position (shifting down all rows from position)
-     * by providing an array of arrays or key-value pairs
-     */
-    insertRows(pos: number, values: RowValues[], style?: string): Row[] | undefined;
+    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;
     /**

package/dist/types/index.d.ts

@@ -13,6 +13,9 @@ export { Image } from "./doc/image.js";
 export * from "./doc/anchor.js";
 export { Table } from "./doc/table.js";
 export { DataValidations } from "./doc/data-validations.js";
+export type { WorkbookReaderOptions, ParseEvent, SharedStringEvent, WorksheetReadyEvent, HyperlinksEvent } from "./stream/xlsx/workbook-reader.js";
+export type { WorksheetReaderOptions, WorksheetEvent, RowEvent, HyperlinkEvent, WorksheetHyperlink } from "./stream/xlsx/worksheet-reader.js";
+export type { WorkbookWriterOptions, ZipOptions, ZlibOptions } from "./stream/xlsx/workbook-writer.js";
 export type { PivotTable, PivotTableModel, PivotTableSource, CacheField, DataField, PivotTableSubtotal, ParsedCacheDefinition, ParsedCacheRecords } from "./doc/pivot-table.js";
 export * from "./doc/enums.js";
 export * from "./types.js";

package/dist/types/stream/xlsx/hyperlink-reader.d.ts

@@ -1,24 +1,24 @@
 import { EventEmitter } from "events";
-interface HyperlinkReaderOptions {
-    workbook: any;
+import type { WorkbookReader, InternalWorksheetOptions } from "./workbook-reader.js";
+export interface HyperlinkReaderOptions {
+    workbook: WorkbookReader;
     id: number;
-    iterator: any;
-    options: any;
+    iterator: AsyncIterable<unknown>;
+    options: InternalWorksheetOptions;
 }
-interface Hyperlink {
+/** Hyperlink relationship parsed from worksheet rels */
+export interface Hyperlink {
     type: number;
     rId: string;
     target: string;
     targetMode: string;
 }
 declare class HyperlinkReader extends EventEmitter {
-    workbook: any;
+    workbook: WorkbookReader;
     id: number;
-    iterator: any;
-    options: any;
-    hyperlinks?: {
-        [key: string]: Hyperlink;
-    };
+    iterator: AsyncIterable<unknown>;
+    options: InternalWorksheetOptions;
+    hyperlinks?: Record<string, Hyperlink>;
     constructor({ workbook, id, iterator, options }: HyperlinkReaderOptions);
     get count(): number;
     each(fn: (hyperlink: Hyperlink, rId: string) => void): void;

package/dist/types/stream/xlsx/workbook-reader.d.ts

@@ -1,44 +1,133 @@
 import { EventEmitter } from "events";
-interface WorkbookReaderOptions {
-    worksheets?: string;
-    sharedStrings?: string;
-    hyperlinks?: string;
-    styles?: string;
-    entries?: string;
+import { Readable } from "stream";
+import { StylesXform } from "../../xlsx/xform/style/styles-xform.js";
+import { WorksheetReader } from "./worksheet-reader.js";
+import { HyperlinkReader } from "./hyperlink-reader.js";
+import type { WorksheetState, Font, WorkbookProperties } from "../../types.js";
+/** Internal options type that includes undocumented 'prep' value */
+export interface InternalWorksheetOptions {
+    worksheets?: "emit" | "ignore" | "prep";
+    sharedStrings?: "cache" | "emit" | "ignore";
+    hyperlinks?: "cache" | "emit" | "ignore";
+    styles?: "cache" | "ignore";
+    entries?: "emit" | "ignore";
 }
-declare class WorkbookReader extends EventEmitter {
-    input: any;
-    options: WorkbookReaderOptions;
-    styles: any;
-    stream?: any;
-    sharedStrings?: any[];
-    workbookRels?: any[];
-    properties?: any;
-    model?: any;
-    constructor(input: any, options?: WorkbookReaderOptions);
-    _getStream(input: any): any;
-    read(input?: any, options?: WorkbookReaderOptions): Promise<void>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
-    parse(input?: any, options?: WorkbookReaderOptions): AsyncIterableIterator<{
-        eventType: string;
-        value: any;
+/** Rich text item from shared strings */
+export interface SharedStringRichText {
+    richText: Array<{
+        font: Partial<Font> | null;
+        text: string | null;
     }>;
-    _emitEntry(payload: any): void;
-    _parseRels(entry: any): Promise<void>;
-    _parseWorkbook(entry: any): Promise<void>;
-    _parseSharedStrings(entry: any): AsyncIterableIterator<{
+}
+/** Shared string value - either plain text or rich text */
+export type SharedStringValue = string | SharedStringRichText;
+/** Relationship entry from workbook.xml.rels */
+export interface WorkbookRelationship {
+    Id: string;
+    Target: string;
+    Type?: string;
+}
+/** Sheet metadata from workbook.xml */
+export interface SheetMetadata {
+    id: number;
+    name: string;
+    state?: WorksheetState;
+    rId: string;
+}
+/** Workbook model parsed from workbook.xml */
+export interface WorkbookModel {
+    sheets?: SheetMetadata[];
+    properties?: Partial<WorkbookProperties>;
+    views?: unknown[];
+    definedNames?: unknown[];
+}
+/** Properties parsed from workbook.xml (workbookPr element) */
+export interface WorkbookPropertiesXform {
+    model?: Partial<WorkbookProperties>;
+}
+/** Entry event payload */
+interface EntryPayload {
+    type: "shared-strings" | "styles" | "workbook" | "worksheet" | "hyperlinks";
+    id?: string;
+}
+/** Parse event types */
+export type ParseEventType = "shared-strings" | "worksheet" | "hyperlinks";
+export interface SharedStringEvent {
+    eventType: "shared-strings";
+    value: {
         index: number;
-        text: any;
-    }>;
-    _parseStyles(entry: any): Promise<void>;
-    _parseWorksheet(iterator: any, sheetNo: string): IterableIterator<{
-        eventType: string;
-        value: any;
-    }>;
-    _parseHyperlinks(iterator: any, sheetNo: string): IterableIterator<{
-        eventType: string;
-        value: any;
+        text: SharedStringValue;
+    };
+}
+export interface WorksheetReadyEvent {
+    eventType: "worksheet";
+    value: WorksheetReader;
+}
+export interface HyperlinksEvent {
+    eventType: "hyperlinks";
+    value: HyperlinkReader;
+}
+export type ParseEvent = SharedStringEvent | WorksheetReadyEvent | HyperlinksEvent;
+/**
+ * Options for WorkbookReader
+ */
+export interface WorkbookReaderOptions {
+    /**
+     * Specifies whether to emit worksheets ('emit') or not ('ignore').
+     * @default 'emit'
+     */
+    worksheets?: "emit" | "ignore";
+    /**
+     * Specifies whether to cache shared strings ('cache'), emit them ('emit'), or ignore them ('ignore').
+     * @default 'cache'
+     */
+    sharedStrings?: "cache" | "emit" | "ignore";
+    /**
+     * Specifies whether to cache hyperlinks ('cache'), emit them ('emit'), or ignore them ('ignore').
+     * @default 'ignore'
+     */
+    hyperlinks?: "cache" | "emit" | "ignore";
+    /**
+     * Specifies whether to cache styles ('cache') or ignore them ('ignore').
+     * @default 'ignore'
+     */
+    styles?: "cache" | "ignore";
+    /**
+     * Specifies whether to emit entries ('emit') or not ('ignore').
+     * @default 'ignore'
+     */
+    entries?: "emit" | "ignore";
+}
+declare class WorkbookReader extends EventEmitter {
+    input: string | Readable;
+    options: {
+        worksheets: "emit" | "ignore";
+        sharedStrings: "cache" | "emit" | "ignore";
+        hyperlinks: "cache" | "emit" | "ignore";
+        styles: "cache" | "ignore";
+        entries: "emit" | "ignore";
+    };
+    styles: StylesXform;
+    stream?: Readable;
+    sharedStrings?: SharedStringValue[];
+    workbookRels?: WorkbookRelationship[];
+    properties?: WorkbookPropertiesXform;
+    model?: WorkbookModel;
+    constructor(input: string | Readable, options?: WorkbookReaderOptions);
+    _getStream(input: string | Readable): Readable;
+    read(input?: string | Readable, options?: WorkbookReaderOptions): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<WorksheetReader>;
+    parse(input?: string | Readable, options?: WorkbookReaderOptions): AsyncIterableIterator<ParseEvent>;
+    _emitEntry(payload: EntryPayload): void;
+    _parseRels(entry: NodeJS.ReadableStream): Promise<void>;
+    _parseWorkbook(entry: NodeJS.ReadableStream): Promise<void>;
+    _parseSharedStrings(entry: NodeJS.ReadableStream): AsyncIterableIterator<{
+        index: number;
+        text: SharedStringValue;
     }>;
+    _parseStyles(entry: NodeJS.ReadableStream): Promise<void>;
+    _parseWorksheet(iterator: AsyncIterable<unknown>, sheetNo: string): IterableIterator<WorksheetReadyEvent>;
+    _parseHyperlinks(iterator: AsyncIterable<unknown>, sheetNo: string): IterableIterator<HyperlinksEvent>;
 }
 declare const WorkbookReaderOptions: {
     readonly worksheets: readonly ["emit", "ignore"];

package/dist/types/stream/xlsx/workbook-writer.d.ts

@@ -1,51 +1,134 @@
+import fs from "fs";
+import { Zip } from "fflate";
+import { StreamBuf } from "../../utils/stream-buf.js";
+import { StylesXform } from "../../xlsx/xform/style/styles-xform.js";
+import { SharedStrings } from "../../utils/shared-strings.js";
+import { DefinedNames } from "../../doc/defined-names.js";
+import { WorksheetWriter } from "./worksheet-writer.js";
 import type Stream from "stream";
-interface WorkbookWriterOptions {
+import type { Image, WorkbookView, AddWorksheetOptions } from "../../types.js";
+/** Internal medium type for storing images in workbook */
+interface Medium extends Image {
+    type: "image";
+    name: string;
+}
+/** Internal comment reference type for tracking comment files */
+interface CommentRef {
+    commentName: string;
+    vmlDrawing: string;
+}
+export interface ZlibOptions {
+    /** @default constants.Z_NO_FLUSH */
+    flush?: number;
+    /** @default constants.Z_FINISH */
+    finishFlush?: number;
+    /** @default 16*1024 */
+    chunkSize?: number;
+    windowBits?: number;
+    /** compression level (0-9) */
+    level?: number;
+    memLevel?: number;
+    strategy?: number;
+    dictionary?: Buffer | NodeJS.TypedArray | DataView | ArrayBuffer;
+}
+export interface ZipOptions {
+    comment?: string;
+    forceLocalTime?: boolean;
+    forceZip64?: boolean;
+    store?: boolean;
+    zlib?: Partial<ZlibOptions>;
+    /** Alternative way to set compression level */
+    compressionOptions?: {
+        level?: number;
+    };
+}
+export interface WorkbookWriterOptions {
+    /** The date the workbook was created */
     created?: Date;
+    /** The date the workbook was last modified */
     modified?: Date;
+    /** The author of the workbook */
     creator?: string;
+    /** Who last modified the workbook */
     lastModifiedBy?: string;
+    /** The date the workbook was last printed */
     lastPrinted?: Date;
+    /** Specifies whether to use shared strings in the workbook. Default is false */
     useSharedStrings?: boolean;
+    /** Specifies whether to add style information to the workbook. Default is false */
     useStyles?: boolean;
-    zip?: any;
+    /** Zip compression options */
+    zip?: Partial<ZipOptions>;
+    /** Specifies a writable stream to write the XLSX workbook to */
     stream?: Stream;
+    /** If stream not specified, this field specifies the path to a file to write the XLSX workbook to */
     filename?: string;
 }
 declare class WorkbookWriter {
+    /** The date the workbook was created */
     created: Date;
+    /** The date the workbook was last modified */
     modified: Date;
+    /** The author of the workbook */
     creator: string;
+    /** Who last modified the workbook */
     lastModifiedBy: string;
+    /** The date the workbook was last printed */
     lastPrinted?: Date;
+    /** Whether to use shared strings */
     useSharedStrings: boolean;
-    sharedStrings: any;
-    styles: any;
-    _definedNames: any;
-    _worksheets: any[];
-    views: any[];
-    zipOptions?: any;
+    /** Shared strings collection - internal use */
+    sharedStrings: SharedStrings;
+    /** Style manager - internal use */
+    styles: StylesXform;
+    /** Defined names - internal use */
+    _definedNames: DefinedNames;
+    /** Worksheets collection */
+    _worksheets: WorksheetWriter[];
+    /** Workbook views controls how many separate windows Excel will open */
+    views: WorkbookView[];
+    /** Zip options - internal use */
+    zipOptions?: Partial<ZipOptions>;
+    /** Compression level (0-9) */
     compressionLevel: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
-    media: any[];
-    commentRefs: any[];
-    zip: any;
-    stream: any;
-    promise: Promise<any>;
+    /** Media collection (images) - internal use */
+    media: Medium[];
+    /** Comment references - internal use */
+    commentRefs: CommentRef[];
+    /** Zip instance - internal use */
+    zip: Zip;
+    /** Output stream - internal use */
+    stream: Stream | fs.WriteStream | InstanceType<typeof StreamBuf>;
+    /** Internal promise for async operations */
+    promise: Promise<void[]>;
     constructor(options?: WorkbookWriterOptions);
-    get definedNames(): any;
-    _openStream(path: string): any;
-    _addFile(data: string | Buffer, name: string, base64?: boolean): void;
+    get definedNames(): DefinedNames;
+    _openStream(path: string): InstanceType<typeof StreamBuf>;
+    _addFile(data: string | Uint8Array, name: string, base64?: boolean): void;
     _commitWorksheets(): Promise<void>;
-    commit(): Promise<any>;
+    commit(): Promise<void>;
     get nextId(): number;
-    addImage(image: any): number;
-    getImage(id: number): any;
-    addWorksheet(name?: string, options?: any): any;
-    getWorksheet(id?: string | number): any;
+    /**
+     * Add Image to Workbook and return the id
+     */
+    addImage(image: Image): number;
+    /**
+     * Get image by id
+     */
+    getImage(id: number): Image | undefined;
+    /**
+     * Add a new worksheet and return a reference to it
+     */
+    addWorksheet(name?: string, options?: Partial<AddWorksheetOptions>): WorksheetWriter;
+    /**
+     * Fetch sheet by name or id
+     */
+    getWorksheet(id?: string | number): WorksheetWriter | undefined;
     addStyles(): Promise<void>;
     addThemes(): Promise<void>;
     addOfficeRels(): Promise<void>;
     addContentTypes(): Promise<void>;
-    addMedia(): Promise<any>;
+    addMedia(): Promise<void[]>;
     addApp(): Promise<void>;
     addCore(): Promise<void>;
     addSharedStrings(): Promise<void>;

package/dist/types/stream/xlsx/worksheet-reader.d.ts

@@ -1,37 +1,55 @@
 import { EventEmitter } from "events";
-interface WorksheetReaderOptions {
-    workbook: any;
+import { Dimensions } from "../../doc/range.js";
+import { Row } from "../../doc/row.js";
+import { Column } from "../../doc/column.js";
+import type { WorkbookReader, InternalWorksheetOptions } from "./workbook-reader.js";
+import type { WorksheetState } from "../../types.js";
+/** Hyperlink reference from worksheet XML */
+export interface WorksheetHyperlink {
+    ref: string;
+    rId: string;
+}
+/** Events emitted during worksheet parsing */
+export type WorksheetEventType = "row" | "hyperlink";
+/** Row event emitted during parsing */
+export interface RowEvent {
+    eventType: "row";
+    value: Row;
+}
+/** Hyperlink event emitted during parsing */
+export interface HyperlinkEvent {
+    eventType: "hyperlink";
+    value: WorksheetHyperlink;
+}
+export type WorksheetEvent = RowEvent | HyperlinkEvent;
+export interface WorksheetReaderOptions {
+    workbook: WorkbookReader;
     id: number;
-    iterator: any;
-    options?: any;
+    iterator: AsyncIterable<unknown>;
+    options?: InternalWorksheetOptions;
 }
 declare class WorksheetReader extends EventEmitter {
-    workbook: any;
+    workbook: WorkbookReader;
     id: number | string;
-    iterator: any;
-    options: any;
+    iterator: AsyncIterable<unknown>;
+    options: InternalWorksheetOptions;
     name: string;
-    state?: string;
+    state?: WorksheetState;
     private _columns;
     private _keys;
     private _dimensions;
-    hyperlinks?: {
-        [key: string]: any;
-    };
+    hyperlinks?: Record<string, WorksheetHyperlink>;
     constructor({ workbook, id, iterator, options }: WorksheetReaderOptions);
     destroy(): void;
-    get dimensions(): any;
-    get columns(): any[] | null;
-    getColumn(c: string | number): any;
-    getColumnKey(key: string): any;
-    setColumnKey(key: string, value: any): void;
+    get dimensions(): Dimensions;
+    get columns(): Column[] | null;
+    getColumn(c: string | number): Column;
+    getColumnKey(key: string): Column | undefined;
+    setColumnKey(key: string, value: Column): void;
     deleteColumnKey(key: string): void;
-    eachColumnKey(f: (column: any, key: string) => void): void;
+    eachColumnKey(f: (column: Column, key: string) => void): void;
     read(): Promise<void>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
-    parse(): AsyncIterableIterator<Array<{
-        eventType: string;
-        value: any;
-    }>>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Row>;
+    parse(): AsyncIterableIterator<WorksheetEvent[]>;
 }
 export { WorksheetReader };