@synopackageland/ui 0.25.21 → 0.25.22

package/dist/modules/vendor/@floating-ui/core/dist/floating-ui.core.js

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