@als-tp/als-react-ts-ui 0.5.1 → 0.5.2

package/dist/als-react-ts-ui391.js

@@ -1,265 +1,285 @@
-import * as a from "react";
-import { getSide as L, getSideAxis as Ee, getAlignment as Me } from "./als-react-ts-ui420.js";
-import { ownerDocument as qe } from "./als-react-ts-ui352.js";
-import { useIsoLayoutEffect as q } from "./als-react-ts-ui267.js";
-import { useValueAsRef as G } from "./als-react-ts-ui318.js";
-import { useStableCallback as Ge } from "./als-react-ts-ui266.js";
-import { useDirection as Je } from "./als-react-ts-ui270.js";
-import { arrow as Ke } from "./als-react-ts-ui422.js";
-import { hide as Ne } from "./als-react-ts-ui423.js";
-import { DEFAULT_SIDES as Qe } from "./als-react-ts-ui392.js";
-import { flip as Ze, offset as et, size as tt, shift as nt, limitShift as ot } from "./als-react-ts-ui371.js";
-import { useFloating as it } from "./als-react-ts-ui370.js";
-import { autoUpdate as $e } from "./als-react-ts-ui384.js";
-function ke(l, f, u) {
-  const n = l === "inline-start" || l === "inline-end";
-  return {
-    top: "top",
-    right: n ? u ? "inline-start" : "inline-end" : "right",
-    bottom: "bottom",
-    left: n ? u ? "inline-end" : "inline-start" : "left"
-  }[f];
+import * as m from "react";
+import { isHTMLElement as ye } from "./als-react-ts-ui338.js";
+import { useValueAsRef as G } from "./als-react-ts-ui336.js";
+import { useStableCallback as ae } from "./als-react-ts-ui223.js";
+import { useIsoLayoutEffect as A } from "./als-react-ts-ui224.js";
+import { useFloatingParentNodeId as Ve, useFloatingTree as Le } from "./als-react-ts-ui352.js";
+import { createChangeEventDetails as X } from "./als-react-ts-ui273.js";
+import { enqueueFocus as ze } from "./als-react-ts-ui378.js";
+import { ARROW_DOWN as ee, ARROW_LEFT as W, ARROW_RIGHT as _, ARROW_UP as Pe } from "./als-react-ts-ui390.js";
+import { isIndexOutOfListBounds as be, getMinListIndex as fe, getMaxListIndex as Me, createGridCellMap as Ge, isListIndexDisabled as de, getGridNavigatedIndex as We, getGridCellIndexOfCorner as _e, getGridCellIndices as qe, findNonDisabledListIndex as Y } from "./als-react-ts-ui392.js";
+import { getFloatingFocusElement as He, isTypeableCombobox as $e, activeElement as Ce, getDocument as Be, contains as Te, getTarget as Ue } from "./als-react-ts-ui330.js";
+import { stopEvent as S, isVirtualClick as je, isVirtualPointerEvent as Je } from "./als-react-ts-ui305.js";
+import { listNavigation as me, focusOut as Qe } from "./als-react-ts-ui275.js";
+const Xe = "Escape";
+function te(o, p, c) {
+  switch (o) {
+    case "vertical":
+      return p;
+    case "horizontal":
+      return c;
+    default:
+      return p || c;
+  }
 }
-function ve(l, f, u) {
-  const {
-    rects: n,
-    placement: s
-  } = l;
-  return {
-    side: ke(f, L(s), u),
-    align: Me(s) || "center",
-    anchor: {
-      width: n.reference.width,
-      height: n.reference.height
+function Z(o, p) {
+  return te(p, o === Pe || o === ee, o === W || o === _);
+}
+function pe(o, p, c) {
+  return te(p, o === ee, c ? o === W : o === _) || o === "Enter" || o === " " || o === "";
+}
+function Ye(o, p, c) {
+  return te(p, c ? o === W : o === _, o === ee);
+}
+function Ze(o, p, c, s) {
+  const g = c ? o === _ : o === W, x = o === Pe;
+  return p === "both" || p === "horizontal" && s && s > 1 ? o === Xe : te(p, g, x);
+}
+function dt(o, p) {
+  const c = "rootStore" in o ? o.rootStore : o, s = c.useState("open"), g = c.useState("floatingElement"), x = c.useState("domReferenceElement"), ge = c.context.dataRef, {
+    listRef: n,
+    activeIndex: y,
+    onNavigate: Se = () => {
     },
-    positioner: {
-      width: n.floating.width,
-      height: n.floating.height
+    enabled: O = !0,
+    selectedIndex: N = null,
+    allowEscape: re = !1,
+    loopFocus: q = !1,
+    nested: b = !1,
+    rtl: E = !1,
+    virtual: f = !1,
+    focusItemOnOpen: M = "auto",
+    focusItemOnHover: ne = !0,
+    openOnArrowKeyDown: oe = !0,
+    disabledIndices: R = void 0,
+    orientation: d = "vertical",
+    parentOrientation: Ie,
+    cols: v = 1,
+    scrollItemIntoView: ve = !0,
+    itemSizes: Fe,
+    dense: Ae = !1,
+    id: Re,
+    externalTree: Ne
+  } = p;
+  process.env.NODE_ENV !== "production" && (re && (q || console.warn("`useListNavigation` looping must be enabled to allow escaping."), f || console.warn("`useListNavigation` must be virtual to allow escaping.")), d === "vertical" && v > 1 && console.warn("In grid list navigation mode (`cols` > 1), the `orientation` should", 'be either "horizontal" or "both".'));
+  const ke = He(g), k = G(ke), H = Ve(), C = Le(Ne);
+  A(() => {
+    ge.current.orientation = d;
+  }, [ge, d]);
+  const ie = $e(x), T = m.useRef(M), r = m.useRef(N ?? -1), P = m.useRef(null), F = m.useRef(!0), l = ae((e) => {
+    Se(r.current === -1 ? null : r.current, e);
+  }), he = m.useRef(l), D = m.useRef(!!g), xe = m.useRef(s), h = m.useRef(!1), $ = m.useRef(!1), ce = G(R), B = G(s), De = G(ve), K = G(N), ue = ae(() => {
+    function e(a) {
+      f ? C?.events.emit("virtualfocus", a) : ze(a, {
+        sync: h.current,
+        preventScroll: !0
+      });
     }
-  };
-}
-function wt(l) {
-  const {
-    // Public parameters
-    anchor: f,
-    positionMethod: u = "absolute",
-    side: n = "bottom",
-    sideOffset: s = 0,
-    align: b = "center",
-    alignOffset: H = 0,
-    collisionBoundary: J,
-    collisionPadding: Ce = 5,
-    sticky: T = !1,
-    arrowPadding: K = 5,
-    disableAnchorTracking: z = !1,
-    // Private parameters
-    keepMounted: B = !1,
-    floatingRootContext: $,
-    mounted: r,
-    collisionAvoidance: V,
-    shiftCrossAxis: w = !1,
-    nodeId: Fe,
-    adaptiveOrigin: I,
-    lazyFlip: N = !1,
-    externalTree: Le
-  } = l, [Q, Z] = a.useState(null);
-  !r && Q !== null && Z(null);
-  const A = V.side || "flip", S = V.align || "flip", He = V.fallbackAxisSide || "end", ee = typeof f == "function" ? f : void 0, Te = Ge(ee), te = ee ? Te : f, v = G(f), p = Je() === "rtl", ne = Q || {
-    top: "top",
-    right: "right",
-    bottom: "bottom",
-    left: "left",
-    "inline-end": p ? "left" : "right",
-    "inline-start": p ? "right" : "left"
-  }[n], ze = b === "center" ? ne : `${ne}-${b}`;
-  let e = Ce;
-  const d = 1, oe = n === "bottom" ? d : 0, ie = n === "top" ? d : 0, re = n === "right" ? d : 0, se = n === "left" ? d : 0;
-  typeof e == "number" ? e = {
-    top: e + oe,
-    right: e + se,
-    bottom: e + ie,
-    left: e + re
-  } : e && (e = {
-    top: (e.top || 0) + oe,
-    right: (e.right || 0) + se,
-    bottom: (e.bottom || 0) + ie,
-    left: (e.left || 0) + re
+    const i = n.current[r.current], t = $.current;
+    i && e(i), (h.current ? (a) => a() : requestAnimationFrame)(() => {
+      const a = n.current[r.current] || i;
+      if (!a)
+        return;
+      i || e(a);
+      const I = De.current;
+      I && // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      se && (t || !F.current) && a.scrollIntoView?.(typeof I == "boolean" ? {
+        block: "nearest",
+        inline: "nearest"
+      } : I);
+    });
   });
-  const D = {
-    boundary: J === "clipping-ancestors" ? "clippingAncestors" : J,
-    padding: e
-  }, m = a.useRef(null), U = G(s), Y = G(H), M = [et((t) => {
-    const o = ve(t, n, p), c = typeof U.current == "function" ? U.current(o) : U.current, i = typeof Y.current == "function" ? Y.current(o) : Y.current;
+  A(() => {
+    O && (s && g ? (r.current = N ?? -1, T.current && N != null && ($.current = !0, l())) : D.current && (r.current = -1, he.current()));
+  }, [O, s, g, N, l]), A(() => {
+    if (O) {
+      if (!s) {
+        h.current = !1;
+        return;
+      }
+      if (g)
+        if (y == null) {
+          if (h.current = !1, K.current != null)
+            return;
+          if (D.current && (r.current = -1, ue()), (!xe.current || !D.current) && T.current && (P.current != null || T.current === !0 && P.current == null)) {
+            let e = 0;
+            const i = () => {
+              n.current[0] == null ? (e < 2 && (e ? requestAnimationFrame : queueMicrotask)(i), e += 1) : (r.current = P.current == null || pe(P.current, d, E) || b ? fe(n) : Me(n), P.current = null, l());
+            };
+            i();
+          }
+        } else be(n, y) || (r.current = y, ue(), $.current = !1);
+    }
+  }, [O, s, g, y, K, b, n, d, E, l, ue, ce]), A(() => {
+    if (!O || g || !C || f || !D.current)
+      return;
+    const e = C.nodesRef.current, i = e.find((a) => a.id === H)?.context?.elements.floating, t = Ce(Be(g)), u = e.some((a) => a.context && Te(a.context.elements.floating, t));
+    i && !u && F.current && i.focus({
+      preventScroll: !0
+    });
+  }, [O, g, C, H, f]), A(() => {
+    he.current = l, xe.current = s, D.current = !!g;
+  }), A(() => {
+    s || (P.current = null, T.current = M);
+  }, [s, M]);
+  const Ee = y != null, se = m.useMemo(() => {
+    function e(t) {
+      if (!B.current)
+        return;
+      const u = n.current.indexOf(t.currentTarget);
+      u !== -1 && r.current !== u && (r.current = u, l(t));
+    }
     return {
-      mainAxis: c,
-      crossAxis: i,
-      alignmentAxis: i
+      onFocus(t) {
+        h.current = !0, e(t);
+      },
+      onClick: ({
+        currentTarget: t
+      }) => t.focus({
+        preventScroll: !0
+      }),
+      // Safari
+      onMouseMove(t) {
+        h.current = !0, $.current = !1, ne && e(t);
+      },
+      onPointerLeave(t) {
+        if (!B.current || !F.current || t.pointerType === "touch")
+          return;
+        h.current = !0;
+        const u = t.relatedTarget;
+        !ne || n.current.includes(u) || (r.current = -1, l(t), f || k.current?.focus({
+          preventScroll: !0
+        }));
+      }
     };
-  }, [typeof s != "function" ? s : 0, typeof H != "function" ? H : 0, p, n])], ce = S === "none" && A !== "shift", le = !ce && (T || w || A === "shift"), ae = A === "none" ? null : Ze({
-    ...D,
-    // Ensure the popup flips if it's been limited by its --available-height and it resizes.
-    // Since the size() padding is smaller than the flip() padding, flip() will take precedence.
-    padding: {
-      top: e.top + d,
-      right: e.right + d,
-      bottom: e.bottom + d,
-      left: e.left + d
+  }, [B, k, ne, n, l, f]), U = m.useCallback(() => Ie ?? C?.nodesRef.current.find((e) => e.id === H)?.context?.dataRef?.current.orientation, [H, C, Ie]), V = ae((e) => {
+    if (F.current = !1, h.current = !0, e.which === 229 || !B.current && e.currentTarget === k.current)
+      return;
+    if (b && Ze(e.key, d, E, v)) {
+      Z(e.key, U()) || S(e), c.setOpen(!1, X(me, e.nativeEvent)), ye(x) && (f ? C?.events.emit("virtualfocus", x) : x.focus());
+      return;
+    }
+    const i = r.current, t = fe(n, R), u = Me(n, R);
+    if (ie || (e.key === "Home" && (S(e), r.current = t, l(e)), e.key === "End" && (S(e), r.current = u, l(e))), v > 1) {
+      const a = Fe || Array.from({
+        length: n.current.length
+      }, () => ({
+        width: 1,
+        height: 1
+      })), I = Ge(a, v, Ae), L = I.findIndex((w) => w != null && !de(n, w, R)), le = I.reduce((w, z, Ke) => z != null && !de(n, z, R) ? Ke : w, -1), Q = I[We({
+        current: I.map((w) => w != null ? n.current[w] : null)
+      }, {
+        event: e,
+        orientation: d,
+        loopFocus: q,
+        rtl: E,
+        cols: v,
+        // treat undefined (empty grid spaces) as disabled indices so we
+        // don't end up in them
+        disabledIndices: qe([...(typeof R != "function" ? R : null) || n.current.map((w, z) => de(n, z, R) ? z : void 0), void 0], I),
+        minIndex: L,
+        maxIndex: le,
+        prevIndex: _e(
+          r.current > u ? t : r.current,
+          a,
+          I,
+          v,
+          // use a corner matching the edge closest to the direction
+          // we're moving in so we don't end up in the same item. Prefer
+          // top/left over bottom/right.
+          // eslint-disable-next-line no-nested-ternary
+          e.key === ee ? "bl" : e.key === (E ? W : _) ? "tr" : "tl"
+        ),
+        stopEvent: !0
+      })];
+      if (Q != null && (r.current = Q, l(e)), d === "both")
+        return;
+    }
+    if (Z(e.key, d)) {
+      if (S(e), s && !f && Ce(e.currentTarget.ownerDocument) === e.currentTarget) {
+        r.current = pe(e.key, d, E) ? t : u, l(e);
+        return;
+      }
+      pe(e.key, d, E) ? q ? i >= u ? re && i !== n.current.length ? r.current = -1 : (h.current = !1, r.current = t) : r.current = Y(n, {
+        startingIndex: i,
+        disabledIndices: R
+      }) : r.current = Math.min(u, Y(n, {
+        startingIndex: i,
+        disabledIndices: R
+      })) : q ? i <= t ? re && i !== -1 ? r.current = n.current.length : (h.current = !1, r.current = u) : r.current = Y(n, {
+        startingIndex: i,
+        decrement: !0,
+        disabledIndices: R
+      }) : r.current = Math.max(t, Y(n, {
+        startingIndex: i,
+        decrement: !0,
+        disabledIndices: R
+      })), be(n, r.current) && (r.current = -1), l(e);
+    }
+  }), j = m.useMemo(() => f && s && Ee && {
+    "aria-activedescendant": `${Re}-${y}`
+  }, [f, s, Ee, Re, y]), Oe = m.useMemo(() => ({
+    "aria-orientation": d === "both" ? void 0 : d,
+    ...ie ? {} : j,
+    onKeyDown(e) {
+      if (e.key === "Tab" && e.shiftKey && s && !f) {
+        const i = Ue(e.nativeEvent);
+        if (i && !Te(k.current, i))
+          return;
+        S(e), c.setOpen(!1, X(Qe, e.nativeEvent)), ye(x) && x.focus();
+        return;
+      }
+      V(e);
     },
-    mainAxis: !w && A === "flip",
-    crossAxis: S === "flip" ? "alignment" : !1,
-    fallbackAxisSideDirection: He
-  }), fe = ce ? null : nt((t) => {
-    const o = qe(t.elements.floating).documentElement;
+    onPointerMove() {
+      F.current = !0;
+    }
+  }), [j, V, k, d, ie, c, s, f, x]), J = m.useMemo(() => {
+    function e(t) {
+      M === "auto" && je(t.nativeEvent) && (T.current = !f);
+    }
+    function i(t) {
+      T.current = M, M === "auto" && Je(t.nativeEvent) && (T.current = !0);
+    }
     return {
-      ...D,
-      // Use the Layout Viewport to avoid shifting around when pinch-zooming
-      // for context menus.
-      rootBoundary: w ? {
-        x: 0,
-        y: 0,
-        width: o.clientWidth,
-        height: o.clientHeight
-      } : void 0,
-      mainAxis: S !== "none",
-      crossAxis: le,
-      limiter: T || w ? void 0 : ot((c) => {
-        if (!m.current)
-          return {};
-        const {
-          width: i,
-          height: x
-        } = m.current.getBoundingClientRect(), y = Ee(L(c.placement)), F = y === "y" ? i : x, j = y === "y" ? e.left + e.right : e.top + e.bottom;
-        return {
-          offset: F / 2 + j / 2
-        };
-      })
-    };
-  }, [D, T, w, e, S]);
-  A === "shift" || S === "shift" || b === "center" ? M.push(fe, ae) : M.push(ae, fe), M.push(tt({
-    ...D,
-    apply({
-      elements: {
-        floating: t
+      onKeyDown(t) {
+        const u = c.select("open");
+        F.current = !1;
+        const a = t.key.startsWith("Arrow"), I = Ye(t.key, U(), E), L = Z(t.key, d), le = (b ? I : L) || t.key === "Enter" || t.key.trim() === "";
+        if (f && u)
+          return V(t);
+        if (!(!u && !oe && a)) {
+          if (le) {
+            const Q = Z(t.key, U());
+            P.current = b && Q ? null : t.key;
+          }
+          if (b) {
+            I && (S(t), u ? (r.current = fe(n, ce.current), l(t)) : c.setOpen(!0, X(me, t.nativeEvent, t.currentTarget)));
+            return;
+          }
+          L && (K.current != null && (r.current = K.current), S(t), !u && oe ? c.setOpen(!0, X(me, t.nativeEvent, t.currentTarget)) : V(t), u && l(t));
+        }
       },
-      rects: {
-        reference: o
+      onFocus(t) {
+        c.select("open") && !f && (r.current = -1, l(t));
       },
-      availableWidth: c,
-      availableHeight: i
-    }) {
-      Object.entries({
-        "--available-width": `${c}px`,
-        "--available-height": `${i}px`,
-        "--anchor-width": `${o.width}px`,
-        "--anchor-height": `${o.height}px`
-      }).forEach(([x, y]) => {
-        t.style.setProperty(x, y);
-      });
-    }
-  }), Ke(() => ({
-    // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,
-    // we'll create a fake element.
-    element: m.current || document.createElement("div"),
-    padding: K,
-    offsetParent: "floating"
-  }), [K]), {
-    name: "transformOrigin",
-    fn(t) {
-      const {
-        elements: o,
-        middlewareData: c,
-        placement: i,
-        rects: x,
-        y
-      } = t, F = L(i), j = Ee(F), Oe = m.current, Be = c.arrow?.x || 0, Ve = c.arrow?.y || 0, Ie = Oe?.clientWidth || 0, Ue = Oe?.clientHeight || 0, _ = Be + Ie / 2, Pe = Ve + Ue / 2, Ye = Math.abs(c.shift?.y || 0), We = x.reference.height / 2, E = typeof s == "function" ? s(ve(t, n, p)) : s, Xe = Ye > E, je = {
-        top: `${_}px calc(100% + ${E}px)`,
-        bottom: `${_}px ${-E}px`,
-        left: `calc(100% + ${E}px) ${Pe}px`,
-        right: `${-E}px ${Pe}px`
-      }[F], _e = `${_}px ${x.reference.y + We - y}px`;
-      return o.floating.style.setProperty("--transform-origin", le && j === "y" && Xe ? _e : je), {};
-    }
-  }, Ne, I), q(() => {
-    !r && $ && $.update({
-      referenceElement: null,
-      floatingElement: null,
-      domReferenceElement: null
-    });
-  }, [r, $]);
-  const W = a.useMemo(() => ({
-    elementResize: !z && typeof ResizeObserver < "u",
-    layoutShift: !z && typeof IntersectionObserver < "u"
-  }), [z]), {
-    refs: h,
-    elements: R,
-    x: de,
-    y: ue,
-    middlewareData: g,
-    update: k,
-    placement: pe,
-    context: me,
-    isPositioned: O,
-    floatingStyles: he
-  } = it({
-    rootContext: $,
-    placement: ze,
-    middleware: M,
-    strategy: u,
-    whileElementsMounted: B ? void 0 : (...t) => $e(...t, W),
-    nodeId: Fe,
-    externalTree: Le
-  }), {
-    sideX: ge,
-    sideY: xe
-  } = g.adaptiveOrigin || Qe, X = O ? u : "fixed", ye = a.useMemo(() => I ? {
-    position: X,
-    [ge]: de,
-    [xe]: ue
-  } : {
-    position: X,
-    ...he
-  }, [I, X, ge, de, xe, ue, he]), C = a.useRef(null);
-  q(() => {
-    if (!r)
-      return;
-    const t = v.current, o = typeof t == "function" ? t() : t, i = (De(o) ? o.current : o) || null || null;
-    i !== C.current && (h.setPositionReference(i), C.current = i);
-  }, [r, h, te, v]), a.useEffect(() => {
-    if (!r)
-      return;
-    const t = v.current;
-    typeof t != "function" && De(t) && t.current !== C.current && (h.setPositionReference(t.current), C.current = t.current);
-  }, [r, h, te, v]), a.useEffect(() => {
-    if (B && r && R.domReference && R.floating)
-      return $e(R.domReference, R.floating, k, W);
-  }, [B, r, R, k, W]);
-  const P = L(pe), be = ke(n, P, p), we = Me(pe) || "center", Ae = !!g.hide?.referenceHidden;
-  q(() => {
-    N && r && O && Z(P);
-  }, [N, r, O, P]);
-  const Se = a.useMemo(() => ({
-    position: "absolute",
-    top: g.arrow?.y,
-    left: g.arrow?.x
-  }), [g.arrow]), Re = g.arrow?.centerOffset !== 0;
-  return a.useMemo(() => ({
-    positionerStyles: ye,
-    arrowStyles: Se,
-    arrowRef: m,
-    arrowUncentered: Re,
-    side: be,
-    align: we,
-    physicalSide: P,
-    anchorHidden: Ae,
-    refs: h,
-    context: me,
-    isPositioned: O,
-    update: k
-  }), [ye, Se, m, Re, be, we, P, Ae, h, me, O, k]);
-}
-function De(l) {
-  return l != null && "current" in l;
+      onPointerDown: i,
+      onPointerEnter: i,
+      onMouseDown: e,
+      onClick: e
+    };
+  }, [V, ce, M, n, b, l, c, oe, d, U, E, K, f]), we = m.useMemo(() => ({
+    ...j,
+    ...J
+  }), [j, J]);
+  return m.useMemo(() => O ? {
+    reference: we,
+    floating: Oe,
+    item: se,
+    trigger: J
+  } : {}, [O, we, Oe, J, se]);
 }
 export {
-  wt as useAnchorPositioning
+  Xe as ESCAPE,
+  dt as useListNavigation
 };