@gridsheet/react-core 0.12.0-rc.0

package/dist/lib/table.js

@@ -0,0 +1,989 @@
+import { defaultParser } from "../parsers/core";
+import { defaultRenderer } from "../renderers/core";
+import { areaShape, createMatrix, matrixShape, putMatrix } from "./structs";
+import { a2p, x2c, p2a, y2r, grantAddressAbsolute } from "./converters";
+import { functions as functionsDefault } from "../formula/mapping";
+import { convertFormulaAbsolute, Lexer } from "../formula/evaluator";
+import { solveFormula } from "../formula/solver";
+import { DEFAULT_HEIGHT, DEFAULT_WIDTH, HISTORY_LIMIT } from "../constants";
+import { shouldTracking } from "../store/helpers";
+const cellFilter = (cell) => true;
+export class Table {
+    constructor({ numRows = 0, numCols = 0, cells = {}, parsers = {}, renderers = {}, labelers = {}, useBigInt = false, historyLimit: historyLimit = HISTORY_LIMIT, minNumRows = 1, maxNumRows = -1, minNumCols = 1, maxNumCols = -1, headerWidth = -1, headerHeight = -1, functions = functionsDefault, }) {
+        this.totalWidth = 0;
+        this.totalHeight = 0;
+        this.headerWidth = 0;
+        this.headerHeight = 0;
+        this.functions = {};
+        this.head = useBigInt ? BigInt(0) : 0;
+        this.data = {};
+        this.area = { top: 0, left: 0, bottom: numRows, right: numCols };
+        this.parsers = parsers;
+        this.renderers = renderers;
+        this.labelers = labelers;
+        this.idMatrix = [];
+        this.histories = [];
+        this.historyIndex = -1;
+        this.addressesById = {};
+        this.historyLimit = historyLimit;
+        this.changedAt = new Date();
+        this.minNumRows = minNumRows;
+        this.maxNumRows = maxNumRows;
+        this.minNumCols = minNumCols;
+        this.maxNumCols = maxNumCols;
+        this.solvedCaches = {};
+        this.headerHeight = headerHeight;
+        this.headerWidth = headerWidth;
+        this.functions = functions;
+        const common = cells.default;
+        // make idMatrix beforehand
+        for (let y = 0; y < numRows + 1; y++) {
+            const ids = [];
+            this.idMatrix.push(ids);
+            for (let x = 0; x < numCols + 1; x++) {
+                const id = this.generateId();
+                ids.push(id);
+                const address = p2a({ y, x });
+                this.addressesById[id] = address;
+            }
+        }
+        for (let y = 0; y < numRows + 1; y++) {
+            const rowId = y2r(y);
+            const rowDefault = cells[rowId];
+            for (let x = 0; x < numCols + 1; x++) {
+                const id = this.getId({ y, x });
+                const address = p2a({ y, x });
+                const colId = x2c(x);
+                const colDefault = cells[colId];
+                const cell = cells[address];
+                const stacked = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, common), rowDefault), colDefault), cell), { style: Object.assign(Object.assign(Object.assign(Object.assign({}, common === null || common === void 0 ? void 0 : common.style), rowDefault === null || rowDefault === void 0 ? void 0 : rowDefault.style), colDefault === null || colDefault === void 0 ? void 0 : colDefault.style), cell === null || cell === void 0 ? void 0 : cell.style) });
+                stacked.value = convertFormulaAbsolute({
+                    value: stacked === null || stacked === void 0 ? void 0 : stacked.value,
+                    table: this,
+                });
+                if (y === 0) {
+                    if (stacked.width == null) {
+                        stacked.width = DEFAULT_WIDTH;
+                    }
+                }
+                else if (x === 0) {
+                    if (stacked.height == null) {
+                        stacked.height = DEFAULT_HEIGHT;
+                    }
+                }
+                else {
+                    delete stacked.height;
+                    delete stacked.width;
+                    delete stacked.labeler;
+                }
+                this.data[id] = stacked;
+            }
+        }
+        this.setTotalSize();
+    }
+    generateId() {
+        return (this.head++).toString(36);
+    }
+    getRectSize({ top, left, bottom, right }) {
+        var _a, _b;
+        let width = 0, height = 0;
+        for (let x = left || 1; x < right; x++) {
+            width += ((_a = this.getByPoint({ y: 0, x })) === null || _a === void 0 ? void 0 : _a.width) || DEFAULT_WIDTH;
+        }
+        for (let y = top || 1; y < bottom; y++) {
+            height += ((_b = this.getByPoint({ y, x: 0 })) === null || _b === void 0 ? void 0 : _b.height) || DEFAULT_HEIGHT;
+        }
+        return { width, height };
+    }
+    setTotalSize() {
+        const { bottom, right } = this.area;
+        const { width, height } = this.getRectSize({ top: 1, left: 1, bottom: bottom + 1, right: right + 1 });
+        this.totalWidth = width + this.headerWidth;
+        this.totalHeight = height + this.headerHeight;
+    }
+    shallowCopy({ copyCache = true } = {}) {
+        const copied = new Table({});
+        copied.changedAt = new Date();
+        copied.lastChangedAt = this.changedAt;
+        copied.head = this.head;
+        copied.idMatrix = this.idMatrix;
+        copied.data = this.data;
+        copied.area = this.area;
+        copied.parsers = this.parsers;
+        copied.renderers = this.renderers;
+        copied.labelers = this.labelers;
+        copied.functions = this.functions;
+        copied.histories = this.histories;
+        copied.historyLimit = this.historyLimit;
+        copied.historyIndex = this.historyIndex;
+        copied.minNumRows = this.minNumRows;
+        copied.maxNumRows = this.maxNumRows;
+        copied.minNumCols = this.minNumCols;
+        copied.maxNumCols = this.maxNumCols;
+        copied.headerHeight = this.headerHeight;
+        copied.headerWidth = this.headerWidth;
+        copied.setTotalSize();
+        if (copyCache) {
+            copied.addressesById = this.addressesById;
+        }
+        else {
+            // force reset
+            this.addressesById = {};
+        }
+        return copied;
+    }
+    getAddressById(id, slideY = 0, slideX = 0) {
+        const absCol = id.startsWith("$");
+        if (absCol) {
+            id = id.slice(1);
+            slideX = 0;
+        }
+        const absRow = id.endsWith("$");
+        if (absRow) {
+            id = id.slice(0, -1);
+            slideY = 0;
+        }
+        for (let y = 0; y < this.idMatrix.length; y++) {
+            const ids = this.idMatrix[y];
+            for (let x = 0; x < ids.length; x++) {
+                const existing = ids[x];
+                const address = p2a({ y, x });
+                this.addressesById[existing] = address;
+                if (existing === id) {
+                    const slidedAddress = p2a({
+                        y: y + slideY,
+                        x: x + slideX,
+                    });
+                    return grantAddressAbsolute(slidedAddress, absCol, absRow);
+                }
+            }
+        }
+    }
+    getAddressesByIds(ids) {
+        const addresses = {};
+        Object.keys(ids).forEach((id) => {
+            const cell = ids[id];
+            const address = this.getAddressById(id);
+            if (cell && address) {
+                addresses[address] = cell;
+            }
+        });
+        return addresses;
+    }
+    getPointById(id) {
+        const address = this.getAddressById(id);
+        if (address) {
+            return a2p(address);
+        }
+        return { y: 0, x: 0 };
+    }
+    getId(point) {
+        var _a;
+        const { y, x } = point;
+        return (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
+    }
+    getByPoint(point) {
+        var _a;
+        const { y, x } = point;
+        if (y === -1 || x === -1) {
+            return undefined;
+        }
+        const id = (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
+        if (id == null) {
+            return undefined;
+        }
+        const value = this.data[id];
+        return value;
+    }
+    getById(id) {
+        return this.data[id];
+    }
+    getNumRows(base = 0) {
+        const { top, left, bottom, right } = this.area;
+        return base + bottom - top;
+    }
+    getNumCols(base = 0) {
+        const { top, left, bottom, right } = this.area;
+        return base + right - left;
+    }
+    get top() {
+        return this.area.top;
+    }
+    get left() {
+        return this.area.left;
+    }
+    get bottom() {
+        return this.area.bottom;
+    }
+    get right() {
+        return this.area.right;
+    }
+    getMatrixFlatten({ area, key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
+        const { top, left, bottom, right } = area || {
+            top: 1,
+            left: 1,
+            bottom: this.area.bottom,
+            right: this.area.right,
+        };
+        const matrix = createMatrix(bottom - top + 1, right - left + 1);
+        for (let y = top; y <= bottom; y++) {
+            for (let x = left; x <= right; x++) {
+                const cell = this.getByPoint({ y, x }) || {};
+                if (!filter(cell)) {
+                    continue;
+                }
+                matrix[y - top][x - left] = evaluates
+                    ? solveFormula({
+                        value: cell[key],
+                        table: this,
+                        raise,
+                    })
+                    : cell[key];
+            }
+        }
+        return matrix;
+    }
+    getObjectFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
+        const result = {};
+        const { top, left, bottom, right } = this.area;
+        for (let y = top; y <= bottom; y++) {
+            for (let x = left; x <= right; x++) {
+                const cell = this.getByPoint({ y: y - top, x: x - left });
+                if (cell != null && filter(cell)) {
+                    result[p2a({ y, x })] = evaluates
+                        ? solveFormula({
+                            value: cell[key],
+                            table: this,
+                            raise,
+                        })
+                        : cell[key];
+                }
+            }
+        }
+        return result;
+    }
+    getRowsFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
+        const result = [];
+        const { top, left, bottom, right } = this.area;
+        for (let y = top; y <= bottom; y++) {
+            const row = {};
+            result.push(row);
+            for (let x = left; x <= right; x++) {
+                const cell = this.getByPoint({ y: y - top, x: x - left });
+                if (cell != null && filter(cell)) {
+                    row[x2c(x) || y2r(y)] = evaluates
+                        ? solveFormula({
+                            value: cell[key],
+                            table: this,
+                            raise,
+                        })
+                        : cell[key];
+                }
+            }
+        }
+        return result;
+    }
+    getColsFlatten({ key = "value", evaluates = true, raise = false, filter = cellFilter, } = {}) {
+        const result = [];
+        const { top, left, bottom, right } = this.area;
+        for (let x = left; x <= right; x++) {
+            const col = {};
+            result.push(col);
+            for (let y = top; y <= bottom; y++) {
+                const cell = this.getByPoint({ y: y - top, x: x - left });
+                if (cell != null && filter(cell)) {
+                    col[y2r(y) || x2c(x)] = evaluates
+                        ? solveFormula({
+                            value: cell[key],
+                            table: this,
+                            raise,
+                        })
+                        : cell[key];
+                }
+            }
+        }
+        return result;
+    }
+    getMatrix({ area, evaluates = true, raise = false, filter = cellFilter, } = {}) {
+        const { top, left, bottom, right } = area || {
+            top: 1,
+            left: 1,
+            bottom: this.area.bottom,
+            right: this.area.right,
+        };
+        const matrix = createMatrix(bottom - top + 1, right - left + 1);
+        for (let y = top; y <= bottom; y++) {
+            for (let x = left; x <= right; x++) {
+                const cell = this.getByPoint({ y, x });
+                if (cell != null && filter(cell)) {
+                    matrix[y - top][x - left] = Object.assign(Object.assign({}, cell), { value: evaluates
+                            ? solveFormula({
+                                value: cell === null || cell === void 0 ? void 0 : cell.value,
+                                table: this,
+                                raise,
+                            })
+                            : cell === null || cell === void 0 ? void 0 : cell.value });
+                }
+            }
+        }
+        return matrix;
+    }
+    getObject({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
+        const result = {};
+        const { top, left, bottom, right } = this.area;
+        for (let y = top; y <= bottom; y++) {
+            for (let x = left; x <= right; x++) {
+                const cell = this.getByPoint({ y: y - top, x: x - left });
+                if (cell != null && filter(cell)) {
+                    result[p2a({ y, x })] = Object.assign(Object.assign({}, cell), { value: evaluates
+                            ? solveFormula({
+                                value: cell === null || cell === void 0 ? void 0 : cell.value,
+                                table: this,
+                                raise,
+                            })
+                            : cell === null || cell === void 0 ? void 0 : cell.value });
+                }
+            }
+        }
+        return result;
+    }
+    getRows({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
+        const result = [];
+        const { top, left, bottom, right } = this.area;
+        for (let y = top; y <= bottom; y++) {
+            const row = {};
+            result.push(row);
+            for (let x = left; x <= right; x++) {
+                const cell = this.getByPoint({ y: y - top, x: x - left });
+                if (cell != null && filter(cell)) {
+                    row[x2c(x) || y2r(y)] = Object.assign(Object.assign({}, cell), { value: evaluates
+                            ? solveFormula({
+                                value: cell === null || cell === void 0 ? void 0 : cell.value,
+                                table: this,
+                                raise,
+                            })
+                            : cell === null || cell === void 0 ? void 0 : cell.value });
+                }
+            }
+        }
+        return result;
+    }
+    getCols({ evaluates = true, raise = false, filter = cellFilter, } = {}) {
+        const result = [];
+        const { top, left, bottom, right } = this.area;
+        for (let x = left; x <= right; x++) {
+            const col = {};
+            result.push(col);
+            for (let y = top; y <= bottom; y++) {
+                const cell = this.getByPoint({ y: y - top, x: x - left });
+                if (cell != null && filter(cell)) {
+                    col[y2r(y) || x2c(x)] = Object.assign(Object.assign({}, cell), { value: evaluates
+                            ? solveFormula({
+                                value: cell === null || cell === void 0 ? void 0 : cell.value,
+                                table: this,
+                                raise,
+                            })
+                            : cell === null || cell === void 0 ? void 0 : cell.value });
+                }
+            }
+        }
+        return result;
+    }
+    pushHistory(history) {
+        const strayedHistories = this.histories.splice(this.historyIndex + 1, this.histories.length);
+        strayedHistories.forEach(this.cleanStrayed.bind(this));
+        this.histories.push(history);
+        this.lastHistory = history;
+        if (this.histories.length > this.historyLimit) {
+            const kickedOut = this.histories.splice(0, 1)[0];
+            this.cleanObsolete(kickedOut);
+        }
+        else {
+            this.historyIndex++;
+        }
+    }
+    cleanObsolete(history) {
+        if (history.operation === "REMOVE_ROWS" ||
+            history.operation === "REMOVE_COLS") {
+            history.idMatrix.forEach((ids) => {
+                ids.forEach((id) => {
+                    delete this.data[id];
+                });
+            });
+        }
+        if (history.operation === "MOVE") {
+            Object.keys(history.lostRows).forEach((address) => {
+                const idMatrix = history.lostRows[address];
+                idMatrix.map((ids) => ids.forEach((id) => {
+                    delete this.data[id];
+                }));
+            });
+        }
+    }
+    cleanStrayed(history) {
+        if (history.operation === "ADD_ROWS" || history.operation === "ADD_COLS") {
+            history.idMatrix.forEach((ids) => {
+                ids.forEach((id) => {
+                    delete this.data[id];
+                });
+            });
+        }
+    }
+    getNewIdMatrix(area) {
+        const matrix = [];
+        const { top, left, bottom, right } = area;
+        for (let y = top; y <= bottom; y++) {
+            const ids = [];
+            matrix.push(ids);
+            for (let x = left; x <= right; x++) {
+                ids.push(this.generateId());
+            }
+        }
+        return matrix;
+    }
+    getIdMatrixFromArea(area) {
+        var _a;
+        const matrix = [];
+        const { top, left, bottom, right } = area;
+        for (let y = top; y <= bottom; y++) {
+            const ids = [];
+            matrix.push(ids);
+            for (let x = left; x <= right; x++) {
+                const id = (_a = this.idMatrix[y]) === null || _a === void 0 ? void 0 : _a[x];
+                if (id) {
+                    ids.push(id);
+                }
+            }
+        }
+        return matrix;
+    }
+    setChangedAt(cell, changedAt) {
+        if (cell == null) {
+            return null;
+        }
+        cell.changedAt = changedAt || new Date();
+        return cell;
+    }
+    copyCellLayout(cell) {
+        if (cell == null) {
+            return undefined;
+        }
+        const newCell = {};
+        if (cell.style != null) {
+            newCell.style = cell.style;
+        }
+        if (cell.justifyContent != null) {
+            newCell.justifyContent = cell.justifyContent;
+        }
+        if (cell.alignItems != null) {
+            newCell.alignItems = cell.alignItems;
+        }
+        if (cell.renderer != null) {
+            newCell.renderer = cell.renderer;
+        }
+        if (cell.parser != null) {
+            newCell.parser = cell.parser;
+        }
+        if (cell.width != null) {
+            newCell.width = cell.width;
+        }
+        if (cell.height != null) {
+            newCell.height = cell.height;
+        }
+        if (cell.labeler != null) {
+            newCell.labeler = cell.labeler;
+        }
+        return newCell;
+    }
+    move({ src, dst, reflection = {}, }) {
+        const changedAt = new Date();
+        const matrixFrom = this.getIdMatrixFromArea(src);
+        const matrixTo = this.getIdMatrixFromArea(dst);
+        const matrixNew = this.getNewIdMatrix(src);
+        putMatrix(this.idMatrix, matrixNew, src);
+        matrixFrom.forEach((ids) => {
+            ids
+                .map(this.getById.bind(this))
+                .filter((c) => c)
+                .forEach((cell) => this.setChangedAt(cell, changedAt));
+        });
+        const lostRows = putMatrix(this.idMatrix, matrixFrom, dst);
+        this.pushHistory({
+            operation: "MOVE",
+            reflection,
+            matrixFrom,
+            matrixTo,
+            matrixNew,
+            pointFrom: { y: src.top, x: src.left },
+            pointTo: { y: dst.top, x: dst.left },
+            lostRows,
+        });
+        return this.shallowCopy({ copyCache: false });
+    }
+    copy({ src, dst, reflection = {}, }) {
+        const { height: maxHeight, width: maxWidth } = areaShape(Object.assign(Object.assign({}, src), { base: 1 }));
+        const { top: topFrom, left: leftFrom } = src;
+        const { top: topTo, left: leftTo, bottom: bottomTo, right: rightTo } = dst;
+        const diff = {};
+        const changedAt = new Date();
+        for (let i = 0; i <= bottomTo - topTo; i++) {
+            const toY = topTo + i;
+            if (toY > this.getNumRows()) {
+                continue;
+            }
+            for (let j = 0; j <= rightTo - leftTo; j++) {
+                const toX = leftTo + j;
+                if (toX > this.getNumCols()) {
+                    continue;
+                }
+                const fromY = topFrom + (i % maxHeight);
+                const fromX = leftFrom + (j % maxWidth);
+                const slideY = toY - fromY;
+                const slideX = toX - fromX;
+                const cell = Object.assign({}, this.getByPoint({
+                    y: topFrom + (i % maxHeight),
+                    x: leftFrom + (j % maxWidth),
+                }));
+                const value = convertFormulaAbsolute({
+                    value: cell === null || cell === void 0 ? void 0 : cell.value,
+                    table: this,
+                    slideY,
+                    slideX,
+                });
+                this.setChangedAt(cell, changedAt);
+                diff[p2a({ y: toY, x: toX })] = Object.assign(Object.assign({}, cell), { style: Object.assign({}, cell === null || cell === void 0 ? void 0 : cell.style), value });
+            }
+        }
+        return this.update({ diff, partial: false, reflection });
+    }
+    _update({ diff, partial = true, updateChangedAt = true, }) {
+        const diffBefore = {};
+        const diffAfter = {};
+        const changedAt = new Date();
+        Object.keys(diff).forEach((address) => {
+            const cell = Object.assign({}, diff[address]);
+            if (updateChangedAt) {
+                this.setChangedAt(cell, changedAt);
+            }
+            cell.value = convertFormulaAbsolute({
+                value: cell.value,
+                table: this,
+            });
+            const point = a2p(address);
+            const id = this.getId(point);
+            // must not partial
+            diffBefore[id] = this.getByPoint(point);
+            diffAfter[id] = cell;
+            if (partial) {
+                this.data[id] = Object.assign(Object.assign({}, this.data[id]), cell);
+            }
+            else {
+                this.data[id] = cell;
+            }
+        });
+        this.solvedCaches = {};
+        return {
+            diffBefore,
+            diffAfter,
+        };
+    }
+    update({ diff, partial = true, updateChangedAt = true, reflection = {}, }) {
+        const { diffBefore, diffAfter } = this._update({
+            diff,
+            partial,
+            updateChangedAt,
+        });
+        this.pushHistory({
+            operation: "UPDATE",
+            reflection,
+            diffBefore,
+            diffAfter,
+            partial,
+        });
+        return this.shallowCopy({ copyCache: true });
+    }
+    writeMatrix({ point, matrix, updateChangedAt = true, reflection = {}, }) {
+        const { y: baseY, x: baseX } = point;
+        const diff = {};
+        matrix.forEach((cols, i) => {
+            const y = baseY + i;
+            if (y > this.bottom) {
+                return;
+            }
+            cols.forEach((value, j) => {
+                const x = baseX + j;
+                if (x > this.right) {
+                    return;
+                }
+                const cell = this.parse({ y, x }, value);
+                diff[p2a({ y, x })] = cell;
+            });
+        });
+        return this.update({
+            diff,
+            partial: true,
+            updateChangedAt,
+            reflection,
+        });
+    }
+    write({ point, value, updateChangedAt = true, reflection = {}, }) {
+        return this.writeMatrix({
+            point,
+            matrix: [[value]],
+            updateChangedAt,
+            reflection,
+        });
+    }
+    addRowsAndUpdate({ y, numRows, baseY, diff, partial, updateChangedAt, reflection = {}, }) {
+        const returned = this.addRows({
+            y,
+            numRows,
+            baseY,
+            reflection,
+        });
+        Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt }), { partial });
+        return returned;
+    }
+    addRows({ y, numRows, baseY, reflection = {}, }) {
+        if (this.maxNumRows !== -1 &&
+            this.getNumRows() + numRows > this.maxNumRows) {
+            console.error(`Rows are limited to ${this.maxNumRows}.`);
+            return this;
+        }
+        const numCols = this.getNumCols(1);
+        const rows = [];
+        const changedAt = new Date();
+        for (let i = 0; i < numRows; i++) {
+            const row = [];
+            for (let j = 0; j < numCols; j++) {
+                const id = this.generateId();
+                row.push(id);
+                const cell = this.getByPoint({ y: baseY, x: j });
+                const copied = this.copyCellLayout(cell);
+                this.data[id] = Object.assign(Object.assign({}, copied), { changedAt });
+            }
+            rows.push(row);
+        }
+        this.idMatrix.splice(y, 0, ...rows);
+        this.area.bottom += numRows;
+        this.pushHistory({
+            operation: "ADD_ROWS",
+            reflection,
+            y,
+            idMatrix: rows,
+        });
+        return this.shallowCopy({ copyCache: false });
+    }
+    removeRows({ y, numRows, reflection = {}, }) {
+        if (this.minNumRows !== -1 &&
+            this.getNumRows() - numRows < this.minNumRows) {
+            console.error(`At least ${this.minNumRows} row(s) are required.`);
+            return this;
+        }
+        const rows = this.idMatrix.splice(y, numRows);
+        this.area.bottom -= numRows;
+        this.pushHistory({
+            operation: "REMOVE_ROWS",
+            reflection,
+            y,
+            idMatrix: rows,
+        });
+        return this.shallowCopy({ copyCache: false });
+    }
+    addColsAndUpdate({ x, numCols, baseX, diff, partial, updateChangedAt, reflection = {}, }) {
+        const returned = this.addCols({
+            x,
+            numCols,
+            baseX,
+            reflection,
+        });
+        Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt }), { partial });
+        return returned;
+    }
+    addCols({ x, numCols, baseX, reflection = {}, }) {
+        if (this.maxNumCols !== -1 &&
+            this.getNumCols() + numCols > this.maxNumCols) {
+            console.error(`Columns are limited to ${this.maxNumCols}.`);
+            return this;
+        }
+        const numRows = this.getNumRows(1);
+        const rows = [];
+        const changedAt = new Date();
+        for (let i = 0; i < numRows; i++) {
+            const row = [];
+            for (let j = 0; j < numCols; j++) {
+                const id = this.generateId();
+                row.push(id);
+                const cell = this.getByPoint({ y: i, x: baseX });
+                const copied = this.copyCellLayout(cell);
+                this.idMatrix[i].splice(x, 0, id);
+                this.data[id] = Object.assign(Object.assign({}, copied), { changedAt });
+            }
+            rows.push(row);
+        }
+        this.area.right += numCols;
+        this.pushHistory({
+            operation: "ADD_COLS",
+            reflection,
+            x,
+            idMatrix: rows,
+        });
+        return this.shallowCopy({ copyCache: false });
+    }
+    removeCols({ x, numCols, reflection = {}, }) {
+        if (this.minNumCols !== -1 &&
+            this.getNumCols() - numCols < this.minNumCols) {
+            console.error(`At least ${this.minNumCols} column(s) are required.`);
+            return this;
+        }
+        const rows = [];
+        this.idMatrix.forEach((row) => {
+            const deleted = row.splice(x, numCols);
+            rows.push(deleted);
+        });
+        this.area.right -= numCols;
+        this.pushHistory({
+            operation: "REMOVE_COLS",
+            reflection,
+            x,
+            idMatrix: rows,
+        });
+        return this.shallowCopy({ copyCache: false });
+    }
+    getHistories() {
+        return [...this.histories];
+    }
+    getHistoryIndex() {
+        return this.historyIndex;
+    }
+    getHistorySize() {
+        return this.histories.length;
+    }
+    getHistoryLimit() {
+        return this.historyLimit;
+    }
+    setFunctions(additionalFunctions) {
+        this.functions = Object.assign(Object.assign({}, functionsDefault), additionalFunctions);
+    }
+    getArea() {
+        return Object.assign({}, this.area);
+    }
+    parse(point, value) {
+        const cell = this.getByPoint(point) || {};
+        const parser = this.parsers[cell.parser || ""] || defaultParser;
+        return parser.parse(value, cell);
+    }
+    render(point, writer) {
+        const cell = this.getByPoint(point) || {};
+        const renderer = this.renderers[cell.renderer || ""] || defaultRenderer;
+        return renderer.render(this, point, writer);
+    }
+    stringify(point, value, evaluates = false) {
+        const cell = this.getByPoint(point);
+        const renderer = this.renderers[(cell === null || cell === void 0 ? void 0 : cell.renderer) || ""] || defaultRenderer;
+        const s = renderer.stringify(typeof value === "undefined" ? Object.assign({}, cell) : Object.assign(Object.assign({}, cell), { value }));
+        if (s[0] === "=") {
+            if (evaluates) {
+                return String(solveFormula({ value: s, table: this, raise: false }));
+            }
+            const lexer = new Lexer(s.substring(1));
+            lexer.tokenize();
+            return "=" + lexer.stringifyToRef(this);
+        }
+        return s;
+    }
+    trim(area) {
+        const copied = new Table({});
+        copied.area = area;
+        copied.idMatrix = this.idMatrix;
+        copied.data = this.data;
+        copied.parsers = this.parsers;
+        copied.renderers = this.renderers;
+        copied.labelers = this.labelers;
+        copied.functions = this.functions;
+        copied.addressesById = this.addressesById;
+        copied.solvedCaches = this.solvedCaches;
+        return copied;
+    }
+    getIdByAddress(address) {
+        const { y, x } = a2p(address);
+        const id = this.getId({ y: Math.abs(y), x: Math.abs(x) });
+        if (id) {
+            return `#${x < 0 ? "$" : ""}${id}${y < 0 ? "$" : ""}`;
+        }
+    }
+    applyDiff(diff, partial = true) {
+        if (!partial) {
+            Object.assign(this.data, diff);
+            return;
+        }
+        Object.keys(diff).map((id) => {
+            const cell = diff[id];
+            this.data[id] = Object.assign(Object.assign({}, this.getById(id)), cell);
+        });
+    }
+    undo() {
+        if (this.historyIndex < 0) {
+            return { history: null, newTable: this };
+        }
+        const history = this.histories[this.historyIndex--];
+        switch (history.operation) {
+            case "UPDATE":
+                // diffBefore is guaranteed as total of cell (not partial)
+                this.applyDiff(history.diffBefore, false);
+                break;
+            case "ADD_ROWS": {
+                if (history.diffBefore) {
+                    this.applyDiff(history.diffBefore, false);
+                }
+                const { height } = matrixShape({ matrix: history.idMatrix });
+                this.idMatrix.splice(history.y, height);
+                this.area.bottom -= height;
+                break;
+            }
+            case "ADD_COLS": {
+                if (history.diffBefore) {
+                    this.applyDiff(history.diffBefore, false);
+                }
+                const { width } = matrixShape({ matrix: history.idMatrix });
+                this.idMatrix.forEach((row) => {
+                    row.splice(history.x, width);
+                });
+                this.area.right -= width;
+                break;
+            }
+            case "REMOVE_ROWS": {
+                const { height } = matrixShape({ matrix: history.idMatrix });
+                this.idMatrix.splice(history.y, 0, ...history.idMatrix);
+                this.area.bottom += height;
+                break;
+            }
+            case "REMOVE_COLS": {
+                const { width } = matrixShape({ matrix: history.idMatrix });
+                this.idMatrix.forEach((row, i) => {
+                    row.splice(history.x, 0, ...history.idMatrix[i]);
+                });
+                this.area.right += width;
+                break;
+            }
+            case "MOVE": {
+                const { y: yFrom, x: xFrom } = history.pointFrom;
+                const { y: yTo, x: xTo } = history.pointTo;
+                const { height: rows, width: cols } = matrixShape({
+                    matrix: history.matrixFrom,
+                    base: -1,
+                });
+                putMatrix(this.idMatrix, history.matrixFrom, {
+                    top: yFrom,
+                    left: xFrom,
+                    bottom: yFrom + rows,
+                    right: xFrom + cols,
+                });
+                putMatrix(this.idMatrix, history.matrixTo, {
+                    top: yTo,
+                    left: xTo,
+                    bottom: yTo + rows,
+                    right: xTo + cols,
+                });
+                break;
+            }
+        }
+        return {
+            history,
+            newTable: this.shallowCopy({
+                copyCache: !shouldTracking(history.operation),
+            }),
+        };
+    }
+    redo() {
+        if (this.historyIndex + 1 >= this.histories.length) {
+            return { history: null, newTable: this };
+        }
+        const history = this.histories[++this.historyIndex];
+        switch (history.operation) {
+            case "UPDATE":
+                this.applyDiff(history.diffAfter, history.partial);
+                break;
+            case "ADD_ROWS": {
+                if (history.diffAfter) {
+                    this.applyDiff(history.diffAfter, history.partial);
+                }
+                const { height } = matrixShape({ matrix: history.idMatrix });
+                this.idMatrix.splice(history.y, 0, ...history.idMatrix);
+                this.area.bottom += height;
+                break;
+            }
+            case "ADD_COLS": {
+                if (history.diffAfter) {
+                    this.applyDiff(history.diffAfter, history.partial);
+                }
+                const { width } = matrixShape({ matrix: history.idMatrix });
+                this.idMatrix.map((row, i) => {
+                    row.splice(history.x, 0, ...history.idMatrix[i]);
+                });
+                this.area.right += width;
+                break;
+            }
+            case "REMOVE_ROWS": {
+                const { height } = matrixShape({ matrix: history.idMatrix });
+                this.idMatrix.splice(history.y, height);
+                this.area.bottom -= height;
+                break;
+            }
+            case "REMOVE_COLS": {
+                const { width } = matrixShape({ matrix: history.idMatrix });
+                this.idMatrix.forEach((row) => {
+                    row.splice(history.x, width);
+                });
+                this.area.right -= width;
+                break;
+            }
+            case "MOVE": {
+                const { y: yFrom, x: xFrom } = history.pointFrom;
+                const { y: yTo, x: xTo } = history.pointTo;
+                const { height: rows, width: cols } = matrixShape({
+                    matrix: history.matrixFrom,
+                    base: -1,
+                });
+                putMatrix(this.idMatrix, history.matrixNew, {
+                    top: yFrom,
+                    left: xFrom,
+                    bottom: yFrom + rows,
+                    right: xFrom + cols,
+                });
+                putMatrix(this.idMatrix, history.matrixFrom, {
+                    top: yTo,
+                    left: xTo,
+                    bottom: yTo + rows,
+                    right: xTo + cols,
+                });
+            }
+        }
+        return {
+            history,
+            newTable: this.shallowCopy({
+                copyCache: !shouldTracking(history.operation),
+            }),
+        };
+    }
+    getFunction(name) {
+        return this.functions[name];
+    }
+    getLabel(key, n) {
+        const labeler = this.labelers[key];
+        return labeler === null || labeler === void 0 ? void 0 : labeler(n);
+    }
+    getBase() {
+        return this;
+    }
+    getSolvedCache(key) {
+        return this.solvedCaches[key];
+    }
+    setSolvedCache(key, value) {
+        this.solvedCaches[key] = value;
+    }
+}
+// just using as a type
+export class ReadonlyTable extends Table {
+}
+//# sourceMappingURL=table.js.map