@gridsheet/react-core 1.4.0 → 2.0.0-rc.0

package/dist/lib/table.js

@@ -1,1259 +0,0 @@
-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,
-    sheetName
-  }) {
-    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 = [];
-    this.sheetName = sheetName || "";
-  }
-  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 = {};
-    }
-    copied.sheetName = this.sheetName;
-    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,
-          origin: { y, x }
-        });
-      }
-    }
-    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,
-            origin: { y, x }
-          });
-        }
-      }
-    }
-    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,
-            origin: { y, x }
-          });
-        }
-      }
-    }
-    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,
-            origin: { y, x }
-          });
-        }
-      }
-    }
-    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,
-              origin: { y, x }
-            })
-          };
-        }
-      }
-    }
-    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,
-              origin: { y, x }
-            })
-          };
-        }
-      }
-    }
-    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,
-              origin: { y, x }
-            })
-          };
-        }
-      }
-    }
-    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,
-              origin: { y, x }
-            })
-          };
-        }
-      }
-    }
-    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, origin: point }));
-      }
-      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