@gridsheet/preact-core 3.2.0 → 3.3.0

package/dist/hooks-ykrgAwg5.mjs

@@ -1,1533 +0,0 @@
-import { useRef, useEffect, useState } from "preact/compat";
-import { x2c, y2r, a2p, Autofill, areaToZone, zoneToArea, areaDiff, restrictZone, matrixShape, superposeArea, p2a, operations, DEFAULT_HEIGHT, DEFAULT_WIDTH, smartScroll, createBook } from "@gridsheet/core";
-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;
-    this.mutation = false;
-  }
-  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;
-const isMutationAction = (type) => {
-  var _a;
-  return ((_a = actions[type]) == null ? void 0 : _a.mutation) === true;
-};
-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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 (operations.hasOperation(cell == null ? void 0 : cell.prevention, operations.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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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
-      })
-    });
-    const numRows2 = sheet.numRows;
-    const numCols2 = sheet.numCols;
-    let adjY = Math.max(1, Math.min(y, numRows2));
-    if (sheet.isRowFiltered(adjY)) {
-      let found = -1;
-      for (let yy = adjY; yy <= numRows2; yy++) {
-        if (!sheet.isRowFiltered(yy)) {
-          found = yy;
-          break;
-        }
-      }
-      if (found === -1) {
-        for (let yy = adjY; yy >= 1; yy--) {
-          if (!sheet.isRowFiltered(yy)) {
-            found = yy;
-            break;
-          }
-        }
-      }
-      if (found !== -1) {
-        adjY = found;
-      }
-    }
-    return {
-      ...store,
-      sheetReactive: { current: sheet },
-      selectingZone: { startY: adjY, startX: 1, endY: adjY, endX: numCols2 },
-      choosing: { y: adjY, x: 1 },
-      leftHeaderSelecting: true,
-      topHeaderSelecting: false
-    };
-  }
-}
-const removeRows = new RemoveRowsAction().bind();
-class RemoveColsAction extends CoreAction {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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
-      })
-    });
-    const numCols2 = sheet.numCols;
-    const numRows2 = sheet.numRows;
-    const adjX = Math.max(1, Math.min(x, numCols2));
-    let choosingY = 1;
-    for (let yy = 1; yy <= numRows2; yy++) {
-      if (!sheet.isRowFiltered(yy)) {
-        choosingY = yy;
-        break;
-      }
-    }
-    return {
-      ...store,
-      sheetReactive: { current: sheet },
-      selectingZone: { startY: 1, startX: adjX, endY: numRows2, endX: adjX },
-      choosing: { y: choosingY, x: adjX },
-      leftHeaderSelecting: false,
-      topHeaderSelecting: true
-    };
-  }
-}
-const removeCols = new RemoveColsAction().bind();
-class SortRowsAction extends CoreAction {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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 {
-  constructor() {
-    super(...arguments);
-    this.mutation = true;
-  }
-  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,
-  isMutationAction as W,
-  userActions as X,
-  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-ykrgAwg5.mjs.map