@vc-shell/framework 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/vendor-floating-ui-core-BoHdh92a.js

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