fina-react-ds 0.0.0

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js

@@ -0,0 +1,159 @@
+var E = Object.defineProperty;
+var n = (t, e) => E(t, "name", { value: e, configurable: !0 });
+function l() {
+  return typeof window < "u";
+}
+n(l, "hasWindow");
+function a(t) {
+  return m(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+n(a, "getNodeName");
+function c(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+n(c, "getWindow");
+function T(t) {
+  var e;
+  return (e = (m(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+n(T, "getDocumentElement");
+function m(t) {
+  return l() ? t instanceof Node || t instanceof c(t).Node : !1;
+}
+n(m, "isNode");
+function w(t) {
+  return l() ? t instanceof Element || t instanceof c(t).Element : !1;
+}
+n(w, "isElement");
+function y(t) {
+  return l() ? t instanceof HTMLElement || t instanceof c(t).HTMLElement : !1;
+}
+n(y, "isHTMLElement");
+function d(t) {
+  return !l() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof c(t).ShadowRoot;
+}
+n(d, "isShadowRoot");
+const v = /* @__PURE__ */ new Set(["inline", "contents"]);
+function h(t) {
+  const {
+    overflow: e,
+    overflowX: o,
+    overflowY: r,
+    display: i
+  } = b(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + r + o) && !v.has(i);
+}
+n(h, "isOverflowElement");
+const L = /* @__PURE__ */ new Set(["table", "td", "th"]);
+function H(t) {
+  return L.has(a(t));
+}
+n(H, "isTableElement");
+const D = [":popover-open", ":modal"];
+function C(t) {
+  return D.some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+n(C, "isTopLayer");
+const k = ["transform", "translate", "scale", "rotate", "perspective"], V = ["transform", "translate", "scale", "rotate", "perspective", "filter"], O = ["paint", "layout", "strict", "content"];
+function R(t) {
+  const e = _(), o = w(t) ? b(t) : t;
+  return k.some((r) => o[r] ? o[r] !== "none" : !1) || (o.containerType ? o.containerType !== "normal" : !1) || !e && (o.backdropFilter ? o.backdropFilter !== "none" : !1) || !e && (o.filter ? o.filter !== "none" : !1) || V.some((r) => (o.willChange || "").includes(r)) || O.some((r) => (o.contain || "").includes(r));
+}
+n(R, "isContainingBlock");
+function M(t) {
+  let e = u(t);
+  for (; y(e) && !S(e); ) {
+    if (R(e))
+      return e;
+    if (C(e))
+      return null;
+    e = u(e);
+  }
+  return null;
+}
+n(M, "getContainingBlock");
+function _() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+n(_, "isWebKit");
+const A = /* @__PURE__ */ new Set(["html", "body", "#document"]);
+function S(t) {
+  return A.has(a(t));
+}
+n(S, "isLastTraversableNode");
+function b(t) {
+  return c(t).getComputedStyle(t);
+}
+n(b, "getComputedStyle");
+function P(t) {
+  return w(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+n(P, "getNodeScroll");
+function u(t) {
+  if (a(t) === "html")
+    return t;
+  const e = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    d(t) && t.host || // Fallback.
+    T(t)
+  );
+  return d(e) ? e.host : e;
+}
+n(u, "getParentNode");
+function g(t) {
+  const e = u(t);
+  return S(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : y(e) && h(e) ? e : g(e);
+}
+n(g, "getNearestOverflowAncestor");
+function p(t, e, o) {
+  var r;
+  e === void 0 && (e = []), o === void 0 && (o = !0);
+  const i = g(t), N = i === ((r = t.ownerDocument) == null ? void 0 : r.body), s = c(i);
+  if (N) {
+    const f = B(s);
+    return e.concat(s, s.visualViewport || [], h(i) ? i : [], f && o ? p(f) : []);
+  }
+  return e.concat(i, p(i, [], o));
+}
+n(p, "getOverflowAncestors");
+function B(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+n(B, "getFrameElement");
+export {
+  b as getComputedStyle,
+  M as getContainingBlock,
+  T as getDocumentElement,
+  B as getFrameElement,
+  g as getNearestOverflowAncestor,
+  a as getNodeName,
+  P as getNodeScroll,
+  p as getOverflowAncestors,
+  u as getParentNode,
+  c as getWindow,
+  R as isContainingBlock,
+  w as isElement,
+  y as isHTMLElement,
+  S as isLastTraversableNode,
+  m as isNode,
+  h as isOverflowElement,
+  d as isShadowRoot,
+  H as isTableElement,
+  C as isTopLayer,
+  _ as isWebKit
+};

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.js

@@ -0,0 +1,149 @@
+var p = Object.defineProperty;
+var n = (t, e) => p(t, "name", { value: e, configurable: !0 });
+const E = ["top", "right", "bottom", "left"], h = Math.min, x = Math.max, R = Math.round, T = Math.floor, k = /* @__PURE__ */ n((t) => ({
+  x: t,
+  y: t
+}), "createCoords"), b = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, d = {
+  start: "end",
+  end: "start"
+};
+function q(t, e, o) {
+  return x(t, h(e, o));
+}
+n(q, "clamp");
+function z(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+n(z, "evaluate");
+function a(t) {
+  return t.split("-")[0];
+}
+n(a, "getSide");
+function m(t) {
+  return t.split("-")[1];
+}
+n(m, "getAlignment");
+function A(t) {
+  return t === "x" ? "y" : "x";
+}
+n(A, "getOppositeAxis");
+function P(t) {
+  return t === "y" ? "height" : "width";
+}
+n(P, "getAxisLength");
+const y = /* @__PURE__ */ new Set(["top", "bottom"]);
+function M(t) {
+  return y.has(a(t)) ? "y" : "x";
+}
+n(M, "getSideAxis");
+function O(t) {
+  return A(M(t));
+}
+n(O, "getAlignmentAxis");
+function B(t, e, o) {
+  o === void 0 && (o = !1);
+  const c = m(t), r = O(t), i = P(r);
+  let s = r === "x" ? c === (o ? "end" : "start") ? "right" : "left" : c === "start" ? "bottom" : "top";
+  return e.reference[i] > e.floating[i] && (s = u(s)), [s, u(s)];
+}
+n(B, "getAlignmentSides");
+function D(t) {
+  const e = u(t);
+  return [f(t), e, f(e)];
+}
+n(D, "getExpandedPlacements");
+function f(t) {
+  return t.replace(/start|end/g, (e) => d[e]);
+}
+n(f, "getOppositeAlignmentPlacement");
+const l = ["left", "right"], g = ["right", "left"], S = ["top", "bottom"], w = ["bottom", "top"];
+function j(t, e, o) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return o ? e ? g : l : e ? l : g;
+    case "left":
+    case "right":
+      return e ? S : w;
+    default:
+      return [];
+  }
+}
+n(j, "getSideList");
+function F(t, e, o, c) {
+  const r = m(t);
+  let i = j(a(t), o === "start", c);
+  return r && (i = i.map((s) => s + "-" + r), e && (i = i.concat(i.map(f)))), i;
+}
+n(F, "getOppositeAxisPlacements");
+function u(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => b[e]);
+}
+n(u, "getOppositePlacement");
+function C(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+n(C, "expandPaddingObject");
+function G(t) {
+  return typeof t != "number" ? C(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+n(G, "getPaddingObject");
+function H(t) {
+  const {
+    x: e,
+    y: o,
+    width: c,
+    height: r
+  } = t;
+  return {
+    width: c,
+    height: r,
+    top: o,
+    left: e,
+    right: e + c,
+    bottom: o + r,
+    x: e,
+    y: o
+  };
+}
+n(H, "rectToClientRect");
+export {
+  q as clamp,
+  k as createCoords,
+  z as evaluate,
+  C as expandPaddingObject,
+  T as floor,
+  m as getAlignment,
+  O as getAlignmentAxis,
+  B as getAlignmentSides,
+  P as getAxisLength,
+  D as getExpandedPlacements,
+  f as getOppositeAlignmentPlacement,
+  A as getOppositeAxis,
+  F as getOppositeAxisPlacements,
+  u as getOppositePlacement,
+  G as getPaddingObject,
+  a as getSide,
+  M as getSideAxis,
+  x as max,
+  h as min,
+  H as rectToClientRect,
+  R as round,
+  E as sides
+};

package/dist/node_modules/@radix-ui/primitive/dist/index.js

@@ -0,0 +1,12 @@
+var h = Object.defineProperty;
+var p = (f, c) => h(f, "name", { value: c, configurable: !0 });
+function P(f, c, { checkForDefaultPrevented: u = !0 } = {}) {
+  return /* @__PURE__ */ p(function(s) {
+    if (f == null || f(s), u === !1 || !s.defaultPrevented)
+      return c == null ? void 0 : c(s);
+  }, "handleEvent");
+}
+p(P, "composeEventHandlers");
+export {
+  P as composeEventHandlers
+};

package/dist/node_modules/@radix-ui/react-arrow/dist/index.js

@@ -0,0 +1,24 @@
+import * as n from "react";
+import { Primitive as p } from "../../react-primitive/dist/index.js";
+import { jsx as o } from "react/jsx-runtime";
+var v = "Arrow", e = n.forwardRef((r, i) => {
+  const { children: t, width: a = 10, height: s = 5, ...m } = r;
+  return /* @__PURE__ */ o(
+    p.svg,
+    {
+      ...m,
+      ref: i,
+      width: a,
+      height: s,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: r.asChild ? t : /* @__PURE__ */ o("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+});
+e.displayName = v;
+var h = e;
+export {
+  e as Arrow,
+  h as Root
+};

package/dist/node_modules/@radix-ui/react-avatar/dist/index.js

@@ -0,0 +1,80 @@
+var h = Object.defineProperty;
+var l = (t, e) => h(t, "name", { value: e, configurable: !0 });
+import * as i from "react";
+import { createContextScope as _ } from "../../react-context/dist/index.js";
+import { useCallbackRef as y } from "../../react-use-callback-ref/dist/index.js";
+import { useLayoutEffect as v } from "../../react-use-layout-effect/dist/index.js";
+import { Primitive as m } from "../../react-primitive/dist/index.js";
+import { useIsHydrated as x } from "../../react-use-is-hydrated/dist/index.js";
+import { jsx as f } from "react/jsx-runtime";
+var g = "Avatar", [N, G] = _(g), [b, L] = N(g), S = i.forwardRef(
+  (t, e) => {
+    const { __scopeAvatar: o, ...r } = t, [n, a] = i.useState("idle");
+    return /* @__PURE__ */ f(
+      b,
+      {
+        scope: o,
+        imageLoadingStatus: n,
+        onImageLoadingStatusChange: a,
+        children: /* @__PURE__ */ f(m.span, { ...r, ref: e })
+      }
+    );
+  }
+);
+S.displayName = g;
+var E = "AvatarImage", I = i.forwardRef(
+  (t, e) => {
+    const { __scopeAvatar: o, src: r, onLoadingStatusChange: n = /* @__PURE__ */ l(() => {
+    }, "onLoadingStatusChange"), ...a } = t, u = L(E, o), s = k(r, a), d = y((c) => {
+      n(c), u.onImageLoadingStatusChange(c);
+    });
+    return v(() => {
+      s !== "idle" && d(s);
+    }, [s, d]), s === "loaded" ? /* @__PURE__ */ f(m.img, { ...a, ref: e, src: r }) : null;
+  }
+);
+I.displayName = E;
+var R = "AvatarFallback", w = i.forwardRef(
+  (t, e) => {
+    const { __scopeAvatar: o, delayMs: r, ...n } = t, a = L(R, o), [u, s] = i.useState(r === void 0);
+    return i.useEffect(() => {
+      if (r !== void 0) {
+        const d = window.setTimeout(() => s(!0), r);
+        return () => window.clearTimeout(d);
+      }
+    }, [r]), u && a.imageLoadingStatus !== "loaded" ? /* @__PURE__ */ f(m.span, { ...n, ref: e }) : null;
+  }
+);
+w.displayName = R;
+function A(t, e) {
+  return t ? e ? (t.src !== e && (t.src = e), t.complete && t.naturalWidth > 0 ? "loaded" : "loading") : "error" : "idle";
+}
+l(A, "resolveLoadingStatus");
+function k(t, { referrerPolicy: e, crossOrigin: o }) {
+  const r = x(), n = i.useRef(null), a = r ? (n.current || (n.current = new window.Image()), n.current) : null, [u, s] = i.useState(
+    () => A(a, t)
+  );
+  return v(() => {
+    s(A(a, t));
+  }, [a, t]), v(() => {
+    const d = /* @__PURE__ */ l((C) => () => {
+      s(C);
+    }, "updateStatus");
+    if (!a) return;
+    const c = d("loaded"), p = d("error");
+    return a.addEventListener("load", c), a.addEventListener("error", p), e && (a.referrerPolicy = e), typeof o == "string" && (a.crossOrigin = o), () => {
+      a.removeEventListener("load", c), a.removeEventListener("error", p);
+    };
+  }, [a, o, e]), u;
+}
+l(k, "useImageLoadingStatus");
+var K = S, V = I, W = w;
+export {
+  S as Avatar,
+  w as AvatarFallback,
+  I as AvatarImage,
+  W as Fallback,
+  V as Image,
+  K as Root,
+  G as createAvatarScope
+};

package/dist/node_modules/@radix-ui/react-checkbox/dist/index.js

@@ -0,0 +1,258 @@
+var O = Object.defineProperty;
+var x = (t, r) => O(t, "name", { value: r, configurable: !0 });
+import * as a from "react";
+import { useComposedRefs as N } from "../../react-compose-refs/dist/index.js";
+import { createContextScope as j } from "../../react-context/dist/index.js";
+import { composeEventHandlers as B } from "../../primitive/dist/index.js";
+import { useControllableState as H } from "../../react-use-controllable-state/dist/index.js";
+import { usePrevious as z } from "../../react-use-previous/dist/index.js";
+import { useSize as G } from "../../react-use-size/dist/index.js";
+import { Presence as K } from "../../react-presence/dist/index.js";
+import { Primitive as E } from "../../react-primitive/dist/index.js";
+import { jsx as b, jsxs as U, Fragment as X } from "react/jsx-runtime";
+var I = "Checkbox", [J, de] = j(I), [Q, y] = J(I);
+function V(t) {
+  const {
+    __scopeCheckbox: r,
+    checked: s,
+    children: u,
+    defaultChecked: n,
+    disabled: e,
+    form: p,
+    name: f,
+    onCheckedChange: i,
+    required: m,
+    value: C = "on",
+    // @ts-expect-error
+    internal_do_not_use_render: d
+  } = t, [l, _] = H({
+    prop: s,
+    defaultProp: n ?? !1,
+    onChange: i,
+    caller: I
+  }), [k, v] = a.useState(null), [g, o] = a.useState(null), c = a.useRef(!1), R = k ? !!p || !!k.closest("form") : (
+    // We set this to true by default so that events bubble to forms without JS (SSR)
+    !0
+  ), P = {
+    checked: l,
+    disabled: e,
+    setChecked: _,
+    control: k,
+    setControl: v,
+    name: f,
+    form: p,
+    value: C,
+    hasConsumerStoppedPropagationRef: c,
+    required: m,
+    defaultChecked: h(n) ? !1 : n,
+    isFormControl: R,
+    bubbleInput: g,
+    setBubbleInput: o
+  };
+  return /* @__PURE__ */ b(
+    Q,
+    {
+      scope: r,
+      ...P,
+      children: Z(d) ? d(P) : u
+    }
+  );
+}
+x(V, "CheckboxProvider");
+var w = "CheckboxTrigger", T = a.forwardRef(
+  ({ __scopeCheckbox: t, onKeyDown: r, onClick: s, ...u }, n) => {
+    const {
+      control: e,
+      value: p,
+      disabled: f,
+      checked: i,
+      required: m,
+      setControl: C,
+      setChecked: d,
+      hasConsumerStoppedPropagationRef: l,
+      isFormControl: _,
+      bubbleInput: k
+    } = y(w, t), v = N(n, C), g = a.useRef(i);
+    return a.useEffect(() => {
+      const o = e == null ? void 0 : e.form;
+      if (o) {
+        const c = /* @__PURE__ */ x(() => d(g.current), "reset");
+        return o.addEventListener("reset", c), () => o.removeEventListener("reset", c);
+      }
+    }, [e, d]), /* @__PURE__ */ b(
+      E.button,
+      {
+        type: "button",
+        role: "checkbox",
+        "aria-checked": h(i) ? "mixed" : i,
+        "aria-required": m,
+        "data-state": D(i),
+        "data-disabled": f ? "" : void 0,
+        disabled: f,
+        value: p,
+        ...u,
+        ref: v,
+        onKeyDown: B(r, (o) => {
+          o.key === "Enter" && o.preventDefault();
+        }),
+        onClick: B(s, (o) => {
+          d((c) => h(c) ? !0 : !c), k && _ && (l.current = o.isPropagationStopped(), l.current || o.stopPropagation());
+        })
+      }
+    );
+  }
+);
+T.displayName = w;
+var W = a.forwardRef(
+  (t, r) => {
+    const {
+      __scopeCheckbox: s,
+      name: u,
+      checked: n,
+      defaultChecked: e,
+      required: p,
+      disabled: f,
+      value: i,
+      onCheckedChange: m,
+      form: C,
+      ...d
+    } = t;
+    return /* @__PURE__ */ b(
+      V,
+      {
+        __scopeCheckbox: s,
+        checked: n,
+        defaultChecked: e,
+        disabled: f,
+        required: p,
+        onCheckedChange: m,
+        name: u,
+        form: C,
+        value: i,
+        internal_do_not_use_render: /* @__PURE__ */ x(({ isFormControl: l }) => /* @__PURE__ */ U(X, { children: [
+          /* @__PURE__ */ b(
+            T,
+            {
+              ...d,
+              ref: r,
+              __scopeCheckbox: s
+            }
+          ),
+          l && /* @__PURE__ */ b(
+            A,
+            {
+              __scopeCheckbox: s
+            }
+          )
+        ] }), "internal_do_not_use_render")
+      }
+    );
+  }
+);
+W.displayName = I;
+var M = "CheckboxIndicator", Y = a.forwardRef(
+  (t, r) => {
+    const { __scopeCheckbox: s, forceMount: u, ...n } = t, e = y(M, s);
+    return /* @__PURE__ */ b(
+      K,
+      {
+        present: u || h(e.checked) || e.checked === !0,
+        children: /* @__PURE__ */ b(
+          E.span,
+          {
+            "data-state": D(e.checked),
+            "data-disabled": e.disabled ? "" : void 0,
+            ...n,
+            ref: r,
+            style: { pointerEvents: "none", ...t.style }
+          }
+        )
+      }
+    );
+  }
+);
+Y.displayName = M;
+var q = "CheckboxBubbleInput", A = a.forwardRef(
+  ({ __scopeCheckbox: t, ...r }, s) => {
+    const {
+      control: u,
+      hasConsumerStoppedPropagationRef: n,
+      checked: e,
+      defaultChecked: p,
+      required: f,
+      disabled: i,
+      name: m,
+      value: C,
+      form: d,
+      bubbleInput: l,
+      setBubbleInput: _
+    } = y(q, t), k = N(s, _), v = z(e), g = G(u);
+    a.useEffect(() => {
+      const c = l;
+      if (!c) return;
+      const R = window.HTMLInputElement.prototype, S = Object.getOwnPropertyDescriptor(
+        R,
+        "checked"
+      ).set, F = !n.current;
+      if (v !== e && S) {
+        const L = new Event("click", { bubbles: F });
+        c.indeterminate = h(e), S.call(c, h(e) ? !1 : e), c.dispatchEvent(L);
+      }
+    }, [l, v, e, n]);
+    const o = a.useRef(h(e) ? !1 : e);
+    return /* @__PURE__ */ b(
+      E.input,
+      {
+        type: "checkbox",
+        "aria-hidden": !0,
+        defaultChecked: p ?? o.current,
+        required: f,
+        disabled: i,
+        name: m,
+        value: C,
+        form: d,
+        ...r,
+        tabIndex: -1,
+        ref: k,
+        style: {
+          ...r.style,
+          ...g,
+          position: "absolute",
+          pointerEvents: "none",
+          opacity: 0,
+          margin: 0,
+          // We transform because the input is absolutely positioned but we have
+          // rendered it **after** the button. This pulls it back to sit on top
+          // of the button.
+          transform: "translateX(-100%)"
+        }
+      }
+    );
+  }
+);
+A.displayName = q;
+function Z(t) {
+  return typeof t == "function";
+}
+x(Z, "isFunction");
+function h(t) {
+  return t === "indeterminate";
+}
+x(h, "isIndeterminate");
+function D(t) {
+  return h(t) ? "indeterminate" : t ? "checked" : "unchecked";
+}
+x(D, "getState");
+export {
+  W as Checkbox,
+  Y as CheckboxIndicator,
+  Y as Indicator,
+  W as Root,
+  de as createCheckboxScope,
+  A as unstable_BubbleInput,
+  A as unstable_CheckboxBubbleInput,
+  V as unstable_CheckboxProvider,
+  T as unstable_CheckboxTrigger,
+  V as unstable_Provider,
+  T as unstable_Trigger
+};