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

package/dist/esm/doc/table.js

@@ -0,0 +1,407 @@
+import { colCache } from "../utils/col-cache.js";
+class Column {
+    constructor(table, column, index) {
+        this.table = table;
+        this.column = column;
+        this.index = index;
+    }
+    _set(name, value) {
+        this.table.cacheState();
+        this.column[name] = value;
+    }
+    get name() {
+        return this.column.name;
+    }
+    set name(value) {
+        this._set("name", value);
+    }
+    get filterButton() {
+        return this.column.filterButton;
+    }
+    set filterButton(value) {
+        this.column.filterButton = value;
+    }
+    get style() {
+        return this.column.style;
+    }
+    set style(value) {
+        this.column.style = value;
+    }
+    get totalsRowLabel() {
+        return this.column.totalsRowLabel;
+    }
+    set totalsRowLabel(value) {
+        this._set("totalsRowLabel", value);
+    }
+    get totalsRowFunction() {
+        return this.column.totalsRowFunction;
+    }
+    set totalsRowFunction(value) {
+        this._set("totalsRowFunction", value);
+    }
+    get totalsRowResult() {
+        return this.column.totalsRowResult;
+    }
+    set totalsRowResult(value) {
+        this._set("totalsRowResult", value);
+    }
+    get totalsRowFormula() {
+        return this.column.totalsRowFormula;
+    }
+    set totalsRowFormula(value) {
+        this._set("totalsRowFormula", value);
+    }
+}
+class Table {
+    constructor(worksheet, table) {
+        this.worksheet = worksheet;
+        if (table) {
+            this.table = table;
+            // check things are ok first
+            this.validate();
+            this.store();
+        }
+    }
+    getFormula(column) {
+        // get the correct formula to apply to the totals row
+        switch (column.totalsRowFunction) {
+            case "none":
+                return null;
+            case "average":
+                return `SUBTOTAL(101,${this.table.name}[${column.name}])`;
+            case "countNums":
+                return `SUBTOTAL(102,${this.table.name}[${column.name}])`;
+            case "count":
+                return `SUBTOTAL(103,${this.table.name}[${column.name}])`;
+            case "max":
+                return `SUBTOTAL(104,${this.table.name}[${column.name}])`;
+            case "min":
+                return `SUBTOTAL(105,${this.table.name}[${column.name}])`;
+            case "stdDev":
+                return `SUBTOTAL(106,${this.table.name}[${column.name}])`;
+            case "var":
+                return `SUBTOTAL(107,${this.table.name}[${column.name}])`;
+            case "sum":
+                return `SUBTOTAL(109,${this.table.name}[${column.name}])`;
+            case "custom":
+                return column.totalsRowFormula || null;
+            default:
+                throw new Error(`Invalid Totals Row Function: ${column.totalsRowFunction}`);
+        }
+    }
+    get width() {
+        // width of the table
+        return this.table.columns.length;
+    }
+    get height() {
+        // height of the table data
+        return this.table.rows.length;
+    }
+    get filterHeight() {
+        // height of the table data plus optional header row
+        return this.height + (this.table.headerRow ? 1 : 0);
+    }
+    get tableHeight() {
+        // full height of the table on the sheet
+        return this.filterHeight + (this.table.totalsRow ? 1 : 0);
+    }
+    validate() {
+        const { table } = this;
+        // set defaults and check is valid
+        const assign = (o, name, dflt) => {
+            if (o[name] === undefined) {
+                o[name] = dflt;
+            }
+        };
+        assign(table, "headerRow", true);
+        assign(table, "totalsRow", false);
+        assign(table, "style", {});
+        assign(table.style, "theme", "TableStyleMedium2");
+        assign(table.style, "showFirstColumn", false);
+        assign(table.style, "showLastColumn", false);
+        assign(table.style, "showRowStripes", false);
+        assign(table.style, "showColumnStripes", false);
+        const assert = (test, message) => {
+            if (!test) {
+                throw new Error(message);
+            }
+        };
+        assert(!!table.ref, "Table must have ref");
+        assert(!!table.columns, "Table must have column definitions");
+        assert(!!table.rows, "Table must have row definitions");
+        table.tl = colCache.decodeAddress(table.ref);
+        const { row, col } = table.tl;
+        assert(row > 0, "Table must be on valid row");
+        assert(col > 0, "Table must be on valid col");
+        const { width, filterHeight, tableHeight } = this;
+        // autoFilterRef is a range that includes optional headers only
+        table.autoFilterRef = colCache.encode(row, col, row + filterHeight - 1, col + width - 1);
+        // tableRef is a range that includes optional headers and totals
+        table.tableRef = colCache.encode(row, col, row + tableHeight - 1, col + width - 1);
+        table.columns.forEach((column, i) => {
+            assert(!!column.name, `Column ${i} must have a name`);
+            if (i === 0) {
+                assign(column, "totalsRowLabel", "Total");
+            }
+            else {
+                assign(column, "totalsRowFunction", "none");
+                column.totalsRowFormula = this.getFormula(column) || undefined;
+            }
+        });
+    }
+    store() {
+        // where the table needs to store table data, headers, footers in
+        // the sheet...
+        const assignStyle = (cell, style) => {
+            if (style) {
+                Object.keys(style).forEach(key => {
+                    cell.style[key] = style[key];
+                });
+            }
+        };
+        const { worksheet, table } = this;
+        const { row, col } = table.tl;
+        let count = 0;
+        if (table.headerRow) {
+            const r = worksheet.getRow(row + count++);
+            table.columns.forEach((column, j) => {
+                const { style, name } = column;
+                const cell = r.getCell(col + j);
+                cell.value = name;
+                assignStyle(cell, style);
+            });
+        }
+        table.rows.forEach(data => {
+            const r = worksheet.getRow(row + count++);
+            data.forEach((value, j) => {
+                const cell = r.getCell(col + j);
+                cell.value = value;
+                assignStyle(cell, table.columns[j].style);
+            });
+        });
+        if (table.totalsRow) {
+            const r = worksheet.getRow(row + count++);
+            table.columns.forEach((column, j) => {
+                const cell = r.getCell(col + j);
+                if (j === 0) {
+                    cell.value = column.totalsRowLabel;
+                }
+                else {
+                    const formula = this.getFormula(column);
+                    if (formula) {
+                        cell.value = {
+                            formula: column.totalsRowFormula,
+                            result: column.totalsRowResult
+                        };
+                    }
+                    else {
+                        cell.value = null;
+                    }
+                }
+                assignStyle(cell, column.style);
+            });
+        }
+    }
+    load(worksheet) {
+        // where the table will read necessary features from a loaded sheet
+        const { table } = this;
+        const { row, col } = table.tl;
+        let count = 0;
+        if (table.headerRow) {
+            const r = worksheet.getRow(row + count++);
+            table.columns.forEach((column, j) => {
+                const cell = r.getCell(col + j);
+                cell.value = column.name;
+            });
+        }
+        table.rows.forEach(data => {
+            const r = worksheet.getRow(row + count++);
+            data.forEach((value, j) => {
+                const cell = r.getCell(col + j);
+                cell.value = value;
+            });
+        });
+        if (table.totalsRow) {
+            const r = worksheet.getRow(row + count++);
+            table.columns.forEach((column, j) => {
+                const cell = r.getCell(col + j);
+                if (j === 0) {
+                    cell.value = column.totalsRowLabel;
+                }
+                else {
+                    const formula = this.getFormula(column);
+                    if (formula) {
+                        cell.value = {
+                            formula: column.totalsRowFormula,
+                            result: column.totalsRowResult
+                        };
+                    }
+                }
+            });
+        }
+    }
+    get model() {
+        return this.table;
+    }
+    set model(value) {
+        this.table = value;
+    }
+    // ================================================================
+    // TODO: Mutating methods
+    cacheState() {
+        if (!this._cache) {
+            this._cache = {
+                ref: this.ref,
+                width: this.width,
+                tableHeight: this.tableHeight
+            };
+        }
+    }
+    commit() {
+        // changes may have been made that might have on-sheet effects
+        if (!this._cache) {
+            return;
+        }
+        // check things are ok first
+        this.validate();
+        const ref = colCache.decodeAddress(this._cache.ref);
+        if (this.ref !== this._cache.ref) {
+            // wipe out whole table footprint at previous location
+            for (let i = 0; i < this._cache.tableHeight; i++) {
+                const row = this.worksheet.getRow(ref.row + i);
+                for (let j = 0; j < this._cache.width; j++) {
+                    const cell = row.getCell(ref.col + j);
+                    cell.value = null;
+                }
+            }
+        }
+        else {
+            // clear out below table if it has shrunk
+            for (let i = this.tableHeight; i < this._cache.tableHeight; i++) {
+                const row = this.worksheet.getRow(ref.row + i);
+                for (let j = 0; j < this._cache.width; j++) {
+                    const cell = row.getCell(ref.col + j);
+                    cell.value = null;
+                }
+            }
+            // clear out to right of table if it has lost columns
+            for (let i = 0; i < this.tableHeight; i++) {
+                const row = this.worksheet.getRow(ref.row + i);
+                for (let j = this.width; j < this._cache.width; j++) {
+                    const cell = row.getCell(ref.col + j);
+                    cell.value = null;
+                }
+            }
+        }
+        this.store();
+    }
+    addRow(values, rowNumber) {
+        // Add a row of data, either insert at rowNumber or append
+        this.cacheState();
+        if (rowNumber === undefined) {
+            this.table.rows.push(values);
+        }
+        else {
+            this.table.rows.splice(rowNumber, 0, values);
+        }
+    }
+    removeRows(rowIndex, count = 1) {
+        // Remove a rows of data
+        this.cacheState();
+        this.table.rows.splice(rowIndex, count);
+    }
+    getColumn(colIndex) {
+        const column = this.table.columns[colIndex];
+        return new Column(this, column, colIndex);
+    }
+    addColumn(column, values, colIndex) {
+        // Add a new column, including column defn and values
+        // Inserts at colNumber or adds to the right
+        this.cacheState();
+        if (colIndex === undefined) {
+            this.table.columns.push(column);
+            this.table.rows.forEach((row, i) => {
+                row.push(values[i]);
+            });
+        }
+        else {
+            this.table.columns.splice(colIndex, 0, column);
+            this.table.rows.forEach((row, i) => {
+                row.splice(colIndex, 0, values[i]);
+            });
+        }
+    }
+    removeColumns(colIndex, count = 1) {
+        // Remove a column with data
+        this.cacheState();
+        this.table.columns.splice(colIndex, count);
+        this.table.rows.forEach(row => {
+            row.splice(colIndex, count);
+        });
+    }
+    _assign(target, prop, value) {
+        this.cacheState();
+        target[prop] = value;
+    }
+    get ref() {
+        return this.table.ref;
+    }
+    set ref(value) {
+        this._assign(this.table, "ref", value);
+    }
+    get name() {
+        return this.table.name;
+    }
+    set name(value) {
+        this.table.name = value;
+    }
+    get displayName() {
+        return this.table.displayName || this.table.name;
+    }
+    set displayName(value) {
+        this.table.displayName = value;
+    }
+    get headerRow() {
+        return this.table.headerRow;
+    }
+    set headerRow(value) {
+        this._assign(this.table, "headerRow", value);
+    }
+    get totalsRow() {
+        return this.table.totalsRow;
+    }
+    set totalsRow(value) {
+        this._assign(this.table, "totalsRow", value);
+    }
+    get theme() {
+        return this.table.style.name;
+    }
+    set theme(value) {
+        this.table.style.name = value;
+    }
+    get showFirstColumn() {
+        return this.table.style.showFirstColumn;
+    }
+    set showFirstColumn(value) {
+        this.table.style.showFirstColumn = value;
+    }
+    get showLastColumn() {
+        return this.table.style.showLastColumn;
+    }
+    set showLastColumn(value) {
+        this.table.style.showLastColumn = value;
+    }
+    get showRowStripes() {
+        return this.table.style.showRowStripes;
+    }
+    set showRowStripes(value) {
+        this.table.style.showRowStripes = value;
+    }
+    get showColumnStripes() {
+        return this.table.style.showColumnStripes;
+    }
+    set showColumnStripes(value) {
+        this.table.style.showColumnStripes = value;
+    }
+}
+export { Table };

