@getflip/swirl-components-react 0.1.0 → 0.2.0

package/dist/floating-ui.dom.esm-1a4e8b8a.87557233.js

@@ -0,0 +1,752 @@
+function k(t) {
+  return t.split("-")[0];
+}
+function I(t) {
+  return t.split("-")[1];
+}
+function _(t) {
+  return ["top", "bottom"].includes(k(t)) ? "x" : "y";
+}
+function ot(t) {
+  return t === "y" ? "height" : "width";
+}
+function J(t, e, n) {
+  let {
+    reference: o,
+    floating: i
+  } = t;
+  const c = o.x + o.width / 2 - i.width / 2, r = o.y + o.height / 2 - i.height / 2, s = _(e), l = ot(s), f = o[l] / 2 - i[l] / 2, h = k(e), a = s === "x";
+  let u;
+  switch (h) {
+    case "top":
+      u = {
+        x: c,
+        y: o.y - i.height
+      };
+      break;
+    case "bottom":
+      u = {
+        x: c,
+        y: o.y + o.height
+      };
+      break;
+    case "right":
+      u = {
+        x: o.x + o.width,
+        y: r
+      };
+      break;
+    case "left":
+      u = {
+        x: o.x - i.width,
+        y: r
+      };
+      break;
+    default:
+      u = {
+        x: o.x,
+        y: o.y
+      };
+  }
+  switch (I(e)) {
+    case "start":
+      u[s] -= f * (n && a ? -1 : 1);
+      break;
+    case "end":
+      u[s] += f * (n && a ? -1 : 1);
+      break;
+  }
+  return u;
+}
+const ht = async (t, e, n) => {
+  const {
+    placement: o = "bottom",
+    strategy: i = "absolute",
+    middleware: c = [],
+    platform: r
+  } = n, s = await (r.isRTL == null ? void 0 : r.isRTL(e));
+  let l = await r.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  }), {
+    x: f,
+    y: h
+  } = J(l, o, s), a = o, u = {}, m = 0;
+  for (let g = 0; g < c.length; g++) {
+    const {
+      name: d,
+      fn: p
+    } = c[g], {
+      x: w,
+      y: x,
+      data: A,
+      reset: y
+    } = await p({
+      x: f,
+      y: h,
+      initialPlacement: o,
+      placement: a,
+      strategy: i,
+      middlewareData: u,
+      rects: l,
+      platform: r,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    if (f = w != null ? w : f, h = x != null ? x : h, u = {
+      ...u,
+      [d]: {
+        ...u[d],
+        ...A
+      }
+    }, y && m <= 50) {
+      m++, typeof y == "object" && (y.placement && (a = y.placement), y.rects && (l = y.rects === !0 ? await r.getElementRects({
+        reference: t,
+        floating: e,
+        strategy: i
+      }) : y.rects), {
+        x: f,
+        y: h
+      } = J(l, a, s)), g = -1;
+      continue;
+    }
+  }
+  return {
+    x: f,
+    y: h,
+    placement: a,
+    strategy: i,
+    middlewareData: u
+  };
+};
+function mt(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function gt(t) {
+  return typeof t != "number" ? mt(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function B(t) {
+  return {
+    ...t,
+    top: t.y,
+    left: t.x,
+    right: t.x + t.width,
+    bottom: t.y + t.height
+  };
+}
+async function it(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const {
+    x: o,
+    y: i,
+    platform: c,
+    rects: r,
+    elements: s,
+    strategy: l
+  } = t, {
+    boundary: f = "clippingAncestors",
+    rootBoundary: h = "viewport",
+    elementContext: a = "floating",
+    altBoundary: u = !1,
+    padding: m = 0
+  } = e, g = gt(m), p = s[u ? a === "floating" ? "reference" : "floating" : a], w = B(await c.getClippingRect({
+    element: (n = await (c.isElement == null ? void 0 : c.isElement(p))) == null || n ? p : p.contextElement || await (c.getDocumentElement == null ? void 0 : c.getDocumentElement(s.floating)),
+    boundary: f,
+    rootBoundary: h,
+    strategy: l
+  })), x = B(c.convertOffsetParentRelativeRectToViewportRelativeRect ? await c.convertOffsetParentRelativeRectToViewportRelativeRect({
+    rect: a === "floating" ? {
+      ...r.floating,
+      x: o,
+      y: i
+    } : r.reference,
+    offsetParent: await (c.getOffsetParent == null ? void 0 : c.getOffsetParent(s.floating)),
+    strategy: l
+  }) : r[a]);
+  return {
+    top: w.top - x.top + g.top,
+    bottom: x.bottom - w.bottom + g.bottom,
+    left: w.left - x.left + g.left,
+    right: x.right - w.right + g.right
+  };
+}
+const pt = Math.min, wt = Math.max;
+function K(t, e, n) {
+  return wt(t, pt(e, n));
+}
+const xt = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function M(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => xt[e]);
+}
+function yt(t, e, n) {
+  n === void 0 && (n = !1);
+  const o = I(t), i = _(t), c = ot(i);
+  let r = i === "x" ? o === (n ? "end" : "start") ? "right" : "left" : o === "start" ? "bottom" : "top";
+  return e.reference[c] > e.floating[c] && (r = M(r)), {
+    main: r,
+    cross: M(r)
+  };
+}
+const vt = {
+  start: "end",
+  end: "start"
+};
+function Q(t) {
+  return t.replace(/start|end/g, (e) => vt[e]);
+}
+function bt(t) {
+  const e = M(t);
+  return [Q(t), e, Q(e)];
+}
+const Mt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var n;
+      const {
+        placement: o,
+        middlewareData: i,
+        rects: c,
+        initialPlacement: r,
+        platform: s,
+        elements: l
+      } = e, {
+        mainAxis: f = !0,
+        crossAxis: h = !0,
+        fallbackPlacements: a,
+        fallbackStrategy: u = "bestFit",
+        flipAlignment: m = !0,
+        ...g
+      } = t, d = k(o), w = a || (d === r || !m ? [M(r)] : bt(r)), x = [r, ...w], A = await it(e, g), y = [];
+      let D = ((n = i.flip) == null ? void 0 : n.overflows) || [];
+      if (f && y.push(A[d]), h) {
+        const {
+          main: P,
+          cross: N
+        } = yt(o, c, await (s.isRTL == null ? void 0 : s.isRTL(l.floating)));
+        y.push(A[P], A[N]);
+      }
+      if (D = [...D, {
+        placement: o,
+        overflows: y
+      }], !y.every((P) => P <= 0)) {
+        var Y, U;
+        const P = ((Y = (U = i.flip) == null ? void 0 : U.index) != null ? Y : 0) + 1, N = x[P];
+        if (N)
+          return {
+            data: {
+              index: P,
+              overflows: D
+            },
+            reset: {
+              placement: N
+            }
+          };
+        let W = "bottom";
+        switch (u) {
+          case "bestFit": {
+            var q;
+            const G = (q = D.map((H) => [H, H.overflows.filter((S) => S > 0).reduce((S, dt) => S + dt, 0)]).sort((H, S) => H[1] - S[1])[0]) == null ? void 0 : q[0].placement;
+            G && (W = G);
+            break;
+          }
+          case "initialPlacement":
+            W = r;
+            break;
+        }
+        if (o !== W)
+          return {
+            reset: {
+              placement: W
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function At(t, e) {
+  const {
+    placement: n,
+    platform: o,
+    elements: i
+  } = t, c = await (o.isRTL == null ? void 0 : o.isRTL(i.floating)), r = k(n), s = I(n), l = _(n) === "x", f = ["left", "top"].includes(r) ? -1 : 1, h = c && l ? -1 : 1, a = typeof e == "function" ? e(t) : e;
+  let {
+    mainAxis: u,
+    crossAxis: m,
+    alignmentAxis: g
+  } = typeof a == "number" ? {
+    mainAxis: a,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: 0,
+    crossAxis: 0,
+    alignmentAxis: null,
+    ...a
+  };
+  return s && typeof g == "number" && (m = s === "end" ? g * -1 : g), l ? {
+    x: m * h,
+    y: u * f
+  } : {
+    x: u * f,
+    y: m * h
+  };
+}
+const Ft = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: o
+      } = e, i = await At(e, t);
+      return {
+        x: n + i.x,
+        y: o + i.y,
+        data: i
+      };
+    }
+  };
+};
+function Rt(t) {
+  return t === "x" ? "y" : "x";
+}
+const $t = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: o,
+        placement: i
+      } = e, {
+        mainAxis: c = !0,
+        crossAxis: r = !1,
+        limiter: s = {
+          fn: (p) => {
+            let {
+              x: w,
+              y: x
+            } = p;
+            return {
+              x: w,
+              y: x
+            };
+          }
+        },
+        ...l
+      } = t, f = {
+        x: n,
+        y: o
+      }, h = await it(e, l), a = _(k(i)), u = Rt(a);
+      let m = f[a], g = f[u];
+      if (c) {
+        const p = a === "y" ? "top" : "left", w = a === "y" ? "bottom" : "right", x = m + h[p], A = m - h[w];
+        m = K(x, m, A);
+      }
+      if (r) {
+        const p = u === "y" ? "top" : "left", w = u === "y" ? "bottom" : "right", x = g + h[p], A = g - h[w];
+        g = K(x, g, A);
+      }
+      const d = s.fn({
+        ...e,
+        [a]: m,
+        [u]: g
+      });
+      return {
+        ...d,
+        data: {
+          x: d.x - n,
+          y: d.y - o
+        }
+      };
+    }
+  };
+};
+function st(t) {
+  return t && t.document && t.location && t.alert && t.setInterval;
+}
+function E(t) {
+  if (t == null)
+    return window;
+  if (!st(t)) {
+    const e = t.ownerDocument;
+    return e && e.defaultView || window;
+  }
+  return t;
+}
+function v(t) {
+  return E(t).getComputedStyle(t);
+}
+function R(t) {
+  return st(t) ? "" : t ? (t.nodeName || "").toLowerCase() : "";
+}
+function rt() {
+  const t = navigator.userAgentData;
+  return t != null && t.brands ? t.brands.map((e) => e.brand + "/" + e.version).join(" ") : navigator.userAgent;
+}
+function b(t) {
+  return t instanceof E(t).HTMLElement;
+}
+function L(t) {
+  return t instanceof E(t).Element;
+}
+function Ct(t) {
+  return t instanceof E(t).Node;
+}
+function T(t) {
+  if (typeof ShadowRoot > "u")
+    return !1;
+  const e = E(t).ShadowRoot;
+  return t instanceof e || t instanceof ShadowRoot;
+}
+function z(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: o
+  } = v(t);
+  return /auto|scroll|overlay|hidden/.test(e + o + n);
+}
+function Et(t) {
+  return ["table", "td", "th"].includes(R(t));
+}
+function ct(t) {
+  const e = /firefox/i.test(rt()), n = v(t);
+  return n.transform !== "none" || n.perspective !== "none" || n.contain === "paint" || ["transform", "perspective"].includes(n.willChange) || e && n.willChange === "filter" || e && (n.filter ? n.filter !== "none" : !1);
+}
+function lt() {
+  return !/^((?!chrome|android).)*safari/i.test(rt());
+}
+const Z = Math.min, V = Math.max, F = Math.round;
+function C(t, e, n) {
+  var o, i, c, r;
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const s = t.getBoundingClientRect();
+  let l = 1, f = 1;
+  e && b(t) && (l = t.offsetWidth > 0 && F(s.width) / t.offsetWidth || 1, f = t.offsetHeight > 0 && F(s.height) / t.offsetHeight || 1);
+  const h = L(t) ? E(t) : window, a = !lt() && n, u = (s.left + (a && (o = (i = h.visualViewport) == null ? void 0 : i.offsetLeft) != null ? o : 0)) / l, m = (s.top + (a && (c = (r = h.visualViewport) == null ? void 0 : r.offsetTop) != null ? c : 0)) / f, g = s.width / l, d = s.height / f;
+  return {
+    width: g,
+    height: d,
+    top: m,
+    right: u + g,
+    bottom: m + d,
+    left: u,
+    x: u,
+    y: m
+  };
+}
+function O(t) {
+  return ((Ct(t) ? t.ownerDocument : t.document) || window.document).documentElement;
+}
+function X(t) {
+  return L(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.pageXOffset,
+    scrollTop: t.pageYOffset
+  };
+}
+function ft(t) {
+  return C(O(t)).left + X(t).scrollLeft;
+}
+function Lt(t) {
+  const e = C(t);
+  return F(e.width) !== t.offsetWidth || F(e.height) !== t.offsetHeight;
+}
+function Ot(t, e, n) {
+  const o = b(e), i = O(e), c = C(
+    t,
+    o && Lt(e),
+    n === "fixed"
+  );
+  let r = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const s = {
+    x: 0,
+    y: 0
+  };
+  if (o || !o && n !== "fixed")
+    if ((R(e) !== "body" || z(i)) && (r = X(e)), b(e)) {
+      const l = C(e, !0);
+      s.x = l.x + e.clientLeft, s.y = l.y + e.clientTop;
+    } else
+      i && (s.x = ft(i));
+  return {
+    x: c.left + r.scrollLeft - s.x,
+    y: c.top + r.scrollTop - s.y,
+    width: c.width,
+    height: c.height
+  };
+}
+function at(t) {
+  return R(t) === "html" ? t : t.assignedSlot || t.parentNode || (T(t) ? t.host : null) || O(t);
+}
+function tt(t) {
+  return !b(t) || v(t).position === "fixed" ? null : Pt(t);
+}
+function Pt(t) {
+  let {
+    offsetParent: e
+  } = t, n = t, o = !1;
+  for (; n && n !== e; ) {
+    const {
+      assignedSlot: i
+    } = n;
+    if (i) {
+      let c = i.offsetParent;
+      if (v(i).display === "contents") {
+        const r = i.hasAttribute("style"), s = i.style.display;
+        i.style.display = v(n).display, c = i.offsetParent, i.style.display = s, r || i.removeAttribute("style");
+      }
+      n = i, e !== c && (e = c, o = !0);
+    } else if (T(n) && n.host && o)
+      break;
+    n = T(n) && n.host || n.parentNode;
+  }
+  return e;
+}
+function Tt(t) {
+  let e = at(t);
+  for (T(e) && (e = e.host); b(e) && !["html", "body"].includes(R(e)); ) {
+    if (ct(e))
+      return e;
+    {
+      const n = e.parentNode;
+      e = T(n) ? n.host : n;
+    }
+  }
+  return null;
+}
+function j(t) {
+  const e = E(t);
+  let n = tt(t);
+  for (; n && Et(n) && v(n).position === "static"; )
+    n = tt(n);
+  return n && (R(n) === "html" || R(n) === "body" && v(n).position === "static" && !ct(n)) ? e : n || Tt(t) || e;
+}
+function et(t) {
+  if (b(t))
+    return {
+      width: t.offsetWidth,
+      height: t.offsetHeight
+    };
+  const e = C(t);
+  return {
+    width: e.width,
+    height: e.height
+  };
+}
+function St(t) {
+  let {
+    rect: e,
+    offsetParent: n,
+    strategy: o
+  } = t;
+  const i = b(n), c = O(n);
+  if (n === c)
+    return e;
+  let r = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const s = {
+    x: 0,
+    y: 0
+  };
+  if ((i || !i && o !== "fixed") && ((R(n) !== "body" || z(c)) && (r = X(n)), b(n))) {
+    const l = C(n, !0);
+    s.x = l.x + n.clientLeft, s.y = l.y + n.clientTop;
+  }
+  return {
+    ...e,
+    x: e.x - r.scrollLeft + s.x,
+    y: e.y - r.scrollTop + s.y
+  };
+}
+function Vt(t, e) {
+  const n = E(t), o = O(t), i = n.visualViewport;
+  let c = o.clientWidth, r = o.clientHeight, s = 0, l = 0;
+  if (i) {
+    c = i.width, r = i.height;
+    const f = lt();
+    (f || !f && e === "fixed") && (s = i.offsetLeft, l = i.offsetTop);
+  }
+  return {
+    width: c,
+    height: r,
+    x: s,
+    y: l
+  };
+}
+function kt(t) {
+  var e;
+  const n = O(t), o = X(t), i = (e = t.ownerDocument) == null ? void 0 : e.body, c = V(n.scrollWidth, n.clientWidth, i ? i.scrollWidth : 0, i ? i.clientWidth : 0), r = V(n.scrollHeight, n.clientHeight, i ? i.scrollHeight : 0, i ? i.clientHeight : 0);
+  let s = -o.scrollLeft + ft(t);
+  const l = -o.scrollTop;
+  return v(i || n).direction === "rtl" && (s += V(n.clientWidth, i ? i.clientWidth : 0) - c), {
+    width: c,
+    height: r,
+    x: s,
+    y: l
+  };
+}
+function ut(t) {
+  const e = at(t);
+  return ["html", "body", "#document"].includes(R(e)) ? t.ownerDocument.body : b(e) && z(e) ? e : ut(e);
+}
+function $(t, e) {
+  var n;
+  e === void 0 && (e = []);
+  const o = ut(t), i = o === ((n = t.ownerDocument) == null ? void 0 : n.body), c = E(o), r = i ? [c].concat(c.visualViewport || [], z(o) ? o : []) : o, s = e.concat(r);
+  return i ? s : s.concat($(r));
+}
+function Dt(t, e) {
+  const n = e.getRootNode == null ? void 0 : e.getRootNode();
+  if (t.contains(e))
+    return !0;
+  if (n && T(n)) {
+    let o = e;
+    do {
+      if (o && t === o)
+        return !0;
+      o = o.parentNode || o.host;
+    } while (o);
+  }
+  return !1;
+}
+function Nt(t, e) {
+  const n = C(t, !1, e === "fixed"), o = n.top + t.clientTop, i = n.left + t.clientLeft;
+  return {
+    top: o,
+    left: i,
+    x: i,
+    y: o,
+    right: i + t.clientWidth,
+    bottom: o + t.clientHeight,
+    width: t.clientWidth,
+    height: t.clientHeight
+  };
+}
+function nt(t, e, n) {
+  return e === "viewport" ? B(Vt(t, n)) : L(e) ? Nt(e, n) : B(kt(O(t)));
+}
+function Wt(t) {
+  const e = $(t), o = ["absolute", "fixed"].includes(v(t).position) && b(t) ? j(t) : t;
+  return L(o) ? e.filter((i) => L(i) && Dt(i, o) && R(i) !== "body") : [];
+}
+function Ht(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: o,
+    strategy: i
+  } = t;
+  const r = [...n === "clippingAncestors" ? Wt(e) : [].concat(n), o], s = r[0], l = r.reduce((f, h) => {
+    const a = nt(e, h, i);
+    return f.top = V(a.top, f.top), f.right = Z(a.right, f.right), f.bottom = Z(a.bottom, f.bottom), f.left = V(a.left, f.left), f;
+  }, nt(e, s, i));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
+  };
+}
+const Bt = {
+  getClippingRect: Ht,
+  convertOffsetParentRelativeRectToViewportRelativeRect: St,
+  isElement: L,
+  getDimensions: et,
+  getOffsetParent: j,
+  getDocumentElement: O,
+  getElementRects: (t) => {
+    let {
+      reference: e,
+      floating: n,
+      strategy: o
+    } = t;
+    return {
+      reference: Ot(e, j(n), o),
+      floating: {
+        ...et(n),
+        x: 0,
+        y: 0
+      }
+    };
+  },
+  getClientRects: (t) => Array.from(t.getClientRects()),
+  isRTL: (t) => v(t).direction === "rtl"
+};
+function _t(t, e, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: i = !0,
+    ancestorResize: c = !0,
+    elementResize: r = !0,
+    animationFrame: s = !1
+  } = o, l = i && !s, f = c && !s, h = l || f ? [...L(t) ? $(t) : [], ...$(e)] : [];
+  h.forEach((d) => {
+    l && d.addEventListener("scroll", n, {
+      passive: !0
+    }), f && d.addEventListener("resize", n);
+  });
+  let a = null;
+  if (r) {
+    let d = !0;
+    a = new ResizeObserver(() => {
+      d || n(), d = !1;
+    }), L(t) && !s && a.observe(t), a.observe(e);
+  }
+  let u, m = s ? C(t) : null;
+  s && g();
+  function g() {
+    const d = C(t);
+    m && (d.x !== m.x || d.y !== m.y || d.width !== m.width || d.height !== m.height) && n(), m = d, u = requestAnimationFrame(g);
+  }
+  return n(), () => {
+    var d;
+    h.forEach((p) => {
+      l && p.removeEventListener("scroll", n), f && p.removeEventListener("resize", n);
+    }), (d = a) == null || d.disconnect(), a = null, s && cancelAnimationFrame(u);
+  };
+}
+const zt = (t, e, n) => ht(t, e, {
+  platform: Bt,
+  ...n
+});
+export {
+  _t as a,
+  zt as c,
+  Mt as f,
+  Ft as o,
+  $t as s
+};