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

package/dist/store/actions.js

@@ -0,0 +1,762 @@
+import { zoneToArea, areaShape, areaToZone, matrixShape, superposeArea } from "../lib/structs.js";
+import { tsv2matrix, a2p, p2a } from "../lib/converters.js";
+import { DEFAULT_HEIGHT, DEFAULT_WIDTH } from "../constants.js";
+import { initSearchStatement, restrictPoints } from "./helpers.js";
+import { smartScroll } from "../lib/virtualization.js";
+import { isPrevented, Write } from "../lib/prevention.js";
+const actions = {};
+const reducer = (store, action) => {
+  const act = actions[action.type];
+  if (act == null) {
+    return store;
+  }
+  return { ...store, ...act.reduce(store, action.value) };
+};
+const _CoreAction = class _CoreAction {
+  constructor() {
+    this.actionId = 1;
+  }
+  reduce(store, payload) {
+    return store;
+  }
+  call(payload) {
+    return {
+      type: this.actionId,
+      value: payload
+    };
+  }
+  bind() {
+    this.actionId = _CoreAction.head++;
+    actions[this.actionId] = this;
+    return this.call.bind(this);
+  }
+};
+_CoreAction.head = 1;
+let CoreAction = _CoreAction;
+class SetSearchQueryAction extends CoreAction {
+  reduce(store, payload) {
+    const searchQuery = payload;
+    const { table } = store;
+    return {
+      ...store,
+      ...initSearchStatement(table, { ...store, searchQuery }),
+      searchQuery
+    };
+  }
+}
+const setSearchQuery = new SetSearchQueryAction().bind();
+class SetSearchCaseSensitiveAction extends CoreAction {
+  reduce(store, payload) {
+    const searchCaseSensitive = payload;
+    const { table } = store;
+    return {
+      ...store,
+      ...initSearchStatement(table, { ...store, searchCaseSensitive }),
+      searchCaseSensitive
+    };
+  }
+}
+const setSearchCaseSensitive = new SetSearchCaseSensitiveAction().bind();
+class SetEditingCellAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      editingCell: payload
+    };
+  }
+}
+const setEditingCell = new SetEditingCellAction().bind();
+class SetEditingOnEnterAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      editingOnEnter: payload
+    };
+  }
+}
+const setEditingOnEnter = new SetEditingOnEnterAction().bind();
+class SetAutofillDraggingToAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      autofillDraggingTo: payload
+    };
+  }
+}
+const setAutofillDraggingTo = new SetAutofillDraggingToAction().bind();
+class SetShowAddressAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      showAddress: payload
+    };
+  }
+}
+const setShowAddress = new SetShowAddressAction().bind();
+class SetContextMenuPositionAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      contextMenuPosition: payload
+    };
+  }
+}
+const setContextMenuPosition = new SetContextMenuPositionAction().bind();
+class SetResizingPositionYAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      resizingPositionY: payload
+    };
+  }
+}
+const setResizingPositionY = new SetResizingPositionYAction().bind();
+class SetResizingPositionXAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      resizingPositionX: payload
+    };
+  }
+}
+const setResizingPositionX = new SetResizingPositionXAction().bind();
+class SetOnSaveAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      onSave: payload
+    };
+  }
+}
+const setOnSave = new SetOnSaveAction().bind();
+class SetEnteringAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      entering: payload
+    };
+  }
+}
+const setEntering = new SetEnteringAction().bind();
+class SetHeaderHeightAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      headerHeight: payload
+    };
+  }
+}
+const setHeaderHeight = new SetHeaderHeightAction().bind();
+class SetHeaderWidthAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      headerWidth: payload
+    };
+  }
+}
+const setHeaderWidth = new SetHeaderWidthAction().bind();
+class SetSheetHeightAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      sheetHeight: payload
+    };
+  }
+}
+const setSheetHeight = new SetSheetHeightAction().bind();
+class SetSheetWidthAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      sheetWidth: payload
+    };
+  }
+}
+const setSheetWidth = new SetSheetWidthAction().bind();
+class InitializeTableAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      table: payload,
+      tableInitialized: true
+    };
+  }
+}
+const initializeTable = new InitializeTableAction().bind();
+class UpdateTableAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      table: payload,
+      ...initSearchStatement(payload, store),
+      ...restrictPoints(store, payload)
+    };
+  }
+}
+const updateTable = new UpdateTableAction().bind();
+class SetEditorRectAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      editorRect: payload
+    };
+  }
+}
+const setEditorRect = new SetEditorRectAction().bind();
+class SetResizingRectAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      resizingRect: payload
+    };
+  }
+}
+new SetResizingRectAction().bind();
+class BlurAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      editingCell: ""
+    };
+  }
+}
+new BlurAction().bind();
+class CopyAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      copyingZone: payload,
+      cutting: false
+    };
+  }
+}
+const copy = new CopyAction().bind();
+class CutAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      copyingZone: payload,
+      cutting: true
+    };
+  }
+}
+const cut = new CutAction().bind();
+class PasteAction extends CoreAction {
+  reduce(store, payload) {
+    const { choosing, copyingZone, selectingZone, cutting, table } = store;
+    let selectingArea = zoneToArea(selectingZone);
+    const copyingArea = zoneToArea(copyingZone);
+    if (cutting) {
+      const src = copyingArea;
+      const { height: h, width: w } = areaShape(copyingArea);
+      const dst = selectingArea.top !== -1 ? {
+        top: selectingArea.top,
+        left: selectingArea.left,
+        bottom: selectingArea.top + h,
+        right: selectingArea.left + w
+      } : {
+        top: choosing.y,
+        left: choosing.x,
+        bottom: choosing.y + h,
+        right: choosing.x + w
+      };
+      const newTable2 = table.move({
+        src,
+        dst,
+        operator: "USER",
+        reflection: {
+          selectingZone: areaToZone(dst),
+          copyingZone,
+          cutting
+        }
+      });
+      return {
+        ...store,
+        ...initSearchStatement(newTable2, store),
+        cutting: false,
+        table: newTable2,
+        selectingZone: areaToZone(dst),
+        copyingZone: { startY: -1, startX: -1, endY: -1, endX: -1 }
+      };
+    }
+    let newTable;
+    let { y, x } = choosing;
+    const { text } = payload;
+    if (copyingArea.top === -1) {
+      const matrixFrom = tsv2matrix(text);
+      const { height, width } = matrixShape({ matrix: matrixFrom, base: -1 });
+      selectingArea = {
+        top: y,
+        left: x,
+        bottom: y + height,
+        right: x + width
+      };
+      newTable = table.writeMatrix({
+        point: { y, x },
+        matrix: matrixFrom,
+        reflection: {
+          selectingZone: areaToZone(selectingArea)
+        }
+      });
+    } else {
+      let { height, width } = areaShape(copyingArea);
+      if (selectingArea.top !== -1) {
+        y = selectingArea.top;
+        x = selectingArea.left;
+        const superposed = superposeArea(selectingArea, copyingArea);
+        height = superposed.height;
+        width = superposed.width;
+      }
+      selectingArea = { top: y, left: x, bottom: y + height, right: x + width };
+      newTable = table.copy({
+        src: copyingArea,
+        dst: selectingArea,
+        operator: "USER",
+        reflection: {
+          copyingZone,
+          selectingZone
+        }
+      });
+    }
+    return {
+      ...store,
+      table: newTable,
+      selectingZone: areaToZone(selectingArea),
+      copyingZone: { startY: -1, startX: -1, endY: -1, endX: -1 },
+      ...initSearchStatement(newTable, store)
+    };
+  }
+}
+const paste = new PasteAction().bind();
+class EscapeAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      copyingZone: { startY: -1, startX: -1, endY: -1, endX: -1 },
+      cutting: false,
+      editingCell: "",
+      leftHeaderSelecting: false,
+      topHeaderSelecting: false
+    };
+  }
+}
+const escape = new EscapeAction().bind();
+class ChooseAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      choosing: payload,
+      entering: true
+    };
+  }
+}
+const choose = new ChooseAction().bind();
+class SelectAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      selectingZone: payload,
+      leftHeaderSelecting: false,
+      topHeaderSelecting: false
+    };
+  }
+}
+const select = new SelectAction().bind();
+class SelectRowsAction extends CoreAction {
+  reduce(store, payload) {
+    const { range, numCols } = payload;
+    const { start, end } = range;
+    const selectingZone = {
+      startY: start,
+      startX: 1,
+      endY: end,
+      endX: numCols
+    };
+    return {
+      ...store,
+      selectingZone,
+      choosing: { y: start, x: 0 },
+      leftHeaderSelecting: true,
+      topHeaderSelecting: false
+    };
+  }
+}
+const selectRows = new SelectRowsAction().bind();
+class SelectColsAction extends CoreAction {
+  reduce(store, payload) {
+    const { range, numRows } = payload;
+    const { start, end } = range;
+    const selectingZone = {
+      startY: 1,
+      startX: start,
+      endY: numRows,
+      endX: end
+    };
+    return {
+      ...store,
+      selectingZone,
+      choosing: { y: 0, x: start },
+      leftHeaderSelecting: false,
+      topHeaderSelecting: true
+    };
+  }
+}
+const selectCols = new SelectColsAction().bind();
+class DragAction extends CoreAction {
+  reduce(store, payload) {
+    const { startY, startX } = store.selectingZone;
+    const selectingZone = {
+      startY,
+      startX,
+      endY: payload.y,
+      endX: payload.x
+    };
+    return { ...store, selectingZone };
+  }
+}
+const drag = new DragAction().bind();
+class SearchAction extends CoreAction {
+  reduce(store, payload) {
+    const { matchingCells } = store;
+    let { matchingCellIndex, choosing } = store;
+    matchingCellIndex += payload;
+    if (matchingCellIndex >= matchingCells.length) {
+      matchingCellIndex = 0;
+    } else if (matchingCellIndex < 0) {
+      matchingCellIndex = matchingCells.length - 1;
+    }
+    if (matchingCells.length > 0) {
+      const address = matchingCells[matchingCellIndex];
+      choosing = a2p(address);
+    }
+    return { ...store, matchingCells, matchingCellIndex, choosing };
+  }
+}
+const search = new SearchAction().bind();
+class WriteAction extends CoreAction {
+  reduce(store, payload) {
+    const { choosing, selectingZone, table } = store;
+    const newTable = table.write({
+      point: choosing,
+      value: payload,
+      operator: "USER",
+      reflection: {
+        selectingZone,
+        choosing
+      }
+    });
+    return {
+      ...store,
+      ...initSearchStatement(newTable, store),
+      table: newTable,
+      copyingZone: { startY: -1, startX: -1, endY: -1, endX: -1 }
+    };
+  }
+}
+const write = new WriteAction().bind();
+class ClearAction extends CoreAction {
+  reduce(store, payload) {
+    const { choosing, selectingZone, table } = store;
+    let selectingArea = zoneToArea(selectingZone);
+    if (selectingArea.top === -1) {
+      const { y, x } = choosing;
+      selectingArea = { top: y, left: x, bottom: y, right: x };
+    }
+    const { top, left, bottom, right } = selectingArea;
+    const diff = {};
+    let diffCount = 0;
+    for (let y = top; y <= bottom; y++) {
+      for (let x = left; x <= right; x++) {
+        const cell = table.getByPoint({ y, x });
+        const address = p2a({ y, x });
+        if (isPrevented(cell == null ? void 0 : cell.prevention, Write)) {
+          continue;
+        }
+        if ((cell == null ? void 0 : cell.value) != null) {
+          diff[address] = { value: null };
+          diffCount++;
+        }
+      }
+    }
+    if (diffCount === 0) {
+      return store;
+    }
+    const newTable = table.update({
+      diff,
+      partial: true,
+      operator: "USER",
+      reflection: {
+        selectingZone,
+        choosing
+      }
+    });
+    return {
+      ...store,
+      ...initSearchStatement(newTable, store),
+      table: newTable
+    };
+  }
+}
+const clear = new ClearAction().bind();
+class UndoAction extends CoreAction {
+  reduce(store, payload) {
+    const { table } = store;
+    const { history, newTable } = table.undo();
+    if (history == null) {
+      return store;
+    }
+    const { reflection } = history;
+    return {
+      ...store,
+      ...restrictPoints(store, table),
+      ...reflection,
+      ...initSearchStatement(newTable, store),
+      table: newTable
+    };
+  }
+}
+const undo = new UndoAction().bind();
+class RedoAction extends CoreAction {
+  reduce(store, payload) {
+    const { table } = store;
+    const { history, newTable } = table.redo();
+    if (history == null) {
+      return store;
+    }
+    const { reflection } = history;
+    return {
+      ...store,
+      ...reflection,
+      ...restrictPoints(store, table),
+      ...initSearchStatement(newTable, store),
+      table: newTable
+    };
+  }
+}
+const redo = new RedoAction().bind();
+class ArrowAction extends CoreAction {
+  reduce(store, payload) {
+    var _a, _b, _c, _d;
+    const { shiftKey, deltaY, deltaX, numRows, numCols } = payload;
+    const { choosing, table, tabularRef } = store;
+    let { selectingZone } = store;
+    const { y, x } = choosing;
+    if (shiftKey) {
+      const [dragEndY, dragEndX] = [
+        selectingZone.endY === -1 ? y : selectingZone.endY,
+        selectingZone.endX === -1 ? x : selectingZone.endX
+      ];
+      const [nextY2, nextX2] = [dragEndY + deltaY, dragEndX + deltaX];
+      if (nextY2 < 1 || numRows < nextY2 || nextX2 < 1 || numCols < nextX2) {
+        return store;
+      }
+      selectingZone = y === nextY2 && x === nextX2 ? { startY: -1, startX: -1, endY: -1, endX: -1 } : { startY: y, startX: x, endY: nextY2, endX: nextX2 };
+      return {
+        ...store,
+        selectingZone
+      };
+    }
+    const [nextY, nextX] = [y + deltaY, x + deltaX];
+    if (nextY < 1 || numRows < nextY || nextX < 1 || numCols < nextX) {
+      return store;
+    }
+    let { y: editorTop, x: editorLeft, height, width } = store.editorRect;
+    if (deltaY > 0) {
+      for (let i = y; i < nextY; i++) {
+        editorTop += ((_a = table.getByPoint({ y: i, x: 0 })) == null ? void 0 : _a.height) || DEFAULT_HEIGHT;
+      }
+    } else if (deltaY < 0) {
+      for (let i = y - 1; i >= nextY; i--) {
+        editorTop -= ((_b = table.getByPoint({ y: i, x: 0 })) == null ? void 0 : _b.height) || DEFAULT_HEIGHT;
+      }
+    }
+    if (deltaX > 0) {
+      for (let i = x; i < nextX; i++) {
+        editorLeft += ((_c = table.getByPoint({ y: 0, x: i })) == null ? void 0 : _c.width) || DEFAULT_WIDTH;
+      }
+    } else if (deltaX < 0) {
+      for (let i = x - 1; i >= nextX; i--) {
+        editorLeft -= ((_d = table.getByPoint({ y: 0, x: i })) == null ? void 0 : _d.width) || DEFAULT_WIDTH;
+      }
+    }
+    const cell = table.getByPoint({ y: nextY, x: nextX });
+    height = (cell == null ? void 0 : cell.height) || DEFAULT_HEIGHT;
+    width = (cell == null ? void 0 : cell.width) || DEFAULT_WIDTH;
+    smartScroll(table, tabularRef.current, { y: nextY, x: nextX });
+    return {
+      ...store,
+      selectingZone: { startY: -1, startX: -1, endY: -1, endX: -1 },
+      choosing: { y: nextY, x: nextX },
+      editorRect: { y: editorTop, x: editorLeft, height, width }
+    };
+  }
+}
+const arrow = new ArrowAction().bind();
+class WalkAction extends CoreAction {
+  reduce(store, payload) {
+    var _a, _b, _c, _d;
+    const { numRows, numCols } = payload;
+    let { deltaY, deltaX } = payload;
+    const { choosing, selectingZone, table, tabularRef: gridOuterRef } = store;
+    let { y: editorTop, x: editorLeft, height, width } = store.editorRect;
+    const { y, x } = choosing;
+    const selectingArea = zoneToArea(selectingZone);
+    const { top, left, bottom, right } = selectingArea;
+    let [nextY, nextX] = [y + deltaY, x + deltaX];
+    if (nextY < top && top !== -1) {
+      deltaY = bottom - nextY;
+      nextY = bottom;
+      if (nextX > left) {
+        nextX--;
+        deltaX--;
+      } else {
+        deltaX = right - nextX;
+        nextX = right;
+      }
+    }
+    if (nextY > bottom && bottom !== -1) {
+      deltaY = top - nextY;
+      nextY = top;
+      if (nextX < right) {
+        nextX++;
+        deltaX++;
+      } else {
+        deltaX = left - nextX;
+        nextX = left;
+      }
+    }
+    if (nextX < left && left !== -1) {
+      deltaX = right - nextX;
+      nextX = right;
+      if (nextY > top) {
+        nextY--;
+        deltaY--;
+      } else {
+        deltaY = bottom - nextY;
+        nextY = bottom;
+      }
+    }
+    if (nextX > right && right !== -1) {
+      deltaX = left - nextX;
+      nextX = left;
+      if (nextY < bottom) {
+        nextY++;
+        deltaY++;
+      } else {
+        deltaY = top - nextY;
+        nextY = top;
+      }
+    }
+    if (nextY < 1 || numRows < nextY || nextX < 1 || numCols < nextX) {
+      return store;
+    }
+    if (deltaY > 0) {
+      for (let i = y; i < nextY; i++) {
+        editorTop += ((_a = table.getByPoint({ y: i, x: 0 })) == null ? void 0 : _a.height) || DEFAULT_HEIGHT;
+      }
+    } else if (deltaY < 0) {
+      for (let i = y - 1; i >= nextY; i--) {
+        editorTop -= ((_b = table.getByPoint({ y: i, x: 0 })) == null ? void 0 : _b.height) || DEFAULT_HEIGHT;
+      }
+    }
+    if (deltaX > 0) {
+      for (let i = x; i < nextX; i++) {
+        editorLeft += ((_c = table.getByPoint({ y: 0, x: i })) == null ? void 0 : _c.width) || DEFAULT_WIDTH;
+      }
+    } else if (deltaX < 0) {
+      for (let i = x - 1; i >= nextX; i--) {
+        editorLeft -= ((_d = table.getByPoint({ y: 0, x: i })) == null ? void 0 : _d.width) || DEFAULT_WIDTH;
+      }
+    }
+    const cell = table.getByPoint({ y: nextY, x: nextX });
+    height = (cell == null ? void 0 : cell.height) || DEFAULT_HEIGHT;
+    width = (cell == null ? void 0 : cell.width) || DEFAULT_WIDTH;
+    smartScroll(table, gridOuterRef.current, { y: nextY, x: nextX });
+    return {
+      ...store,
+      choosing: { y: nextY, x: nextX },
+      editorRect: { y: editorTop, x: editorLeft, height, width }
+    };
+  }
+}
+const walk = new WalkAction().bind();
+class SetLastEditedAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      lastEdited: payload
+    };
+  }
+}
+const setLastEdited = new SetLastEditedAction().bind();
+class SetLastFocusedRefAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      lastFocusedRef: payload
+    };
+  }
+}
+const setLastFocusedRef = new SetLastFocusedRefAction().bind();
+class SetInputtingAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      inputting: payload
+    };
+  }
+}
+const setInputting = new SetInputtingAction().bind();
+class SetModeAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      mode: payload
+    };
+  }
+}
+const setMode = new SetModeAction().bind();
+export {
+  CoreAction,
+  arrow,
+  choose,
+  clear,
+  copy,
+  cut,
+  drag,
+  escape,
+  initializeTable,
+  paste,
+  redo,
+  reducer,
+  search,
+  select,
+  selectCols,
+  selectRows,
+  setAutofillDraggingTo,
+  setContextMenuPosition,
+  setEditingCell,
+  setEditingOnEnter,
+  setEditorRect,
+  setEntering,
+  setHeaderHeight,
+  setHeaderWidth,
+  setInputting,
+  setLastEdited,
+  setLastFocusedRef,
+  setMode,
+  setOnSave,
+  setResizingPositionX,
+  setResizingPositionY,
+  setSearchCaseSensitive,
+  setSearchQuery,
+  setSheetHeight,
+  setSheetWidth,
+  setShowAddress,
+  undo,
+  updateTable,
+  walk,
+  write
+};
+//# sourceMappingURL=actions.js.map