package/dist/esm/doc/workbook.js

@@ -0,0 +1,178 @@
+import { Worksheet } from "./worksheet.js";
+import { DefinedNames } from "./defined-names.js";
+import { XLSX } from "../xlsx/xlsx.js";
+import { CSV } from "../csv/csv.js";
+// Workbook requirements
+//  Load and Save from file and stream
+//  Access/Add/Delete individual worksheets
+//  Manage String table, Hyperlink table, etc.
+//  Manage scaffolding for contained objects to write to/read from
+class Workbook {
+    constructor() {
+        this.category = "";
+        this.company = "";
+        this.created = new Date();
+        this.description = "";
+        this.keywords = "";
+        this.manager = "";
+        this.modified = this.created;
+        this.properties = {};
+        this.calcProperties = {};
+        this._worksheets = [];
+        this.subject = "";
+        this.title = "";
+        this.views = [];
+        this.media = [];
+        this.pivotTables = [];
+        this._definedNames = new DefinedNames();
+    }
+    get xlsx() {
+        if (!this._xlsx) {
+            this._xlsx = new XLSX(this);
+        }
+        return this._xlsx;
+    }
+    get csv() {
+        if (!this._csv) {
+            this._csv = new CSV(this);
+        }
+        return this._csv;
+    }
+    get nextId() {
+        // find the next unique spot to add worksheet
+        for (let i = 1; i < this._worksheets.length; i++) {
+            if (!this._worksheets[i]) {
+                return i;
+            }
+        }
+        return this._worksheets.length || 1;
+    }
+    addWorksheet(name, options) {
+        const id = this.nextId;
+        const lastOrderNo = this._worksheets.reduce((acc, ws) => ((ws && ws.orderNo) > acc ? ws.orderNo : acc), 0);
+        const worksheetOptions = Object.assign({}, options, {
+            id,
+            name,
+            orderNo: lastOrderNo + 1,
+            workbook: this
+        });
+        const worksheet = new Worksheet(worksheetOptions);
+        this._worksheets[id] = worksheet;
+        return worksheet;
+    }
+    removeWorksheetEx(worksheet) {
+        delete this._worksheets[worksheet.id];
+    }
+    removeWorksheet(id) {
+        const worksheet = this.getWorksheet(id);
+        if (worksheet) {
+            worksheet.destroy();
+        }
+    }
+    getWorksheet(id) {
+        if (id === undefined) {
+            return this._worksheets.find(Boolean);
+        }
+        if (typeof id === "number") {
+            return this._worksheets[id];
+        }
+        if (typeof id === "string") {
+            return this._worksheets.find(worksheet => worksheet && worksheet.name === id);
+        }
+        return undefined;
+    }
+    get worksheets() {
+        // return a clone of _worksheets
+        return this._worksheets
+            .slice(1)
+            .sort((a, b) => a.orderNo - b.orderNo)
+            .filter(Boolean);
+    }
+    eachSheet(iteratee) {
+        this.worksheets.forEach(sheet => {
+            iteratee(sheet, sheet.id);
+        });
+    }
+    get definedNames() {
+        return this._definedNames;
+    }
+    clearThemes() {
+        // Note: themes are not an exposed feature, meddle at your peril!
+        this._themes = undefined;
+    }
+    addImage(image) {
+        // TODO:  validation?
+        const id = this.media.length;
+        this.media.push(Object.assign({}, image, { type: "image" }));
+        return id;
+    }
+    getImage(id) {
+        return this.media[id];
+    }
+    get model() {
+        return {
+            creator: this.creator || "Unknown",
+            lastModifiedBy: this.lastModifiedBy || "Unknown",
+            lastPrinted: this.lastPrinted,
+            created: this.created,
+            modified: this.modified,
+            properties: this.properties,
+            worksheets: this.worksheets.map(worksheet => worksheet.model),
+            sheets: this.worksheets.map(ws => ws.model).filter(Boolean),
+            definedNames: this._definedNames.model,
+            views: this.views,
+            company: this.company,
+            manager: this.manager,
+            title: this.title,
+            subject: this.subject,
+            keywords: this.keywords,
+            category: this.category,
+            description: this.description,
+            language: this.language,
+            revision: this.revision,
+            contentStatus: this.contentStatus,
+            themes: this._themes,
+            media: this.media,
+            pivotTables: this.pivotTables,
+            calcProperties: this.calcProperties
+        };
+    }
+    set model(value) {
+        this.creator = value.creator;
+        this.lastModifiedBy = value.lastModifiedBy;
+        this.lastPrinted = value.lastPrinted;
+        this.created = value.created;
+        this.modified = value.modified;
+        this.company = value.company;
+        this.manager = value.manager;
+        this.title = value.title;
+        this.subject = value.subject;
+        this.keywords = value.keywords;
+        this.category = value.category;
+        this.description = value.description;
+        this.language = value.language;
+        this.revision = value.revision;
+        this.contentStatus = value.contentStatus;
+        this.properties = value.properties;
+        this.calcProperties = value.calcProperties;
+        this._worksheets = [];
+        value.worksheets.forEach(worksheetModel => {
+            const { id, name, state } = worksheetModel;
+            const orderNo = value.sheets && value.sheets.findIndex(ws => ws.id === id);
+            const worksheet = (this._worksheets[id] = new Worksheet({
+                id,
+                name,
+                orderNo: orderNo !== -1 ? orderNo : undefined,
+                state,
+                workbook: this
+            }));
+            worksheet.model = worksheetModel;
+        });
+        this._definedNames.model = value.definedNames;
+        this.views = value.views;
+        this._themes = value.themes;
+        this.media = value.media || [];
+        this.pivotTables = value.pivotTables || [];
+    }
+}
+export { Workbook };