@gridsheet/preact-core 3.0.0-rc.6 → 3.0.0-rc.8

package/dist/hooks-hS8l-fYa.mjs

@@ -0,0 +1,1440 @@
+import { useRef, useEffect, useState } from "preact/compat";
+import { createBook } from "@gridsheet/core";
+import { areaToZone, zoneToArea, areaDiff, restrictZone, matrixShape, superposeArea } from "@gridsheet/core/lib/spatial";
+import { x2c, y2r, a2p, p2a } from "@gridsheet/core/lib/coords";
+import { DEFAULT_HEIGHT, DEFAULT_WIDTH } from "@gridsheet/core/constants";
+import { smartScroll } from "@gridsheet/core/lib/virtualization";
+import * as prevention from "@gridsheet/core/lib/operation";
+import { Autofill } from "@gridsheet/core/lib/autofill";
+const compactReflection = (reflection) => {
+  const result = { ...reflection };
+  if (result.selectingZone != null && result.selectingZone.endY === -1 && result.selectingZone.endX === -1) {
+    delete result.selectingZone;
+  }
+  return result;
+};
+const restrictPoints = (store, sheet) => {
+  const { choosing, selectingZone } = store;
+  let { y, x } = choosing;
+  let { startY: y1, startX: x1, endY: y2, endX: x2 } = selectingZone;
+  const [numRows, numCols] = [sheet.numRows, sheet.numCols];
+  if (y > numRows) {
+    y = numRows;
+  }
+  if (x > numCols) {
+    x = numCols;
+  }
+  if (y1 > numRows) {
+    y1 = numRows;
+  }
+  if (y2 > numRows) {
+    y2 = numRows;
+  }
+  if (x1 > numCols) {
+    x1 = numCols;
+  }
+  if (x2 > numCols) {
+    x2 = numCols;
+  }
+  return {
+    choosing: { y, x },
+    selectingZone: { startY: y1, startX: x1, endY: y2, endX: x2 }
+  };
+};
+const FLASH_CLASS = "gs-flash-overlay--active";
+const FLASH_DURATION_MS = 600;
+const flashSheet = (el) => {
+  if (!el) {
+    return;
+  }
+  el.classList.remove(FLASH_CLASS);
+  void el.offsetWidth;
+  el.classList.add(FLASH_CLASS);
+  setTimeout(() => el.classList.remove(FLASH_CLASS), FLASH_DURATION_MS);
+};
+const flashWithCallback = (store, sheet, callback) => ({
+  ...store,
+  sheetReactive: { current: sheet },
+  callback: (s) => {
+    callback == null ? void 0 : callback(s);
+    flashSheet(store.flashRef.current);
+  }
+});
+const initSearchStatement = (sheet, store) => {
+  const { searchQuery, searchCaseSensitive, searchRegex, searchRange } = store;
+  let { choosing } = store;
+  if (!searchQuery) {
+    return { matchingCells: [] };
+  }
+  const matchingCells = [];
+  let matcher;
+  if (searchRegex) {
+    try {
+      const flags = searchCaseSensitive ? "" : "i";
+      const regex = new RegExp(searchQuery, flags);
+      matcher = (v) => regex.test(v);
+    } catch (e) {
+      const q = searchCaseSensitive ? searchQuery : searchQuery.toLowerCase();
+      matcher = (v) => {
+        const s = searchCaseSensitive ? v : v.toLowerCase();
+        return s.indexOf(q) !== -1;
+      };
+    }
+  } else {
+    const q = searchCaseSensitive ? searchQuery : searchQuery.toLowerCase();
+    matcher = (v) => {
+      const s = searchCaseSensitive ? v : v.toLowerCase();
+      return s.indexOf(q) !== -1;
+    };
+  }
+  let startY = 1, endY = sheet.bottom;
+  let startX = 1, endX = sheet.right;
+  if (searchRange) {
+    startY = searchRange.startY;
+    endY = searchRange.endY;
+    startX = searchRange.startX;
+    endX = searchRange.endX;
+  }
+  for (let y = startY; y <= endY; y++) {
+    for (let x = startX; x <= endX; x++) {
+      const v = sheet.getSerializedValue({ point: { y, x } });
+      if (matcher(v)) {
+        matchingCells.push(`${x2c(x)}${y2r(y)}`);
+      }
+    }
+  }
+  const matchingCellIndex = matchingCells.length === store.matchingCells.length ? store.matchingCellIndex : 0;
+  if (matchingCells.length > 0) {
+    const address = matchingCells[matchingCellIndex];
+    choosing = a2p(address);
+  }
+  return { matchingCells, searchQuery, matchingCellIndex, choosing };
+};
+const isXSheetFocused = (store) => {
+  const { sheetId, sheetReactive: sheetRef } = store;
+  const sheet = sheetRef.current;
+  if (!sheet) {
+    return false;
+  }
+  if (sheetId === sheet.registry.editingSheetId) {
+    return false;
+  }
+  return !!sheet.registry.editingAddress;
+};
+const resetZone = { startY: -1, startX: -1, endY: -1, endX: -1 };
+const actions = {};
+const reducer = (store, action) => {
+  var _a, _b;
+  const act = actions[action.type];
+  if (act == null) {
+    return store;
+  }
+  const registry = (_a = store.sheetReactive.current) == null ? void 0 : _a.registry;
+  if ((_b = registry == null ? void 0 : registry._strictModeCache) == null ? void 0 : _b.has(action)) {
+    const cached = registry._strictModeCache.get(action);
+    registry._strictModeCache.delete(action);
+    return cached;
+  }
+  const { callback, ...newStore } = act.reduce(store, action.value);
+  callback == null ? void 0 : callback(newStore);
+  const result = { ...store, ...newStore };
+  if (registry) {
+    if (!registry._strictModeCache) {
+      registry._strictModeCache = /* @__PURE__ */ new Map();
+    }
+    registry._strictModeCache.set(action, result);
+    queueMicrotask(() => {
+      var _a2;
+      (_a2 = registry._strictModeCache) == null ? void 0 : _a2.delete(action);
+    });
+  }
+  return result;
+};
+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 { sheetReactive: sheetRef } = store;
+    if (sheetRef.current == null) {
+      return store;
+    }
+    return {
+      ...store,
+      ...initSearchStatement(sheetRef.current, { ...store, searchQuery }),
+      searchQuery
+    };
+  }
+}
+const setSearchQuery = new SetSearchQueryAction().bind();
+class SetSearchCaseSensitiveAction extends CoreAction {
+  reduce(store, payload) {
+    const searchCaseSensitive = payload;
+    const { sheetReactive: sheetRef } = store;
+    if (sheetRef.current == null) {
+      return store;
+    }
+    return {
+      ...store,
+      ...initSearchStatement(sheetRef.current, { ...store, searchCaseSensitive }),
+      searchCaseSensitive
+    };
+  }
+}
+const setSearchCaseSensitive = new SetSearchCaseSensitiveAction().bind();
+class SetSearchRegexAction extends CoreAction {
+  reduce(store, payload) {
+    const searchRegex = payload;
+    const { sheetReactive: sheetRef } = store;
+    if (sheetRef.current == null) {
+      return store;
+    }
+    return {
+      ...store,
+      ...initSearchStatement(sheetRef.current, { ...store, searchRegex }),
+      searchRegex
+    };
+  }
+}
+const setSearchRegex = new SetSearchRegexAction().bind();
+class SetSearchRangeAction extends CoreAction {
+  reduce(store, payload) {
+    const searchRange = payload;
+    const { sheetReactive: sheetRef } = store;
+    if (sheetRef.current == null) {
+      return store;
+    }
+    return {
+      ...store,
+      ...initSearchStatement(sheetRef.current, { ...store, searchRange }),
+      searchRange
+    };
+  }
+}
+const setSearchRange = new SetSearchRangeAction().bind();
+class SetEditingAddressAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      editingAddress: payload
+    };
+  }
+}
+const setEditingAddress = new SetEditingAddressAction().bind();
+class SetAutofillDraggingToAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      autofillDraggingTo: payload
+    };
+  }
+}
+const setAutofillDraggingTo = new SetAutofillDraggingToAction().bind();
+class SubmitAutofillAction extends CoreAction {
+  reduce(store, payload) {
+    const autofill = new Autofill(store, payload);
+    const sheet = autofill.applied;
+    const selectingZone = areaToZone(autofill.wholeArea);
+    return {
+      ...store,
+      sheetReactive: { current: sheet },
+      ...initSearchStatement(sheet, store),
+      ...restrictPoints(store, sheet),
+      selectingZone,
+      leftHeaderSelecting: false,
+      topHeaderSelecting: false,
+      autofillDraggingTo: null
+    };
+  }
+}
+const submitAutofill = new SubmitAutofillAction().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 SetEnteringAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      entering: payload
+    };
+  }
+}
+const setEntering = new SetEnteringAction().bind();
+class UpdateSheetAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      sheetReactive: { current: payload },
+      ...initSearchStatement(payload, store),
+      ...restrictPoints(store, payload)
+    };
+  }
+}
+const updateSheet = new UpdateSheetAction().bind();
+class SetEditorRectAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      editorRect: payload
+    };
+  }
+}
+const setEditorRect = new SetEditorRectAction().bind();
+class SetDragging extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      dragging: payload
+    };
+  }
+}
+const setDragging = new SetDragging().bind();
+class BlurAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      editingAddress: ""
+    };
+  }
+}
+const blur = new BlurAction().bind();
+class CopyAction extends CoreAction {
+  reduce(store, payload) {
+    const { sheetReactive: sheetRef } = store;
+    const sheet = sheetRef.current;
+    if (!sheet) {
+      return store;
+    }
+    return {
+      ...store,
+      callback: ({ sheetReactive: sheetRef2 }) => {
+        sheet.registry.transmit({
+          copyingSheetId: sheet.id,
+          copyingZone: payload,
+          cutting: false
+        });
+      }
+    };
+  }
+}
+const copy = new CopyAction().bind();
+class CutAction extends CoreAction {
+  reduce(store, payload) {
+    const { sheetReactive: sheetRef } = store;
+    const sheet = sheetRef.current;
+    if (!sheet) {
+      return store;
+    }
+    return {
+      ...store,
+      callback: ({ sheetReactive: sheetRef2 }) => {
+        sheet.registry.transmit({
+          copyingSheetId: sheet.id,
+          copyingZone: payload,
+          cutting: true
+        });
+      }
+    };
+  }
+}
+const cut = new CutAction().bind();
+class PasteAction extends CoreAction {
+  reduce(store, payload) {
+    const { choosing, selectingZone, sheetReactive: dstSheetRef } = store;
+    const dstSheet = dstSheetRef.current;
+    if (!dstSheet) {
+      return store;
+    }
+    const { registry } = dstSheet;
+    const { copyingSheetId, copyingZone, cutting } = registry;
+    const srcSheet = dstSheet.getSheetBySheetId(copyingSheetId);
+    let selectingArea = zoneToArea(selectingZone);
+    const copyingArea = zoneToArea(copyingZone);
+    const { matrix, onlyValue } = payload;
+    if (cutting) {
+      if (!srcSheet) {
+        return store;
+      }
+      const src = copyingArea;
+      const { rows: dy, cols: dx } = areaDiff(copyingArea);
+      const dst = selectingArea.top !== -1 ? {
+        top: selectingArea.top,
+        left: selectingArea.left,
+        bottom: selectingArea.top + dy,
+        right: selectingArea.left + dx
+      } : {
+        top: choosing.y,
+        left: choosing.x,
+        bottom: choosing.y + dy,
+        right: choosing.x + dx
+      };
+      const nextSelectingZone2 = restrictZone(areaToZone(dst));
+      const newSheet2 = dstSheet.move({
+        srcSheet,
+        src,
+        dst,
+        operator: "USER",
+        undoReflection: compactReflection({
+          sheetId: srcSheet.id,
+          selectingZone: nextSelectingZone2,
+          choosing,
+          transmit: { copyingSheetId: srcSheet.id, copyingZone, cutting: true }
+        }),
+        redoReflection: compactReflection({
+          sheetId: srcSheet.id,
+          choosing,
+          transmit: { copyingSheetId: srcSheet.id, copyingZone: resetZone }
+        })
+      });
+      return {
+        ...store,
+        ...initSearchStatement(newSheet2, store),
+        sheetReactive: { current: newSheet2 },
+        selectingZone: nextSelectingZone2,
+        inputting: newSheet2.getSerializedValue({ point: choosing, resolution: "RAW" }),
+        callback: ({ sheetReactive: sheetRef }) => {
+          registry.transmit({
+            cutting: false,
+            copyingZone: resetZone
+          });
+        }
+      };
+    }
+    let newSheet;
+    let { y, x } = choosing;
+    if (copyingArea.top === -1) {
+      const { rows: height, cols: width } = matrixShape({ matrix, base: -1 });
+      selectingArea = {
+        top: y,
+        left: x,
+        bottom: y + height,
+        right: x + width
+      };
+      const nextSelectingZone2 = restrictZone(areaToZone(selectingArea));
+      newSheet = dstSheet.writeRawCellMatrix({
+        point: { y, x },
+        matrix,
+        onlyValue,
+        undoReflection: compactReflection({
+          sheetId: dstSheet.id,
+          selectingZone: nextSelectingZone2,
+          choosing
+        }),
+        redoReflection: compactReflection({
+          sheetId: dstSheet.id,
+          selectingZone: nextSelectingZone2,
+          choosing
+        })
+      });
+    } else {
+      if (srcSheet == null) {
+        return store;
+      }
+      let { rows: dy, cols: dx } = areaDiff(copyingArea);
+      if (selectingArea.top !== -1) {
+        y = selectingArea.top;
+        x = selectingArea.left;
+        const superposed = superposeArea(selectingArea, copyingArea);
+        dy = superposed.rows;
+        dx = superposed.cols;
+      }
+      selectingArea = { top: y, left: x, bottom: y + dy, right: x + dx };
+      newSheet = dstSheet.copy({
+        srcSheet,
+        src: copyingArea,
+        dst: selectingArea,
+        onlyValue,
+        operator: "USER",
+        undoReflection: compactReflection({
+          sheetId: srcSheet.id,
+          transmit: { copyingZone },
+          choosing,
+          selectingZone
+        }),
+        redoReflection: compactReflection({
+          sheetId: srcSheet.id,
+          transmit: { copyingSheetId: srcSheet.id, copyingZone: resetZone },
+          choosing,
+          selectingZone: areaToZone(selectingArea)
+        })
+      });
+    }
+    const nextSelectingZone = restrictZone(areaToZone(selectingArea));
+    nextSelectingZone.endX = Math.min(nextSelectingZone.endX, newSheet.numCols);
+    nextSelectingZone.endY = Math.min(nextSelectingZone.endY, newSheet.numRows);
+    return {
+      ...store,
+      sheetReactive: { current: newSheet },
+      selectingZone: nextSelectingZone,
+      inputting: newSheet.getSerializedValue({ point: choosing, resolution: "RAW" }),
+      ...initSearchStatement(newSheet, store),
+      callback: ({ sheetReactive: sheetRef }) => {
+        registry.transmit({
+          copyingZone: resetZone
+        });
+      }
+    };
+  }
+}
+const paste = new PasteAction().bind();
+class EscapeAction extends CoreAction {
+  reduce(store, payload) {
+    const { sheetReactive: sheetRef } = store;
+    return {
+      ...store,
+      editingAddress: "",
+      leftHeaderSelecting: false,
+      topHeaderSelecting: false,
+      callback: ({ sheetReactive: sheetRef2 }) => {
+        sheetRef2.current.registry.transmit({
+          copyingZone: resetZone,
+          cutting: 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 sheet = store.sheetReactive.current;
+    const selectingZone = {
+      startY: start,
+      startX: 1,
+      endY: end,
+      endX: numCols
+    };
+    let choosingY = start;
+    if (sheet) {
+      for (let y = start; y <= end; y++) {
+        if (!sheet.isRowFiltered(y)) {
+          choosingY = y;
+          break;
+        }
+      }
+    }
+    return {
+      ...store,
+      selectingZone,
+      choosing: { y: choosingY, x: 1 },
+      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 sheet = store.sheetReactive.current;
+    const selectingZone = {
+      startY: 1,
+      startX: start,
+      endY: numRows,
+      endX: end
+    };
+    let choosingY = 1;
+    if (sheet) {
+      for (let y = 1; y <= numRows; y++) {
+        if (!sheet.isRowFiltered(y)) {
+          choosingY = y;
+          break;
+        }
+      }
+    }
+    return {
+      ...store,
+      selectingZone,
+      choosing: { y: choosingY, 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
+    };
+    if (startY === payload.y && startX === payload.x) {
+      selectingZone.endY = -1;
+      selectingZone.endX = -1;
+    }
+    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) {
+    let { value, point } = payload;
+    const { choosing, selectingZone, sheetReactive: sheetRef } = store;
+    if (point == null) {
+      point = choosing;
+    }
+    const sheet = sheetRef.current;
+    if (!sheet) {
+      return store;
+    }
+    const newSheet = sheet.write({
+      point,
+      value,
+      operator: "USER",
+      undoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing: point
+      }),
+      redoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing: point
+      })
+    });
+    return {
+      ...store,
+      ...initSearchStatement(newSheet, store),
+      sheetReactive: { current: newSheet },
+      callback: ({ sheetReactive: sheetRef2 }) => {
+        sheet.registry.transmit({
+          copyingZone: resetZone
+        });
+      }
+    };
+  }
+}
+const write = new WriteAction().bind();
+class ClearAction extends CoreAction {
+  reduce(store, payload) {
+    var _a;
+    const { choosing, selectingZone, sheetReactive: sheetRef } = store;
+    const sheet = sheetRef.current;
+    if (!sheet) {
+      return 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++) {
+      if (sheet.isRowFiltered(y)) {
+        continue;
+      }
+      for (let x = left; x <= right; x++) {
+        const cell = sheet.getCell({ y, x }, { resolution: "SYSTEM" });
+        const address = p2a({ y, x });
+        if (prevention.hasOperation(cell == null ? void 0 : cell.prevention, prevention.Write)) {
+          continue;
+        }
+        if (((_a = sheet.getSystem({ y, x })) == null ? void 0 : _a.spilledFrom) != null) {
+          continue;
+        }
+        if ((cell == null ? void 0 : cell.value) != null) {
+          diff[address] = { value: void 0 };
+          diffCount++;
+        }
+      }
+    }
+    if (diffCount === 0) {
+      return store;
+    }
+    sheet.update({
+      diff,
+      partial: true,
+      operator: "USER",
+      undoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      }),
+      redoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      })
+    });
+    return {
+      ...store,
+      ...initSearchStatement(sheet, store),
+      sheetReactive: { current: sheet }
+    };
+  }
+}
+const clear = new ClearAction().bind();
+class UndoAction extends CoreAction {
+  reduce(store, payload) {
+    const { sheetReactive: sheetRef } = store;
+    const sheet = sheetRef.current;
+    if (!sheet) {
+      return store;
+    }
+    const { history, callback } = sheet.undo();
+    if (history == null) {
+      return store;
+    }
+    if (history.dstSheetId !== sheet.id) {
+      const { dispatch, store: dstStore } = sheet.registry.contextsBySheetId[history.dstSheetId];
+      dispatch(
+        setStore({
+          ...dstStore,
+          ...history.undoReflection,
+          sheetReactive: { current: dstStore.sheetReactive.current }
+        })
+      );
+      flashSheet(dstStore.flashRef.current);
+      if (history.srcSheetId === sheet.id) {
+        return flashWithCallback(store, sheet, callback);
+      }
+      return store;
+    }
+    return {
+      ...store,
+      ...restrictPoints(store, sheet),
+      ...history.undoReflection,
+      ...initSearchStatement(sheet, store),
+      sheetReactive: { current: sheet },
+      callback: (s) => {
+        callback == null ? void 0 : callback(s);
+        flashSheet(store.flashRef.current);
+      }
+    };
+  }
+}
+const undo = new UndoAction().bind();
+class RedoAction extends CoreAction {
+  reduce(store, payload) {
+    const { sheetReactive: sheetRef } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    const { history, newSheet, callback } = sheet.redo();
+    if (history == null) {
+      return store;
+    }
+    if (history.dstSheetId !== sheet.id) {
+      const { dispatch, store: dstStore } = sheet.registry.contextsBySheetId[history.dstSheetId];
+      dispatch(
+        setStore({
+          ...dstStore,
+          ...history.redoReflection,
+          sheetReactive: { current: dstStore.sheetReactive.current }
+        })
+      );
+      flashSheet(dstStore.flashRef.current);
+      if (history.srcSheetId === sheet.id) {
+        return flashWithCallback(store, sheet, callback);
+      }
+      return store;
+    }
+    return {
+      ...store,
+      ...restrictPoints(store, sheet),
+      ...history.redoReflection,
+      ...initSearchStatement(sheet, store),
+      sheetReactive: { current: sheet },
+      callback: (s) => {
+        callback == null ? void 0 : callback(s);
+        flashSheet(store.flashRef.current);
+      }
+    };
+  }
+}
+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, sheetReactive: sheetRef, tabularRef } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return 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 resolvedY = nextY;
+    if (sheet.isRowFiltered(resolvedY)) {
+      const dir = deltaY >= 0 ? 1 : -1;
+      while (resolvedY >= 1 && resolvedY <= numRows && sheet.isRowFiltered(resolvedY)) {
+        resolvedY += dir;
+      }
+      if (resolvedY < 1 || resolvedY > numRows) {
+        return store;
+      }
+    }
+    let { y: editorTop, x: editorLeft, height, width } = store.editorRect;
+    if (deltaY > 0) {
+      for (let i = y; i < resolvedY; i++) {
+        editorTop += ((_a = sheet.getCell({ y: i, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : _a.height) || DEFAULT_HEIGHT;
+      }
+    } else if (deltaY < 0) {
+      for (let i = y - 1; i >= resolvedY; i--) {
+        editorTop -= ((_b = sheet.getCell({ y: i, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : _b.height) || DEFAULT_HEIGHT;
+      }
+    }
+    if (deltaX > 0) {
+      for (let i = x; i < nextX; i++) {
+        editorLeft += ((_c = sheet.getCell({ y: 0, x: i }, { resolution: "SYSTEM" })) == null ? void 0 : _c.width) || DEFAULT_WIDTH;
+      }
+    } else if (deltaX < 0) {
+      for (let i = x - 1; i >= nextX; i--) {
+        editorLeft -= ((_d = sheet.getCell({ y: 0, x: i }, { resolution: "SYSTEM" })) == null ? void 0 : _d.width) || DEFAULT_WIDTH;
+      }
+    }
+    const cell = sheet.getCell({ y: resolvedY, x: nextX }, { resolution: "SYSTEM" });
+    height = (cell == null ? void 0 : cell.height) || DEFAULT_HEIGHT;
+    width = (cell == null ? void 0 : cell.width) || DEFAULT_WIDTH;
+    smartScroll(sheet, tabularRef.current, { y: resolvedY, x: nextX });
+    return {
+      ...store,
+      selectingZone: { startY: -1, startX: -1, endY: -1, endX: -1 },
+      choosing: { y: resolvedY, 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, sheetReactive: sheetRef, tabularRef: gridOuterRef } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return 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 (sheet.isRowFiltered(nextY)) {
+      const dir = deltaY >= 0 ? 1 : -1;
+      const lo = top !== -1 ? top : 1;
+      const hi = bottom !== -1 ? bottom : numRows;
+      while (nextY >= lo && nextY <= hi && sheet.isRowFiltered(nextY)) {
+        nextY += dir;
+      }
+      if (nextY < lo || nextY > hi || sheet.isRowFiltered(nextY)) {
+        return store;
+      }
+    }
+    if (deltaY > 0) {
+      for (let i = y; i < nextY; i++) {
+        editorTop += ((_a = sheet.getCell({ y: i, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : _a.height) || DEFAULT_HEIGHT;
+      }
+    } else if (deltaY < 0) {
+      for (let i = y - 1; i >= nextY; i--) {
+        editorTop -= ((_b = sheet.getCell({ y: i, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : _b.height) || DEFAULT_HEIGHT;
+      }
+    }
+    if (deltaX > 0) {
+      for (let i = x; i < nextX; i++) {
+        editorLeft += ((_c = sheet.getCell({ y: 0, x: i }, { resolution: "SYSTEM" })) == null ? void 0 : _c.width) || DEFAULT_WIDTH;
+      }
+    } else if (deltaX < 0) {
+      for (let i = x - 1; i >= nextX; i--) {
+        editorLeft -= ((_d = sheet.getCell({ y: 0, x: i }, { resolution: "SYSTEM" })) == null ? void 0 : _d.width) || DEFAULT_WIDTH;
+      }
+    }
+    const cell = sheet.getCell({ y: nextY, x: nextX }, { resolution: "SYSTEM" });
+    height = (cell == null ? void 0 : cell.height) || DEFAULT_HEIGHT;
+    width = (cell == null ? void 0 : cell.width) || DEFAULT_WIDTH;
+    smartScroll(sheet, 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 SetInputtingAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      inputting: payload
+    };
+  }
+}
+const setInputting = new SetInputtingAction().bind();
+class InsertRowsAboveAction extends CoreAction {
+  reduce(store, payload) {
+    const { numRows, y, operator } = payload;
+    const { sheetReactive: sheetRef, selectingZone, choosing } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    sheet.insertRows({
+      y,
+      numRows,
+      baseY: y,
+      operator,
+      undoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      }),
+      redoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      })
+    });
+    return {
+      ...store,
+      sheetReactive: { current: sheet }
+    };
+  }
+}
+const insertRowsAbove = new InsertRowsAboveAction().bind();
+class InsertRowsBelowAction extends CoreAction {
+  reduce(store, payload) {
+    const { numRows, y, operator } = payload;
+    const { sheetReactive: sheetRef, selectingZone, choosing, editorRef } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    const nextSelectingZone = {
+      ...selectingZone,
+      startY: selectingZone.startY + numRows,
+      endY: selectingZone.endY + numRows
+    };
+    const nextChoosing = { ...choosing, y: choosing.y + numRows };
+    sheet.insertRows({
+      y: y + 1,
+      numRows,
+      baseY: y,
+      operator,
+      undoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      }),
+      redoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone: nextSelectingZone,
+        choosing: nextChoosing
+      })
+    });
+    return {
+      ...store,
+      selectingZone: nextSelectingZone,
+      choosing: nextChoosing,
+      sheetReactive: { current: sheet }
+    };
+  }
+}
+const insertRowsBelow = new InsertRowsBelowAction().bind();
+class InsertColsLeftAction extends CoreAction {
+  reduce(store, payload) {
+    const { numCols, x, operator } = payload;
+    const { sheetReactive: sheetRef, selectingZone, choosing, editorRef } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    sheet.insertCols({
+      x,
+      numCols,
+      baseX: x,
+      operator,
+      undoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      }),
+      redoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      })
+    });
+    return {
+      ...store,
+      sheetReactive: { current: sheet }
+    };
+  }
+}
+const insertColsLeft = new InsertColsLeftAction().bind();
+class InsertColsRightAction extends CoreAction {
+  reduce(store, payload) {
+    const { numCols, x, operator } = payload;
+    const { sheetReactive: sheetRef, selectingZone, choosing } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    const nextSelectingZone = {
+      ...selectingZone,
+      startX: selectingZone.startX + numCols,
+      endX: selectingZone.endX + numCols
+    };
+    const nextChoosing = { ...choosing, x: choosing.x + numCols };
+    selectingZone.startX += numCols;
+    selectingZone.endX += numCols;
+    sheet.insertCols({
+      x: x + 1,
+      numCols,
+      baseX: x,
+      operator,
+      undoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      }),
+      redoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone: nextSelectingZone,
+        choosing: nextChoosing
+      })
+    });
+    return {
+      ...store,
+      selectingZone: nextSelectingZone,
+      choosing: nextChoosing,
+      sheetReactive: { current: sheet }
+    };
+  }
+}
+const insertColsRight = new InsertColsRightAction().bind();
+class RemoveRowsAction extends CoreAction {
+  reduce(store, payload) {
+    const { numRows, y, operator } = payload;
+    const { sheetReactive: sheetRef, selectingZone, choosing, editorRef } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    sheet.removeRows({
+      y,
+      numRows,
+      operator,
+      undoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing,
+        sheetHeight: store.sheetHeight
+      }),
+      redoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      })
+    });
+    return {
+      ...store,
+      sheetReactive: { current: sheet }
+    };
+  }
+}
+const removeRows = new RemoveRowsAction().bind();
+class RemoveColsAction extends CoreAction {
+  reduce(store, payload) {
+    const { numCols, x, operator } = payload;
+    const { sheetReactive: sheetRef, selectingZone, choosing, editorRef } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    sheet.removeCols({
+      x,
+      numCols,
+      operator,
+      undoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing,
+        sheetWidth: store.sheetWidth
+      }),
+      redoReflection: compactReflection({
+        sheetId: sheet.id,
+        selectingZone,
+        choosing
+      })
+    });
+    return {
+      ...store,
+      sheetReactive: { current: sheet }
+    };
+  }
+}
+const removeCols = new RemoveColsAction().bind();
+class SortRowsAction extends CoreAction {
+  reduce(store, payload) {
+    const { x, direction } = payload;
+    const { sheetReactive: sheetRef, selectingZone, choosing } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    sheet.sortRows({ x, direction });
+    const reflection = compactReflection({ sheetId: sheet.id, selectingZone, choosing });
+    if (sheet.registry.lastHistory) {
+      sheet.registry.lastHistory.undoReflection = reflection;
+      sheet.registry.lastHistory.redoReflection = reflection;
+    }
+    return {
+      ...store,
+      sheetReactive: { current: sheet }
+    };
+  }
+}
+const sortRows = new SortRowsAction().bind();
+class FilterRowsAction extends CoreAction {
+  reduce(store, payload) {
+    const { x, filter } = payload;
+    const { sheetReactive: sheetRef, selectingZone, choosing } = store;
+    const sheet = sheetRef.current;
+    if (sheet == null) {
+      return store;
+    }
+    sheet.filterRows({ x, filter });
+    const reflection = compactReflection({ sheetId: sheet.id, selectingZone, choosing });
+    if (sheet.registry.lastHistory) {
+      sheet.registry.lastHistory.undoReflection = reflection;
+      sheet.registry.lastHistory.redoReflection = reflection;
+    }
+    let newChoosing = choosing;
+    if (sheet.isRowFiltered(choosing.y)) {
+      for (let y = 1; y <= sheet.numRows; y++) {
+        if (!sheet.isRowFiltered(y)) {
+          newChoosing = { y, x: choosing.x };
+          break;
+        }
+      }
+    }
+    return {
+      ...store,
+      choosing: newChoosing,
+      selectingZone: newChoosing !== choosing ? resetZone : selectingZone,
+      sheetReactive: { current: sheet },
+      callback: ({ sheetReactive: sheetRef2 }) => {
+        const t = sheetRef2.current;
+        if (t) {
+          t.registry.transmit({
+            cutting: false,
+            copyingZone: resetZone
+          });
+        }
+      }
+    };
+  }
+}
+const filterRows = new FilterRowsAction().bind();
+class SetColumnMenuAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      columnMenuState: payload
+    };
+  }
+}
+const setColumnMenu = new SetColumnMenuAction().bind();
+class SetRowMenuAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      rowMenuState: payload
+    };
+  }
+}
+const setRowMenu = new SetRowMenuAction().bind();
+class SetEditorHoveringAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      editorHovering: payload
+    };
+  }
+}
+const setEditorHovering = new SetEditorHoveringAction().bind();
+class setStoreAction extends CoreAction {
+  reduce(store, payload) {
+    return {
+      ...store,
+      ...payload
+    };
+  }
+}
+const setStore = new setStoreAction().bind();
+const userActions = {
+  blur,
+  copy,
+  cut,
+  paste,
+  escape,
+  choose,
+  select,
+  selectRows,
+  selectCols,
+  drag,
+  search,
+  write,
+  clear,
+  undo,
+  redo,
+  arrow,
+  walk,
+  insertRowsAbove,
+  insertRowsBelow,
+  insertColsLeft,
+  insertColsRight,
+  removeRows,
+  removeCols,
+  sortRows,
+  filterRows
+};
+const useBrowser = () => {
+  const [ok, setOk] = useState(false);
+  useEffect(() => {
+    setOk(true);
+  }, []);
+  if (ok && typeof window !== "undefined") {
+    return { window, document };
+  }
+  return { window: null, document: null };
+};
+const useDebounceCallback = (callback, delay = 100) => {
+  const debouncedCallback = useRef(callback);
+  const timerRef = useRef();
+  useEffect(() => {
+    debouncedCallback.current = callback;
+  }, [callback]);
+  return (...args) => {
+    window.clearTimeout(timerRef.current);
+    timerRef.current = window.setTimeout(() => {
+      debouncedCallback.current(...args);
+    }, delay);
+  };
+};
+const useBook = (props = {}) => {
+  const [book, setBook] = useState(() => createBook(props));
+  const { registry } = book;
+  registry.updateSheet = updateSheet;
+  registry.transmit = (patch) => {
+    Object.assign(registry, patch);
+    if (!registry.ready) {
+      return;
+    }
+    requestAnimationFrame(() => setBook({ registry }));
+  };
+  useEffect(() => {
+    Object.assign(registry, props);
+  }, [props]);
+  return book;
+};
+export {
+  insertColsLeft as A,
+  insertRowsBelow as B,
+  insertRowsAbove as C,
+  setContextMenuPosition as D,
+  setColumnMenu as E,
+  setRowMenu as F,
+  isXSheetFocused as G,
+  setEditorRect as H,
+  choose as I,
+  drag as J,
+  setDragging as K,
+  submitAutofill as L,
+  setAutofillDraggingTo as M,
+  selectCols as N,
+  useDebounceCallback as O,
+  selectRows as P,
+  search as Q,
+  setSearchCaseSensitive as R,
+  setSearchRegex as S,
+  setSearchRange as T,
+  useBook as U,
+  reducer as V,
+  userActions as W,
+  setInputting as a,
+  updateSheet as b,
+  undo as c,
+  cut as d,
+  setSearchQuery as e,
+  setEntering as f,
+  copy as g,
+  select as h,
+  arrow as i,
+  escape as j,
+  clear as k,
+  walk as l,
+  setEditorHovering as m,
+  setStore as n,
+  setResizingPositionY as o,
+  paste as p,
+  setResizingPositionX as q,
+  redo as r,
+  setEditingAddress as s,
+  filterRows as t,
+  useBrowser as u,
+  sortRows as v,
+  write as w,
+  removeCols as x,
+  removeRows as y,
+  insertColsRight as z
+};
+//# sourceMappingURL=hooks-hS8l-fYa.mjs.map