@cj-tech-master/excelts 1.4.5-canary.20251212064440.3eb099f → 1.4.5-canary.20251212160853.7621827

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

@@ -45,9 +45,6 @@ interface WorksheetOptions {
     views?: Partial<WorksheetView>[];
     autoFilter?: AutoFilter | null;
 }
-interface EachRowOptions {
-    includeEmpty?: boolean;
-}
 interface PageSetupMargins {
     left: number;
     right: number;
@@ -140,62 +137,212 @@ declare class Worksheet {
     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 Issue: 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;
+    /**
+     * 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;
     _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 Issue: If a splice causes any merged cells to move, the results may be unpredictable
+     */
     spliceRows(start: number, count: number, ...inserts: RowValues[]): void;
-    eachRow(iteratee: (row: any, rowNumber: number) => void): void;
-    eachRow(options: EachRowOptions, iteratee: (row: any, rowNumber: number) => void): 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;

package/dist/types/utils/unzip/extract.d.ts

@@ -1,16 +1,17 @@
 /**
  * Simple ZIP extraction utilities
  * Provides easy-to-use Promise-based API for extracting ZIP files
+ * Works in both Node.js and browser environments
  */
-import { type ZipEntry } from "./parse.js";
+import { type ZipEntryInfo } from "./zip-parser.js";
 /**
  * Extracted file entry
  */
 export interface ExtractedFile {
     /** File path within the ZIP */
     path: string;
-    /** File content as Buffer */
-    data: Buffer;
+    /** File content as Uint8Array */
+    data: Uint8Array;
     /** Whether this is a directory */
     isDirectory: boolean;
     /** Uncompressed size */
@@ -19,7 +20,7 @@ export interface ExtractedFile {
 /**
  * Extract all files from a ZIP buffer
  *
- * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
  * @returns Map of file paths to their content
  *
  * @example
@@ -34,13 +35,13 @@ export interface ExtractedFile {
  * }
  * ```
  */
-export declare function extractAll(zipData: Buffer | Uint8Array): Promise<Map<string, ExtractedFile>>;
+export declare function extractAll(zipData: Uint8Array | ArrayBuffer): Promise<Map<string, ExtractedFile>>;
 /**
  * Extract a single file from a ZIP buffer
  *
- * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
  * @param filePath - Path of the file to extract
- * @returns File content as Buffer, or null if not found
+ * @returns File content as Uint8Array, or null if not found
  *
  * @example
  * ```ts
@@ -49,15 +50,15 @@ export declare function extractAll(zipData: Buffer | Uint8Array): Promise<Map<st
  * const zipData = fs.readFileSync("archive.zip");
  * const content = await extractFile(zipData, "readme.txt");
  * if (content) {
- *   console.log(content.toString("utf-8"));
+ *   console.log(new TextDecoder().decode(content));
  * }
  * ```
  */
-export declare function extractFile(zipData: Buffer | Uint8Array, filePath: string): Promise<Buffer | null>;
+export declare function extractFile(zipData: Uint8Array | ArrayBuffer, filePath: string): Promise<Uint8Array | null>;
 /**
  * List all file paths in a ZIP buffer (without extracting content)
  *
- * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
  * @returns Array of file paths
  *
  * @example
@@ -69,11 +70,11 @@ export declare function extractFile(zipData: Buffer | Uint8Array, filePath: stri
  * console.log(paths); // ["file1.txt", "folder/file2.txt", ...]
  * ```
  */
-export declare function listFiles(zipData: Buffer | Uint8Array): Promise<string[]>;
+export declare function listFiles(zipData: Uint8Array | ArrayBuffer): Promise<string[]>;
 /**
  * Iterate over ZIP entries with a callback (memory efficient for large ZIPs)
  *
- * @param zipData - ZIP file data as Buffer or Uint8Array
+ * @param zipData - ZIP file data as Buffer, Uint8Array, or ArrayBuffer
  * @param callback - Async callback for each entry, return false to stop iteration
  *
  * @example
@@ -83,10 +84,11 @@ export declare function listFiles(zipData: Buffer | Uint8Array): Promise<string[
  * await forEachEntry(zipData, async (path, getData) => {
  *   if (path.endsWith(".xml")) {
  *     const content = await getData();
- *     console.log(content.toString("utf-8"));
+ *     console.log(new TextDecoder().decode(content));
  *   }
  *   return true; // continue iteration
  * });
  * ```
  */
-export declare function forEachEntry(zipData: Buffer | Uint8Array, callback: (path: string, getData: () => Promise<Buffer>, entry: ZipEntry) => Promise<boolean | void>): Promise<void>;
+export declare function forEachEntry(zipData: Uint8Array | ArrayBuffer, callback: (path: string, getData: () => Promise<Uint8Array>, entry: ZipEntryInfo) => Promise<boolean | void>): Promise<void>;
+export { ZipParser, type ZipEntryInfo, type ZipParseOptions } from "./zip-parser.js";

package/dist/types/utils/unzip/index.d.ts

@@ -1,5 +1,19 @@
 /**
  * Unzip utilities for parsing ZIP archives
+ *
+ * Two APIs are provided:
+ *
+ * 1. **Stream-based API** (Node.js only):
+ *    - `Parse`, `createParse` - Parse ZIP files as a stream
+ *    - Best for large files where you don't want to load entire file into memory
+ *    - Requires Node.js `stream` module
+ *
+ * 2. **Buffer-based API** (Browser + Node.js):
+ *    - `extractAll`, `extractFile`, `listFiles`, `forEachEntry`, `ZipParser`
+ *    - Works in both Node.js and browser environments
+ *    - Uses native `DecompressionStream` in browser, `zlib` in Node.js
+ *    - Best for files already loaded into memory (ArrayBuffer, Uint8Array)
+ *
  * Original source: https://github.com/ZJONSSON/node-unzipper
  * License: MIT
  */
@@ -10,4 +24,4 @@ export { bufferStream } from "./buffer-stream.js";
 export { parse as parseBuffer } from "./parse-buffer.js";
 export { parseDateTime } from "./parse-datetime.js";
 export { parseExtraField, type ExtraField, type ZipVars } from "./parse-extra-field.js";
-export { extractAll, extractFile, listFiles, forEachEntry, type ExtractedFile } from "./extract.js";
+export { extractAll, extractFile, listFiles, forEachEntry, ZipParser, type ExtractedFile, type ZipEntryInfo, type ZipParseOptions } from "./extract.js";

package/dist/types/utils/unzip/zip-parser.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Pure Uint8Array-based ZIP parser
+ * Works in both Node.js and browser environments
+ * No dependency on Node.js stream module
+ */
+/**
+ * Parsed ZIP entry
+ */
+export interface ZipEntryInfo {
+    /** File path within the ZIP */
+    path: string;
+    /** Whether this is a directory */
+    isDirectory: boolean;
+    /** Compressed size */
+    compressedSize: number;
+    /** Uncompressed size */
+    uncompressedSize: number;
+    /** Compression method (0 = stored, 8 = deflate) */
+    compressionMethod: number;
+    /** CRC-32 checksum */
+    crc32: number;
+    /** Last modified date */
+    lastModified: Date;
+    /** Offset to local file header */
+    localHeaderOffset: number;
+    /** File comment */
+    comment: string;
+    /** External file attributes */
+    externalAttributes: number;
+    /** Is encrypted */
+    isEncrypted: boolean;
+}
+/**
+ * ZIP parsing options
+ */
+export interface ZipParseOptions {
+    /** Whether to decode file names as UTF-8 (default: true) */
+    decodeStrings?: boolean;
+}
+/**
+ * Parse ZIP file entries from Central Directory
+ */
+export declare function parseZipEntries(data: Uint8Array, options?: ZipParseOptions): ZipEntryInfo[];
+/**
+ * Extract file data for a specific entry
+ */
+export declare function extractEntryData(data: Uint8Array, entry: ZipEntryInfo): Promise<Uint8Array>;
+/**
+ * Extract file data synchronously (Node.js only)
+ */
+export declare function extractEntryDataSync(data: Uint8Array, entry: ZipEntryInfo): Uint8Array;
+/**
+ * High-level ZIP parser class
+ */
+export declare class ZipParser {
+    private data;
+    private entries;
+    private entryMap;
+    constructor(data: Uint8Array | ArrayBuffer, options?: ZipParseOptions);
+    /**
+     * Get all entries in the ZIP file
+     */
+    getEntries(): ZipEntryInfo[];
+    /**
+     * Get entry by path
+     */
+    getEntry(path: string): ZipEntryInfo | undefined;
+    /**
+     * Check if entry exists
+     */
+    hasEntry(path: string): boolean;
+    /**
+     * List all file paths
+     */
+    listFiles(): string[];
+    /**
+     * Extract a single file (async)
+     */
+    extract(path: string): Promise<Uint8Array | null>;
+    /**
+     * Extract a single file (sync, Node.js only)
+     */
+    extractSync(path: string): Uint8Array | null;
+    /**
+     * Extract all files (async)
+     */
+    extractAll(): Promise<Map<string, Uint8Array>>;
+    /**
+     * Iterate over entries with async callback
+     */
+    forEach(callback: (entry: ZipEntryInfo, getData: () => Promise<Uint8Array>) => Promise<boolean | void>): Promise<void>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cj-tech-master/excelts",
-  "version": "1.4.5-canary.20251212064440.3eb099f",
+  "version": "1.4.5-canary.20251212160853.7621827",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "private": false,
   "publishConfig": {