@arolariu/components 0.0.16 → 0.0.17

package/dist/es/node_modules/@radix-ui/react-radio-group/dist/index.js

@@ -0,0 +1,224 @@
+import * as s from "react";
+import { composeEventHandlers as y } from "../../primitive/dist/index.js";
+import { useComposedRefs as P } from "../../react-compose-refs/dist/index.js";
+import { createContextScope as w } from "../../react-context/dist/index.js";
+import { Primitive as k } from "../../react-primitive/dist/index.js";
+import { createRovingFocusGroupScope as E, Root as L, Item as q } from "../../react-roving-focus/dist/index.js";
+import { useControllableState as K } from "../../react-use-controllable-state/dist/index.js";
+import { useDirection as V } from "../../react-direction/dist/index.js";
+import { useSize as T } from "../../react-use-size/dist/index.js";
+import { usePrevious as j } from "../../react-use-previous/dist/index.js";
+import { Presence as U } from "../../react-presence/dist/index.js";
+import { jsx as p, jsxs as z } from "react/jsx-runtime";
+var C = "Radio", [B, G] = w(C), [H, W] = B(C), S = s.forwardRef(
+  (t, c) => {
+    const {
+      __scopeRadio: e,
+      name: n,
+      checked: o = !1,
+      required: r,
+      disabled: a,
+      value: l = "on",
+      onCheck: d,
+      form: f,
+      ...R
+    } = t, [u, m] = s.useState(null), i = P(c, (b) => m(b)), v = s.useRef(!1), h = u ? f || !!u.closest("form") : !0;
+    return /* @__PURE__ */ z(H, { scope: e, checked: o, disabled: a, children: [
+      /* @__PURE__ */ p(
+        k.button,
+        {
+          type: "button",
+          role: "radio",
+          "aria-checked": o,
+          "data-state": A(o),
+          "data-disabled": a ? "" : void 0,
+          disabled: a,
+          value: l,
+          ...R,
+          ref: i,
+          onClick: y(t.onClick, (b) => {
+            o || d == null || d(), h && (v.current = b.isPropagationStopped(), v.current || b.stopPropagation());
+          })
+        }
+      ),
+      h && /* @__PURE__ */ p(
+        X,
+        {
+          control: u,
+          bubbles: !v.current,
+          name: n,
+          value: l,
+          checked: o,
+          required: r,
+          disabled: a,
+          form: f,
+          style: { transform: "translateX(-100%)" }
+        }
+      )
+    ] });
+  }
+);
+S.displayName = C;
+var g = "RadioIndicator", _ = s.forwardRef(
+  (t, c) => {
+    const { __scopeRadio: e, forceMount: n, ...o } = t, r = W(g, e);
+    return /* @__PURE__ */ p(U, { present: n || r.checked, children: /* @__PURE__ */ p(
+      k.span,
+      {
+        "data-state": A(r.checked),
+        "data-disabled": r.disabled ? "" : void 0,
+        ...o,
+        ref: c
+      }
+    ) });
+  }
+);
+_.displayName = g;
+var X = (t) => {
+  const { control: c, checked: e, bubbles: n = !0, ...o } = t, r = s.useRef(null), a = j(e), l = T(c);
+  return s.useEffect(() => {
+    const d = r.current, f = window.HTMLInputElement.prototype, u = Object.getOwnPropertyDescriptor(f, "checked").set;
+    if (a !== e && u) {
+      const m = new Event("click", { bubbles: n });
+      u.call(d, e), d.dispatchEvent(m);
+    }
+  }, [a, e, n]), /* @__PURE__ */ p(
+    "input",
+    {
+      type: "radio",
+      "aria-hidden": !0,
+      defaultChecked: e,
+      ...o,
+      tabIndex: -1,
+      ref: r,
+      style: {
+        ...t.style,
+        ...l,
+        position: "absolute",
+        pointerEvents: "none",
+        opacity: 0,
+        margin: 0
+      }
+    }
+  );
+};
+function A(t) {
+  return t ? "checked" : "unchecked";
+}
+var Y = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"], I = "RadioGroup", [J, pe] = w(I, [
+  E,
+  G
+]), N = E(), x = G(), [Q, Z] = J(I), D = s.forwardRef(
+  (t, c) => {
+    const {
+      __scopeRadioGroup: e,
+      name: n,
+      defaultValue: o,
+      value: r,
+      required: a = !1,
+      disabled: l = !1,
+      orientation: d,
+      dir: f,
+      loop: R = !0,
+      onValueChange: u,
+      ...m
+    } = t, i = N(e), v = V(f), [h, b] = K({
+      prop: r,
+      defaultProp: o,
+      onChange: u
+    });
+    return /* @__PURE__ */ p(
+      Q,
+      {
+        scope: e,
+        name: n,
+        required: a,
+        disabled: l,
+        value: h,
+        onValueChange: b,
+        children: /* @__PURE__ */ p(
+          L,
+          {
+            asChild: !0,
+            ...i,
+            orientation: d,
+            dir: v,
+            loop: R,
+            children: /* @__PURE__ */ p(
+              k.div,
+              {
+                role: "radiogroup",
+                "aria-required": a,
+                "aria-orientation": d,
+                "data-disabled": l ? "" : void 0,
+                dir: v,
+                ...m,
+                ref: c
+              }
+            )
+          }
+        )
+      }
+    );
+  }
+);
+D.displayName = I;
+var M = "RadioGroupItem", O = s.forwardRef(
+  (t, c) => {
+    const { __scopeRadioGroup: e, disabled: n, ...o } = t, r = Z(M, e), a = r.disabled || n, l = N(e), d = x(e), f = s.useRef(null), R = P(c, f), u = r.value === o.value, m = s.useRef(!1);
+    return s.useEffect(() => {
+      const i = (h) => {
+        Y.includes(h.key) && (m.current = !0);
+      }, v = () => m.current = !1;
+      return document.addEventListener("keydown", i), document.addEventListener("keyup", v), () => {
+        document.removeEventListener("keydown", i), document.removeEventListener("keyup", v);
+      };
+    }, []), /* @__PURE__ */ p(
+      q,
+      {
+        asChild: !0,
+        ...l,
+        focusable: !a,
+        active: u,
+        children: /* @__PURE__ */ p(
+          S,
+          {
+            disabled: a,
+            required: r.required,
+            checked: u,
+            ...d,
+            ...o,
+            name: r.name,
+            ref: R,
+            onCheck: () => r.onValueChange(o.value),
+            onKeyDown: y((i) => {
+              i.key === "Enter" && i.preventDefault();
+            }),
+            onFocus: y(o.onFocus, () => {
+              var i;
+              m.current && ((i = f.current) == null || i.click());
+            })
+          }
+        )
+      }
+    );
+  }
+);
+O.displayName = M;
+var $ = "RadioGroupIndicator", F = s.forwardRef(
+  (t, c) => {
+    const { __scopeRadioGroup: e, ...n } = t, o = x(e);
+    return /* @__PURE__ */ p(_, { ...o, ...n, ref: c });
+  }
+);
+F.displayName = $;
+var le = D, fe = O, me = F;
+export {
+  me as Indicator,
+  fe as Item,
+  D as RadioGroup,
+  F as RadioGroupIndicator,
+  O as RadioGroupItem,
+  le as Root,
+  pe as createRadioGroupScope
+};

