fina-react-ds 1.0.21 → 1.0.23

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/F1na/fina-react-ds"
   },
   "private": false,
-  "version": "1.0.21",
+  "version": "1.0.23",
   "type": "module",
   "files": [
     "dist"
@@ -27,6 +27,7 @@
     "date-fns": "^4.0.0",
     "lucide-react": "^0.525.0",
     "next-themes": "^0.4.6",
+    "qs": "^6.14.0",
     "radix-ui": "^1.4.2",
     "react-colorful": "^5.6.1",
     "react-day-picker": "9.7.0",
@@ -35,13 +36,16 @@
     "react-spinners": "^0.17.0",
     "sonner": "^2.0.5",
     "tailwind-merge": "^3.3.1",
-    "tw-animate-css": "^1.3.5"
+    "tw-animate-css": "^1.3.5",
+    "ufo": "^1.6.1",
+    "yup": "^1.6.1"
   },
   "devDependencies": {
     "@eslint/js": "^9.29.0",
     "@tailwindcss/cli": "^4.1.11",
     "@tailwindcss/vite": "^4.1.11",
     "@types/node": "^22.15.32",
+    "@types/qs": "^6.14.0",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
     "@vitejs/plugin-react-swc": "^3.10.2",
@@ -70,7 +74,6 @@
     "clsx": "^2.1.1",
     "date-fns": "^4.0.0",
     "next-themes": "^0.4.6",
-    "radix-ui": "^1.4.2",
     "react": "^19.1.0",
     "react-colorful": "^5.6.1",
     "react-day-picker": "9.7.0",

package/dist/_virtual/index.js

@@ -1,5 +0,0 @@
-import { __require as r } from "../node_modules/use-sync-external-store/shim/index.js";
-var i = /* @__PURE__ */ r();
-export {
-  i as s
-};

package/dist/_virtual/index2.js

@@ -1,4 +0,0 @@
-var e = { exports: {} };
-export {
-  e as __module
-};

package/dist/_virtual/use-sync-external-store-shim.development.js

@@ -1,4 +0,0 @@
-var e = {};
-export {
-  e as __exports
-};

package/dist/_virtual/use-sync-external-store-shim.production.js

@@ -1,4 +0,0 @@
-var r = {};
-export {
-  r as __exports
-};

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

@@ -1,534 +0,0 @@
-var te = Object.defineProperty;
-var b = (t, e) => te(t, "name", { value: e, configurable: !0 });
-import { evaluate as H, getSideAxis as L, getSide as W, clamp as _, getOppositePlacement as ne, getExpandedPlacements as ie, getOppositeAxisPlacements as se, getAlignmentSides as oe, getAlignment as X, min as z, max as Y, getPaddingObject as K, rectToClientRect as I, getOppositeAxis as N, getAlignmentAxis as Q, sides as ae, getAxisLength as U } from "../../utils/dist/floating-ui.utils.js";
-function q(t, e, d) {
-  let {
-    reference: a,
-    floating: r
-  } = t;
-  const n = L(e), o = Q(e), m = U(o), u = W(e), h = n === "y", c = a.x + a.width / 2 - r.width / 2, s = a.y + a.height / 2 - r.height / 2, f = a[m] / 2 - r[m] / 2;
-  let i;
-  switch (u) {
-    case "top":
-      i = {
-        x: c,
-        y: a.y - r.height
-      };
-      break;
-    case "bottom":
-      i = {
-        x: c,
-        y: a.y + a.height
-      };
-      break;
-    case "right":
-      i = {
-        x: a.x + a.width,
-        y: s
-      };
-      break;
-    case "left":
-      i = {
-        x: a.x - r.width,
-        y: s
-      };
-      break;
-    default:
-      i = {
-        x: a.x,
-        y: a.y
-      };
-  }
-  switch (X(e)) {
-    case "start":
-      i[o] -= f * (d && h ? -1 : 1);
-      break;
-    case "end":
-      i[o] += f * (d && h ? -1 : 1);
-      break;
-  }
-  return i;
-}
-b(q, "computeCoordsFromPlacement");
-const fe = /* @__PURE__ */ b(async (t, e, d) => {
-  const {
-    placement: a = "bottom",
-    strategy: r = "absolute",
-    middleware: n = [],
-    platform: o
-  } = d, m = n.filter(Boolean), u = await (o.isRTL == null ? void 0 : o.isRTL(e));
-  let h = await o.getElementRects({
-    reference: t,
-    floating: e,
-    strategy: r
-  }), {
-    x: c,
-    y: s
-  } = q(h, a, u), f = a, i = {}, l = 0;
-  for (let g = 0; g < m.length; g++) {
-    const {
-      name: x,
-      fn: y
-    } = m[g], {
-      x: A,
-      y: p,
-      data: v,
-      reset: w
-    } = await y({
-      x: c,
-      y: s,
-      initialPlacement: a,
-      placement: f,
-      strategy: r,
-      middlewareData: i,
-      rects: h,
-      platform: o,
-      elements: {
-        reference: t,
-        floating: e
-      }
-    });
-    c = A ?? c, s = p ?? s, i = {
-      ...i,
-      [x]: {
-        ...i[x],
-        ...v
-      }
-    }, w && l <= 50 && (l++, typeof w == "object" && (w.placement && (f = w.placement), w.rects && (h = w.rects === !0 ? await o.getElementRects({
-      reference: t,
-      floating: e,
-      strategy: r
-    }) : w.rects), {
-      x: c,
-      y: s
-    } = q(h, f, u)), g = -1);
-  }
-  return {
-    x: c,
-    y: s,
-    placement: f,
-    strategy: r,
-    middlewareData: i
-  };
-}, "computePosition");
-async function $(t, e) {
-  var d;
-  e === void 0 && (e = {});
-  const {
-    x: a,
-    y: r,
-    platform: n,
-    rects: o,
-    elements: m,
-    strategy: u
-  } = t, {
-    boundary: h = "clippingAncestors",
-    rootBoundary: c = "viewport",
-    elementContext: s = "floating",
-    altBoundary: f = !1,
-    padding: i = 0
-  } = H(e, t), l = K(i), x = m[f ? s === "floating" ? "reference" : "floating" : s], y = I(await n.getClippingRect({
-    element: (d = await (n.isElement == null ? void 0 : n.isElement(x))) == null || d ? x : x.contextElement || await (n.getDocumentElement == null ? void 0 : n.getDocumentElement(m.floating)),
-    boundary: h,
-    rootBoundary: c,
-    strategy: u
-  })), A = s === "floating" ? {
-    x: a,
-    y: r,
-    width: o.floating.width,
-    height: o.floating.height
-  } : o.reference, p = await (n.getOffsetParent == null ? void 0 : n.getOffsetParent(m.floating)), v = await (n.isElement == null ? void 0 : n.isElement(p)) ? await (n.getScale == null ? void 0 : n.getScale(p)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, w = I(n.convertOffsetParentRelativeRectToViewportRelativeRect ? await n.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: m,
-    rect: A,
-    offsetParent: p,
-    strategy: u
-  }) : A);
-  return {
-    top: (y.top - w.top + l.top) / v.y,
-    bottom: (w.bottom - y.bottom + l.bottom) / v.y,
-    left: (y.left - w.left + l.left) / v.x,
-    right: (w.right - y.right + l.right) / v.x
-  };
-}
-b($, "detectOverflow");
-const me = /* @__PURE__ */ b((t) => ({
-  name: "arrow",
-  options: t,
-  async fn(e) {
-    const {
-      x: d,
-      y: a,
-      placement: r,
-      rects: n,
-      platform: o,
-      elements: m,
-      middlewareData: u
-    } = e, {
-      element: h,
-      padding: c = 0
-    } = H(t, e) || {};
-    if (h == null)
-      return {};
-    const s = K(c), f = {
-      x: d,
-      y: a
-    }, i = Q(r), l = U(i), g = await o.getDimensions(h), x = i === "y", y = x ? "top" : "left", A = x ? "bottom" : "right", p = x ? "clientHeight" : "clientWidth", v = n.reference[l] + n.reference[i] - f[i] - n.floating[l], w = f[i] - n.reference[i], C = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(h));
-    let S = C ? C[p] : 0;
-    (!S || !await (o.isElement == null ? void 0 : o.isElement(C))) && (S = m.floating[p] || n.floating[l]);
-    const E = v / 2 - w / 2, D = S / 2 - g[l] / 2 - 1, P = z(s[y], D), F = z(s[A], D), M = P, V = S - g[l] - F, O = S / 2 - g[l] / 2 + E, j = _(M, O, V), T = !u.arrow && X(r) != null && O !== j && n.reference[l] / 2 - (O < M ? P : F) - g[l] / 2 < 0, R = T ? O < M ? O - M : O - V : 0;
-    return {
-      [i]: f[i] + R,
-      data: {
-        [i]: j,
-        centerOffset: O - j - R,
-        ...T && {
-          alignmentOffset: R
-        }
-      },
-      reset: T
-    };
-  }
-}), "arrow"), de = /* @__PURE__ */ b(function(t) {
-  return t === void 0 && (t = {}), {
-    name: "flip",
-    options: t,
-    async fn(e) {
-      var d, a;
-      const {
-        placement: r,
-        middlewareData: n,
-        rects: o,
-        initialPlacement: m,
-        platform: u,
-        elements: h
-      } = e, {
-        mainAxis: c = !0,
-        crossAxis: s = !0,
-        fallbackPlacements: f,
-        fallbackStrategy: i = "bestFit",
-        fallbackAxisSideDirection: l = "none",
-        flipAlignment: g = !0,
-        ...x
-      } = H(t, e);
-      if ((d = n.arrow) != null && d.alignmentOffset)
-        return {};
-      const y = W(r), A = L(m), p = W(m) === m, v = await (u.isRTL == null ? void 0 : u.isRTL(h.floating)), w = f || (p || !g ? [ne(m)] : ie(m)), C = l !== "none";
-      !f && C && w.push(...se(m, g, l, v));
-      const S = [m, ...w], E = await $(e, x), D = [];
-      let P = ((a = n.flip) == null ? void 0 : a.overflows) || [];
-      if (c && D.push(E[y]), s) {
-        const O = oe(r, o, v);
-        D.push(E[O[0]], E[O[1]]);
-      }
-      if (P = [...P, {
-        placement: r,
-        overflows: D
-      }], !D.every((O) => O <= 0)) {
-        var F, M;
-        const O = (((F = n.flip) == null ? void 0 : F.index) || 0) + 1, j = S[O];
-        if (j && (!(s === "alignment" ? A !== L(j) : !1) || // We leave the current main axis only if every placement on that axis
-        // overflows the main axis.
-        P.every((k) => k.overflows[0] > 0 && L(k.placement) === A)))
-          return {
-            data: {
-              index: O,
-              overflows: P
-            },
-            reset: {
-              placement: j
-            }
-          };
-        let T = (M = P.filter((R) => R.overflows[0] <= 0).sort((R, k) => R.overflows[1] - k.overflows[1])[0]) == null ? void 0 : M.placement;
-        if (!T)
-          switch (i) {
-            case "bestFit": {
-              var V;
-              const R = (V = P.filter((k) => {
-                if (C) {
-                  const B = L(k.placement);
-                  return B === A || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  B === "y";
-                }
-                return !0;
-              }).map((k) => [k.placement, k.overflows.filter((B) => B > 0).reduce((B, ee) => B + ee, 0)]).sort((k, B) => k[1] - B[1])[0]) == null ? void 0 : V[0];
-              R && (T = R);
-              break;
-            }
-            case "initialPlacement":
-              T = m;
-              break;
-          }
-        if (r !== T)
-          return {
-            reset: {
-              placement: T
-            }
-          };
-      }
-      return {};
-    }
-  };
-}, "flip");
-function G(t, e) {
-  return {
-    top: t.top - e.height,
-    right: t.right - e.width,
-    bottom: t.bottom - e.height,
-    left: t.left - e.width
-  };
-}
-b(G, "getSideOffsets");
-function J(t) {
-  return ae.some((e) => t[e] >= 0);
-}
-b(J, "isAnySideFullyClipped");
-const xe = /* @__PURE__ */ b(function(t) {
-  return t === void 0 && (t = {}), {
-    name: "hide",
-    options: t,
-    async fn(e) {
-      const {
-        rects: d
-      } = e, {
-        strategy: a = "referenceHidden",
-        ...r
-      } = H(t, e);
-      switch (a) {
-        case "referenceHidden": {
-          const n = await $(e, {
-            ...r,
-            elementContext: "reference"
-          }), o = G(n, d.reference);
-          return {
-            data: {
-              referenceHiddenOffsets: o,
-              referenceHidden: J(o)
-            }
-          };
-        }
-        case "escaped": {
-          const n = await $(e, {
-            ...r,
-            altBoundary: !0
-          }), o = G(n, d.floating);
-          return {
-            data: {
-              escapedOffsets: o,
-              escaped: J(o)
-            }
-          };
-        }
-        default:
-          return {};
-      }
-    }
-  };
-}, "hide"), Z = /* @__PURE__ */ new Set(["left", "top"]);
-async function ce(t, e) {
-  const {
-    placement: d,
-    platform: a,
-    elements: r
-  } = t, n = await (a.isRTL == null ? void 0 : a.isRTL(r.floating)), o = W(d), m = X(d), u = L(d) === "y", h = Z.has(o) ? -1 : 1, c = n && u ? -1 : 1, s = H(e, t);
-  let {
-    mainAxis: f,
-    crossAxis: i,
-    alignmentAxis: l
-  } = typeof s == "number" ? {
-    mainAxis: s,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: s.mainAxis || 0,
-    crossAxis: s.crossAxis || 0,
-    alignmentAxis: s.alignmentAxis
-  };
-  return m && typeof l == "number" && (i = m === "end" ? l * -1 : l), u ? {
-    x: i * c,
-    y: f * h
-  } : {
-    x: f * h,
-    y: i * c
-  };
-}
-b(ce, "convertValueToCoords");
-const ge = /* @__PURE__ */ b(function(t) {
-  return t === void 0 && (t = 0), {
-    name: "offset",
-    options: t,
-    async fn(e) {
-      var d, a;
-      const {
-        x: r,
-        y: n,
-        placement: o,
-        middlewareData: m
-      } = e, u = await ce(e, t);
-      return o === ((d = m.offset) == null ? void 0 : d.placement) && (a = m.arrow) != null && a.alignmentOffset ? {} : {
-        x: r + u.x,
-        y: n + u.y,
-        data: {
-          ...u,
-          placement: o
-        }
-      };
-    }
-  };
-}, "offset"), ue = /* @__PURE__ */ b(function(t) {
-  return t === void 0 && (t = {}), {
-    name: "shift",
-    options: t,
-    async fn(e) {
-      const {
-        x: d,
-        y: a,
-        placement: r
-      } = e, {
-        mainAxis: n = !0,
-        crossAxis: o = !1,
-        limiter: m = {
-          fn: /* @__PURE__ */ b((x) => {
-            let {
-              x: y,
-              y: A
-            } = x;
-            return {
-              x: y,
-              y: A
-            };
-          }, "fn")
-        },
-        ...u
-      } = H(t, e), h = {
-        x: d,
-        y: a
-      }, c = await $(e, u), s = L(W(r)), f = N(s);
-      let i = h[f], l = h[s];
-      if (n) {
-        const x = f === "y" ? "top" : "left", y = f === "y" ? "bottom" : "right", A = i + c[x], p = i - c[y];
-        i = _(A, i, p);
-      }
-      if (o) {
-        const x = s === "y" ? "top" : "left", y = s === "y" ? "bottom" : "right", A = l + c[x], p = l - c[y];
-        l = _(A, l, p);
-      }
-      const g = m.fn({
-        ...e,
-        [f]: i,
-        [s]: l
-      });
-      return {
-        ...g,
-        data: {
-          x: g.x - d,
-          y: g.y - a,
-          enabled: {
-            [f]: n,
-            [s]: o
-          }
-        }
-      };
-    }
-  };
-}, "shift"), he = /* @__PURE__ */ b(function(t) {
-  return t === void 0 && (t = {}), {
-    options: t,
-    fn(e) {
-      const {
-        x: d,
-        y: a,
-        placement: r,
-        rects: n,
-        middlewareData: o
-      } = e, {
-        offset: m = 0,
-        mainAxis: u = !0,
-        crossAxis: h = !0
-      } = H(t, e), c = {
-        x: d,
-        y: a
-      }, s = L(r), f = N(s);
-      let i = c[f], l = c[s];
-      const g = H(m, e), x = typeof g == "number" ? {
-        mainAxis: g,
-        crossAxis: 0
-      } : {
-        mainAxis: 0,
-        crossAxis: 0,
-        ...g
-      };
-      if (u) {
-        const p = f === "y" ? "height" : "width", v = n.reference[f] - n.floating[p] + x.mainAxis, w = n.reference[f] + n.reference[p] - x.mainAxis;
-        i < v ? i = v : i > w && (i = w);
-      }
-      if (h) {
-        var y, A;
-        const p = f === "y" ? "width" : "height", v = Z.has(W(r)), w = n.reference[s] - n.floating[p] + (v && ((y = o.offset) == null ? void 0 : y[s]) || 0) + (v ? 0 : x.crossAxis), C = n.reference[s] + n.reference[p] + (v ? 0 : ((A = o.offset) == null ? void 0 : A[s]) || 0) - (v ? x.crossAxis : 0);
-        l < w ? l = w : l > C && (l = C);
-      }
-      return {
-        [f]: i,
-        [s]: l
-      };
-    }
-  };
-}, "limitShift"), we = /* @__PURE__ */ b(function(t) {
-  return t === void 0 && (t = {}), {
-    name: "size",
-    options: t,
-    async fn(e) {
-      var d, a;
-      const {
-        placement: r,
-        rects: n,
-        platform: o,
-        elements: m
-      } = e, {
-        apply: u = /* @__PURE__ */ b(() => {
-        }, "apply"),
-        ...h
-      } = H(t, e), c = await $(e, h), s = W(r), f = X(r), i = L(r) === "y", {
-        width: l,
-        height: g
-      } = n.floating;
-      let x, y;
-      s === "top" || s === "bottom" ? (x = s, y = f === (await (o.isRTL == null ? void 0 : o.isRTL(m.floating)) ? "start" : "end") ? "left" : "right") : (y = s, x = f === "end" ? "top" : "bottom");
-      const A = g - c.top - c.bottom, p = l - c.left - c.right, v = z(g - c[x], A), w = z(l - c[y], p), C = !e.middlewareData.shift;
-      let S = v, E = w;
-      if ((d = e.middlewareData.shift) != null && d.enabled.x && (E = p), (a = e.middlewareData.shift) != null && a.enabled.y && (S = A), C && !f) {
-        const P = Y(c.left, 0), F = Y(c.right, 0), M = Y(c.top, 0), V = Y(c.bottom, 0);
-        i ? E = l - 2 * (P !== 0 || F !== 0 ? P + F : Y(c.left, c.right)) : S = g - 2 * (M !== 0 || V !== 0 ? M + V : Y(c.top, c.bottom));
-      }
-      await u({
-        ...e,
-        availableWidth: E,
-        availableHeight: S
-      });
-      const D = await o.getDimensions(m.floating);
-      return l !== D.width || g !== D.height ? {
-        reset: {
-          rects: !0
-        }
-      } : {};
-    }
-  };
-}, "size");
-export {
-  me as arrow,
-  fe as computePosition,
-  $ as detectOverflow,
-  de as flip,
-  xe as hide,
-  he as limitShift,
-  ge as offset,
-  I as rectToClientRect,
-  ue as shift,
-  we as size
-};