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

package/dist/esm/doc/pivot-table.js

@@ -0,0 +1,108 @@
+import { objectFromProps, range, toSortedArray } from "../utils/utils.js";
+// TK(2023-10-10): turn this into a class constructor.
+function makePivotTable(worksheet, model) {
+    // Example `model`:
+    // {
+    //   // Source of data: the entire sheet range is taken,
+    //   // akin to `worksheet1.getSheetValues()`.
+    //   sourceSheet: worksheet1,
+    //
+    //   // Pivot table fields: values indicate field names;
+    //   // they come from the first row in `worksheet1`.
+    //   rows: ['A', 'B'],
+    //   columns: ['C'],
+    //   values: ['E'], // only 1 item possible for now
+    //   metric: 'sum', // only 'sum' possible for now
+    // }
+    validate(worksheet, model);
+    const { sourceSheet } = model;
+    const { rows, columns, values } = model;
+    const cacheFields = makeCacheFields(sourceSheet, [...rows, ...columns]);
+    const nameToIndex = cacheFields.reduce((result, cacheField, index) => {
+        result[cacheField.name] = index;
+        return result;
+    }, {});
+    const rowIndices = rows.map(row => nameToIndex[row]);
+    const columnIndices = columns.map(column => nameToIndex[column]);
+    const valueIndices = values.map(value => nameToIndex[value]);
+    // form pivot table object
+    return {
+        sourceSheet,
+        rows: rowIndices,
+        columns: columnIndices,
+        values: valueIndices,
+        metric: "sum",
+        cacheFields,
+        // defined in <pivotTableDefinition> of xl/pivotTables/pivotTable1.xml;
+        // also used in xl/workbook.xml
+        cacheId: "10"
+    };
+}
+function validate(worksheet, model) {
+    if (worksheet.workbook.pivotTables.length === 1) {
+        throw new Error("A pivot table was already added. At this time, ExcelTS supports at most one pivot table per file.");
+    }
+    if (model.metric && model.metric !== "sum") {
+        throw new Error('Only the "sum" metric is supported at this time.');
+    }
+    const headerNames = model.sourceSheet.getRow(1).values.slice(1);
+    const isInHeaderNames = objectFromProps(headerNames, true);
+    for (const name of [...model.rows, ...model.columns, ...model.values]) {
+        if (!isInHeaderNames[name]) {
+            throw new Error(`The header name "${name}" was not found in ${model.sourceSheet.name}.`);
+        }
+    }
+    if (!model.rows.length) {
+        throw new Error("No pivot table rows specified.");
+    }
+    if (!model.columns.length) {
+        throw new Error("No pivot table columns specified.");
+    }
+    if (model.values.length !== 1) {
+        throw new Error("Exactly 1 value needs to be specified at this time.");
+    }
+}
+function makeCacheFields(worksheet, fieldNamesWithSharedItems) {
+    // Cache fields are used in pivot tables to reference source data.
+    //
+    // Example
+    // -------
+    // Turn
+    //
+    //  `worksheet` sheet values [
+    //    ['A', 'B', 'C', 'D', 'E'],
+    //    ['a1', 'b1', 'c1', 4, 5],
+    //    ['a1', 'b2', 'c1', 4, 5],
+    //    ['a2', 'b1', 'c2', 14, 24],
+    //    ['a2', 'b2', 'c2', 24, 35],
+    //    ['a3', 'b1', 'c3', 34, 45],
+    //    ['a3', 'b2', 'c3', 44, 45]
+    //  ];
+    //  fieldNamesWithSharedItems = ['A', 'B', 'C'];
+    //
+    // into
+    //
+    //  [
+    //    { name: 'A', sharedItems: ['a1', 'a2', 'a3'] },
+    //    { name: 'B', sharedItems: ['b1', 'b2'] },
+    //    { name: 'C', sharedItems: ['c1', 'c2', 'c3'] },
+    //    { name: 'D', sharedItems: null },
+    //    { name: 'E', sharedItems: null }
+    //  ]
+    const names = worksheet.getRow(1).values;
+    const nameToHasSharedItems = objectFromProps(fieldNamesWithSharedItems, true);
+    const aggregate = (columnIndex) => {
+        const columnValues = worksheet.getColumn(columnIndex).values.splice(2);
+        const columnValuesAsSet = new Set(columnValues);
+        return toSortedArray(columnValuesAsSet);
+    };
+    // make result
+    const result = [];
+    for (const columnIndex of range(1, names.length)) {
+        const name = names[columnIndex];
+        const sharedItems = nameToHasSharedItems[name] ? aggregate(columnIndex) : null;
+        result.push({ name, sharedItems });
+    }
+    return result;
+}
+export { makePivotTable };

