@gridsheet/react-core 3.0.5 → 3.0.7

package/dist/hooks-CvkA2lFB.mjs

@@ -0,0 +1,1186 @@
+import { useRef as V, useEffect as O, useState as N } from "react";
+import { x2c as ne, y2r as se, a2p as $, Autofill as ie, areaToZone as L, zoneToArea as z, areaDiff as G, restrictZone as U, matrixShape as oe, superposeArea as re, p2a as ce, operations as K, DEFAULT_HEIGHT as F, DEFAULT_WIDTH as k, smartScroll as J, createBook as ae } from "@gridsheet/core";
+const p = (o) => {
+  const e = { ...o };
+  return e.selectingZone != null && e.selectingZone.endY === -1 && e.selectingZone.endX === -1 && delete e.selectingZone, e;
+}, W = (o, e) => {
+  const { choosing: s, selectingZone: t } = o;
+  let { y: n, x: i } = s, { startY: r, startX: a, endY: c, endX: d } = t;
+  const [l, u] = [e.numRows, e.numCols];
+  return n > l && (n = l), i > u && (i = u), r > l && (r = l), c > l && (c = l), a > u && (a = u), d > u && (d = u), {
+    choosing: { y: n, x: i },
+    selectingZone: { startY: r, startX: a, endY: c, endX: d }
+  };
+}, _ = "gs-flash-overlay--active", le = 600, D = (o) => {
+  o && (o.classList.remove(_), o.offsetWidth, o.classList.add(_), setTimeout(() => o.classList.remove(_), le));
+}, ee = (o, e, s) => ({
+  ...o,
+  sheetReactive: { current: e },
+  callback: (t) => {
+    s == null || s(t), D(o.flashRef.current);
+  }
+}), M = (o, e) => {
+  const { searchQuery: s, searchCaseSensitive: t, searchRegex: n, searchRange: i } = e;
+  let { choosing: r } = e;
+  if (!s)
+    return { matchingCells: [] };
+  const a = [];
+  let c;
+  if (n)
+    try {
+      const R = t ? "" : "i", h = new RegExp(s, R);
+      c = (w) => h.test(w);
+    } catch {
+      const h = t ? s : s.toLowerCase();
+      c = (w) => (t ? w : w.toLowerCase()).indexOf(h) !== -1;
+    }
+  else {
+    const R = t ? s : s.toLowerCase();
+    c = (h) => (t ? h : h.toLowerCase()).indexOf(R) !== -1;
+  }
+  let d = 1, l = o.bottom, u = 1, g = o.right;
+  i && (d = i.startY, l = i.endY, u = i.startX, g = i.endX);
+  for (let R = d; R <= l; R++)
+    for (let h = u; h <= g; h++) {
+      const w = o.getSerializedValue({ point: { y: R, x: h } });
+      c(w) && a.push(`${ne(h)}${se(R)}`);
+    }
+  const S = a.length === e.matchingCells.length ? e.matchingCellIndex : 0;
+  if (a.length > 0) {
+    const R = a[S];
+    r = $(R);
+  }
+  return { matchingCells: a, searchQuery: s, matchingCellIndex: S, choosing: r };
+}, Zt = (o) => {
+  const { sheetId: e, sheetReactive: s } = o, t = s.current;
+  return !t || e === t.registry.editingSheetId ? !1 : !!t.registry.editingAddress;
+}, E = { startY: -1, startX: -1, endY: -1, endX: -1 }, j = {}, Xt = (o, e) => {
+  var a, c;
+  const s = j[e.type];
+  if (s == null)
+    return o;
+  const t = (a = o.sheetReactive.current) == null ? void 0 : a.registry;
+  if ((c = t == null ? void 0 : t._strictModeCache) != null && c.has(e)) {
+    const d = t._strictModeCache.get(e);
+    return t._strictModeCache.delete(e), d;
+  }
+  const { callback: n, ...i } = s.reduce(o, e.value);
+  n == null || n(i);
+  const r = { ...o, ...i };
+  return t && (t._strictModeCache || (t._strictModeCache = /* @__PURE__ */ new Map()), t._strictModeCache.set(e, r), queueMicrotask(() => {
+    var d;
+    (d = t._strictModeCache) == null || d.delete(e);
+  })), r;
+}, B = class B {
+  constructor() {
+    this.actionId = 1, this.mutation = !1;
+  }
+  reduce(e, s) {
+    return e;
+  }
+  call(e) {
+    return {
+      type: this.actionId,
+      value: e
+    };
+  }
+  bind() {
+    return this.actionId = B.head++, j[this.actionId] = this, this.call.bind(this);
+  }
+};
+B.head = 1;
+let f = B;
+const Mt = (o) => {
+  var e;
+  return ((e = j[o]) == null ? void 0 : e.mutation) === !0;
+};
+class ue extends f {
+  reduce(e, s) {
+    const t = s, { sheetReactive: n } = e;
+    return n.current == null ? e : {
+      ...e,
+      ...M(n.current, { ...e, searchQuery: t }),
+      searchQuery: t
+    };
+  }
+}
+const Et = new ue().bind();
+class de extends f {
+  reduce(e, s) {
+    const t = s, { sheetReactive: n } = e;
+    return n.current == null ? e : {
+      ...e,
+      ...M(n.current, { ...e, searchCaseSensitive: t }),
+      searchCaseSensitive: t
+    };
+  }
+}
+const Ht = new de().bind();
+class he extends f {
+  reduce(e, s) {
+    const t = s, { sheetReactive: n } = e;
+    return n.current == null ? e : {
+      ...e,
+      ...M(n.current, { ...e, searchRegex: t }),
+      searchRegex: t
+    };
+  }
+}
+const Tt = new he().bind();
+class fe extends f {
+  reduce(e, s) {
+    const t = s, { sheetReactive: n } = e;
+    return n.current == null ? e : {
+      ...e,
+      ...M(n.current, { ...e, searchRange: t }),
+      searchRange: t
+    };
+  }
+}
+const Ft = new fe().bind();
+class ge extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      editingAddress: s
+    };
+  }
+}
+const kt = new ge().bind();
+class Re extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      autofillDraggingTo: s
+    };
+  }
+}
+const Lt = new Re().bind();
+class we extends f {
+  reduce(e, s) {
+    const t = new ie(e, s), n = t.applied, i = L(t.wholeArea);
+    return {
+      ...e,
+      sheetReactive: { current: n },
+      ...M(n, e),
+      ...W(e, n),
+      selectingZone: i,
+      leftHeaderSelecting: !1,
+      topHeaderSelecting: !1,
+      autofillDraggingTo: null
+    };
+  }
+}
+const Dt = new we().bind();
+class Se extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      contextMenuPosition: s
+    };
+  }
+}
+const Pt = new Se().bind();
+class xe extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      resizingPositionY: s
+    };
+  }
+}
+const zt = new xe().bind();
+class me extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      resizingPositionX: s
+    };
+  }
+}
+const Bt = new me().bind();
+class ye extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      entering: s
+    };
+  }
+}
+const Wt = new ye().bind();
+class pe extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      sheetReactive: { current: s },
+      ...M(s, e),
+      ...W(e, s)
+    };
+  }
+}
+const ve = new pe().bind();
+class be extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      editorRect: s
+    };
+  }
+}
+const Ut = new be().bind();
+class Ae extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      dragging: s
+    };
+  }
+}
+const _t = new Ae().bind();
+class Ce extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      editingAddress: ""
+    };
+  }
+}
+const Ye = new Ce().bind();
+class Ie extends f {
+  reduce(e, s) {
+    const { sheetReactive: t } = e, n = t.current;
+    return n ? {
+      ...e,
+      callback: ({ sheetReactive: i }) => {
+        n.registry.transmit({
+          copyingSheetId: n.id,
+          copyingZone: s,
+          cutting: !1
+        });
+      }
+    } : e;
+  }
+}
+const Ze = new Ie().bind();
+class Xe extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { sheetReactive: t } = e, n = t.current;
+    return n ? {
+      ...e,
+      callback: ({ sheetReactive: i }) => {
+        n.registry.transmit({
+          copyingSheetId: n.id,
+          copyingZone: s,
+          cutting: !0
+        });
+      }
+    } : e;
+  }
+}
+const Me = new Xe().bind();
+class Ee extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { choosing: t, selectingZone: n, sheetReactive: i } = e, r = i.current;
+    if (!r)
+      return e;
+    const { registry: a } = r, { copyingSheetId: c, copyingZone: d, cutting: l } = a, u = r.getSheetBySheetId(c);
+    let g = z(n);
+    const S = z(d), { matrix: R, onlyValue: h } = s;
+    if (l) {
+      if (!u)
+        return e;
+      const I = S, { rows: C, cols: v } = G(S), x = g.top !== -1 ? {
+        top: g.top,
+        left: g.left,
+        bottom: g.top + C,
+        right: g.left + v
+      } : {
+        top: t.y,
+        left: t.x,
+        bottom: t.y + C,
+        right: t.x + v
+      }, y = U(L(x)), X = r.move({
+        srcSheet: u,
+        src: I,
+        dst: x,
+        operator: "USER",
+        undoReflection: p({
+          sheetId: u.id,
+          selectingZone: y,
+          choosing: t,
+          transmit: { copyingSheetId: u.id, copyingZone: d, cutting: !0 }
+        }),
+        redoReflection: p({
+          sheetId: u.id,
+          choosing: t,
+          transmit: { copyingSheetId: u.id, copyingZone: E }
+        })
+      });
+      return {
+        ...e,
+        ...M(X, e),
+        sheetReactive: { current: X },
+        selectingZone: y,
+        inputting: X.getSerializedValue({ point: t, resolution: "RAW" }),
+        callback: ({ sheetReactive: T }) => {
+          a.transmit({
+            cutting: !1,
+            copyingZone: E
+          });
+        }
+      };
+    }
+    let w, { y: m, x: Z } = t;
+    if (S.top === -1) {
+      const { rows: I, cols: C } = oe({ matrix: R, base: -1 });
+      g = {
+        top: m,
+        left: Z,
+        bottom: m + I,
+        right: Z + C
+      };
+      const v = U(L(g));
+      w = r.writeRawCellMatrix({
+        point: { y: m, x: Z },
+        matrix: R,
+        onlyValue: h,
+        undoReflection: p({
+          sheetId: r.id,
+          selectingZone: v,
+          choosing: t
+        }),
+        redoReflection: p({
+          sheetId: r.id,
+          selectingZone: v,
+          choosing: t
+        })
+      });
+    } else {
+      if (u == null)
+        return e;
+      let { rows: I, cols: C } = G(S);
+      if (g.top !== -1) {
+        m = g.top, Z = g.left;
+        const v = re(g, S);
+        I = v.rows, C = v.cols;
+      }
+      g = { top: m, left: Z, bottom: m + I, right: Z + C }, w = r.copy({
+        srcSheet: u,
+        src: S,
+        dst: g,
+        onlyValue: h,
+        operator: "USER",
+        undoReflection: p({
+          sheetId: u.id,
+          transmit: { copyingZone: d },
+          choosing: t,
+          selectingZone: n
+        }),
+        redoReflection: p({
+          sheetId: u.id,
+          transmit: { copyingSheetId: u.id, copyingZone: E },
+          choosing: t,
+          selectingZone: L(g)
+        })
+      });
+    }
+    const Y = U(L(g));
+    return Y.endX = Math.min(Y.endX, w.numCols), Y.endY = Math.min(Y.endY, w.numRows), {
+      ...e,
+      sheetReactive: { current: w },
+      selectingZone: Y,
+      inputting: w.getSerializedValue({ point: t, resolution: "RAW" }),
+      ...M(w, e),
+      callback: ({ sheetReactive: I }) => {
+        a.transmit({
+          copyingZone: E
+        });
+      }
+    };
+  }
+}
+const He = new Ee().bind();
+class Te extends f {
+  reduce(e, s) {
+    const { sheetReactive: t } = e;
+    return {
+      ...e,
+      editingAddress: "",
+      leftHeaderSelecting: !1,
+      topHeaderSelecting: !1,
+      callback: ({ sheetReactive: n }) => {
+        n.current.registry.transmit({
+          copyingZone: E,
+          cutting: !1
+        });
+      }
+    };
+  }
+}
+const Fe = new Te().bind();
+class ke extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      choosing: s,
+      entering: !0
+    };
+  }
+}
+const Le = new ke().bind();
+class De extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      selectingZone: s,
+      leftHeaderSelecting: !1,
+      topHeaderSelecting: !1
+    };
+  }
+}
+const Pe = new De().bind();
+class ze extends f {
+  reduce(e, s) {
+    const { range: t, numCols: n } = s, { start: i, end: r } = t, a = e.sheetReactive.current, c = {
+      startY: i,
+      startX: 1,
+      endY: r,
+      endX: n
+    };
+    let d = i;
+    if (a) {
+      for (let l = i; l <= r; l++)
+        if (!a.isRowFiltered(l)) {
+          d = l;
+          break;
+        }
+    }
+    return {
+      ...e,
+      selectingZone: c,
+      choosing: { y: d, x: 1 },
+      leftHeaderSelecting: !0,
+      topHeaderSelecting: !1
+    };
+  }
+}
+const Be = new ze().bind();
+class We extends f {
+  reduce(e, s) {
+    const { range: t, numRows: n } = s, { start: i, end: r } = t, a = e.sheetReactive.current, c = {
+      startY: 1,
+      startX: i,
+      endY: n,
+      endX: r
+    };
+    let d = 1;
+    if (a) {
+      for (let l = 1; l <= n; l++)
+        if (!a.isRowFiltered(l)) {
+          d = l;
+          break;
+        }
+    }
+    return {
+      ...e,
+      selectingZone: c,
+      choosing: { y: d, x: i },
+      leftHeaderSelecting: !1,
+      topHeaderSelecting: !0
+    };
+  }
+}
+const Ue = new We().bind();
+class _e extends f {
+  reduce(e, s) {
+    const { startY: t, startX: n } = e.selectingZone, i = {
+      startY: t,
+      startX: n,
+      endY: s.y,
+      endX: s.x
+    };
+    return t === s.y && n === s.x && (i.endY = -1, i.endX = -1), { ...e, selectingZone: i };
+  }
+}
+const Oe = new _e().bind();
+class je extends f {
+  reduce(e, s) {
+    const { matchingCells: t } = e;
+    let { matchingCellIndex: n, choosing: i } = e;
+    if (n += s, n >= t.length ? n = 0 : n < 0 && (n = t.length - 1), t.length > 0) {
+      const r = t[n];
+      i = $(r);
+    }
+    return { ...e, matchingCells: t, matchingCellIndex: n, choosing: i };
+  }
+}
+const qe = new je().bind();
+class Qe extends f {
+  reduce(e, s) {
+    let { value: t, point: n } = s;
+    const { choosing: i, selectingZone: r, sheetReactive: a } = e;
+    n == null && (n = i);
+    const c = a.current;
+    if (!c)
+      return e;
+    const d = c.write({
+      point: n,
+      value: t,
+      operator: "USER",
+      undoReflection: p({
+        sheetId: c.id,
+        selectingZone: r,
+        choosing: n
+      }),
+      redoReflection: p({
+        sheetId: c.id,
+        selectingZone: r,
+        choosing: n
+      })
+    });
+    return {
+      ...e,
+      ...M(d, e),
+      sheetReactive: { current: d },
+      callback: ({ sheetReactive: l }) => {
+        c.registry.transmit({
+          copyingZone: E
+        });
+      }
+    };
+  }
+}
+const Ve = new Qe().bind();
+class Ge extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    var R;
+    const { choosing: t, selectingZone: n, sheetReactive: i } = e, r = i.current;
+    if (!r)
+      return e;
+    let a = z(n);
+    if (a.top === -1) {
+      const { y: h, x: w } = t;
+      a = { top: h, left: w, bottom: h, right: w };
+    }
+    const { top: c, left: d, bottom: l, right: u } = a, g = {};
+    let S = 0;
+    for (let h = c; h <= l; h++)
+      if (!r.isRowFiltered(h))
+        for (let w = d; w <= u; w++) {
+          const m = r.getCell({ y: h, x: w }, { resolution: "SYSTEM" }), Z = ce({ y: h, x: w });
+          K.hasOperation(m == null ? void 0 : m.prevention, K.Write) || ((R = r.getSystem({ y: h, x: w })) == null ? void 0 : R.spilledFrom) == null && (m == null ? void 0 : m.value) != null && (g[Z] = { value: void 0 }, S++);
+        }
+    return S === 0 ? e : (r.update({
+      diff: g,
+      partial: !0,
+      operator: "USER",
+      undoReflection: p({
+        sheetId: r.id,
+        selectingZone: n,
+        choosing: t
+      }),
+      redoReflection: p({
+        sheetId: r.id,
+        selectingZone: n,
+        choosing: t
+      })
+    }), {
+      ...e,
+      ...M(r, e),
+      sheetReactive: { current: r }
+    });
+  }
+}
+const Ke = new Ge().bind();
+class Ne extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { sheetReactive: t } = e, n = t.current;
+    if (!n)
+      return e;
+    const { history: i, callback: r } = n.undo();
+    if (i == null)
+      return e;
+    if (i.dstSheetId !== n.id) {
+      const { dispatch: a, store: c } = n.registry.contextsBySheetId[i.dstSheetId];
+      return a(
+        te({
+          ...c,
+          ...i.undoReflection,
+          sheetReactive: { current: c.sheetReactive.current }
+        })
+      ), D(c.flashRef.current), i.srcSheetId === n.id ? ee(e, n, r) : e;
+    }
+    return {
+      ...e,
+      ...W(e, n),
+      ...i.undoReflection,
+      ...M(n, e),
+      sheetReactive: { current: n },
+      callback: (a) => {
+        r == null || r(a), D(e.flashRef.current);
+      }
+    };
+  }
+}
+const $e = new Ne().bind();
+class Je extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { sheetReactive: t } = e, n = t.current;
+    if (n == null)
+      return e;
+    const { history: i, newSheet: r, callback: a } = n.redo();
+    if (i == null)
+      return e;
+    if (i.dstSheetId !== n.id) {
+      const { dispatch: c, store: d } = n.registry.contextsBySheetId[i.dstSheetId];
+      return c(
+        te({
+          ...d,
+          ...i.redoReflection,
+          sheetReactive: { current: d.sheetReactive.current }
+        })
+      ), D(d.flashRef.current), i.srcSheetId === n.id ? ee(e, n, a) : e;
+    }
+    return {
+      ...e,
+      ...W(e, n),
+      ...i.redoReflection,
+      ...M(n, e),
+      sheetReactive: { current: n },
+      callback: (c) => {
+        a == null || a(c), D(e.flashRef.current);
+      }
+    };
+  }
+}
+const et = new Je().bind();
+class tt extends f {
+  reduce(e, s) {
+    var x, y, X, T;
+    const { shiftKey: t, deltaY: n, deltaX: i, numRows: r, numCols: a } = s, { choosing: c, sheetReactive: d, tabularRef: l } = e, u = d.current;
+    if (u == null)
+      return e;
+    let { selectingZone: g } = e;
+    const { y: S, x: R } = c;
+    if (t) {
+      const [b, P] = [
+        g.endY === -1 ? S : g.endY,
+        g.endX === -1 ? R : g.endX
+      ], [H, A] = [b + n, P + i];
+      return H < 1 || r < H || A < 1 || a < A ? e : (g = S === H && R === A ? { startY: -1, startX: -1, endY: -1, endX: -1 } : { startY: S, startX: R, endY: H, endX: A }, {
+        ...e,
+        selectingZone: g
+      });
+    }
+    const [h, w] = [S + n, R + i];
+    if (h < 1 || r < h || w < 1 || a < w)
+      return e;
+    let m = h;
+    if (u.isRowFiltered(m)) {
+      const b = n >= 0 ? 1 : -1;
+      for (; m >= 1 && m <= r && u.isRowFiltered(m); )
+        m += b;
+      if (m < 1 || m > r)
+        return e;
+    }
+    let { y: Z, x: Y, height: I, width: C } = e.editorRect;
+    if (n > 0)
+      for (let b = S; b < m; b++)
+        Z += ((x = u.getCell({ y: b, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : x.height) || F;
+    else if (n < 0)
+      for (let b = S - 1; b >= m; b--)
+        Z -= ((y = u.getCell({ y: b, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : y.height) || F;
+    if (i > 0)
+      for (let b = R; b < w; b++)
+        Y += ((X = u.getCell({ y: 0, x: b }, { resolution: "SYSTEM" })) == null ? void 0 : X.width) || k;
+    else if (i < 0)
+      for (let b = R - 1; b >= w; b--)
+        Y -= ((T = u.getCell({ y: 0, x: b }, { resolution: "SYSTEM" })) == null ? void 0 : T.width) || k;
+    const v = u.getCell({ y: m, x: w }, { resolution: "SYSTEM" });
+    return I = (v == null ? void 0 : v.height) || F, C = (v == null ? void 0 : v.width) || k, J(u, l.current, { y: m, x: w }), {
+      ...e,
+      selectingZone: { startY: -1, startX: -1, endY: -1, endX: -1 },
+      choosing: { y: m, x: w },
+      editorRect: { y: Z, x: Y, height: I, width: C }
+    };
+  }
+}
+const nt = new tt().bind();
+class st extends f {
+  reduce(e, s) {
+    var T, b, P, H;
+    const { numRows: t, numCols: n } = s;
+    let { deltaY: i, deltaX: r } = s;
+    const { choosing: a, selectingZone: c, sheetReactive: d, tabularRef: l } = e, u = d.current;
+    if (u == null)
+      return e;
+    let { y: g, x: S, height: R, width: h } = e.editorRect;
+    const { y: w, x: m } = a, Z = z(c), { top: Y, left: I, bottom: C, right: v } = Z;
+    let [x, y] = [w + i, m + r];
+    if (x < Y && Y !== -1 && (i = C - x, x = C, y > I ? (y--, r--) : (r = v - y, y = v)), x > C && C !== -1 && (i = Y - x, x = Y, y < v ? (y++, r++) : (r = I - y, y = I)), y < I && I !== -1 && (r = v - y, y = v, x > Y ? (x--, i--) : (i = C - x, x = C)), y > v && v !== -1 && (r = I - y, y = I, x < C ? (x++, i++) : (i = Y - x, x = Y)), x < 1 || t < x || y < 1 || n < y)
+      return e;
+    if (u.isRowFiltered(x)) {
+      const A = i >= 0 ? 1 : -1, q = Y !== -1 ? Y : 1, Q = C !== -1 ? C : t;
+      for (; x >= q && x <= Q && u.isRowFiltered(x); )
+        x += A;
+      if (x < q || x > Q || u.isRowFiltered(x))
+        return e;
+    }
+    if (i > 0)
+      for (let A = w; A < x; A++)
+        g += ((T = u.getCell({ y: A, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : T.height) || F;
+    else if (i < 0)
+      for (let A = w - 1; A >= x; A--)
+        g -= ((b = u.getCell({ y: A, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : b.height) || F;
+    if (r > 0)
+      for (let A = m; A < y; A++)
+        S += ((P = u.getCell({ y: 0, x: A }, { resolution: "SYSTEM" })) == null ? void 0 : P.width) || k;
+    else if (r < 0)
+      for (let A = m - 1; A >= y; A--)
+        S -= ((H = u.getCell({ y: 0, x: A }, { resolution: "SYSTEM" })) == null ? void 0 : H.width) || k;
+    const X = u.getCell({ y: x, x: y }, { resolution: "SYSTEM" });
+    return R = (X == null ? void 0 : X.height) || F, h = (X == null ? void 0 : X.width) || k, J(u, l.current, { y: x, x: y }), {
+      ...e,
+      choosing: { y: x, x: y },
+      editorRect: { y: g, x: S, height: R, width: h }
+    };
+  }
+}
+const it = new st().bind();
+class ot extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      inputting: s
+    };
+  }
+}
+const Ot = new ot().bind();
+class rt extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { numRows: t, y: n, operator: i } = s, { sheetReactive: r, selectingZone: a, choosing: c } = e, d = r.current;
+    return d == null ? e : (d.insertRows({
+      y: n,
+      numRows: t,
+      baseY: n,
+      operator: i,
+      undoReflection: p({
+        sheetId: d.id,
+        selectingZone: a,
+        choosing: c
+      }),
+      redoReflection: p({
+        sheetId: d.id,
+        selectingZone: a,
+        choosing: c
+      })
+    }), {
+      ...e,
+      sheetReactive: { current: d }
+    });
+  }
+}
+const ct = new rt().bind();
+class at extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { numRows: t, y: n, operator: i } = s, { sheetReactive: r, selectingZone: a, choosing: c, editorRef: d } = e, l = r.current;
+    if (l == null)
+      return e;
+    const u = {
+      ...a,
+      startY: a.startY + t,
+      endY: a.endY + t
+    }, g = { ...c, y: c.y + t };
+    return l.insertRows({
+      y: n + 1,
+      numRows: t,
+      baseY: n,
+      operator: i,
+      undoReflection: p({
+        sheetId: l.id,
+        selectingZone: a,
+        choosing: c
+      }),
+      redoReflection: p({
+        sheetId: l.id,
+        selectingZone: u,
+        choosing: g
+      })
+    }), {
+      ...e,
+      selectingZone: u,
+      choosing: g,
+      sheetReactive: { current: l }
+    };
+  }
+}
+const lt = new at().bind();
+class ut extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { numCols: t, x: n, operator: i } = s, { sheetReactive: r, selectingZone: a, choosing: c, editorRef: d } = e, l = r.current;
+    return l == null ? e : (l.insertCols({
+      x: n,
+      numCols: t,
+      baseX: n,
+      operator: i,
+      undoReflection: p({
+        sheetId: l.id,
+        selectingZone: a,
+        choosing: c
+      }),
+      redoReflection: p({
+        sheetId: l.id,
+        selectingZone: a,
+        choosing: c
+      })
+    }), {
+      ...e,
+      sheetReactive: { current: l }
+    });
+  }
+}
+const dt = new ut().bind();
+class ht extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { numCols: t, x: n, operator: i } = s, { sheetReactive: r, selectingZone: a, choosing: c } = e, d = r.current;
+    if (d == null)
+      return e;
+    const l = {
+      ...a,
+      startX: a.startX + t,
+      endX: a.endX + t
+    }, u = { ...c, x: c.x + t };
+    return a.startX += t, a.endX += t, d.insertCols({
+      x: n + 1,
+      numCols: t,
+      baseX: n,
+      operator: i,
+      undoReflection: p({
+        sheetId: d.id,
+        selectingZone: a,
+        choosing: c
+      }),
+      redoReflection: p({
+        sheetId: d.id,
+        selectingZone: l,
+        choosing: u
+      })
+    }), {
+      ...e,
+      selectingZone: l,
+      choosing: u,
+      sheetReactive: { current: d }
+    };
+  }
+}
+const ft = new ht().bind();
+class gt extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { numRows: t, y: n, operator: i } = s, { sheetReactive: r, selectingZone: a, choosing: c, editorRef: d } = e, l = r.current;
+    if (l == null)
+      return e;
+    l.removeRows({
+      y: n,
+      numRows: t,
+      operator: i,
+      undoReflection: p({
+        sheetId: l.id,
+        selectingZone: a,
+        choosing: c,
+        sheetHeight: e.sheetHeight
+      }),
+      redoReflection: p({
+        sheetId: l.id,
+        selectingZone: a,
+        choosing: c
+      })
+    });
+    const u = l.numRows, g = l.numCols;
+    let S = Math.max(1, Math.min(n, u));
+    if (l.isRowFiltered(S)) {
+      let R = -1;
+      for (let h = S; h <= u; h++)
+        if (!l.isRowFiltered(h)) {
+          R = h;
+          break;
+        }
+      if (R === -1) {
+        for (let h = S; h >= 1; h--)
+          if (!l.isRowFiltered(h)) {
+            R = h;
+            break;
+          }
+      }
+      R !== -1 && (S = R);
+    }
+    return {
+      ...e,
+      sheetReactive: { current: l },
+      selectingZone: { startY: S, startX: 1, endY: S, endX: g },
+      choosing: { y: S, x: 1 },
+      leftHeaderSelecting: !0,
+      topHeaderSelecting: !1
+    };
+  }
+}
+const Rt = new gt().bind();
+class wt extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { numCols: t, x: n, operator: i } = s, { sheetReactive: r, selectingZone: a, choosing: c, editorRef: d } = e, l = r.current;
+    if (l == null)
+      return e;
+    l.removeCols({
+      x: n,
+      numCols: t,
+      operator: i,
+      undoReflection: p({
+        sheetId: l.id,
+        selectingZone: a,
+        choosing: c,
+        sheetWidth: e.sheetWidth
+      }),
+      redoReflection: p({
+        sheetId: l.id,
+        selectingZone: a,
+        choosing: c
+      })
+    });
+    const u = l.numCols, g = l.numRows, S = Math.max(1, Math.min(n, u));
+    let R = 1;
+    for (let h = 1; h <= g; h++)
+      if (!l.isRowFiltered(h)) {
+        R = h;
+        break;
+      }
+    return {
+      ...e,
+      sheetReactive: { current: l },
+      selectingZone: { startY: 1, startX: S, endY: g, endX: S },
+      choosing: { y: R, x: S },
+      leftHeaderSelecting: !1,
+      topHeaderSelecting: !0
+    };
+  }
+}
+const St = new wt().bind();
+class xt extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { x: t, direction: n } = s, { sheetReactive: i, selectingZone: r, choosing: a } = e, c = i.current;
+    if (c == null)
+      return e;
+    c.sortRows({ x: t, direction: n });
+    const d = p({ sheetId: c.id, selectingZone: r, choosing: a });
+    return c.registry.lastHistory && (c.registry.lastHistory.undoReflection = d, c.registry.lastHistory.redoReflection = d), {
+      ...e,
+      sheetReactive: { current: c }
+    };
+  }
+}
+const mt = new xt().bind();
+class yt extends f {
+  constructor() {
+    super(...arguments), this.mutation = !0;
+  }
+  reduce(e, s) {
+    const { x: t, filter: n } = s, { sheetReactive: i, selectingZone: r, choosing: a } = e, c = i.current;
+    if (c == null)
+      return e;
+    c.filterRows({ x: t, filter: n });
+    const d = p({ sheetId: c.id, selectingZone: r, choosing: a });
+    c.registry.lastHistory && (c.registry.lastHistory.undoReflection = d, c.registry.lastHistory.redoReflection = d);
+    let l = a;
+    if (c.isRowFiltered(a.y)) {
+      for (let u = 1; u <= c.numRows; u++)
+        if (!c.isRowFiltered(u)) {
+          l = { y: u, x: a.x };
+          break;
+        }
+    }
+    return {
+      ...e,
+      choosing: l,
+      selectingZone: l !== a ? E : r,
+      sheetReactive: { current: c },
+      callback: ({ sheetReactive: u }) => {
+        const g = u.current;
+        g && g.registry.transmit({
+          cutting: !1,
+          copyingZone: E
+        });
+      }
+    };
+  }
+}
+const pt = new yt().bind();
+class vt extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      columnMenuState: s
+    };
+  }
+}
+const jt = new vt().bind();
+class bt extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      rowMenuState: s
+    };
+  }
+}
+const qt = new bt().bind();
+class At extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      editorHovering: s
+    };
+  }
+}
+const Qt = new At().bind();
+class Ct extends f {
+  reduce(e, s) {
+    return {
+      ...e,
+      ...s
+    };
+  }
+}
+const te = new Ct().bind(), Vt = {
+  blur: Ye,
+  copy: Ze,
+  cut: Me,
+  paste: He,
+  escape: Fe,
+  choose: Le,
+  select: Pe,
+  selectRows: Be,
+  selectCols: Ue,
+  drag: Oe,
+  search: qe,
+  write: Ve,
+  clear: Ke,
+  undo: $e,
+  redo: et,
+  arrow: nt,
+  walk: it,
+  insertRowsAbove: ct,
+  insertRowsBelow: lt,
+  insertColsLeft: dt,
+  insertColsRight: ft,
+  removeRows: Rt,
+  removeCols: St,
+  sortRows: mt,
+  filterRows: pt
+}, Gt = () => {
+  const [o, e] = N(!1);
+  return O(() => {
+    e(!0);
+  }, []), o && typeof window < "u" ? { window, document } : { window: null, document: null };
+}, Kt = (o, e = 100) => {
+  const s = V(o), t = V();
+  return O(() => {
+    s.current = o;
+  }, [o]), (...n) => {
+    window.clearTimeout(t.current), t.current = window.setTimeout(() => {
+      s.current(...n);
+    }, e);
+  };
+}, Nt = (o = {}) => {
+  const [e, s] = N(() => ae(o)), { registry: t } = e;
+  return t.updateSheet = ve, t.transmit = (n) => {
+    Object.assign(t, n), t.ready && requestAnimationFrame(() => s({ registry: t }));
+  }, O(() => {
+    Object.assign(t, o);
+  }, [o]), e;
+};
+export {
+  dt as A,
+  lt as B,
+  ct as C,
+  Pt as D,
+  jt as E,
+  qt as F,
+  Zt as G,
+  Ut as H,
+  Le as I,
+  Oe as J,
+  _t as K,
+  Dt as L,
+  Lt as M,
+  Ue as N,
+  Kt as O,
+  Be as P,
+  qe as Q,
+  Ht as R,
+  Tt as S,
+  Ft as T,
+  Nt as U,
+  Xt as V,
+  Mt as W,
+  Vt as X,
+  Ot as a,
+  ve as b,
+  $e as c,
+  Me as d,
+  Et as e,
+  Wt as f,
+  Ze as g,
+  Pe as h,
+  nt as i,
+  Fe as j,
+  Ke as k,
+  it as l,
+  Qt as m,
+  te as n,
+  zt as o,
+  He as p,
+  Bt as q,
+  et as r,
+  kt as s,
+  pt as t,
+  Gt as u,
+  mt as v,
+  Ve as w,
+  St as x,
+  Rt as y,
+  ft as z
+};
+//# sourceMappingURL=hooks-CvkA2lFB.mjs.map