@cj-tech-master/excelts 1.4.5-canary.20251212053535.13d32d8 → 1.4.5-canary.20251212143538.45665af

package/dist/esm/doc/worksheet.js

@@ -130,14 +130,21 @@ class Worksheet {
         }
         this._name = name;
     }
+    /**
+     * The workbook that contains this worksheet
+     */
     get workbook() {
         return this._workbook;
     }
-    // when you're done with this worksheet, call this to remove from workbook
+    /**
+     * When you're done with this worksheet, call this to remove from workbook
+     */
     destroy() {
         this._workbook.removeWorksheetEx(this);
     }
-    // Get the bounding range of the cells in this worksheet
+    /**
+     * Get the bounding range of the cells in this worksheet
+     */
     get dimensions() {
         const dimensions = new Range();
         this._rows.forEach(row => {
@@ -152,12 +159,18 @@ class Worksheet {
     }
     // =========================================================================
     // Columns
-    // get the current columns array.
+    /**
+     * Get the current columns array
+     */
     get columns() {
         return this._columns;
     }
-    // set the columns from an array of column definitions.
-    // Note: any headers defined will overwrite existing values.
+    /**
+     * 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) {
         // calculate max header row count
         this._headerRowCount = value.reduce((pv, cv) => {
@@ -185,7 +198,9 @@ class Worksheet {
     eachColumnKey(f) {
         Object.keys(this._keys).forEach(key => f(this._keys[key], key));
     }
-    // get a single column by col number. If it doesn't exist, create it and any gaps before it
+    /**
+     * Access an individual column by key, letter and 1-based column number
+     */
     getColumn(c) {
         let colNum;
         if (typeof c === "string") {
@@ -211,6 +226,17 @@ class Worksheet {
         }
         return this._columns[colNum - 1];
     }
+    /**
+     * 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, count, ...inserts) {
         const rows = this._rows;
         const nRows = rows.length;
@@ -250,9 +276,15 @@ class Worksheet {
         // account for defined names
         this.workbook.definedNames.spliceColumns(this.name, start, count, inserts.length);
     }
+    /**
+     * Get the last column in a worksheet
+     */
     get lastColumn() {
         return this.getColumn(this.columnCount);
     }
+    /**
+     * The total column size of the document. Equal to the maximum cell count from all of the rows
+     */
     get columnCount() {
         let maxCount = 0;
         this.eachRow(row => {
@@ -260,6 +292,9 @@ class Worksheet {
         });
         return maxCount;
     }
+    /**
+     * A count of the number of columns that have values
+     */
     get actualColumnCount() {
         // performance nightmare - for each row, counts all the columns used
         const counts = [];
@@ -291,23 +326,41 @@ class Worksheet {
     get _nextRow() {
         return this._lastRowNumber + 1;
     }
+    /**
+     * Get the last editable row in a worksheet (or undefined if there are none)
+     */
     get lastRow() {
         if (this._rows.length) {
             return this._rows[this._rows.length - 1];
         }
         return undefined;
     }
-    // find a row (if exists) by row number
+    /**
+     * Tries to find and return row for row number, else undefined
+     *
+     * @param r - The 1-indexed row number
+     */
     findRow(r) {
         return this._rows[r - 1];
     }
-    // find multiple rows (if exists) by row number
+    /**
+     * 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, length) {
         return this._rows.slice(start - 1, start - 1 + length);
     }
+    /**
+     * The total row size of the document. Equal to the row number of the last row that has values.
+     */
     get rowCount() {
         return this._lastRowNumber;
     }
+    /**
+     * 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() {
         // counts actual rows that have actual data
         let count = 0;
@@ -316,7 +369,9 @@ class Worksheet {
         });
         return count;
     }
-    // get a row by row number.
+    /**
+     * Get or create row by 1-based index
+     */
     getRow(r) {
         let row = this._rows[r - 1];
         if (!row) {
@@ -324,7 +379,9 @@ class Worksheet {
         }
         return row;
     }
-    // get multiple rows by row number.
+    /**
+     * Get or create rows by 1-based index
+     */
     getRows(start, length) {
         if (length < 1) {
             return undefined;
@@ -335,6 +392,10 @@ class Worksheet {
         }
         return rows;
     }
+    /**
+     * 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, style = "n") {
         const rowNo = this._nextRow;
         const row = this.getRow(rowNo);
@@ -342,6 +403,9 @@ class Worksheet {
         this._setStyleOption(rowNo, style[0] === "i" ? style : "n");
         return row;
     }
+    /**
+     * Add multiple rows by providing an array of arrays or key-value pairs
+     */
     addRows(value, style = "n") {
         const rows = [];
         value.forEach(row => {
@@ -349,11 +413,19 @@ class Worksheet {
         });
         return rows;
     }
+    /**
+     * 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, value, style = "n") {
         this.spliceRows(pos, 0, value);
         this._setStyleOption(pos, style);
         return this.getRow(pos);
     }
+    /**
+     * Insert multiple rows at position (shifting down all rows from position)
+     * by providing an array of arrays or key-value pairs
+     */
     insertRows(pos, values, style = "n") {
         this.spliceRows(pos, 0, ...values);
         if (style !== "n") {
@@ -387,6 +459,9 @@ class Worksheet {
         });
         rDst.height = rSrc.height;
     }
+    /**
+     * Duplicate rows and insert new rows
+     */
     duplicateRow(rowNum, count, insert = false) {
         // create count duplicates of rowNum
         // either inserting new or overwriting existing rows
@@ -403,6 +478,12 @@ class Worksheet {
             });
         }
     }
+    /**
+     * 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, count, ...inserts) {
         // same problem as row.splice, except worse.
         const nKeep = start + count;
@@ -467,31 +548,33 @@ class Worksheet {
         // account for defined names
         this.workbook.definedNames.spliceRows(this.name, start, count, nInserts);
     }
-    eachRow(optionsOrIteratee, maybeIteratee) {
+    eachRow(optOrCallback, maybeCallback) {
         let options;
-        let iteratee;
-        if (typeof optionsOrIteratee === "function") {
-            iteratee = optionsOrIteratee;
+        let callback;
+        if (typeof optOrCallback === "function") {
+            callback = optOrCallback;
         }
         else {
-            options = optionsOrIteratee;
-            iteratee = maybeIteratee;
+            options = optOrCallback;
+            callback = maybeCallback;
         }
         if (options && options.includeEmpty) {
             const n = this._rows.length;
             for (let i = 1; i <= n; i++) {
-                iteratee(this.getRow(i), i);
+                callback(this.getRow(i), i);
             }
         }
         else {
             this._rows.forEach(row => {
                 if (row && row.hasValues) {
-                    iteratee(row, row.number);
+                    callback(row, row.number);
                 }
             });
         }
     }
-    // return all rows as sparse array
+    /**
+     * Return all rows as sparse array
+     */
     getSheetValues() {
         const rows = [];
         this._rows.forEach(row => {
@@ -503,13 +586,17 @@ class Worksheet {
     }
     // =========================================================================
     // Cells
-    // returns the cell at [r,c] or address given by r. If not found, return undefined
+    /**
+     * Returns the cell at [r,c] or address given by r. If not found, return undefined
+     */
     findCell(r, c) {
         const address = colCache.getAddress(r, c);
         const row = this._rows[address.row - 1];
         return row ? row.findCell(address.col) : undefined;
     }
-    // return the cell at [r,c] or address given by r. If not found, create a new one.
+    /**
+     * Get or create cell at [r,c] or address given by r
+     */
     getCell(r, c) {
         const address = colCache.getAddress(r, c);
         const row = this.getRow(address.row);
@@ -517,7 +604,15 @@ class Worksheet {
     }
     // =========================================================================
     // Merge
-    // convert the range defined by ['tl:br'], [tl,br] or [t,l,b,r] into a single 'merged' 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) {
         const dimensions = new Range(cells);
         this._mergeCellsInternal(dimensions);
@@ -562,9 +657,11 @@ class Worksheet {
         // return true if this._merges has a merge object
         return Object.values(this._merges).some(Boolean);
     }
-    // scan the range defined by ['tl:br'], [tl,br] or [t,l,b,r] 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.
+    /**
+     * 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) {
         const dimensions = new Range(cells);
         // find any cells in that range and unmerge them
@@ -636,6 +733,10 @@ class Worksheet {
     }
     // =========================================================================
     // Images
+    /**
+     * Using the image id from `Workbook.addImage`,
+     * embed an image within the worksheet to cover a range
+     */
     addImage(imageId, range) {
         const model = {
             type: "image",
@@ -647,6 +748,9 @@ class Worksheet {
     getImages() {
         return this._media.filter(m => m.type === "image");
     }
+    /**
+     * Using the image id from `Workbook.addImage`, set the background to the worksheet
+     */
     addBackgroundImage(imageId) {
         const model = {
             type: "background",
@@ -660,6 +764,9 @@ class Worksheet {
     }
     // =========================================================================
     // Worksheet Protection
+    /**
+     * Protect the worksheet with optional password and options
+     */
     protect(password, options) {
         // TODO: make this function truly async
         // perhaps marshal to worker thread or something
@@ -694,17 +801,29 @@ class Worksheet {
     }
     // =========================================================================
     // Tables
+    /**
+     * Add a new table and return a reference to it
+     */
     addTable(model) {
         const table = new Table(this, model);
         this.tables[model.name] = table;
         return table;
     }
+    /**
+     * Fetch table by name
+     */
     getTable(name) {
         return this.tables[name];
     }
+    /**
+     * Delete table by name
+     */
     removeTable(name) {
         delete this.tables[name];
     }
+    /**
+     * Fetch all tables in the worksheet
+     */
     getTables() {
         return Object.values(this.tables);
     }
@@ -720,9 +839,15 @@ Please leave feedback at https://github.com/excelts/excelts/discussions/2575`);
     }
     // ===========================================================================
     // Conditional Formatting
+    /**
+     * Add conditional formatting rules
+     */
     addConditionalFormatting(cf) {
         this.conditionalFormattings.push(cf);
     }
+    /**
+     * Delete conditional formatting rules
+     */
     removeConditionalFormatting(filter) {
         if (typeof filter === "number") {
             this.conditionalFormattings.splice(filter, 1);

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

@@ -19,40 +19,75 @@ export interface ColumnModel {
     outlineLevel?: number;
     collapsed?: boolean;
 }
+/**
+ * Column defines the column properties for 1 column.
+ * This includes header rows, widths, key, (style), etc.
+ * Worksheet will condense the columns as appropriate during serialization
+ */
 declare class Column {
     private _worksheet;
     private _number;
     private _header;
     private _key;
+    /** The width of the column */
     width?: number;
     private _hidden;
     private _outlineLevel;
+    /** Styles applied to the column */
     style: Partial<Style>;
     constructor(worksheet: Worksheet, number: number, defn?: ColumnDefn | false);
     get number(): number;
     get worksheet(): Worksheet;
+    /**
+     * Column letter key
+     */
     get letter(): string;
     get isCustomWidth(): boolean;
     get defn(): ColumnDefn;
     set defn(value: ColumnDefn | undefined);
     get headers(): string[];
+    /**
+     * Can be a string to set one row high header or an array to set multi-row high header
+     */
     get header(): string | string[] | undefined;
     set header(value: string | string[] | undefined);
+    /**
+     * The name of the properties associated with this column in each row
+     */
     get key(): string | undefined;
     set key(value: string | undefined);
+    /**
+     * Hides the column
+     */
     get hidden(): boolean;
     set hidden(value: boolean);
+    /**
+     * Set an outline level for columns
+     */
     get outlineLevel(): number;
     set outlineLevel(value: number | undefined);
+    /**
+     * Indicate the collapsed state based on outlineLevel
+     */
     get collapsed(): boolean;
     toString(): string;
     equivalentTo(other: Column): boolean;
     equivalentToModel(model: ColumnModel): boolean;
     get isDefault(): boolean;
     get headerCount(): number;
-    eachCell(options: {
+    /**
+     * Iterate over all current cells in this column
+     */
+    eachCell(callback: (cell: Cell, rowNumber: number) => void): void;
+    /**
+     * Iterate over all current cells in this column including empty cells
+     */
+    eachCell(opt: {
         includeEmpty?: boolean;
-    } | ((cell: Cell, rowNumber: number) => void), iteratee?: (cell: Cell, rowNumber: number) => void): void;
+    }, callback: (cell: Cell, rowNumber: number) => void): void;
+    /**
+     * The cell values in the column
+     */
     get values(): CellValueType[];
     set values(v: CellValueType[]);
     get numFmt(): string | NumFmt | undefined;

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

@@ -16,9 +16,6 @@ export interface RowModel {
     outlineLevel: number;
     collapsed: boolean;
 }
-interface EachCellOptions {
-    includeEmpty?: boolean;
-}
 declare class Row {
     private _worksheet;
     private _number;
@@ -28,22 +25,70 @@ declare class Row {
     private _outlineLevel?;
     height?: number;
     constructor(worksheet: Worksheet, number: number);
+    /**
+     * The row number
+     */
     get number(): number;
+    /**
+     * The worksheet that contains this row
+     */
     get worksheet(): Worksheet;
+    /**
+     * Commit a completed row to stream.
+     * Inform Streaming Writer that this row (and all rows before it) are complete
+     * and ready to write. Has no effect on Worksheet document.
+     */
     commit(): void;
+    /**
+     * Helps GC by breaking cyclic references
+     */
     destroy(): void;
     findCell(colNumber: number): Cell | undefined;
     getCellEx(address: CellAddress): Cell;
+    /**
+     * Get cell by number, column letter or column key
+     */
     getCell(col: string | number): Cell;
+    /**
+     * Cut one or more cells (cells to the right are shifted left)
+     *
+     * Note: this operation will not affect other rows
+     */
     splice(start: number, count: number, ...inserts: CellValue[]): void;
-    eachCell(iteratee: (cell: Cell, colNumber: number) => void): void;
-    eachCell(options: EachCellOptions, iteratee: (cell: Cell, colNumber: number) => void): void;
+    /**
+     * Iterate over all non-null cells in a row
+     */
+    eachCell(callback: (cell: Cell, colNumber: number) => void): void;
+    /**
+     * Iterate over all cells in a row (including empty cells)
+     */
+    eachCell(opt: {
+        includeEmpty?: boolean;
+    }, callback: (cell: Cell, colNumber: number) => void): void;
     addPageBreak(lft?: number, rght?: number): void;
+    /**
+     * Get a row as a sparse array
+     */
     get values(): CellValue[];
+    /**
+     * Set the values by contiguous or sparse array, or by key'd object literal
+     */
     set values(value: RowValues);
+    /**
+     * Returns true if the row includes at least one cell with a value
+     */
     get hasValues(): boolean;
+    /**
+     * Number of cells including empty ones
+     */
     get cellCount(): number;
+    /**
+     * Number of non-empty cells
+     */
     get actualCellCount(): number;
+    /**
+     * Get the min and max column number for the non-null cells in this row or null
+     */
     get dimensions(): RowDimensions | null;
     private _applyStyle;
     get numFmt(): string | NumFmt | undefined;

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

@@ -65,17 +65,40 @@ declare class Workbook {
     private _xlsx?;
     private _csv?;
     constructor();
+    /**
+     * xlsx file format operations
+     */
     get xlsx(): XLSX;
+    /**
+     * csv file format operations
+     */
     get csv(): CSV;
     get nextId(): number;
+    /**
+     * Add a new worksheet and return a reference to it
+     */
     addWorksheet(name?: string, options?: AddWorksheetOptions): Worksheet;
     removeWorksheetEx(worksheet: Worksheet): void;
     removeWorksheet(id: number | string): void;
+    /**
+     * Fetch sheet by name or id
+     */
     getWorksheet(id?: number | string): Worksheet | undefined;
+    /**
+     * Return a clone of worksheets in order
+     */
     get worksheets(): Worksheet[];
-    eachSheet(iteratee: (sheet: Worksheet, id: number) => void): void;
+    /**
+     * Iterate over all sheets.
+     *
+     * Note: `workbook.worksheets.forEach` will still work but this is better.
+     */
+    eachSheet(callback: (sheet: Worksheet, id: number) => void): void;
     get definedNames(): DefinedNames;
     clearThemes(): void;
+    /**
+     * Add Image to Workbook and return the id
+     */
     addImage(image: Image): number;
     getImage(id: number | string): WorkbookMedia | undefined;
     get model(): WorkbookModel;