laif-ds 0.2.5 → 0.2.6

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

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