package/dist/es/node_modules/@radix-ui/react-roving-focus/dist/index.js

@@ -0,0 +1,180 @@
+import * as s from "react";
+import { composeEventHandlers as p } from "../../primitive/dist/index.js";
+import { createCollection as V } from "../../react-collection/dist/index.js";
+import { useComposedRefs as j } from "../../react-compose-refs/dist/index.js";
+import { createContextScope as z } from "../../react-context/dist/index.js";
+import { useId as q } from "../../react-id/dist/index.js";
+import { Primitive as x } from "../../react-primitive/dist/index.js";
+import { useCallbackRef as J } from "../../react-use-callback-ref/dist/index.js";
+import { useControllableState as Q } from "../../react-use-controllable-state/dist/index.js";
+import { useDirection as W } from "../../react-direction/dist/index.js";
+import { jsx as d } from "react/jsx-runtime";
+var h = "rovingFocusGroup.onEntryFocus", X = { bubbles: !1, cancelable: !0 }, b = "RovingFocusGroup", [y, G, Z] = V(b), [$, Fe] = z(
+  b,
+  [Z]
+), [ee, oe] = $(b), N = s.forwardRef(
+  (e, r) => /* @__PURE__ */ d(y.Provider, { scope: e.__scopeRovingFocusGroup, children: /* @__PURE__ */ d(y.Slot, { scope: e.__scopeRovingFocusGroup, children: /* @__PURE__ */ d(te, { ...e, ref: r }) }) })
+);
+N.displayName = b;
+var te = s.forwardRef((e, r) => {
+  const {
+    __scopeRovingFocusGroup: c,
+    orientation: o,
+    loop: F = !1,
+    dir: g,
+    currentTabStopId: R,
+    defaultCurrentTabStopId: E,
+    onCurrentTabStopIdChange: m,
+    onEntryFocus: u,
+    preventScrollOnEntryFocus: w = !1,
+    ...C
+  } = e, v = s.useRef(null), I = j(r, v), t = W(g), [f = null, T] = Q({
+    prop: R,
+    defaultProp: E,
+    onChange: m
+  }), [a, i] = s.useState(!1), S = J(u), k = G(c), A = s.useRef(!1), [L, D] = s.useState(0);
+  return s.useEffect(() => {
+    const n = v.current;
+    if (n)
+      return n.addEventListener(h, S), () => n.removeEventListener(h, S);
+  }, [S]), /* @__PURE__ */ d(
+    ee,
+    {
+      scope: c,
+      orientation: o,
+      dir: t,
+      loop: F,
+      currentTabStopId: f,
+      onItemFocus: s.useCallback(
+        (n) => T(n),
+        [T]
+      ),
+      onItemShiftTab: s.useCallback(() => i(!0), []),
+      onFocusableItemAdd: s.useCallback(
+        () => D((n) => n + 1),
+        []
+      ),
+      onFocusableItemRemove: s.useCallback(
+        () => D((n) => n - 1),
+        []
+      ),
+      children: /* @__PURE__ */ d(
+        x.div,
+        {
+          tabIndex: a || L === 0 ? -1 : 0,
+          "data-orientation": o,
+          ...C,
+          ref: I,
+          style: { outline: "none", ...e.style },
+          onMouseDown: p(e.onMouseDown, () => {
+            A.current = !0;
+          }),
+          onFocus: p(e.onFocus, (n) => {
+            const U = !A.current;
+            if (n.target === n.currentTarget && U && !a) {
+              const P = new CustomEvent(h, X);
+              if (n.currentTarget.dispatchEvent(P), !P.defaultPrevented) {
+                const _ = k().filter((l) => l.focusable), B = _.find((l) => l.active), Y = _.find((l) => l.id === f), H = [B, Y, ..._].filter(
+                  Boolean
+                ).map((l) => l.ref.current);
+                M(H, w);
+              }
+            }
+            A.current = !1;
+          }),
+          onBlur: p(e.onBlur, () => i(!1))
+        }
+      )
+    }
+  );
+}), O = "RovingFocusGroupItem", K = s.forwardRef(
+  (e, r) => {
+    const {
+      __scopeRovingFocusGroup: c,
+      focusable: o = !0,
+      active: F = !1,
+      tabStopId: g,
+      ...R
+    } = e, E = q(), m = g || E, u = oe(O, c), w = u.currentTabStopId === m, C = G(c), { onFocusableItemAdd: v, onFocusableItemRemove: I } = u;
+    return s.useEffect(() => {
+      if (o)
+        return v(), () => I();
+    }, [o, v, I]), /* @__PURE__ */ d(
+      y.ItemSlot,
+      {
+        scope: c,
+        id: m,
+        focusable: o,
+        active: F,
+        children: /* @__PURE__ */ d(
+          x.span,
+          {
+            tabIndex: w ? 0 : -1,
+            "data-orientation": u.orientation,
+            ...R,
+            ref: r,
+            onMouseDown: p(e.onMouseDown, (t) => {
+              o ? u.onItemFocus(m) : t.preventDefault();
+            }),
+            onFocus: p(e.onFocus, () => u.onItemFocus(m)),
+            onKeyDown: p(e.onKeyDown, (t) => {
+              if (t.key === "Tab" && t.shiftKey) {
+                u.onItemShiftTab();
+                return;
+              }
+              if (t.target !== t.currentTarget) return;
+              const f = se(t, u.orientation, u.dir);
+              if (f !== void 0) {
+                if (t.metaKey || t.ctrlKey || t.altKey || t.shiftKey) return;
+                t.preventDefault();
+                let a = C().filter((i) => i.focusable).map((i) => i.ref.current);
+                if (f === "last") a.reverse();
+                else if (f === "prev" || f === "next") {
+                  f === "prev" && a.reverse();
+                  const i = a.indexOf(t.currentTarget);
+                  a = u.loop ? ce(a, i + 1) : a.slice(i + 1);
+                }
+                setTimeout(() => M(a));
+              }
+            })
+          }
+        )
+      }
+    );
+  }
+);
+K.displayName = O;
+var re = {
+  ArrowLeft: "prev",
+  ArrowUp: "prev",
+  ArrowRight: "next",
+  ArrowDown: "next",
+  PageUp: "first",
+  Home: "first",
+  PageDown: "last",
+  End: "last"
+};
+function ne(e, r) {
+  return r !== "rtl" ? e : e === "ArrowLeft" ? "ArrowRight" : e === "ArrowRight" ? "ArrowLeft" : e;
+}
+function se(e, r, c) {
+  const o = ne(e.key, c);
+  if (!(r === "vertical" && ["ArrowLeft", "ArrowRight"].includes(o)) && !(r === "horizontal" && ["ArrowUp", "ArrowDown"].includes(o)))
+    return re[o];
+}
+function M(e, r = !1) {
+  const c = document.activeElement;
+  for (const o of e)
+    if (o === c || (o.focus({ preventScroll: r }), document.activeElement !== c)) return;
+}
+function ce(e, r) {
+  return e.map((c, o) => e[(r + o) % e.length]);
+}
+var ge = N, Re = K;
+export {
+  Re as Item,
+  ge as Root,
+  N as RovingFocusGroup,
+  K as RovingFocusGroupItem,
+  Fe as createRovingFocusGroupScope
+};