@gridsheet/react-core 0.12.13 → 0.13.0-alpha.0

package/dist/lib/table.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = void 0;
 const core_1 = require("../parsers/core");
@@ -10,6 +33,7 @@ const evaluator_1 = require("../formula/evaluator");
 const solver_1 = require("../formula/solver");
 const constants_1 = require("../constants");
 const helpers_1 = require("../store/helpers");
+const prevention = __importStar(require("./prevention"));
 const cellFilter = (cell) => true;
 class Table {
     constructor({ numRows = 0, numCols = 0, cells = {}, parsers = {}, renderers = {}, labelers = {}, useBigInt = false, historyLimit: historyLimit, minNumRows = 1, maxNumRows = -1, minNumCols = 1, maxNumCols = -1, headerWidth = -1, headerHeight = -1, functions = mapping_1.functions, }) {
@@ -38,7 +62,6 @@ class Table {
         this.headerHeight = headerHeight || 0;
         this.headerWidth = headerWidth || 0;
         this.functions = functions;
-        const common = cells === null || cells === void 0 ? void 0 : cells['default'];
         // make idMatrix beforehand
         for (let y = 0; y < numRows + 1; y++) {
             const ids = [];
@@ -50,6 +73,15 @@ class Table {
                 this.addressesById[id] = address;
             }
         }
+        Object.keys(cells).forEach((address) => {
+            const range = (0, structs_1.expandRange)(address);
+            const data = cells[address];
+            range.forEach((address) => {
+                const origin = cells[address];
+                cells[address] = Object.assign(Object.assign(Object.assign({}, origin), data), { style: Object.assign(Object.assign({}, origin === null || origin === void 0 ? void 0 : origin.style), data === null || data === void 0 ? void 0 : data.style), prevention: ((origin === null || origin === void 0 ? void 0 : origin.prevention) || 0) | ((data === null || data === void 0 ? void 0 : data.prevention) || 0) });
+            });
+        });
+        const common = cells === null || cells === void 0 ? void 0 : cells['default'];
         for (let y = 0; y < numRows + 1; y++) {
             const rowId = (0, converters_1.y2r)(y);
             const rowDefault = cells === null || cells === void 0 ? void 0 : cells[rowId];
@@ -59,7 +91,7 @@ class Table {
                 const colId = (0, converters_1.x2c)(x);
                 const colDefault = cells === null || cells === void 0 ? void 0 : cells[colId];
                 const cell = cells === null || cells === void 0 ? void 0 : 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) });
+                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), prevention: ((common === null || common === void 0 ? void 0 : common.prevention) || 0) | ((rowDefault === null || rowDefault === void 0 ? void 0 : rowDefault.prevention) || 0) | ((colDefault === null || colDefault === void 0 ? void 0 : colDefault.prevention) || 0) | ((cell === null || cell === void 0 ? void 0 : cell.prevention) || 0) });
                 stacked.value = (0, evaluator_1.convertFormulaAbsolute)({
                     value: stacked === null || stacked === void 0 ? void 0 : stacked.value,
                     table: this,
@@ -407,9 +439,9 @@ class Table {
         }
     }
     cleanObsolete(history) {
-        if (history.operation === "REMOVE_ROWS" ||
-            history.operation === "REMOVE_COLS") {
-            history.idMatrix.forEach((ids) => {
+        if (history.operation === "DELETE_ROWS" ||
+            history.operation === "DELETE_COLS") {
+            history.deleted.forEach((ids) => {
                 ids.forEach((id) => {
                     delete this.data[id];
                 });
@@ -419,7 +451,9 @@ class Table {
             Object.keys(history.lostRows).forEach((address) => {
                 const idMatrix = history.lostRows[address];
                 idMatrix.map((ids) => ids.forEach((id) => {
-                    delete this.data[id];
+                    if (id != null) {
+                        delete this.data[id];
+                    }
                 }));
             });
         }
@@ -454,9 +488,10 @@ class Table {
             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);
+                if (id == null) {
+                    continue;
                 }
+                ids.push(id);
             }
         }
         return matrix;
@@ -499,33 +534,45 @@ class Table {
         }
         return newCell;
     }
-    move({ src, dst, reflection = {}, }) {
-        const changedAt = new Date();
+    move({ src, dst, historicize = true, operator = "SYSTEM", reflection = {}, }) {
+        const matrixNew = this.getNewIdMatrix(src);
         const matrixFrom = this.getIdMatrixFromArea(src);
         const matrixTo = this.getIdMatrixFromArea(dst);
-        const matrixNew = this.getNewIdMatrix(src);
-        (0, structs_1.putMatrix)(this.idMatrix, matrixNew, src);
-        matrixFrom.forEach((ids) => {
-            ids
-                .map(this.getById.bind(this))
-                .filter((c) => c)
-                .forEach((cell) => this.setChangedAt(cell, changedAt));
+        (0, structs_1.putMatrix)(this.idMatrix, matrixNew, src, (_, id) => {
+            const cell = this.data[id];
+            if (operator === 'USER' && prevention.isPrevented(cell === null || cell === void 0 ? void 0 : cell.prevention, prevention.MoveFrom)) {
+                return false;
+            }
+            return true;
         });
-        const lostRows = (0, structs_1.putMatrix)(this.idMatrix, matrixFrom, dst);
-        this.pushHistory({
-            applyed: true,
-            operation: "MOVE",
-            reflection,
-            matrixFrom,
-            matrixTo,
-            matrixNew,
-            pointFrom: { y: src.top, x: src.left },
-            pointTo: { y: dst.top, x: dst.left },
-            lostRows,
+        const lostRows = (0, structs_1.putMatrix)(this.idMatrix, matrixFrom, dst, (srcId, dstId) => {
+            const srcCell = this.data[srcId];
+            const dstCell = this.data[dstId];
+            if (operator === 'USER' && (prevention.isPrevented(srcCell === null || srcCell === void 0 ? void 0 : srcCell.prevention, prevention.MoveFrom) ||
+                prevention.isPrevented(dstCell === null || dstCell === void 0 ? void 0 : dstCell.prevention, prevention.MoveTo))) {
+                return false;
+            }
+            if (srcCell != null) {
+                this.setChangedAt(srcCell, new Date());
+            }
+            return true;
         });
+        if (historicize) {
+            this.pushHistory({
+                applyed: true,
+                operation: "MOVE",
+                reflection,
+                src,
+                dst,
+                matrixFrom,
+                matrixTo,
+                matrixNew,
+                lostRows,
+            });
+        }
         return this.shallowCopy({ copyCache: false });
     }
-    copy({ src, dst, reflection = {}, }) {
+    copy({ src, dst, operator = "SYSTEM", reflection = {}, }) {
         const { height: maxHeight, width: maxWidth } = (0, structs_1.areaShape)(Object.assign(Object.assign({}, src), { base: 1 }));
         const { top: topFrom, left: leftFrom } = src;
         const { top: topTo, left: leftTo, bottom: bottomTo, right: rightTo } = dst;
@@ -545,10 +592,10 @@ class Table {
                 const fromX = leftFrom + (j % maxWidth);
                 const slideY = toY - fromY;
                 const slideX = toX - fromX;
-                const cell = Object.assign({}, this.getByPoint({
+                const cell = Object.assign(Object.assign({}, this.getByPoint({
                     y: topFrom + (i % maxHeight),
                     x: leftFrom + (j % maxWidth),
-                }));
+                })), { prevention: 0 });
                 const value = (0, evaluator_1.convertFormulaAbsolute)({
                     value: cell === null || cell === void 0 ? void 0 : cell.value,
                     table: this,
@@ -559,16 +606,21 @@ class Table {
                 diff[(0, converters_1.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 });
+        return this.update({
+            diff,
+            partial: false,
+            operator,
+            reflection,
+        });
     }
-    _update({ diff, partial = true, updateChangedAt = true, }) {
+    _update({ diff, partial = true, updateChangedAt = true, ignoreFields = ['labeler', 'prevention'], operator = 'SYSTEM', }) {
         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);
+            if (operator === 'USER' && prevention.isPrevented(cell === null || cell === void 0 ? void 0 : cell.prevention, prevention.Update)) {
+                return;
             }
             cell.value = (0, evaluator_1.convertFormulaAbsolute)({
                 value: cell.value,
@@ -576,11 +628,36 @@ class Table {
             });
             const point = (0, converters_1.a2p)(address);
             const id = this.getId(point);
+            const current = this.data[id];
+            ignoreFields.forEach((key) => {
+                cell[key] = current === null || current === void 0 ? void 0 : current[key];
+            });
+            if (operator === 'USER' && prevention.isPrevented(current === null || current === void 0 ? void 0 : current.prevention, prevention.Write)) {
+                cell.value = current === null || current === void 0 ? void 0 : current.value;
+            }
+            if (operator === 'USER' && prevention.isPrevented(current === null || current === void 0 ? void 0 : current.prevention, prevention.Style)) {
+                cell.style = current === null || current === void 0 ? void 0 : current.style;
+                cell.justifyContent = current === null || current === void 0 ? void 0 : current.justifyContent;
+                cell.alignItems = current === null || current === void 0 ? void 0 : current.alignItems;
+            }
+            if (operator === 'USER' && prevention.isPrevented(current === null || current === void 0 ? void 0 : current.prevention, prevention.Resize)) {
+                cell.width = current === null || current === void 0 ? void 0 : current.width;
+                cell.height = current === null || current === void 0 ? void 0 : current.height;
+            }
+            if (operator === 'USER' && prevention.isPrevented(current === null || current === void 0 ? void 0 : current.prevention, prevention.SetRenderer)) {
+                cell.renderer = current === null || current === void 0 ? void 0 : current.renderer;
+            }
+            if (operator === 'USER' && prevention.isPrevented(current === null || current === void 0 ? void 0 : current.prevention, prevention.SetParser)) {
+                cell.parser = current === null || current === void 0 ? void 0 : current.parser;
+            }
+            if (updateChangedAt) {
+                this.setChangedAt(cell, changedAt);
+            }
             // must not partial
             diffBefore[id] = this.getByPoint(point);
             diffAfter[id] = cell;
             if (partial) {
-                this.data[id] = Object.assign(Object.assign({}, this.data[id]), cell);
+                this.data[id] = Object.assign(Object.assign({}, current), cell);
             }
             else {
                 this.data[id] = cell;
@@ -592,23 +669,26 @@ class Table {
             diffAfter,
         };
     }
-    update({ diff, partial = true, updateChangedAt = true, reflection = {}, }) {
+    update({ diff, partial = true, updateChangedAt = true, historicize = true, operator = "SYSTEM", reflection = {}, }) {
         const { diffBefore, diffAfter } = this._update({
             diff,
             partial,
+            operator,
             updateChangedAt,
         });
-        this.pushHistory({
-            applyed: true,
-            operation: "UPDATE",
-            reflection,
-            diffBefore,
-            diffAfter,
-            partial,
-        });
+        if (historicize) {
+            this.pushHistory({
+                applyed: true,
+                operation: "UPDATE",
+                reflection,
+                diffBefore,
+                diffAfter,
+                partial,
+            });
+        }
         return this.shallowCopy({ copyCache: true });
     }
-    writeMatrix({ point, matrix, updateChangedAt = true, reflection = {}, }) {
+    writeMatrix({ point, matrix, updateChangedAt = true, historicize = true, operator = "SYSTEM", reflection = {}, }) {
         const { y: baseY, x: baseX } = point;
         const diff = {};
         matrix.forEach((cols, i) => {
@@ -629,28 +709,32 @@ class Table {
             diff,
             partial: true,
             updateChangedAt,
+            historicize,
+            operator,
             reflection,
         });
     }
-    write({ point, value, updateChangedAt = true, reflection = {}, }) {
+    write({ point, value, updateChangedAt = true, historicize = true, operator = "SYSTEM", reflection = {}, }) {
         return this.writeMatrix({
             point,
             matrix: [[value]],
             updateChangedAt,
+            historicize,
+            operator,
             reflection,
         });
     }
-    addRowsAndUpdate({ y, numRows, baseY, diff, partial, updateChangedAt, reflection = {}, }) {
+    addRowsAndUpdate({ y, numRows, baseY, diff, partial, updateChangedAt, operator = "SYSTEM", reflection = {}, }) {
         const returned = this.addRows({
             y,
             numRows,
             baseY,
             reflection,
         });
-        Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt }), { partial });
+        Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt, operator }), { partial });
         return returned;
     }
-    addRows({ y, numRows, baseY, reflection = {}, }) {
+    addRows({ y, numRows, baseY, operator = "SYSTEM", reflection = {}, }) {
         if (this.maxNumRows !== -1 &&
             this.getNumRows() + numRows > this.maxNumRows) {
             console.error(`Rows are limited to ${this.maxNumRows}.`);
@@ -682,21 +766,33 @@ class Table {
         });
         return this.shallowCopy({ copyCache: false });
     }
-    removeRows({ y, numRows, reflection = {}, }) {
+    deleteRows({ y, numRows, operator = "SYSTEM", 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;
+        const ys = [];
+        for (let i = y; i < y + numRows; i++) {
+            const cell = this.getByPoint({ y: i, x: 0 });
+            if (operator === "USER" && prevention.isPrevented(cell === null || cell === void 0 ? void 0 : cell.prevention, prevention.DeleteRow)) {
+                console.warn(`Cannot delete row ${i}.`);
+                return this;
+            }
+            ys.unshift(i);
+        }
+        const deleted = [];
+        ys.forEach((y) => {
+            const row = this.idMatrix.splice(y, 1);
+            deleted.unshift(row[0]);
+        });
+        this.area.bottom -= ys.length;
         this.pushHistory({
             applyed: true,
-            operation: "REMOVE_ROWS",
+            operation: "DELETE_ROWS",
             reflection,
-            y,
-            numRows,
-            idMatrix: rows,
+            ys: ys.reverse(),
+            deleted,
         });
         return this.shallowCopy({ copyCache: false });
     }
@@ -742,25 +838,37 @@ class Table {
         });
         return this.shallowCopy({ copyCache: false });
     }
-    removeCols({ x, numCols, reflection = {}, }) {
+    deleteCols({ x, numCols, operator = "SYSTEM", reflection = {}, }) {
         if (this.minNumCols !== -1 &&
             this.getNumCols() - numCols < this.minNumCols) {
             console.error(`At least ${this.minNumCols} column(s) are required.`);
             return this;
         }
-        const rows = [];
+        const xs = [];
+        for (let i = x; i < x + numCols; i++) {
+            const cell = this.getByPoint({ y: 0, x: i });
+            if (operator === "USER" && prevention.isPrevented(cell === null || cell === void 0 ? void 0 : cell.prevention, prevention.DeleteCol)) {
+                console.warn(`Cannot delete col ${i}.`);
+                continue;
+            }
+            xs.unshift(i);
+        }
+        const deleted = [];
         this.idMatrix.forEach((row) => {
-            const deleted = row.splice(x, numCols);
-            rows.push(deleted);
+            const deleting = [];
+            deleted.push(deleting);
+            // reverse and delete
+            xs.forEach((x) => {
+                deleting.unshift(...row.splice(x, 1));
+            });
         });
-        this.area.right -= numCols;
+        this.area.right -= xs.length;
         this.pushHistory({
             applyed: true,
-            operation: "REMOVE_COLS",
+            operation: "DELETE_COLS",
             reflection,
-            x,
-            numCols,
-            idMatrix: rows,
+            xs: xs.reverse(),
+            deleted,
         });
         return this.shallowCopy({ copyCache: false });
     }
@@ -868,23 +976,27 @@ class Table {
                 this.area.right -= width;
                 break;
             }
-            case "REMOVE_ROWS": {
-                const { height } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
-                this.idMatrix.splice(history.y, 0, ...history.idMatrix);
-                this.area.bottom += height;
+            case "DELETE_ROWS": {
+                const { ys, deleted } = history;
+                ys.forEach((y, i) => {
+                    this.idMatrix.splice(y, 0, deleted[i]);
+                });
+                this.area.bottom += ys.length;
                 break;
             }
-            case "REMOVE_COLS": {
-                const { width } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
+            case "DELETE_COLS": {
+                const { xs, deleted } = history;
                 this.idMatrix.forEach((row, i) => {
-                    row.splice(history.x, 0, ...history.idMatrix[i]);
+                    for (let j = 0; j < xs.length; j++) {
+                        row.splice(xs[j], 0, deleted[i][j]);
+                    }
                 });
-                this.area.right += width;
+                this.area.right += xs.length;
                 break;
             }
             case "MOVE": {
-                const { y: yFrom, x: xFrom } = history.pointFrom;
-                const { y: yTo, x: xTo } = history.pointTo;
+                const { top: yFrom, left: xFrom } = history.src;
+                const { top: yTo, left: xTo } = history.dst;
                 const { height: rows, width: cols } = (0, structs_1.matrixShape)({
                     matrix: history.matrixFrom,
                     base: -1,
@@ -942,39 +1054,27 @@ class Table {
                 this.area.right += width;
                 break;
             }
-            case "REMOVE_ROWS": {
-                const { height } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
-                this.idMatrix.splice(history.y, height);
-                this.area.bottom -= height;
+            case "DELETE_ROWS": {
+                const { ys } = history;
+                [...ys].reverse().forEach((y) => {
+                    this.idMatrix.splice(y, 1);
+                });
+                this.area.bottom -= ys.length;
                 break;
             }
-            case "REMOVE_COLS": {
-                const { width } = (0, structs_1.matrixShape)({ matrix: history.idMatrix });
-                this.idMatrix.forEach((row) => {
-                    row.splice(history.x, width);
+            case "DELETE_COLS": {
+                const { xs } = history;
+                [...xs].reverse().forEach((x) => {
+                    this.idMatrix.forEach((row) => {
+                        row.splice(x, 1);
+                    });
                 });
-                this.area.right -= width;
+                this.area.right -= xs.length;
                 break;
             }
             case "MOVE": {
-                const { y: yFrom, x: xFrom } = history.pointFrom;
-                const { y: yTo, x: xTo } = history.pointTo;
-                const { height: rows, width: cols } = (0, structs_1.matrixShape)({
-                    matrix: history.matrixFrom,
-                    base: -1,
-                });
-                (0, structs_1.putMatrix)(this.idMatrix, history.matrixNew, {
-                    top: yFrom,
-                    left: xFrom,
-                    bottom: yFrom + rows,
-                    right: xFrom + cols,
-                });
-                (0, structs_1.putMatrix)(this.idMatrix, history.matrixFrom, {
-                    top: yTo,
-                    left: xTo,
-                    bottom: yTo + rows,
-                    right: xTo + cols,
-                });
+                const { src, dst } = history;
+                this.move({ src, dst, operator: "USER", historicize: false });
             }
         }
         return {