npm - fina-react-ds - Versions diffs - 0.0.0 - Mend

fina-react-ds 0.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (106) hide show

package/dist/node_modules/@floating-ui/dom/dist/floating-ui.dom.js ADDED Viewed

@@ -0,0 +1,430 @@
+var st = Object.defineProperty;
+var u = (t, e) => st(t, "name", { value: e, configurable: !0 });
+import { offset as rt, shift as ct, flip as lt, size as ft, hide as ut, limitShift as ht, computePosition as at, arrow as dt } from "../../core/dist/floating-ui.core.js";
+import { createCoords as x, round as H, max as F, min as V, rectToClientRect as Q, floor as A } from "../../utils/dist/floating-ui.utils.js";
+import { isElement as R, getDocumentElement as b, getOverflowAncestors as $, getComputedStyle as O, isHTMLElement as C, getWindow as T, isTopLayer as M, getParentNode as B, isLastTraversableNode as N, isTableElement as gt, isContainingBlock as Y, getContainingBlock as pt, getNodeName as _, isOverflowElement as q, getNodeScroll as I, getFrameElement as j, isWebKit as Z } from "../../utils/dist/floating-ui.utils.dom.js";
+function X(t) {
+  const e = O(t);
+  let i = parseFloat(e.width) || 0, n = parseFloat(e.height) || 0;
+  const o = C(t), r = o ? t.offsetWidth : i, s = o ? t.offsetHeight : n, c = H(i) !== r || H(n) !== s;
+  return c && (i = r, n = s), {
+    width: i,
+    height: n,
+    $: c
+  };
+}
+u(X, "getCssDimensions");
+function k(t) {
+  return R(t) ? t : t.contextElement;
+}
+u(k, "unwrapElement");
+function W(t) {
+  const e = k(t);
+  if (!C(e))
+    return x(1);
+  const i = e.getBoundingClientRect(), {
+    width: n,
+    height: o,
+    $: r
+  } = X(e);
+  let s = (r ? H(i.width) : i.width) / n, c = (r ? H(i.height) : i.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+u(W, "getScale");
+const wt = /* @__PURE__ */ x(0);
+function tt(t) {
+  const e = T(t);
+  return !Z() || !e.visualViewport ? wt : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+u(tt, "getVisualOffsets");
+function mt(t, e, i) {
+  return e === void 0 && (e = !1), !i || e && i !== T(t) ? !1 : e;
+}
+u(mt, "shouldAddVisualOffsets");
+function E(t, e, i, n) {
+  e === void 0 && (e = !1), i === void 0 && (i = !1);
+  const o = t.getBoundingClientRect(), r = k(t);
+  let s = x(1);
+  e && (n ? R(n) && (s = W(n)) : s = W(t));
+  const c = mt(r, i, n) ? tt(r) : x(0);
+  let l = (o.left + c.x) / s.x, f = (o.top + c.y) / s.y, h = o.width / s.x, a = o.height / s.y;
+  if (r) {
+    const w = T(r), d = n && R(n) ? T(n) : n;
+    let y = w, p = j(y);
+    for (; p && n && d !== y; ) {
+      const m = W(p), g = p.getBoundingClientRect(), v = O(p), L = g.left + (p.clientLeft + parseFloat(v.paddingLeft)) * m.x, z = g.top + (p.clientTop + parseFloat(v.paddingTop)) * m.y;
+      l *= m.x, f *= m.y, h *= m.x, a *= m.y, l += L, f += z, y = T(p), p = j(y);
+    }
+  }
+  return Q({
+    width: h,
+    height: a,
+    x: l,
+    y: f
+  });
+}
+u(E, "getBoundingClientRect");
+function P(t, e) {
+  const i = I(t).scrollLeft;
+  return e ? e.left + i : E(b(t)).left + i;
+}
+u(P, "getWindowScrollBarX");
+function et(t, e, i) {
+  i === void 0 && (i = !1);
+  const n = t.getBoundingClientRect(), o = n.left + e.scrollLeft - (i ? 0 : (
+    // RTL <body> scrollbar.
+    P(t, n)
+  )), r = n.top + e.scrollTop;
+  return {
+    x: o,
+    y: r
+  };
+}
+u(et, "getHTMLOffset");
+function xt(t) {
+  let {
+    elements: e,
+    rect: i,
+    offsetParent: n,
+    strategy: o
+  } = t;
+  const r = o === "fixed", s = b(n), c = e ? M(e.floating) : !1;
+  if (n === s || c && r)
+    return i;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, f = x(1);
+  const h = x(0), a = C(n);
+  if ((a || !a && !r) && ((_(n) !== "body" || q(s)) && (l = I(n)), C(n))) {
+    const d = E(n);
+    f = W(n), h.x = d.x + n.clientLeft, h.y = d.y + n.clientTop;
+  }
+  const w = s && !a && !r ? et(s, l, !0) : x(0);
+  return {
+    width: i.width * f.x,
+    height: i.height * f.y,
+    x: i.x * f.x - l.scrollLeft * f.x + h.x + w.x,
+    y: i.y * f.y - l.scrollTop * f.y + h.y + w.y
+  };
+}
+u(xt, "convertOffsetParentRelativeRectToViewportRelativeRect");
+function yt(t) {
+  return Array.from(t.getClientRects());
+}
+u(yt, "getClientRects");
+function vt(t) {
+  const e = b(t), i = I(t), n = t.ownerDocument.body, o = F(e.scrollWidth, e.clientWidth, n.scrollWidth, n.clientWidth), r = F(e.scrollHeight, e.clientHeight, n.scrollHeight, n.clientHeight);
+  let s = -i.scrollLeft + P(t);
+  const c = -i.scrollTop;
+  return O(n).direction === "rtl" && (s += F(e.clientWidth, n.clientWidth) - o), {
+    width: o,
+    height: r,
+    x: s,
+    y: c
+  };
+}
+u(vt, "getDocumentRect");
+function Rt(t, e) {
+  const i = T(t), n = b(t), o = i.visualViewport;
+  let r = n.clientWidth, s = n.clientHeight, c = 0, l = 0;
+  if (o) {
+    r = o.width, s = o.height;
+    const f = Z();
+    (!f || f && e === "fixed") && (c = o.offsetLeft, l = o.offsetTop);
+  }
+  return {
+    width: r,
+    height: s,
+    x: c,
+    y: l
+  };
+}
+u(Rt, "getViewportRect");
+const Ot = /* @__PURE__ */ new Set(["absolute", "fixed"]);
+function bt(t, e) {
+  const i = E(t, !0, e === "fixed"), n = i.top + t.clientTop, o = i.left + t.clientLeft, r = C(t) ? W(t) : x(1), s = t.clientWidth * r.x, c = t.clientHeight * r.y, l = o * r.x, f = n * r.y;
+  return {
+    width: s,
+    height: c,
+    x: l,
+    y: f
+  };
+}
+u(bt, "getInnerBoundingClientRect");
+function G(t, e, i) {
+  let n;
+  if (e === "viewport")
+    n = Rt(t, i);
+  else if (e === "document")
+    n = vt(b(t));
+  else if (R(e))
+    n = bt(e, i);
+  else {
+    const o = tt(t);
+    n = {
+      x: e.x - o.x,
+      y: e.y - o.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return Q(n);
+}
+u(G, "getClientRectFromClippingAncestor");
+function it(t, e) {
+  const i = B(t);
+  return i === e || !R(i) || N(i) ? !1 : O(i).position === "fixed" || it(i, e);
+}
+u(it, "hasFixedPositionAncestor");
+function Ct(t, e) {
+  const i = e.get(t);
+  if (i)
+    return i;
+  let n = $(t, [], !1).filter((c) => R(c) && _(c) !== "body"), o = null;
+  const r = O(t).position === "fixed";
+  let s = r ? B(t) : t;
+  for (; R(s) && !N(s); ) {
+    const c = O(s), l = Y(s);
+    !l && c.position === "fixed" && (o = null), (r ? !l && !o : !l && c.position === "static" && !!o && Ot.has(o.position) || q(s) && !l && it(t, s)) ? n = n.filter((h) => h !== s) : o = c, s = B(s);
+  }
+  return e.set(t, n), n;
+}
+u(Ct, "getClippingElementAncestors");
+function Lt(t) {
+  let {
+    element: e,
+    boundary: i,
+    rootBoundary: n,
+    strategy: o
+  } = t;
+  const s = [...i === "clippingAncestors" ? M(e) ? [] : Ct(e, this._c) : [].concat(i), n], c = s[0], l = s.reduce((f, h) => {
+    const a = G(e, h, o);
+    return f.top = F(a.top, f.top), f.right = V(a.right, f.right), f.bottom = V(a.bottom, f.bottom), f.left = F(a.left, f.left), f;
+  }, G(e, c, o));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
+  };
+}
+u(Lt, "getClippingRect");
+function Tt(t) {
+  const {
+    width: e,
+    height: i
+  } = X(t);
+  return {
+    width: e,
+    height: i
+  };
+}
+u(Tt, "getDimensions");
+function Et(t, e, i) {
+  const n = C(e), o = b(e), r = i === "fixed", s = E(t, !0, r, e);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = x(0);
+  function f() {
+    l.x = P(o);
+  }
+  if (u(f, "setLeftRTLScrollbarOffset"), n || !n && !r)
+    if ((_(e) !== "body" || q(o)) && (c = I(e)), n) {
+      const d = E(e, !0, r, e);
+      l.x = d.x + e.clientLeft, l.y = d.y + e.clientTop;
+    } else o && f();
+  r && !n && o && f();
+  const h = o && !n && !r ? et(o, c) : x(0), a = s.left + c.scrollLeft - l.x - h.x, w = s.top + c.scrollTop - l.y - h.y;
+  return {
+    x: a,
+    y: w,
+    width: s.width,
+    height: s.height
+  };
+}
+u(Et, "getRectRelativeToOffsetParent");
+function S(t) {
+  return O(t).position === "static";
+}
+u(S, "isStaticPositioned");
+function J(t, e) {
+  if (!C(t) || O(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let i = t.offsetParent;
+  return b(t) === i && (i = i.ownerDocument.body), i;
+}
+u(J, "getTrueOffsetParent");
+function nt(t, e) {
+  const i = T(t);
+  if (M(t))
+    return i;
+  if (!C(t)) {
+    let o = B(t);
+    for (; o && !N(o); ) {
+      if (R(o) && !S(o))
+        return o;
+      o = B(o);
+    }
+    return i;
+  }
+  let n = J(t, e);
+  for (; n && gt(n) && S(n); )
+    n = J(n, e);
+  return n && N(n) && S(n) && !Y(n) ? i : n || pt(t) || i;
+}
+u(nt, "getOffsetParent");
+const Ft = /* @__PURE__ */ u(async function(t) {
+  const e = this.getOffsetParent || nt, i = this.getDimensions, n = await i(t.floating);
+  return {
+    reference: Et(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+}, "getElementRects");
+function Wt(t) {
+  return O(t).direction === "rtl";
+}
+u(Wt, "isRTL");
+const Bt = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: xt,
+  getDocumentElement: b,
+  getClippingRect: Lt,
+  getOffsetParent: nt,
+  getElementRects: Ft,
+  getClientRects: yt,
+  getDimensions: Tt,
+  getScale: W,
+  isElement: R,
+  isRTL: Wt
+};
+function ot(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+u(ot, "rectsAreEqual");
+function zt(t, e) {
+  let i = null, n;
+  const o = b(t);
+  function r() {
+    var c;
+    clearTimeout(n), (c = i) == null || c.disconnect(), i = null;
+  }
+  u(r, "cleanup");
+  function s(c, l) {
+    c === void 0 && (c = !1), l === void 0 && (l = 1), r();
+    const f = t.getBoundingClientRect(), {
+      left: h,
+      top: a,
+      width: w,
+      height: d
+    } = f;
+    if (c || e(), !w || !d)
+      return;
+    const y = A(a), p = A(o.clientWidth - (h + w)), m = A(o.clientHeight - (a + d)), g = A(h), L = {
+      rootMargin: -y + "px " + -p + "px " + -m + "px " + -g + "px",
+      threshold: F(0, V(1, l)) || 1
+    };
+    let z = !0;
+    function U(K) {
+      const D = K[0].intersectionRatio;
+      if (D !== l) {
+        if (!z)
+          return s();
+        D ? s(!1, D) : n = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      D === 1 && !ot(f, t.getBoundingClientRect()) && s(), z = !1;
+    }
+    u(U, "handleObserve");
+    try {
+      i = new IntersectionObserver(U, {
+        ...L,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      i = new IntersectionObserver(U, L);
+    }
+    i.observe(t);
+  }
+  return u(s, "refresh"), s(!0), r;
+}
+u(zt, "observeMove");
+function It(t, e, i, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: r = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: c = typeof IntersectionObserver == "function",
+    animationFrame: l = !1
+  } = n, f = k(t), h = o || r ? [...f ? $(f) : [], ...$(e)] : [];
+  h.forEach((g) => {
+    o && g.addEventListener("scroll", i, {
+      passive: !0
+    }), r && g.addEventListener("resize", i);
+  });
+  const a = f && c ? zt(f, i) : null;
+  let w = -1, d = null;
+  s && (d = new ResizeObserver((g) => {
+    let [v] = g;
+    v && v.target === f && d && (d.unobserve(e), cancelAnimationFrame(w), w = requestAnimationFrame(() => {
+      var L;
+      (L = d) == null || L.observe(e);
+    })), i();
+  }), f && !l && d.observe(f), d.observe(e));
+  let y, p = l ? E(t) : null;
+  l && m();
+  function m() {
+    const g = E(t);
+    p && !ot(p, g) && i(), p = g, y = requestAnimationFrame(m);
+  }
+  return u(m, "frameLoop"), i(), () => {
+    var g;
+    h.forEach((v) => {
+      o && v.removeEventListener("scroll", i), r && v.removeEventListener("resize", i);
+    }), a == null || a(), (g = d) == null || g.disconnect(), d = null, l && cancelAnimationFrame(y);
+  };
+}
+u(It, "autoUpdate");
+const St = rt, Vt = ct, $t = lt, Mt = ft, _t = ut, qt = dt, kt = ht, Pt = /* @__PURE__ */ u((t, e, i) => {
+  const n = /* @__PURE__ */ new Map(), o = {
+    platform: Bt,
+    ...i
+  }, r = {
+    ...o.platform,
+    _c: n
+  };
+  return at(t, e, {
+    ...o,
+    platform: r
+  });
+}, "computePosition");
+export {
+  qt as arrow,
+  It as autoUpdate,
+  Pt as computePosition,
+  $t as flip,
+  $ as getOverflowAncestors,
+  _t as hide,
+  kt as limitShift,
+  St as offset,
+  Bt as platform,
+  Vt as shift,
+  Mt as size
+};

package/dist/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js ADDED Viewed

@@ -0,0 +1,215 @@
+var J = Object.defineProperty;
+var o = (e, t) => J(e, "name", { value: t, configurable: !0 });
+import { computePosition as K, offset as N, shift as Q, flip as T, size as X, hide as Y, limitShift as Z, arrow as L } from "../../dom/dist/floating-ui.dom.js";
+import { autoUpdate as he, platform as we } from "../../dom/dist/floating-ui.dom.js";
+import * as f from "react";
+import { useLayoutEffect as b } from "react";
+import * as ee from "react-dom";
+var te = typeof document < "u", ne = /* @__PURE__ */ o(function() {
+}, "noop"), R = te ? b : ne;
+function x(e, t) {
+  if (e === t)
+    return !0;
+  if (typeof e != typeof t)
+    return !1;
+  if (typeof e == "function" && e.toString() === t.toString())
+    return !0;
+  let n, r, s;
+  if (e && t && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (n = e.length, n !== t.length) return !1;
+      for (r = n; r-- !== 0; )
+        if (!x(e[r], t[r]))
+          return !1;
+      return !0;
+    }
+    if (s = Object.keys(e), n = s.length, n !== Object.keys(t).length)
+      return !1;
+    for (r = n; r-- !== 0; )
+      if (!{}.hasOwnProperty.call(t, s[r]))
+        return !1;
+    for (r = n; r-- !== 0; ) {
+      const g = s[r];
+      if (!(g === "_owner" && e.$$typeof) && !x(e[g], t[g]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && t !== t;
+}
+o(x, "deepEqual");
+function q(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+o(q, "getDPR");
+function A(e, t) {
+  const n = q(e);
+  return Math.round(t * n) / n;
+}
+o(A, "roundByDPR");
+function D(e) {
+  const t = f.useRef(e);
+  return R(() => {
+    t.current = e;
+  }), t;
+}
+o(D, "useLatestRef");
+function se(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: t = "bottom",
+    strategy: n = "absolute",
+    middleware: r = [],
+    platform: s,
+    elements: {
+      reference: g,
+      floating: B
+    } = {},
+    transform: E = !0,
+    whileElementsMounted: C,
+    open: M
+  } = e, [u, O] = f.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: t,
+    middlewareData: {},
+    isPositioned: !1
+  }), [S, U] = f.useState(r);
+  x(S, r) || U(r);
+  const [V, W] = f.useState(null), [G, H] = f.useState(null), _ = f.useCallback((i) => {
+    i !== d.current && (d.current = i, W(i));
+  }, []), v = f.useCallback((i) => {
+    i !== m.current && (m.current = i, H(i));
+  }, []), l = g || V, c = B || G, d = f.useRef(null), m = f.useRef(null), h = f.useRef(u), I = C != null, P = D(C), $ = D(s), F = D(M), y = f.useCallback(() => {
+    if (!d.current || !m.current)
+      return;
+    const i = {
+      placement: t,
+      strategy: n,
+      middleware: S
+    };
+    $.current && (i.platform = $.current), K(d.current, m.current, i).then((w) => {
+      const p = {
+        ...w,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: F.current !== !1
+      };
+      k.current && !x(h.current, p) && (h.current = p, ee.flushSync(() => {
+        O(p);
+      }));
+    });
+  }, [S, t, n, $, F]);
+  R(() => {
+    M === !1 && h.current.isPositioned && (h.current.isPositioned = !1, O((i) => ({
+      ...i,
+      isPositioned: !1
+    })));
+  }, [M]);
+  const k = f.useRef(!1);
+  R(() => (k.current = !0, () => {
+    k.current = !1;
+  }), []), R(() => {
+    if (l && (d.current = l), c && (m.current = c), l && c) {
+      if (P.current)
+        return P.current(l, c, y);
+      y();
+    }
+  }, [l, c, y, P, I]);
+  const j = f.useMemo(() => ({
+    reference: d,
+    floating: m,
+    setReference: _,
+    setFloating: v
+  }), [_, v]), a = f.useMemo(() => ({
+    reference: l,
+    floating: c
+  }), [l, c]), z = f.useMemo(() => {
+    const i = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!a.floating)
+      return i;
+    const w = A(a.floating, u.x), p = A(a.floating, u.y);
+    return E ? {
+      ...i,
+      transform: "translate(" + w + "px, " + p + "px)",
+      ...q(a.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: n,
+      left: w,
+      top: p
+    };
+  }, [n, E, a.floating, u.x, u.y]);
+  return f.useMemo(() => ({
+    ...u,
+    update: y,
+    refs: j,
+    elements: a,
+    floatingStyles: z
+  }), [u, y, j, a, z]);
+}
+o(se, "useFloating");
+const re = /* @__PURE__ */ o((e) => {
+  function t(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return o(t, "isRef"), {
+    name: "arrow",
+    options: e,
+    fn(n) {
+      const {
+        element: r,
+        padding: s
+      } = typeof e == "function" ? e(n) : e;
+      return r && t(r) ? r.current != null ? L({
+        element: r.current,
+        padding: s
+      }).fn(n) : {} : r ? L({
+        element: r,
+        padding: s
+      }).fn(n) : {};
+    }
+  };
+}, "arrow$1"), ue = /* @__PURE__ */ o((e, t) => ({
+  ...N(e),
+  options: [e, t]
+}), "offset"), le = /* @__PURE__ */ o((e, t) => ({
+  ...Q(e),
+  options: [e, t]
+}), "shift"), ce = /* @__PURE__ */ o((e, t) => ({
+  ...Z(e),
+  options: [e, t]
+}), "limitShift"), ae = /* @__PURE__ */ o((e, t) => ({
+  ...T(e),
+  options: [e, t]
+}), "flip"), de = /* @__PURE__ */ o((e, t) => ({
+  ...X(e),
+  options: [e, t]
+}), "size"), me = /* @__PURE__ */ o((e, t) => ({
+  ...Y(e),
+  options: [e, t]
+}), "hide"), pe = /* @__PURE__ */ o((e, t) => ({
+  ...re(e),
+  options: [e, t]
+}), "arrow");
+export {
+  pe as arrow,
+  he as autoUpdate,
+  K as computePosition,
+  ae as flip,
+  me as hide,
+  ce as limitShift,
+  ue as offset,
+  we as platform,
+  le as shift,
+  de as size,
+  se as useFloating
+};