@gridsheet/react-core 0.12.2 → 0.12.4-alpha.0

package/dist/lib/table.js

@@ -1,989 +0,0 @@
-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.call(value, cell);
-    }
-    render(point, writer) {
-        const cell = this.getByPoint(point) || {};
-        const renderer = this.renderers[cell.renderer || ""] || defaultRenderer;
-        return renderer.call(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