@midas-ds/components 13.0.1 → 14.1.0

package/SelectionManager-C469yQeD.js

@@ -0,0 +1,1063 @@
+import H, { useRef as F, useEffect as q, useMemo as j, useState as se } from "react";
+import { $ as Ie, b as we, m as ue, c as xe } from "./utils-Dxh86KaB.js";
+import { $ as he, a as Y, c as Fe, d as ye, e as Ce } from "./mergeProps-Ct8m5-xW.js";
+import { b as Pe, c as Te, f as Me } from "./usePress-BqQIhkNY.js";
+import { $ as J } from "./useEvent-smuTnX4G.js";
+import { a as Be, b as pe } from "./scrollIntoView-BVI21Y4-.js";
+import { $ as Le } from "./SelectionIndicator-ant6jeC1.js";
+import { h as Re, o as Oe, g as ve } from "./useHover-DkC5FyNd.js";
+import { b as ae } from "./useFocusable-BJj-Bkig.js";
+import { flushSync as Ue } from "react-dom";
+import { $ as ze } from "./context-Dl_saGB6.js";
+import { $ as Ve } from "./useDescription-BFwQx7Rp.js";
+import { $ as He } from "./useControlledState-u436Wbp1.js";
+function be(i, e) {
+  const t = F(!0), l = F(null);
+  he(() => (t.current = !0, () => {
+    t.current = !1;
+  }), []), he(() => {
+    t.current ? t.current = !1 : (!l.current || e.some((n, c) => !Object.is(n, l[c]))) && i(), l.current = e;
+  }, e);
+}
+function G(i) {
+  return Re() ? i.metaKey : i.ctrlKey;
+}
+const We = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+function gt(i) {
+  return i instanceof HTMLInputElement && !We.has(i.type) || i instanceof HTMLTextAreaElement || i instanceof HTMLElement && i.isContentEditable;
+}
+const Ge = "react-aria-clear-focus", qe = "react-aria-focus", je = 500;
+function Ye(i) {
+  let { isDisabled: e, onLongPressStart: t, onLongPressEnd: l, onLongPress: n, threshold: c = je, accessibilityDescription: o } = i;
+  const d = F(void 0);
+  let { addGlobalListener: a, removeGlobalListener: w } = Ie(), { pressProps: k } = Pe({
+    isDisabled: e,
+    onPressStart(h) {
+      if (h.continuePropagation(), (h.pointerType === "mouse" || h.pointerType === "touch") && (t && t({
+        ...h,
+        type: "longpressstart"
+      }), d.current = setTimeout(() => {
+        h.target.dispatchEvent(new PointerEvent("pointercancel", {
+          bubbles: !0
+        })), we(h.target).activeElement !== h.target && ue(h.target), n && n({
+          ...h,
+          type: "longpress"
+        }), d.current = void 0;
+      }, c), h.pointerType === "touch")) {
+        let g = (v) => {
+          v.preventDefault();
+        };
+        a(h.target, "contextmenu", g, {
+          once: !0
+        }), a(window, "pointerup", () => {
+          setTimeout(() => {
+            w(h.target, "contextmenu", g);
+          }, 30);
+        }, {
+          once: !0
+        });
+      }
+    },
+    onPressEnd(h) {
+      d.current && clearTimeout(d.current), l && (h.pointerType === "mouse" || h.pointerType === "touch") && l({
+        ...h,
+        type: "longpressend"
+      });
+    }
+  }), m = Ve(n && !e ? o : void 0);
+  return {
+    longPressProps: Y(k, m)
+  };
+}
+function Ee(i) {
+  let e = Je(we(i));
+  e !== i && (e && Ze(e, i), i && De(i, e));
+}
+function Ze(i, e) {
+  i.dispatchEvent(new FocusEvent("blur", {
+    relatedTarget: e
+  })), i.dispatchEvent(new FocusEvent("focusout", {
+    bubbles: !0,
+    relatedTarget: e
+  }));
+}
+function De(i, e) {
+  i.dispatchEvent(new FocusEvent("focus", {
+    relatedTarget: e
+  })), i.dispatchEvent(new FocusEvent("focusin", {
+    bubbles: !0,
+    relatedTarget: e
+  }));
+}
+function Je(i) {
+  let e = xe(i), t = e == null ? void 0 : e.getAttribute("aria-activedescendant");
+  return t && i.getElementById(t) || e;
+}
+function fe(i) {
+  return Oe() ? i.altKey : i.ctrlKey;
+}
+function oe(i, e) {
+  var t, l;
+  let n = `[data-key="${CSS.escape(String(e))}"]`, c = (t = i.current) === null || t === void 0 ? void 0 : t.dataset.collection;
+  return c && (n = `[data-collection="${CSS.escape(c)}"]${n}`), (l = i.current) === null || l === void 0 ? void 0 : l.querySelector(n);
+}
+const ke = /* @__PURE__ */ new WeakMap();
+function Qe(i) {
+  let e = Fe();
+  return ke.set(i, e), e;
+}
+function Xe(i) {
+  return ke.get(i);
+}
+const Ne = 1e3;
+function _e(i) {
+  let { keyboardDelegate: e, selectionManager: t, onTypeSelect: l } = i, n = F({
+    search: "",
+    timeout: void 0
+  }).current, c = (o) => {
+    let d = et(o.key);
+    if (!(!d || o.ctrlKey || o.metaKey || !o.currentTarget.contains(o.target) || n.search.length === 0 && d === " ")) {
+      if (d === " " && n.search.trim().length > 0 && (o.preventDefault(), "continuePropagation" in o || o.stopPropagation()), n.search += d, e.getKeyForSearch != null) {
+        let a = e.getKeyForSearch(n.search, t.focusedKey);
+        a == null && (a = e.getKeyForSearch(n.search)), a != null && (t.setFocusedKey(a), l && l(a));
+      }
+      clearTimeout(n.timeout), n.timeout = setTimeout(() => {
+        n.search = "";
+      }, Ne);
+    }
+  };
+  return {
+    typeSelectProps: {
+      // Using a capturing listener to catch the keydown event before
+      // other hooks in order to handle the Spacebar event.
+      onKeyDownCapture: e.getKeyForSearch ? c : void 0
+    }
+  };
+}
+function et(i) {
+  return i.length === 1 || !/^[A-Z]/i.test(i) ? i : "";
+}
+function Kt(i) {
+  let { selectionManager: e, keyboardDelegate: t, ref: l, autoFocus: n = !1, shouldFocusWrap: c = !1, disallowEmptySelection: o = !1, disallowSelectAll: d = !1, escapeKeyBehavior: a = "clearSelection", selectOnFocus: w = e.selectionBehavior === "replace", disallowTypeAhead: k = !1, shouldUseVirtualFocus: m, allowsTabNavigation: h = !1, isVirtualized: g, scrollRef: v = l, linkBehavior: A = "action" } = i, { direction: y } = ze(), x = Te(), p = (r) => {
+    var f;
+    if (r.altKey && r.key === "Tab" && r.preventDefault(), !(!((f = l.current) === null || f === void 0) && f.contains(r.target))) return;
+    const $ = (u, z) => {
+      if (u != null) {
+        if (e.isLink(u) && A === "selection" && w && !fe(r)) {
+          Ue(() => {
+            e.setFocusedKey(u, z);
+          });
+          let V = oe(l, u), de = e.getItemProps(u);
+          V && x.open(V, r, de.href, de.routerOptions);
+          return;
+        }
+        if (e.setFocusedKey(u, z), e.isLink(u) && A === "override") return;
+        r.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(u) : w && !fe(r) && e.replaceSelection(u);
+      }
+    };
+    switch (r.key) {
+      case "ArrowDown":
+        if (t.getKeyBelow) {
+          var s, S, E;
+          let u = e.focusedKey != null ? (s = t.getKeyBelow) === null || s === void 0 ? void 0 : s.call(t, e.focusedKey) : (S = t.getFirstKey) === null || S === void 0 ? void 0 : S.call(t);
+          u == null && c && (u = (E = t.getFirstKey) === null || E === void 0 ? void 0 : E.call(t, e.focusedKey)), u != null && (r.preventDefault(), $(u));
+        }
+        break;
+      case "ArrowUp":
+        if (t.getKeyAbove) {
+          var B, O, N;
+          let u = e.focusedKey != null ? (B = t.getKeyAbove) === null || B === void 0 ? void 0 : B.call(t, e.focusedKey) : (O = t.getLastKey) === null || O === void 0 ? void 0 : O.call(t);
+          u == null && c && (u = (N = t.getLastKey) === null || N === void 0 ? void 0 : N.call(t, e.focusedKey)), u != null && (r.preventDefault(), $(u));
+        }
+        break;
+      case "ArrowLeft":
+        if (t.getKeyLeftOf) {
+          var _, ee, te;
+          let u = e.focusedKey != null ? (_ = t.getKeyLeftOf) === null || _ === void 0 ? void 0 : _.call(t, e.focusedKey) : null;
+          u == null && c && (u = y === "rtl" ? (ee = t.getFirstKey) === null || ee === void 0 ? void 0 : ee.call(t, e.focusedKey) : (te = t.getLastKey) === null || te === void 0 ? void 0 : te.call(t, e.focusedKey)), u != null && (r.preventDefault(), $(u, y === "rtl" ? "first" : "last"));
+        }
+        break;
+      case "ArrowRight":
+        if (t.getKeyRightOf) {
+          var le, ie, ne;
+          let u = e.focusedKey != null ? (le = t.getKeyRightOf) === null || le === void 0 ? void 0 : le.call(t, e.focusedKey) : null;
+          u == null && c && (u = y === "rtl" ? (ie = t.getLastKey) === null || ie === void 0 ? void 0 : ie.call(t, e.focusedKey) : (ne = t.getFirstKey) === null || ne === void 0 ? void 0 : ne.call(t, e.focusedKey)), u != null && (r.preventDefault(), $(u, y === "rtl" ? "last" : "first"));
+        }
+        break;
+      case "Home":
+        if (t.getFirstKey) {
+          if (e.focusedKey === null && r.shiftKey) return;
+          r.preventDefault();
+          let u = t.getFirstKey(e.focusedKey, G(r));
+          e.setFocusedKey(u), u != null && (G(r) && r.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(u) : w && e.replaceSelection(u));
+        }
+        break;
+      case "End":
+        if (t.getLastKey) {
+          if (e.focusedKey === null && r.shiftKey) return;
+          r.preventDefault();
+          let u = t.getLastKey(e.focusedKey, G(r));
+          e.setFocusedKey(u), u != null && (G(r) && r.shiftKey && e.selectionMode === "multiple" ? e.extendSelection(u) : w && e.replaceSelection(u));
+        }
+        break;
+      case "PageDown":
+        if (t.getKeyPageBelow && e.focusedKey != null) {
+          let u = t.getKeyPageBelow(e.focusedKey);
+          u != null && (r.preventDefault(), $(u));
+        }
+        break;
+      case "PageUp":
+        if (t.getKeyPageAbove && e.focusedKey != null) {
+          let u = t.getKeyPageAbove(e.focusedKey);
+          u != null && (r.preventDefault(), $(u));
+        }
+        break;
+      case "a":
+        G(r) && e.selectionMode === "multiple" && d !== !0 && (r.preventDefault(), e.selectAll());
+        break;
+      case "Escape":
+        a === "clearSelection" && !o && e.selectedKeys.size !== 0 && (r.stopPropagation(), r.preventDefault(), e.clearSelection());
+        break;
+      case "Tab":
+        if (!h) {
+          if (r.shiftKey) l.current.focus();
+          else {
+            let u = Le(l.current, {
+              tabbable: !0
+            }), z, V;
+            do
+              V = u.lastChild(), V && (z = V);
+            while (V);
+            z && !z.contains(document.activeElement) && ue(z);
+          }
+          break;
+        }
+    }
+  }, b = F({
+    top: 0,
+    left: 0
+  });
+  J(v, "scroll", g ? void 0 : () => {
+    var r, f, $, s;
+    b.current = {
+      top: ($ = (r = v.current) === null || r === void 0 ? void 0 : r.scrollTop) !== null && $ !== void 0 ? $ : 0,
+      left: (s = (f = v.current) === null || f === void 0 ? void 0 : f.scrollLeft) !== null && s !== void 0 ? s : 0
+    };
+  });
+  let K = (r) => {
+    if (e.isFocused) {
+      r.currentTarget.contains(r.target) || e.setFocused(!1);
+      return;
+    }
+    if (r.currentTarget.contains(r.target)) {
+      if (e.setFocused(!0), e.focusedKey == null) {
+        var f, $;
+        let E = (O) => {
+          O != null && (e.setFocusedKey(O), w && !e.isSelected(O) && e.replaceSelection(O));
+        }, B = r.relatedTarget;
+        var s, S;
+        B && r.currentTarget.compareDocumentPosition(B) & Node.DOCUMENT_POSITION_FOLLOWING ? E((s = e.lastSelectedKey) !== null && s !== void 0 ? s : (f = t.getLastKey) === null || f === void 0 ? void 0 : f.call(t)) : E((S = e.firstSelectedKey) !== null && S !== void 0 ? S : ($ = t.getFirstKey) === null || $ === void 0 ? void 0 : $.call(t));
+      } else !g && v.current && (v.current.scrollTop = b.current.top, v.current.scrollLeft = b.current.left);
+      if (e.focusedKey != null && v.current) {
+        let E = oe(l, e.focusedKey);
+        E instanceof HTMLElement && (!E.contains(document.activeElement) && !m && ue(E), ve() === "keyboard" && pe(E, {
+          containingElement: l.current
+        }));
+      }
+    }
+  }, L = (r) => {
+    r.currentTarget.contains(r.relatedTarget) || e.setFocused(!1);
+  }, D = F(!1);
+  J(l, qe, m ? (r) => {
+    let { detail: f } = r;
+    r.stopPropagation(), e.setFocused(!0), (f == null ? void 0 : f.focusStrategy) === "first" && (D.current = !0);
+  } : void 0);
+  let C = ye(() => {
+    var r, f;
+    let $ = (f = (r = t.getFirstKey) === null || r === void 0 ? void 0 : r.call(t)) !== null && f !== void 0 ? f : null;
+    if ($ == null) {
+      let s = xe();
+      Ee(l.current), De(s, null), e.collection.size > 0 && (D.current = !1);
+    } else
+      e.setFocusedKey($), D.current = !1;
+  });
+  be(() => {
+    D.current && C();
+  }, [
+    e.collection,
+    C
+  ]);
+  let T = ye(() => {
+    e.collection.size > 0 && (D.current = !1);
+  });
+  be(() => {
+    T();
+  }, [
+    e.focusedKey,
+    T
+  ]), J(l, Ge, m ? (r) => {
+    var f;
+    r.stopPropagation(), e.setFocused(!1), !((f = r.detail) === null || f === void 0) && f.clearFocusKey && e.setFocusedKey(null);
+  } : void 0);
+  const W = F(n), U = F(!1);
+  q(() => {
+    if (W.current) {
+      var r, f;
+      let S = null;
+      var $;
+      n === "first" && (S = ($ = (r = t.getFirstKey) === null || r === void 0 ? void 0 : r.call(t)) !== null && $ !== void 0 ? $ : null);
+      var s;
+      n === "last" && (S = (s = (f = t.getLastKey) === null || f === void 0 ? void 0 : f.call(t)) !== null && s !== void 0 ? s : null);
+      let E = e.selectedKeys;
+      if (E.size) {
+        for (let B of E) if (e.canSelectItem(B)) {
+          S = B;
+          break;
+        }
+      }
+      e.setFocused(!0), e.setFocusedKey(S), S == null && !m && l.current && ae(l.current), e.collection.size > 0 && (W.current = !1, U.current = !0);
+    }
+  });
+  let R = F(e.focusedKey), M = F(null);
+  q(() => {
+    if (e.isFocused && e.focusedKey != null && (e.focusedKey !== R.current || U.current) && v.current && l.current) {
+      let r = ve(), f = oe(l, e.focusedKey);
+      if (!(f instanceof HTMLElement))
+        return;
+      (r === "keyboard" || U.current) && (M.current && cancelAnimationFrame(M.current), M.current = requestAnimationFrame(() => {
+        v.current && (Be(v.current, f), r !== "virtual" && pe(f, {
+          containingElement: l.current
+        }));
+      }));
+    }
+    !m && e.isFocused && e.focusedKey == null && R.current != null && l.current && ae(l.current), R.current = e.focusedKey, U.current = !1;
+  }), q(() => () => {
+    M.current && cancelAnimationFrame(M.current);
+  }, []), J(l, "react-aria-focus-scope-restore", (r) => {
+    r.preventDefault(), e.setFocused(!0);
+  });
+  let P = {
+    onKeyDown: p,
+    onFocus: K,
+    onBlur: L,
+    onMouseDown(r) {
+      v.current === r.target && r.preventDefault();
+    }
+  }, { typeSelectProps: Q } = _e({
+    keyboardDelegate: t,
+    selectionManager: e
+  });
+  k || (P = Y(Q, P));
+  let Z;
+  m || (Z = e.focusedKey == null ? 0 : -1);
+  let X = Qe(e.collection);
+  return {
+    collectionProps: Y(P, {
+      tabIndex: Z,
+      "data-collection": X
+    })
+  };
+}
+function St(i) {
+  let { id: e, selectionManager: t, key: l, ref: n, shouldSelectOnPressUp: c, shouldUseVirtualFocus: o, focus: d, isDisabled: a, onAction: w, allowsDifferentPressOrigin: k, linkBehavior: m = "action" } = i, h = Te();
+  e = Fe(e);
+  let g = (s) => {
+    if (s.pointerType === "keyboard" && fe(s)) t.toggleSelection(l);
+    else {
+      if (t.selectionMode === "none") return;
+      if (t.isLink(l)) {
+        if (m === "selection" && n.current) {
+          let S = t.getItemProps(l);
+          h.open(n.current, s, S.href, S.routerOptions), t.setSelectedKeys(t.selectedKeys);
+          return;
+        } else if (m === "override" || m === "none") return;
+      }
+      t.selectionMode === "single" ? t.isSelected(l) && !t.disallowEmptySelection ? t.toggleSelection(l) : t.replaceSelection(l) : s && s.shiftKey ? t.extendSelection(l) : t.selectionBehavior === "toggle" || s && (G(s) || s.pointerType === "touch" || s.pointerType === "virtual") ? t.toggleSelection(l) : t.replaceSelection(l);
+    }
+  };
+  q(() => {
+    l === t.focusedKey && t.isFocused && (o ? Ee(n.current) : d ? d() : document.activeElement !== n.current && n.current && ae(n.current));
+  }, [
+    n,
+    l,
+    t.focusedKey,
+    t.childFocusStrategy,
+    t.isFocused,
+    o
+  ]), a = a || t.isDisabled(l);
+  let v = {};
+  !o && !a ? v = {
+    tabIndex: l === t.focusedKey ? 0 : -1,
+    onFocus(s) {
+      s.target === n.current && t.setFocusedKey(l);
+    }
+  } : a && (v.onMouseDown = (s) => {
+    s.preventDefault();
+  });
+  let A = t.isLink(l) && m === "override", y = w && i.UNSTABLE_itemBehavior === "action", x = t.isLink(l) && m !== "selection" && m !== "none", p = !a && t.canSelectItem(l) && !A && !y, b = (w || x) && !a, K = b && (t.selectionBehavior === "replace" ? !p : !p || t.isEmpty), L = b && p && t.selectionBehavior === "replace", D = K || L, C = F(null), T = D && p, W = F(!1), U = F(!1), R = t.getItemProps(l), M = (s) => {
+    if (w) {
+      var S;
+      w(), (S = n.current) === null || S === void 0 || S.dispatchEvent(new CustomEvent("react-aria-item-action", {
+        bubbles: !0
+      }));
+    }
+    x && n.current && h.open(n.current, s, R.href, R.routerOptions);
+  }, P = {
+    ref: n
+  };
+  if (c ? (P.onPressStart = (s) => {
+    C.current = s.pointerType, W.current = T, s.pointerType === "keyboard" && (!D || me()) && g(s);
+  }, k ? (P.onPressUp = K ? void 0 : (s) => {
+    s.pointerType === "mouse" && p && g(s);
+  }, P.onPress = K ? M : (s) => {
+    s.pointerType !== "keyboard" && s.pointerType !== "mouse" && p && g(s);
+  }) : P.onPress = (s) => {
+    if (K || L && s.pointerType !== "mouse") {
+      if (s.pointerType === "keyboard" && !$e()) return;
+      M(s);
+    } else s.pointerType !== "keyboard" && p && g(s);
+  }) : (P.onPressStart = (s) => {
+    C.current = s.pointerType, W.current = T, U.current = K, p && (s.pointerType === "mouse" && !K || s.pointerType === "keyboard" && (!b || me())) && g(s);
+  }, P.onPress = (s) => {
+    (s.pointerType === "touch" || s.pointerType === "pen" || s.pointerType === "virtual" || s.pointerType === "keyboard" && D && $e() || s.pointerType === "mouse" && U.current) && (D ? M(s) : p && g(s));
+  }), v["data-collection"] = Xe(t.collection), v["data-key"] = l, P.preventFocusOnPress = o, o && (P = Y(P, {
+    onPressStart(s) {
+      s.pointerType !== "touch" && (t.setFocused(!0), t.setFocusedKey(l));
+    },
+    onPress(s) {
+      s.pointerType === "touch" && (t.setFocused(!0), t.setFocusedKey(l));
+    }
+  })), R)
+    for (let s of [
+      "onPressStart",
+      "onPressEnd",
+      "onPressChange",
+      "onPress",
+      "onPressUp",
+      "onClick"
+    ]) R[s] && (P[s] = Ce(P[s], R[s]));
+  let { pressProps: Q, isPressed: Z } = Pe(P), X = L ? (s) => {
+    C.current === "mouse" && (s.stopPropagation(), s.preventDefault(), M(s));
+  } : void 0, { longPressProps: r } = Ye({
+    isDisabled: !T,
+    onLongPress(s) {
+      s.pointerType === "touch" && (g(s), t.setSelectionBehavior("toggle"));
+    }
+  }), f = (s) => {
+    C.current === "touch" && W.current && s.preventDefault();
+  }, $ = m !== "none" && t.isLink(l) ? (s) => {
+    Me.isOpening || s.preventDefault();
+  } : void 0;
+  return {
+    itemProps: Y(
+      v,
+      p || K || o && !a ? Q : {},
+      T ? r : {},
+      {
+        onDoubleClick: X,
+        onDragStartCapture: f,
+        onClick: $,
+        id: e
+      },
+      // Prevent DOM focus from moving on mouse down when using virtual focus
+      o ? {
+        onMouseDown: (s) => s.preventDefault()
+      } : void 0
+    ),
+    isPressed: Z,
+    isSelected: t.isSelected(l),
+    isFocused: t.isFocused && t.focusedKey === l,
+    isDisabled: a,
+    allowsSelection: p,
+    hasAction: D
+  };
+}
+function $e() {
+  let i = window.event;
+  return (i == null ? void 0 : i.key) === "Enter";
+}
+function me() {
+  let i = window.event;
+  return (i == null ? void 0 : i.key) === " " || (i == null ? void 0 : i.code) === "Space";
+}
+class tt {
+  build(e, t) {
+    return this.context = t, ge(() => this.iterateCollection(e));
+  }
+  *iterateCollection(e) {
+    let { children: t, items: l } = e;
+    if (H.isValidElement(t) && t.type === H.Fragment) yield* this.iterateCollection({
+      children: t.props.children,
+      items: l
+    });
+    else if (typeof t == "function") {
+      if (!l) throw new Error("props.children was a function but props.items is missing");
+      let n = 0;
+      for (let c of l)
+        yield* this.getFullNode({
+          value: c,
+          index: n
+        }, {
+          renderer: t
+        }), n++;
+    } else {
+      let n = [];
+      H.Children.forEach(t, (o) => {
+        o && n.push(o);
+      });
+      let c = 0;
+      for (let o of n) {
+        let d = this.getFullNode({
+          element: o,
+          index: c
+        }, {});
+        for (let a of d)
+          c++, yield a;
+      }
+    }
+  }
+  getKey(e, t, l, n) {
+    if (e.key != null) return e.key;
+    if (t.type === "cell" && t.key != null) return `${n}${t.key}`;
+    let c = t.value;
+    if (c != null) {
+      var o;
+      let d = (o = c.key) !== null && o !== void 0 ? o : c.id;
+      if (d == null) throw new Error("No key found for item");
+      return d;
+    }
+    return n ? `${n}.${t.index}` : `$.${t.index}`;
+  }
+  getChildState(e, t) {
+    return {
+      renderer: t.renderer || e.renderer
+    };
+  }
+  *getFullNode(e, t, l, n) {
+    if (H.isValidElement(e.element) && e.element.type === H.Fragment) {
+      let y = [];
+      H.Children.forEach(e.element.props.children, (p) => {
+        y.push(p);
+      });
+      var c;
+      let x = (c = e.index) !== null && c !== void 0 ? c : 0;
+      for (const p of y) yield* this.getFullNode({
+        element: p,
+        index: x++
+      }, t, l, n);
+      return;
+    }
+    let o = e.element;
+    if (!o && e.value && t && t.renderer) {
+      let y = this.cache.get(e.value);
+      if (y && (!y.shouldInvalidate || !y.shouldInvalidate(this.context))) {
+        y.index = e.index, y.parentKey = n ? n.key : null, yield y;
+        return;
+      }
+      o = t.renderer(e.value);
+    }
+    if (H.isValidElement(o)) {
+      let y = o.type;
+      if (typeof y != "function" && typeof y.getCollectionNode != "function") {
+        let K = o.type;
+        throw new Error(`Unknown element <${K}> in collection.`);
+      }
+      let x = y.getCollectionNode(o.props, this.context);
+      var d;
+      let p = (d = e.index) !== null && d !== void 0 ? d : 0, b = x.next();
+      for (; !b.done && b.value; ) {
+        let K = b.value;
+        e.index = p;
+        var a;
+        let L = (a = K.key) !== null && a !== void 0 ? a : null;
+        L == null && (L = K.element ? null : this.getKey(o, e, t, l));
+        let C = [
+          ...this.getFullNode({
+            ...K,
+            key: L,
+            index: p,
+            wrapper: lt(e.wrapper, K.wrapper)
+          }, this.getChildState(t, K), l ? `${l}${o.key}` : o.key, n)
+        ];
+        for (let T of C) {
+          var w, k;
+          T.value = (k = (w = K.value) !== null && w !== void 0 ? w : e.value) !== null && k !== void 0 ? k : null, T.value && this.cache.set(T.value, T);
+          var m;
+          if (e.type && T.type !== e.type) throw new Error(`Unsupported type <${re(T.type)}> in <${re((m = n == null ? void 0 : n.type) !== null && m !== void 0 ? m : "unknown parent type")}>. Only <${re(e.type)}> is supported.`);
+          p++, yield T;
+        }
+        b = x.next(C);
+      }
+      return;
+    }
+    if (e.key == null || e.type == null) return;
+    let h = this;
+    var g, v;
+    let A = {
+      type: e.type,
+      props: e.props,
+      key: e.key,
+      parentKey: n ? n.key : null,
+      value: (g = e.value) !== null && g !== void 0 ? g : null,
+      level: n ? n.level + 1 : 0,
+      index: e.index,
+      rendered: e.rendered,
+      textValue: (v = e.textValue) !== null && v !== void 0 ? v : "",
+      "aria-label": e["aria-label"],
+      wrapper: e.wrapper,
+      shouldInvalidate: e.shouldInvalidate,
+      hasChildNodes: e.hasChildNodes || !1,
+      childNodes: ge(function* () {
+        if (!e.hasChildNodes || !e.childNodes) return;
+        let y = 0;
+        for (let x of e.childNodes()) {
+          x.key != null && (x.key = `${A.key}${x.key}`);
+          let p = h.getFullNode({
+            ...x,
+            index: y
+          }, h.getChildState(t, x), A.key, A);
+          for (let b of p)
+            y++, yield b;
+        }
+      })
+    };
+    yield A;
+  }
+  constructor() {
+    this.cache = /* @__PURE__ */ new WeakMap();
+  }
+}
+function ge(i) {
+  let e = [], t = null;
+  return {
+    *[Symbol.iterator]() {
+      for (let l of e) yield l;
+      t || (t = i());
+      for (let l of t)
+        e.push(l), yield l;
+    }
+  };
+}
+function lt(i, e) {
+  if (i && e) return (t) => i(e(t));
+  if (i) return i;
+  if (e) return e;
+}
+function re(i) {
+  return i[0].toUpperCase() + i.slice(1);
+}
+function wt(i, e, t) {
+  let l = j(() => new tt(), []), { children: n, items: c, collection: o } = i;
+  return j(() => {
+    if (o) return o;
+    let a = l.build({
+      children: n,
+      items: c
+    }, t);
+    return e(a);
+  }, [
+    l,
+    n,
+    c,
+    o,
+    t,
+    e
+  ]);
+}
+function it(i, e) {
+  return typeof e.getChildren == "function" ? e.getChildren(i.key) : i.childNodes;
+}
+function nt(i) {
+  return st(i, 0);
+}
+function st(i, e) {
+  if (e < 0) return;
+  let t = 0;
+  for (let l of i) {
+    if (t === e) return l;
+    t++;
+  }
+}
+function xt(i) {
+  let e;
+  for (let t of i) e = t;
+  return e;
+}
+function ce(i, e, t) {
+  if (e.parentKey === t.parentKey) return e.index - t.index;
+  let l = [
+    ...Ke(i, e),
+    e
+  ], n = [
+    ...Ke(i, t),
+    t
+  ], c = l.slice(0, n.length).findIndex((o, d) => o !== n[d]);
+  return c !== -1 ? (e = l[c], t = n[c], e.index - t.index) : l.findIndex((o) => o === t) >= 0 ? 1 : (n.findIndex((o) => o === e) >= 0, -1);
+}
+function Ke(i, e) {
+  let t = [], l = e;
+  for (; (l == null ? void 0 : l.parentKey) != null; )
+    l = i.getItem(l.parentKey), l && t.unshift(l);
+  return t;
+}
+class I extends Set {
+  constructor(e, t, l) {
+    super(e), e instanceof I ? (this.anchorKey = t ?? e.anchorKey, this.currentKey = l ?? e.currentKey) : (this.anchorKey = t ?? null, this.currentKey = l ?? null);
+  }
+}
+function ot(i, e) {
+  if (i.size !== e.size) return !1;
+  for (let t of i)
+    if (!e.has(t)) return !1;
+  return !0;
+}
+function Ft(i) {
+  let { selectionMode: e = "none", disallowEmptySelection: t = !1, allowDuplicateSelectionEvents: l, selectionBehavior: n = "toggle", disabledBehavior: c = "all" } = i, o = F(!1), [, d] = se(!1), a = F(null), w = F(null), [, k] = se(null), m = j(() => Se(i.selectedKeys), [
+    i.selectedKeys
+  ]), h = j(() => Se(i.defaultSelectedKeys, new I()), [
+    i.defaultSelectedKeys
+  ]), [g, v] = He(m, h, i.onSelectionChange), A = j(() => i.disabledKeys ? new Set(i.disabledKeys) : /* @__PURE__ */ new Set(), [
+    i.disabledKeys
+  ]), [y, x] = se(n);
+  n === "replace" && y === "toggle" && typeof g == "object" && g.size === 0 && x("replace");
+  let p = F(n);
+  return q(() => {
+    n !== p.current && (x(n), p.current = n);
+  }, [
+    n
+  ]), {
+    selectionMode: e,
+    disallowEmptySelection: t,
+    selectionBehavior: y,
+    setSelectionBehavior: x,
+    get isFocused() {
+      return o.current;
+    },
+    setFocused(b) {
+      o.current = b, d(b);
+    },
+    get focusedKey() {
+      return a.current;
+    },
+    get childFocusStrategy() {
+      return w.current;
+    },
+    setFocusedKey(b, K = "first") {
+      a.current = b, w.current = K, k(b);
+    },
+    selectedKeys: g,
+    setSelectedKeys(b) {
+      (l || !ot(b, g)) && v(b);
+    },
+    disabledKeys: A,
+    disabledBehavior: c
+  };
+}
+function Se(i, e) {
+  return i ? i === "all" ? "all" : new I(i) : e;
+}
+class Ae {
+  /**
+  * The type of selection that is allowed in the collection.
+  */
+  get selectionMode() {
+    return this.state.selectionMode;
+  }
+  /**
+  * Whether the collection allows empty selection.
+  */
+  get disallowEmptySelection() {
+    return this.state.disallowEmptySelection;
+  }
+  /**
+  * The selection behavior for the collection.
+  */
+  get selectionBehavior() {
+    return this.state.selectionBehavior;
+  }
+  /**
+  * Sets the selection behavior for the collection.
+  */
+  setSelectionBehavior(e) {
+    this.state.setSelectionBehavior(e);
+  }
+  /**
+  * Whether the collection is currently focused.
+  */
+  get isFocused() {
+    return this.state.isFocused;
+  }
+  /**
+  * Sets whether the collection is focused.
+  */
+  setFocused(e) {
+    this.state.setFocused(e);
+  }
+  /**
+  * The current focused key in the collection.
+  */
+  get focusedKey() {
+    return this.state.focusedKey;
+  }
+  /** Whether the first or last child of the focused key should receive focus. */
+  get childFocusStrategy() {
+    return this.state.childFocusStrategy;
+  }
+  /**
+  * Sets the focused key.
+  */
+  setFocusedKey(e, t) {
+    (e == null || this.collection.getItem(e)) && this.state.setFocusedKey(e, t);
+  }
+  /**
+  * The currently selected keys in the collection.
+  */
+  get selectedKeys() {
+    return this.state.selectedKeys === "all" ? new Set(this.getSelectAllKeys()) : this.state.selectedKeys;
+  }
+  /**
+  * The raw selection value for the collection.
+  * Either 'all' for select all, or a set of keys.
+  */
+  get rawSelection() {
+    return this.state.selectedKeys;
+  }
+  /**
+  * Returns whether a key is selected.
+  */
+  isSelected(e) {
+    if (this.state.selectionMode === "none") return !1;
+    let t = this.getKey(e);
+    return t == null ? !1 : this.state.selectedKeys === "all" ? this.canSelectItem(t) : this.state.selectedKeys.has(t);
+  }
+  /**
+  * Whether the selection is empty.
+  */
+  get isEmpty() {
+    return this.state.selectedKeys !== "all" && this.state.selectedKeys.size === 0;
+  }
+  /**
+  * Whether all items in the collection are selected.
+  */
+  get isSelectAll() {
+    if (this.isEmpty) return !1;
+    if (this.state.selectedKeys === "all") return !0;
+    if (this._isSelectAll != null) return this._isSelectAll;
+    let e = this.getSelectAllKeys(), t = this.state.selectedKeys;
+    return this._isSelectAll = e.every((l) => t.has(l)), this._isSelectAll;
+  }
+  get firstSelectedKey() {
+    let e = null;
+    for (let l of this.state.selectedKeys) {
+      let n = this.collection.getItem(l);
+      (!e || n && ce(this.collection, n, e) < 0) && (e = n);
+    }
+    var t;
+    return (t = e == null ? void 0 : e.key) !== null && t !== void 0 ? t : null;
+  }
+  get lastSelectedKey() {
+    let e = null;
+    for (let l of this.state.selectedKeys) {
+      let n = this.collection.getItem(l);
+      (!e || n && ce(this.collection, n, e) > 0) && (e = n);
+    }
+    var t;
+    return (t = e == null ? void 0 : e.key) !== null && t !== void 0 ? t : null;
+  }
+  get disabledKeys() {
+    return this.state.disabledKeys;
+  }
+  get disabledBehavior() {
+    return this.state.disabledBehavior;
+  }
+  /**
+  * Extends the selection to the given key.
+  */
+  extendSelection(e) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single") {
+      this.replaceSelection(e);
+      return;
+    }
+    let t = this.getKey(e);
+    if (t == null) return;
+    let l;
+    if (this.state.selectedKeys === "all") l = new I([
+      t
+    ], t, t);
+    else {
+      let o = this.state.selectedKeys;
+      var n;
+      let d = (n = o.anchorKey) !== null && n !== void 0 ? n : t;
+      l = new I(o, d, t);
+      var c;
+      for (let a of this.getKeyRange(d, (c = o.currentKey) !== null && c !== void 0 ? c : t)) l.delete(a);
+      for (let a of this.getKeyRange(t, d)) this.canSelectItem(a) && l.add(a);
+    }
+    this.state.setSelectedKeys(l);
+  }
+  getKeyRange(e, t) {
+    let l = this.collection.getItem(e), n = this.collection.getItem(t);
+    return l && n ? ce(this.collection, l, n) <= 0 ? this.getKeyRangeInternal(e, t) : this.getKeyRangeInternal(t, e) : [];
+  }
+  getKeyRangeInternal(e, t) {
+    var l;
+    if (!((l = this.layoutDelegate) === null || l === void 0) && l.getKeyRange) return this.layoutDelegate.getKeyRange(e, t);
+    let n = [], c = e;
+    for (; c != null; ) {
+      let o = this.collection.getItem(c);
+      if (o && (o.type === "item" || o.type === "cell" && this.allowsCellSelection) && n.push(c), c === t) return n;
+      c = this.collection.getKeyAfter(c);
+    }
+    return [];
+  }
+  getKey(e) {
+    let t = this.collection.getItem(e);
+    if (!t || t.type === "cell" && this.allowsCellSelection) return e;
+    for (; t && t.type !== "item" && t.parentKey != null; ) t = this.collection.getItem(t.parentKey);
+    return !t || t.type !== "item" ? null : t.key;
+  }
+  /**
+  * Toggles whether the given key is selected.
+  */
+  toggleSelection(e) {
+    if (this.selectionMode === "none") return;
+    if (this.selectionMode === "single" && !this.isSelected(e)) {
+      this.replaceSelection(e);
+      return;
+    }
+    let t = this.getKey(e);
+    if (t == null) return;
+    let l = new I(this.state.selectedKeys === "all" ? this.getSelectAllKeys() : this.state.selectedKeys);
+    l.has(t) ? l.delete(t) : this.canSelectItem(t) && (l.add(t), l.anchorKey = t, l.currentKey = t), !(this.disallowEmptySelection && l.size === 0) && this.state.setSelectedKeys(l);
+  }
+  /**
+  * Replaces the selection with only the given key.
+  */
+  replaceSelection(e) {
+    if (this.selectionMode === "none") return;
+    let t = this.getKey(e);
+    if (t == null) return;
+    let l = this.canSelectItem(t) ? new I([
+      t
+    ], t, t) : new I();
+    this.state.setSelectedKeys(l);
+  }
+  /**
+  * Replaces the selection with the given keys.
+  */
+  setSelectedKeys(e) {
+    if (this.selectionMode === "none") return;
+    let t = new I();
+    for (let l of e) {
+      let n = this.getKey(l);
+      if (n != null && (t.add(n), this.selectionMode === "single"))
+        break;
+    }
+    this.state.setSelectedKeys(t);
+  }
+  getSelectAllKeys() {
+    let e = [], t = (l) => {
+      for (; l != null; ) {
+        if (this.canSelectItem(l)) {
+          var n;
+          let o = this.collection.getItem(l);
+          (o == null ? void 0 : o.type) === "item" && e.push(l);
+          var c;
+          o != null && o.hasChildNodes && (this.allowsCellSelection || o.type !== "item") && t((c = (n = nt(it(o, this.collection))) === null || n === void 0 ? void 0 : n.key) !== null && c !== void 0 ? c : null);
+        }
+        l = this.collection.getKeyAfter(l);
+      }
+    };
+    return t(this.collection.getFirstKey()), e;
+  }
+  /**
+  * Selects all items in the collection.
+  */
+  selectAll() {
+    !this.isSelectAll && this.selectionMode === "multiple" && this.state.setSelectedKeys("all");
+  }
+  /**
+  * Removes all keys from the selection.
+  */
+  clearSelection() {
+    !this.disallowEmptySelection && (this.state.selectedKeys === "all" || this.state.selectedKeys.size > 0) && this.state.setSelectedKeys(new I());
+  }
+  /**
+  * Toggles between select all and an empty selection.
+  */
+  toggleSelectAll() {
+    this.isSelectAll ? this.clearSelection() : this.selectAll();
+  }
+  select(e, t) {
+    this.selectionMode !== "none" && (this.selectionMode === "single" ? this.isSelected(e) && !this.disallowEmptySelection ? this.toggleSelection(e) : this.replaceSelection(e) : this.selectionBehavior === "toggle" || t && (t.pointerType === "touch" || t.pointerType === "virtual") ? this.toggleSelection(e) : this.replaceSelection(e));
+  }
+  /**
+  * Returns whether the current selection is equal to the given selection.
+  */
+  isSelectionEqual(e) {
+    if (e === this.state.selectedKeys) return !0;
+    let t = this.selectedKeys;
+    if (e.size !== t.size) return !1;
+    for (let l of e)
+      if (!t.has(l)) return !1;
+    for (let l of t)
+      if (!e.has(l)) return !1;
+    return !0;
+  }
+  canSelectItem(e) {
+    var t;
+    if (this.state.selectionMode === "none" || this.state.disabledKeys.has(e)) return !1;
+    let l = this.collection.getItem(e);
+    return !(!l || !(l == null || (t = l.props) === null || t === void 0) && t.isDisabled || l.type === "cell" && !this.allowsCellSelection);
+  }
+  isDisabled(e) {
+    var t, l;
+    return this.state.disabledBehavior === "all" && (this.state.disabledKeys.has(e) || !!(!((l = this.collection.getItem(e)) === null || l === void 0 || (t = l.props) === null || t === void 0) && t.isDisabled));
+  }
+  isLink(e) {
+    var t, l;
+    return !!(!((l = this.collection.getItem(e)) === null || l === void 0 || (t = l.props) === null || t === void 0) && t.href);
+  }
+  getItemProps(e) {
+    var t;
+    return (t = this.collection.getItem(e)) === null || t === void 0 ? void 0 : t.props;
+  }
+  withCollection(e) {
+    return new Ae(e, this.state, {
+      allowsCellSelection: this.allowsCellSelection,
+      layoutDelegate: this.layoutDelegate || void 0
+    });
+  }
+  constructor(e, t, l) {
+    this.collection = e, this.state = t;
+    var n;
+    this.allowsCellSelection = (n = l == null ? void 0 : l.allowsCellSelection) !== null && n !== void 0 ? n : !1, this._isSelectAll = null, this.layoutDelegate = (l == null ? void 0 : l.layoutDelegate) || null;
+  }
+}
+export {
+  Ft as $,
+  wt as a,
+  Ae as b,
+  oe as c,
+  St as d,
+  Kt as e,
+  it as f,
+  gt as g,
+  _e as h,
+  De as i,
+  xt as j,
+  nt as k,
+  st as l,
+  Ye as m
+};