@serendie/ui 0.1.12 → 0.1.13

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

@@ -0,0 +1,467 @@
+import { evaluate as L, getPaddingObject as G, getAlignmentAxis as J, getAlignment as z, getSide as F, getSideAxis as j, getOppositePlacement as U, getExpandedPlacements as Z, getOppositeAxisPlacements as _, getAlignmentSides as tt, clamp as X, min as W, max as H, rectToClientRect as I, getAxisLength as K, getOppositeAxis as N } from "../../utils/dist/floating-ui.utils.js";
+function q(i, n, x) {
+  let {
+    reference: l,
+    floating: r
+  } = i;
+  const e = j(n), f = J(n), m = K(f), o = F(n), g = e === "y", d = l.x + l.width / 2 - r.width / 2, c = l.y + l.height / 2 - r.height / 2, a = l[m] / 2 - r[m] / 2;
+  let t;
+  switch (o) {
+    case "top":
+      t = {
+        x: d,
+        y: l.y - r.height
+      };
+      break;
+    case "bottom":
+      t = {
+        x: d,
+        y: l.y + l.height
+      };
+      break;
+    case "right":
+      t = {
+        x: l.x + l.width,
+        y: c
+      };
+      break;
+    case "left":
+      t = {
+        x: l.x - r.width,
+        y: c
+      };
+      break;
+    default:
+      t = {
+        x: l.x,
+        y: l.y
+      };
+  }
+  switch (z(n)) {
+    case "start":
+      t[f] -= a * (x && g ? -1 : 1);
+      break;
+    case "end":
+      t[f] += a * (x && g ? -1 : 1);
+      break;
+  }
+  return t;
+}
+const it = async (i, n, x) => {
+  const {
+    placement: l = "bottom",
+    strategy: r = "absolute",
+    middleware: e = [],
+    platform: f
+  } = x, m = e.filter(Boolean), o = await (f.isRTL == null ? void 0 : f.isRTL(n));
+  let g = await f.getElementRects({
+    reference: i,
+    floating: n,
+    strategy: r
+  }), {
+    x: d,
+    y: c
+  } = q(g, l, o), a = l, t = {}, s = 0;
+  for (let w = 0; w < m.length; w++) {
+    const {
+      name: u,
+      fn: A
+    } = m[w], {
+      x: y,
+      y: p,
+      data: v,
+      reset: h
+    } = await A({
+      x: d,
+      y: c,
+      initialPlacement: l,
+      placement: a,
+      strategy: r,
+      middlewareData: t,
+      rects: g,
+      platform: f,
+      elements: {
+        reference: i,
+        floating: n
+      }
+    });
+    d = y ?? d, c = p ?? c, t = {
+      ...t,
+      [u]: {
+        ...t[u],
+        ...v
+      }
+    }, h && s <= 50 && (s++, typeof h == "object" && (h.placement && (a = h.placement), h.rects && (g = h.rects === !0 ? await f.getElementRects({
+      reference: i,
+      floating: n,
+      strategy: r
+    }) : h.rects), {
+      x: d,
+      y: c
+    } = q(g, a, o)), w = -1);
+  }
+  return {
+    x: d,
+    y: c,
+    placement: a,
+    strategy: r,
+    middlewareData: t
+  };
+};
+async function $(i, n) {
+  var x;
+  n === void 0 && (n = {});
+  const {
+    x: l,
+    y: r,
+    platform: e,
+    rects: f,
+    elements: m,
+    strategy: o
+  } = i, {
+    boundary: g = "clippingAncestors",
+    rootBoundary: d = "viewport",
+    elementContext: c = "floating",
+    altBoundary: a = !1,
+    padding: t = 0
+  } = L(n, i), s = G(t), u = m[a ? c === "floating" ? "reference" : "floating" : c], A = I(await e.getClippingRect({
+    element: (x = await (e.isElement == null ? void 0 : e.isElement(u))) == null || x ? u : u.contextElement || await (e.getDocumentElement == null ? void 0 : e.getDocumentElement(m.floating)),
+    boundary: g,
+    rootBoundary: d,
+    strategy: o
+  })), y = c === "floating" ? {
+    x: l,
+    y: r,
+    width: f.floating.width,
+    height: f.floating.height
+  } : f.reference, p = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(m.floating)), v = await (e.isElement == null ? void 0 : e.isElement(p)) ? await (e.getScale == null ? void 0 : e.getScale(p)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, h = I(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: m,
+    rect: y,
+    offsetParent: p,
+    strategy: o
+  }) : y);
+  return {
+    top: (A.top - h.top + s.top) / v.y,
+    bottom: (h.bottom - A.bottom + s.bottom) / v.y,
+    left: (A.left - h.left + s.left) / v.x,
+    right: (h.right - A.right + s.right) / v.x
+  };
+}
+const st = (i) => ({
+  name: "arrow",
+  options: i,
+  async fn(n) {
+    const {
+      x,
+      y: l,
+      placement: r,
+      rects: e,
+      platform: f,
+      elements: m,
+      middlewareData: o
+    } = n, {
+      element: g,
+      padding: d = 0
+    } = L(i, n) || {};
+    if (g == null)
+      return {};
+    const c = G(d), a = {
+      x,
+      y: l
+    }, t = J(r), s = K(t), w = await f.getDimensions(g), u = t === "y", A = u ? "top" : "left", y = u ? "bottom" : "right", p = u ? "clientHeight" : "clientWidth", v = e.reference[s] + e.reference[t] - a[t] - e.floating[s], h = a[t] - e.reference[t], P = await (f.getOffsetParent == null ? void 0 : f.getOffsetParent(g));
+    let R = P ? P[p] : 0;
+    (!R || !await (f.isElement == null ? void 0 : f.isElement(P))) && (R = m.floating[p] || e.floating[s]);
+    const D = v / 2 - h / 2, C = R / 2 - w[s] / 2 - 1, O = W(c[A], C), M = W(c[y], C), V = O, Y = R - w[s] - M, b = R / 2 - w[s] / 2 + D, B = X(V, b, Y), k = !o.arrow && z(r) != null && b !== B && e.reference[s] / 2 - (b < V ? O : M) - w[s] / 2 < 0, S = k ? b < V ? b - V : b - Y : 0;
+    return {
+      [t]: a[t] + S,
+      data: {
+        [t]: B,
+        centerOffset: b - B - S,
+        ...k && {
+          alignmentOffset: S
+        }
+      },
+      reset: k
+    };
+  }
+}), ot = function(i) {
+  return i === void 0 && (i = {}), {
+    name: "flip",
+    options: i,
+    async fn(n) {
+      var x, l;
+      const {
+        placement: r,
+        middlewareData: e,
+        rects: f,
+        initialPlacement: m,
+        platform: o,
+        elements: g
+      } = n, {
+        mainAxis: d = !0,
+        crossAxis: c = !0,
+        fallbackPlacements: a,
+        fallbackStrategy: t = "bestFit",
+        fallbackAxisSideDirection: s = "none",
+        flipAlignment: w = !0,
+        ...u
+      } = L(i, n);
+      if ((x = e.arrow) != null && x.alignmentOffset)
+        return {};
+      const A = F(r), y = j(m), p = F(m) === m, v = await (o.isRTL == null ? void 0 : o.isRTL(g.floating)), h = a || (p || !w ? [U(m)] : Z(m)), P = s !== "none";
+      !a && P && h.push(..._(m, w, s, v));
+      const R = [m, ...h], D = await $(n, u), C = [];
+      let O = ((l = e.flip) == null ? void 0 : l.overflows) || [];
+      if (d && C.push(D[A]), c) {
+        const b = tt(r, f, v);
+        C.push(D[b[0]], D[b[1]]);
+      }
+      if (O = [...O, {
+        placement: r,
+        overflows: C
+      }], !C.every((b) => b <= 0)) {
+        var M, V;
+        const b = (((M = e.flip) == null ? void 0 : M.index) || 0) + 1, B = R[b];
+        if (B)
+          return {
+            data: {
+              index: b,
+              overflows: O
+            },
+            reset: {
+              placement: B
+            }
+          };
+        let k = (V = O.filter((S) => S.overflows[0] <= 0).sort((S, E) => S.overflows[1] - E.overflows[1])[0]) == null ? void 0 : V.placement;
+        if (!k)
+          switch (t) {
+            case "bestFit": {
+              var Y;
+              const S = (Y = O.filter((E) => {
+                if (P) {
+                  const T = j(E.placement);
+                  return T === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  T === "y";
+                }
+                return !0;
+              }).map((E) => [E.placement, E.overflows.filter((T) => T > 0).reduce((T, Q) => T + Q, 0)]).sort((E, T) => E[1] - T[1])[0]) == null ? void 0 : Y[0];
+              S && (k = S);
+              break;
+            }
+            case "initialPlacement":
+              k = m;
+              break;
+          }
+        if (r !== k)
+          return {
+            reset: {
+              placement: k
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function et(i, n) {
+  const {
+    placement: x,
+    platform: l,
+    elements: r
+  } = i, e = await (l.isRTL == null ? void 0 : l.isRTL(r.floating)), f = F(x), m = z(x), o = j(x) === "y", g = ["left", "top"].includes(f) ? -1 : 1, d = e && o ? -1 : 1, c = L(n, i);
+  let {
+    mainAxis: a,
+    crossAxis: t,
+    alignmentAxis: s
+  } = typeof c == "number" ? {
+    mainAxis: c,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: 0,
+    crossAxis: 0,
+    alignmentAxis: null,
+    ...c
+  };
+  return m && typeof s == "number" && (t = m === "end" ? s * -1 : s), o ? {
+    x: t * d,
+    y: a * g
+  } : {
+    x: a * g,
+    y: t * d
+  };
+}
+const ct = function(i) {
+  return i === void 0 && (i = 0), {
+    name: "offset",
+    options: i,
+    async fn(n) {
+      var x, l;
+      const {
+        x: r,
+        y: e,
+        placement: f,
+        middlewareData: m
+      } = n, o = await et(n, i);
+      return f === ((x = m.offset) == null ? void 0 : x.placement) && (l = m.arrow) != null && l.alignmentOffset ? {} : {
+        x: r + o.x,
+        y: e + o.y,
+        data: {
+          ...o,
+          placement: f
+        }
+      };
+    }
+  };
+}, lt = function(i) {
+  return i === void 0 && (i = {}), {
+    name: "shift",
+    options: i,
+    async fn(n) {
+      const {
+        x,
+        y: l,
+        placement: r
+      } = n, {
+        mainAxis: e = !0,
+        crossAxis: f = !1,
+        limiter: m = {
+          fn: (u) => {
+            let {
+              x: A,
+              y
+            } = u;
+            return {
+              x: A,
+              y
+            };
+          }
+        },
+        ...o
+      } = L(i, n), g = {
+        x,
+        y: l
+      }, d = await $(n, o), c = j(F(r)), a = N(c);
+      let t = g[a], s = g[c];
+      if (e) {
+        const u = a === "y" ? "top" : "left", A = a === "y" ? "bottom" : "right", y = t + d[u], p = t - d[A];
+        t = X(y, t, p);
+      }
+      if (f) {
+        const u = c === "y" ? "top" : "left", A = c === "y" ? "bottom" : "right", y = s + d[u], p = s - d[A];
+        s = X(y, s, p);
+      }
+      const w = m.fn({
+        ...n,
+        [a]: t,
+        [c]: s
+      });
+      return {
+        ...w,
+        data: {
+          x: w.x - x,
+          y: w.y - l
+        }
+      };
+    }
+  };
+}, at = function(i) {
+  return i === void 0 && (i = {}), {
+    options: i,
+    fn(n) {
+      const {
+        x,
+        y: l,
+        placement: r,
+        rects: e,
+        middlewareData: f
+      } = n, {
+        offset: m = 0,
+        mainAxis: o = !0,
+        crossAxis: g = !0
+      } = L(i, n), d = {
+        x,
+        y: l
+      }, c = j(r), a = N(c);
+      let t = d[a], s = d[c];
+      const w = L(m, n), u = typeof w == "number" ? {
+        mainAxis: w,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...w
+      };
+      if (o) {
+        const p = a === "y" ? "height" : "width", v = e.reference[a] - e.floating[p] + u.mainAxis, h = e.reference[a] + e.reference[p] - u.mainAxis;
+        t < v ? t = v : t > h && (t = h);
+      }
+      if (g) {
+        var A, y;
+        const p = a === "y" ? "width" : "height", v = ["top", "left"].includes(F(r)), h = e.reference[c] - e.floating[p] + (v && ((A = f.offset) == null ? void 0 : A[c]) || 0) + (v ? 0 : u.crossAxis), P = e.reference[c] + e.reference[p] + (v ? 0 : ((y = f.offset) == null ? void 0 : y[c]) || 0) - (v ? u.crossAxis : 0);
+        s < h ? s = h : s > P && (s = P);
+      }
+      return {
+        [a]: t,
+        [c]: s
+      };
+    }
+  };
+}, rt = function(i) {
+  return i === void 0 && (i = {}), {
+    name: "size",
+    options: i,
+    async fn(n) {
+      const {
+        placement: x,
+        rects: l,
+        platform: r,
+        elements: e
+      } = n, {
+        apply: f = () => {
+        },
+        ...m
+      } = L(i, n), o = await $(n, m), g = F(x), d = z(x), c = j(x) === "y", {
+        width: a,
+        height: t
+      } = l.floating;
+      let s, w;
+      g === "top" || g === "bottom" ? (s = g, w = d === (await (r.isRTL == null ? void 0 : r.isRTL(e.floating)) ? "start" : "end") ? "left" : "right") : (w = g, s = d === "end" ? "top" : "bottom");
+      const u = t - o.top - o.bottom, A = a - o.left - o.right, y = W(t - o[s], u), p = W(a - o[w], A), v = !n.middlewareData.shift;
+      let h = y, P = p;
+      if (c ? P = d || v ? W(p, A) : A : h = d || v ? W(y, u) : u, v && !d) {
+        const D = H(o.left, 0), C = H(o.right, 0), O = H(o.top, 0), M = H(o.bottom, 0);
+        c ? P = a - 2 * (D !== 0 || C !== 0 ? D + C : H(o.left, o.right)) : h = t - 2 * (O !== 0 || M !== 0 ? O + M : H(o.top, o.bottom));
+      }
+      await f({
+        ...n,
+        availableWidth: P,
+        availableHeight: h
+      });
+      const R = await r.getDimensions(e.floating);
+      return a !== R.width || t !== R.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+export {
+  st as arrow,
+  it as computePosition,
+  $ as detectOverflow,
+  ot as flip,
+  at as limitShift,
+  ct as offset,
+  I as rectToClientRect,
+  lt as shift,
+  rt as size
+};