package/dist/esm/doc/range.js

@@ -0,0 +1,244 @@
+import { colCache } from "../utils/col-cache.js";
+// used by worksheet to calculate sheet dimensions
+class Range {
+    constructor(...args) {
+        this.decode(args);
+    }
+    setTLBR(t, l, b, r, s) {
+        if (arguments.length < 4) {
+            // setTLBR(tl, br, s)
+            const tl = colCache.decodeAddress(t);
+            const br = colCache.decodeAddress(l);
+            this.model = {
+                top: Math.min(tl.row, br.row),
+                left: Math.min(tl.col, br.col),
+                bottom: Math.max(tl.row, br.row),
+                right: Math.max(tl.col, br.col),
+                sheetName: b
+            };
+            this.setTLBR(tl.row, tl.col, br.row, br.col, s);
+        }
+        else {
+            // setTLBR(t, l, b, r, s)
+            this.model = {
+                top: Math.min(t, b),
+                left: Math.min(l, r),
+                bottom: Math.max(t, b),
+                right: Math.max(l, r),
+                sheetName: s
+            };
+        }
+    }
+    decode(argv) {
+        switch (argv.length) {
+            case 5: // [t,l,b,r,s]
+                this.setTLBR(argv[0], argv[1], argv[2], argv[3], argv[4]);
+                break;
+            case 4: // [t,l,b,r]
+                this.setTLBR(argv[0], argv[1], argv[2], argv[3]);
+                break;
+            case 3: // [tl,br,s]
+                this.setTLBR(argv[0], argv[1], argv[2]);
+                break;
+            case 2: // [tl,br]
+                this.setTLBR(argv[0], argv[1]);
+                break;
+            case 1: {
+                const value = argv[0];
+                if (value instanceof Range) {
+                    // copy constructor
+                    this.model = {
+                        top: value.model.top,
+                        left: value.model.left,
+                        bottom: value.model.bottom,
+                        right: value.model.right,
+                        sheetName: value.sheetName
+                    };
+                }
+                else if (value instanceof Array) {
+                    // an arguments array
+                    this.decode(value);
+                }
+                else if (value.top && value.left && value.bottom && value.right) {
+                    // a model
+                    this.model = {
+                        top: value.top,
+                        left: value.left,
+                        bottom: value.bottom,
+                        right: value.right,
+                        sheetName: value.sheetName
+                    };
+                }
+                else {
+                    // [sheetName!]tl:br
+                    const tlbr = colCache.decodeEx(value);
+                    if (tlbr.top) {
+                        this.model = {
+                            top: tlbr.top,
+                            left: tlbr.left,
+                            bottom: tlbr.bottom,
+                            right: tlbr.right,
+                            sheetName: tlbr.sheetName
+                        };
+                    }
+                    else {
+                        this.model = {
+                            top: tlbr.row,
+                            left: tlbr.col,
+                            bottom: tlbr.row,
+                            right: tlbr.col,
+                            sheetName: tlbr.sheetName
+                        };
+                    }
+                }
+                break;
+            }
+            case 0:
+                this.model = {
+                    top: 0,
+                    left: 0,
+                    bottom: 0,
+                    right: 0
+                };
+                break;
+            default:
+                throw new Error(`Invalid number of arguments to _getDimensions() - ${argv.length}`);
+        }
+    }
+    get top() {
+        return this.model.top || 1;
+    }
+    set top(value) {
+        this.model.top = value;
+    }
+    get left() {
+        return this.model.left || 1;
+    }
+    set left(value) {
+        this.model.left = value;
+    }
+    get bottom() {
+        return this.model.bottom || 1;
+    }
+    set bottom(value) {
+        this.model.bottom = value;
+    }
+    get right() {
+        return this.model.right || 1;
+    }
+    set right(value) {
+        this.model.right = value;
+    }
+    get sheetName() {
+        return this.model.sheetName;
+    }
+    set sheetName(value) {
+        this.model.sheetName = value;
+    }
+    get _serialisedSheetName() {
+        const { sheetName } = this.model;
+        if (sheetName) {
+            if (/^[a-zA-Z0-9]*$/.test(sheetName)) {
+                return `${sheetName}!`;
+            }
+            return `'${sheetName}'!`;
+        }
+        return "";
+    }
+    expand(top, left, bottom, right) {
+        if (!this.model.top || top < this.top) {
+            this.top = top;
+        }
+        if (!this.model.left || left < this.left) {
+            this.left = left;
+        }
+        if (!this.model.bottom || bottom > this.bottom) {
+            this.bottom = bottom;
+        }
+        if (!this.model.right || right > this.right) {
+            this.right = right;
+        }
+    }
+    expandRow(row) {
+        if (row) {
+            const { dimensions, number } = row;
+            if (dimensions) {
+                this.expand(number, dimensions.min, number, dimensions.max);
+            }
+        }
+    }
+    expandToAddress(addressStr) {
+        const address = colCache.decodeEx(addressStr);
+        this.expand(address.row, address.col, address.row, address.col);
+    }
+    get tl() {
+        return colCache.n2l(this.left) + this.top;
+    }
+    get $t$l() {
+        return `$${colCache.n2l(this.left)}$${this.top}`;
+    }
+    get br() {
+        return colCache.n2l(this.right) + this.bottom;
+    }
+    get $b$r() {
+        return `$${colCache.n2l(this.right)}$${this.bottom}`;
+    }
+    get range() {
+        return `${this._serialisedSheetName + this.tl}:${this.br}`;
+    }
+    get $range() {
+        return `${this._serialisedSheetName + this.$t$l}:${this.$b$r}`;
+    }
+    get shortRange() {
+        return this.count > 1 ? this.range : this._serialisedSheetName + this.tl;
+    }
+    get $shortRange() {
+        return this.count > 1 ? this.$range : this._serialisedSheetName + this.$t$l;
+    }
+    get count() {
+        return (1 + this.bottom - this.top) * (1 + this.right - this.left);
+    }
+    toString() {
+        return this.range;
+    }
+    intersects(other) {
+        if (other.sheetName && this.sheetName && other.sheetName !== this.sheetName) {
+            return false;
+        }
+        if (other.bottom < this.top) {
+            return false;
+        }
+        if (other.top > this.bottom) {
+            return false;
+        }
+        if (other.right < this.left) {
+            return false;
+        }
+        if (other.left > this.right) {
+            return false;
+        }
+        return true;
+    }
+    contains(addressStr) {
+        const address = colCache.decodeEx(addressStr);
+        return this.containsEx(address);
+    }
+    containsEx(address) {
+        if (address.sheetName && this.sheetName && address.sheetName !== this.sheetName) {
+            return false;
+        }
+        return (address.row >= this.top &&
+            address.row <= this.bottom &&
+            address.col >= this.left &&
+            address.col <= this.right);
+    }
+    forEachAddress(cb) {
+        for (let col = this.left; col <= this.right; col++) {
+            for (let row = this.top; row <= this.bottom; row++) {
+                cb(colCache.encodeAddress(row, col), row, col);
+            }
+        }
+    }
+}
+export { Range };
+export { Range as Dimensions };