@gridsheet/react-core 1.4.0-alpha.2 → 1.4.0-alpha.3

package/dist/lib/table.js

@@ -0,0 +1,1248 @@
+import { defaultParser } from "../parsers/core.js";
+import { defaultRenderer } from "../renderers/core.js";
+import { getMaxSizesFromCells, expandRange, createMatrix, putMatrix, areaShape, matrixShape } from "./structs.js";
+import { p2a, x2c, grantAddressAbsolute, a2p, y2r } from "./converters.js";
+import { functions } from "../formula/mapping.js";
+import { absolutizeFormula, Lexer, stripSheetName } from "../formula/evaluator.js";
+import { solveFormula } from "../formula/solver.js";
+import { HISTORY_LIMIT, HEADER_HEIGHT, HEADER_WIDTH, DEFAULT_WIDTH, DEFAULT_HEIGHT } from "../constants.js";
+import { shouldTracking } from "../store/helpers.js";
+import { isPrevented, MoveFrom, MoveTo, Update, Write, Style, Resize, SetRenderer, SetParser, DeleteRow, DeleteCol } from "./prevention.js";
+const noFilter = () => true;
+class Table {
+  constructor({
+    parsers = {},
+    renderers = {},
+    labelers = {},
+    useBigInt = false,
+    historyLimit,
+    minNumRows = 1,
+    maxNumRows = -1,
+    minNumCols = 1,
+    maxNumCols = -1,
+    headerWidth = HEADER_WIDTH,
+    headerHeight = HEADER_HEIGHT,
+    functions: functions$1 = functions
+  }) {
+    this.totalWidth = 0;
+    this.totalHeight = 0;
+    this.headerWidth = 0;
+    this.headerHeight = 0;
+    this.sheetId = 0;
+    this.sheetName = "";
+    this.sheets = {};
+    this.tables = {};
+    this.data = {};
+    this.area = { top: 0, left: 0, bottom: 0, right: 0 };
+    this.functions = {};
+    this.head = useBigInt ? BigInt(0) : 0;
+    this.parsers = parsers || {};
+    this.renderers = renderers || {};
+    this.labelers = labelers || {};
+    this.idMatrix = [];
+    this.histories = [];
+    this.historyIndex = -1;
+    this.addressesById = {};
+    this.historyLimit = historyLimit || HISTORY_LIMIT;
+    this.changedAt = /* @__PURE__ */ new Date();
+    this.minNumRows = minNumRows || 0;
+    this.maxNumRows = maxNumRows || 0;
+    this.minNumCols = minNumCols || 0;
+    this.maxNumCols = maxNumCols || 0;
+    this.solvedCaches = {};
+    this.headerHeight = headerHeight;
+    this.headerWidth = headerWidth;
+    this.functions = functions$1;
+    this.idsToBeAbsoluted = [];
+  }
+  getTableBySheetName(sheetName) {
+    const sheetId = this.sheets[sheetName];
+    return this.tables[sheetId];
+  }
+  initialize(cells) {
+    var _a, _b;
+    const auto = getMaxSizesFromCells(cells);
+    this.area = {
+      top: 0,
+      left: 0,
+      bottom: auto.numRows || 0,
+      right: auto.numCols || 0
+    };
+    for (let y = 0; y < auto.numRows + 1; y++) {
+      const ids = [];
+      this.idMatrix.push(ids);
+      for (let x = 0; x < auto.numCols + 1; x++) {
+        const id = this.generateId();
+        ids.push(id);
+        const address = p2a({ y, x });
+        this.addressesById[id] = address;
+      }
+    }
+    Object.keys(cells).forEach((address) => {
+      const range = expandRange(address);
+      const data = cells[address];
+      range.forEach((address2) => {
+        const origin = cells[address2];
+        cells[address2] = {
+          ...origin,
+          ...data,
+          style: {
+            ...origin == null ? void 0 : origin.style,
+            ...data == null ? void 0 : data.style
+          },
+          prevention: ((origin == null ? void 0 : origin.prevention) || 0) | ((data == null ? void 0 : data.prevention) || 0)
+        };
+      });
+    });
+    const common = cells == null ? void 0 : cells["default"];
+    for (let y = 0; y < auto.numRows + 1; y++) {
+      const rowId = y2r(y);
+      const rowDefault = cells == null ? void 0 : cells[rowId];
+      for (let x = 0; x < auto.numCols + 1; x++) {
+        const id = this.getId({ y, x });
+        const address = p2a({ y, x });
+        const colId = x2c(x);
+        const colDefault = cells == null ? void 0 : cells[colId];
+        const cell = cells == null ? void 0 : cells[address];
+        const stacked = {
+          ...common,
+          ...rowDefault,
+          ...colDefault,
+          ...cell,
+          style: {
+            ...common == null ? void 0 : common.style,
+            ...rowDefault == null ? void 0 : rowDefault.style,
+            ...colDefault == null ? void 0 : colDefault.style,
+            ...cell == null ? void 0 : cell.style
+          },
+          prevention: ((common == null ? void 0 : common.prevention) || 0) | ((rowDefault == null ? void 0 : rowDefault.prevention) || 0) | ((colDefault == null ? void 0 : colDefault.prevention) || 0) | ((cell == null ? void 0 : cell.prevention) || 0)
+        };
+        if ((_b = (_a = stacked == null ? void 0 : stacked.value) == null ? void 0 : _a.startsWith) == null ? void 0 : _b.call(_a, "=")) {
+          this.idsToBeAbsoluted.push(id);
+        }
+        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();
+  }
+  absolutizeFormula() {
+    this.idsToBeAbsoluted.forEach((id) => {
+      const cell = this.data[id];
+      if (cell == null) {
+        return;
+      }
+      cell.value = absolutizeFormula({
+        value: cell == null ? void 0 : cell.value,
+        table: this
+      });
+    });
+  }
+  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 ? void 0 : _a.width) || DEFAULT_WIDTH;
+    }
+    for (let y = top || 1; y < bottom; y++) {
+      height += ((_b = this.getByPoint({ y, x: 0 })) == null ? 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 = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    copied.changedAt = /* @__PURE__ */ new Date();
+    copied.lastChangedAt = this.changedAt;
+    copied.setTotalSize();
+    copied.idsToBeAbsoluted = [];
+    copied.solvedCaches = {};
+    if (!copyCache) {
+      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[Math.abs(y)]) == null ? void 0 : _a[Math.abs(x)];
+  }
+  getByPoint(point) {
+    var _a;
+    const { y, x } = point;
+    if (y === -1 || x === -1) {
+      return void 0;
+    }
+    const id = (_a = this.idMatrix[y]) == null ? void 0 : _a[x];
+    if (id == null) {
+      return void 0;
+    }
+    const value = this.data[id];
+    return value;
+  }
+  getById(id) {
+    return this.data[id];
+  }
+  getNumRows(base = 0) {
+    const { top, bottom } = this.area;
+    return base + bottom - top;
+  }
+  getNumCols(base = 0) {
+    const { left, 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 = noFilter
+  } = {}) {
+    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] = solveFormula({
+          value: cell[key],
+          table: this,
+          raise,
+          evaluates
+        });
+      }
+    }
+    return matrix;
+  }
+  getObjectFlatten({ key = "value", evaluates = true, raise = false, filter = noFilter } = {}) {
+    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 })] = solveFormula({
+            value: cell[key],
+            table: this,
+            raise,
+            evaluates
+          });
+        }
+      }
+    }
+    return result;
+  }
+  getRowsFlatten({ key = "value", evaluates = true, raise = false, filter = noFilter } = {}) {
+    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)] = solveFormula({
+            value: cell[key],
+            table: this,
+            raise,
+            evaluates
+          });
+        }
+      }
+    }
+    return result;
+  }
+  getColsFlatten({ key = "value", evaluates = true, raise = false, filter = noFilter } = {}) {
+    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)] = solveFormula({
+            value: cell[key],
+            table: this,
+            raise,
+            evaluates
+          });
+        }
+      }
+    }
+    return result;
+  }
+  getMatrix({
+    area,
+    evaluates = true,
+    raise = false,
+    filter = noFilter
+  } = {}) {
+    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] = {
+            ...cell,
+            value: solveFormula({
+              value: cell == null ? void 0 : cell.value,
+              table: this,
+              raise,
+              evaluates
+            })
+          };
+        }
+      }
+    }
+    return matrix;
+  }
+  getObject({ evaluates = true, raise = false, filter = noFilter } = {}) {
+    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 })] = {
+            ...cell,
+            value: solveFormula({
+              value: cell == null ? void 0 : cell.value,
+              table: this,
+              raise,
+              evaluates
+            })
+          };
+        }
+      }
+    }
+    return result;
+  }
+  getRows({ evaluates = true, raise = false, filter = noFilter } = {}) {
+    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)] = {
+            ...cell,
+            value: solveFormula({
+              value: cell == null ? void 0 : cell.value,
+              table: this,
+              raise,
+              evaluates
+            })
+          };
+        }
+      }
+    }
+    return result;
+  }
+  getCols({ evaluates = true, raise = false, filter = noFilter } = {}) {
+    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)] = {
+            ...cell,
+            value: solveFormula({
+              value: cell == null ? void 0 : cell.value,
+              table: this,
+              raise,
+              evaluates
+            })
+          };
+        }
+      }
+    }
+    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 = this.currentHistory = 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 === "DELETE_ROWS" || history.operation === "DELETE_COLS") {
+      history.deleted.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) => {
+            if (id != null) {
+              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 ? void 0 : _a[x];
+        if (id == null) {
+          continue;
+        }
+        ids.push(id);
+      }
+    }
+    return matrix;
+  }
+  setChangedAt(cell, changedAt) {
+    if (cell == null) {
+      return null;
+    }
+    cell.changedAt = changedAt || /* @__PURE__ */ new Date();
+    return cell;
+  }
+  copyCellLayout(cell) {
+    if (cell == null) {
+      return void 0;
+    }
+    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, historicize = true, operator = "SYSTEM", reflection = {} }) {
+    const matrixNew = this.getNewIdMatrix(src);
+    const matrixFrom = this.getIdMatrixFromArea(src);
+    const matrixTo = this.getIdMatrixFromArea(dst);
+    putMatrix(this.idMatrix, matrixNew, src, (_, id) => {
+      const cell = this.data[id];
+      if (operator === "USER" && isPrevented(cell == null ? void 0 : cell.prevention, MoveFrom)) {
+        return false;
+      }
+      return true;
+    });
+    const lostRows = putMatrix(this.idMatrix, matrixFrom, dst, (srcId, dstId) => {
+      const srcCell = this.data[srcId];
+      const dstCell = this.data[dstId];
+      if (operator === "USER" && (isPrevented(srcCell == null ? void 0 : srcCell.prevention, MoveFrom) || isPrevented(dstCell == null ? void 0 : dstCell.prevention, MoveTo))) {
+        return false;
+      }
+      if (srcCell != null) {
+        this.setChangedAt(srcCell, /* @__PURE__ */ 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, operator = "SYSTEM", reflection = {} }) {
+    const { height: maxHeight, width: maxWidth } = areaShape({
+      ...src,
+      base: 1
+    });
+    const { top: topFrom, left: leftFrom } = src;
+    const { top: topTo, left: leftTo, bottom: bottomTo, right: rightTo } = dst;
+    const diff = {};
+    const changedAt = /* @__PURE__ */ 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 = {
+          ...this.getByPoint({
+            y: topFrom + i % maxHeight,
+            x: leftFrom + j % maxWidth
+          }),
+          prevention: 0
+          // Is this okay?
+        };
+        const value = absolutizeFormula({
+          value: cell == null ? void 0 : cell.value,
+          table: this,
+          slideY,
+          slideX
+        });
+        this.setChangedAt(cell, changedAt);
+        diff[p2a({ y: toY, x: toX })] = {
+          ...cell,
+          style: { ...cell == null ? void 0 : cell.style },
+          value
+        };
+      }
+    }
+    return this.update({
+      diff,
+      partial: false,
+      operator,
+      reflection
+    });
+  }
+  _update({
+    diff,
+    partial = true,
+    updateChangedAt = true,
+    ignoreFields = ["labeler", "prevention"],
+    operator = "SYSTEM"
+  }) {
+    const diffBefore = {};
+    const diffAfter = {};
+    const changedAt = /* @__PURE__ */ new Date();
+    Object.keys(diff).forEach((address) => {
+      const cell = { ...diff[address] };
+      if (operator === "USER" && isPrevented(cell == null ? void 0 : cell.prevention, Update)) {
+        return;
+      }
+      cell.value = absolutizeFormula({
+        value: cell.value,
+        table: this
+      });
+      const point = a2p(address);
+      const id = this.getId(point);
+      const current = this.data[id];
+      ignoreFields.forEach((key) => {
+        cell[key] = current == null ? void 0 : current[key];
+      });
+      if (operator === "USER" && isPrevented(current == null ? void 0 : current.prevention, Write)) {
+        cell.value = current == null ? void 0 : current.value;
+      }
+      if (operator === "USER" && isPrevented(current == null ? void 0 : current.prevention, Style)) {
+        cell.style = current == null ? void 0 : current.style;
+        cell.justifyContent = current == null ? void 0 : current.justifyContent;
+        cell.alignItems = current == null ? void 0 : current.alignItems;
+      }
+      if (operator === "USER" && isPrevented(current == null ? void 0 : current.prevention, Resize)) {
+        cell.width = current == null ? void 0 : current.width;
+        cell.height = current == null ? void 0 : current.height;
+      }
+      if (operator === "USER" && isPrevented(current == null ? void 0 : current.prevention, SetRenderer)) {
+        cell.renderer = current == null ? void 0 : current.renderer;
+      }
+      if (operator === "USER" && isPrevented(current == null ? void 0 : current.prevention, SetParser)) {
+        cell.parser = current == null ? void 0 : current.parser;
+      }
+      if (updateChangedAt) {
+        this.setChangedAt(cell, changedAt);
+      }
+      diffBefore[id] = this.getByPoint(point);
+      diffAfter[id] = cell;
+      if (partial) {
+        this.data[id] = { ...current, ...cell };
+      } else {
+        this.data[id] = cell;
+      }
+    });
+    this.solvedCaches = {};
+    return {
+      diffBefore,
+      diffAfter
+    };
+  }
+  update({
+    diff,
+    partial = true,
+    updateChangedAt = true,
+    historicize = true,
+    operator = "SYSTEM",
+    reflection = {}
+  }) {
+    const { diffBefore, diffAfter } = this._update({
+      diff,
+      partial,
+      operator,
+      updateChangedAt
+    });
+    if (historicize) {
+      this.pushHistory({
+        applyed: true,
+        operation: "UPDATE",
+        reflection,
+        diffBefore,
+        diffAfter,
+        partial
+      });
+    }
+    return this.shallowCopy({ copyCache: true });
+  }
+  writeMatrix({
+    point,
+    matrix,
+    updateChangedAt = true,
+    historicize = true,
+    operator = "SYSTEM",
+    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,
+      historicize,
+      operator,
+      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,
+    operator = "SYSTEM",
+    reflection = {}
+  }) {
+    const returned = this.addRows({
+      y,
+      numRows,
+      baseY,
+      reflection
+    });
+    Object.assign(this.lastHistory, this._update({ diff, partial, updateChangedAt, operator }), { partial });
+    return returned;
+  }
+  addRows({
+    y,
+    numRows,
+    baseY,
+    // operator = 'SYSTEM',
+    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 = /* @__PURE__ */ 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] = { ...copied, changedAt };
+      }
+      rows.push(row);
+    }
+    this.idMatrix.splice(y, 0, ...rows);
+    this.area.bottom += numRows;
+    this.pushHistory({
+      applyed: true,
+      operation: "ADD_ROWS",
+      reflection,
+      y,
+      numRows,
+      idMatrix: rows
+    });
+    return this.shallowCopy({ copyCache: false });
+  }
+  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 ys = [];
+    for (let i = y; i < y + numRows; i++) {
+      const cell = this.getByPoint({ y: i, x: 0 });
+      if (operator === "USER" && isPrevented(cell == null ? void 0 : cell.prevention, DeleteRow)) {
+        console.warn(`Cannot delete row ${i}.`);
+        return this;
+      }
+      ys.unshift(i);
+    }
+    const deleted = [];
+    ys.forEach((y2) => {
+      const row = this.idMatrix.splice(y2, 1);
+      deleted.unshift(row[0]);
+    });
+    this.area.bottom -= ys.length;
+    this.pushHistory({
+      applyed: true,
+      operation: "DELETE_ROWS",
+      reflection,
+      ys: ys.reverse(),
+      deleted
+    });
+    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 = /* @__PURE__ */ 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] = { ...copied, changedAt };
+      }
+      rows.push(row);
+    }
+    this.area.right += numCols;
+    this.pushHistory({
+      applyed: true,
+      operation: "ADD_COLS",
+      reflection,
+      x,
+      numCols,
+      idMatrix: rows
+    });
+    return this.shallowCopy({ copyCache: false });
+  }
+  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 xs = [];
+    for (let i = x; i < x + numCols; i++) {
+      const cell = this.getByPoint({ y: 0, x: i });
+      if (operator === "USER" && isPrevented(cell == null ? void 0 : cell.prevention, DeleteCol)) {
+        console.warn(`Cannot delete col ${i}.`);
+        continue;
+      }
+      xs.unshift(i);
+    }
+    const deleted = [];
+    this.idMatrix.forEach((row) => {
+      const deleting = [];
+      deleted.push(deleting);
+      xs.forEach((x2) => {
+        deleting.unshift(...row.splice(x2, 1));
+      });
+    });
+    this.area.right -= xs.length;
+    this.pushHistory({
+      applyed: true,
+      operation: "DELETE_COLS",
+      reflection,
+      xs: xs.reverse(),
+      deleted
+    });
+    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 = { ...functions, ...additionalFunctions };
+  }
+  getArea() {
+    return { ...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 ? void 0 : cell.renderer) || ""] || defaultRenderer;
+    const s = renderer.stringify(typeof value === "undefined" ? { ...cell } : { ...cell, value });
+    if (s[0] === "=") {
+      if (evaluates) {
+        return String(solveFormula({ value: s, table: this, raise: false, evaluates }));
+      }
+      const lexer = new Lexer(s.substring(1));
+      lexer.tokenize();
+      return "=" + lexer.stringifyToRef(this);
+    }
+    return s;
+  }
+  trim(area) {
+    const copied = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    copied.area = area;
+    return copied;
+  }
+  getIdByAddress(address) {
+    let table = this;
+    if (address.indexOf("!") !== -1) {
+      const [sheetName, addr] = address.split("!");
+      const sheetId = this.sheets[stripSheetName(sheetName)];
+      table = this.tables[sheetId];
+      address = addr;
+    }
+    const { y, x } = a2p(address);
+    const id = table.getId({ y, x });
+    if (id) {
+      const prefix = table === this ? "" : `#${table.sheetId}!`;
+      return `${prefix}#${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] = { ...this.getById(id), ...cell };
+    });
+  }
+  undo() {
+    if (this.historyIndex < 0) {
+      return { history: null, newTable: this };
+    }
+    const history = this.histories[this.historyIndex--];
+    history.applyed = false;
+    this.currentHistory = history;
+    switch (history.operation) {
+      case "UPDATE":
+        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 "DELETE_ROWS": {
+        const { ys, deleted } = history;
+        ys.forEach((y, i) => {
+          this.idMatrix.splice(y, 0, deleted[i]);
+        });
+        this.area.bottom += ys.length;
+        break;
+      }
+      case "DELETE_COLS": {
+        const { xs, deleted } = history;
+        this.idMatrix.forEach((row, i) => {
+          for (let j = 0; j < xs.length; j++) {
+            row.splice(xs[j], 0, deleted[i][j]);
+          }
+        });
+        this.area.right += xs.length;
+        break;
+      }
+      case "MOVE": {
+        const { top: yFrom, left: xFrom } = history.src;
+        const { top: yTo, left: xTo } = history.dst;
+        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];
+    history.applyed = true;
+    this.currentHistory = history;
+    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 "DELETE_ROWS": {
+        const { ys } = history;
+        [...ys].reverse().forEach((y) => {
+          this.idMatrix.splice(y, 1);
+        });
+        this.area.bottom -= ys.length;
+        break;
+      }
+      case "DELETE_COLS": {
+        const { xs } = history;
+        [...xs].reverse().forEach((x) => {
+          this.idMatrix.forEach((row) => {
+            row.splice(x, 1);
+          });
+        });
+        this.area.right -= xs.length;
+        break;
+      }
+      case "MOVE": {
+        const { src, dst } = history;
+        this.move({ src, dst, operator: "USER", historicize: false });
+      }
+    }
+    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 ? void 0 : labeler(n);
+  }
+  getBase() {
+    return this;
+  }
+  getSolvedCache(key) {
+    return this.solvedCaches[key];
+  }
+  setSolvedCache(key, value) {
+    this.solvedCaches[key] = value;
+  }
+  wrappedSheetName() {
+    const sheetName = this.sheetName;
+    if (sheetName.indexOf(" ") !== -1) {
+      return `'${sheetName}'`;
+    }
+    return sheetName;
+  }
+  sheetPrefix(omit = false) {
+    if (omit) {
+      return "";
+    }
+    if (this.sheetName) {
+      return `${this.wrappedSheetName()}!`;
+    }
+    return "";
+  }
+  rangeToArea(range) {
+    const cells = range.split(":");
+    let [start, end] = cells;
+    if (start.match(/[a-zA-Z]$/)) {
+      start += "1";
+    }
+    if (start.match(/^[1-9]/)) {
+      start = `A${start}`;
+    }
+    if (end == null ? void 0 : end.match(/[a-zA-Z]$/)) {
+      end += this.bottom;
+    }
+    if (end == null ? void 0 : end.match(/^[1-9]/)) {
+      end = `${x2c(this.right)}${end}`;
+    }
+    const { y: top, x: left } = a2p(start);
+    const { y: bottom, x: right } = a2p(end || start);
+    return {
+      top: Math.abs(top),
+      left: Math.abs(left),
+      bottom: Math.abs(bottom),
+      right: Math.abs(right)
+    };
+  }
+}
+export {
+  Table
+};
+//# sourceMappingURL=table.js.map