bitboss-ui 0.2.70 → 0.2.72

package/dist/index214.js

@@ -1,376 +1,371 @@
-import { evaluate as j, getSide as M, getOppositePlacement as G, getExpandedPlacements as J, getOppositeAxisPlacements as K, getAlignmentSides as N, getAlignment as F, getSideAxis as Y, clamp as B, getPaddingObject as z, rectToClientRect as $, getAlignmentAxis as H, getOppositeAxis as Q, getAxisLength as I, min as X } from "./index245.js";
-function _(o, i, m) {
-  let {
-    reference: n,
-    floating: r
-  } = o;
-  const e = Y(i), l = H(i), a = I(l), g = M(i), x = e === "y", d = n.x + n.width / 2 - r.width / 2, c = n.y + n.height / 2 - r.height / 2, f = n[a] / 2 - r[a] / 2;
-  let t;
-  switch (g) {
-    case "top":
-      t = {
-        x: d,
-        y: n.y - r.height
-      };
-      break;
-    case "bottom":
-      t = {
-        x: d,
-        y: n.y + n.height
-      };
-      break;
-    case "right":
-      t = {
-        x: n.x + n.width,
-        y: c
-      };
-      break;
-    case "left":
-      t = {
-        x: n.x - r.width,
-        y: c
-      };
-      break;
-    default:
-      t = {
-        x: n.x,
-        y: n.y
-      };
-  }
-  switch (F(i)) {
-    case "start":
-      t[l] -= f * (m && x ? -1 : 1);
-      break;
-    case "end":
-      t[l] += f * (m && x ? -1 : 1);
-      break;
+import { shift as P, flip as tt, arrow as et, computePosition as ot } from "./index219.js";
+import { detectOverflow as At, offset as Nt } from "./index219.js";
+import { createCoords as x, rectToClientRect as q, round as N, floor as A, max as T, min as I } from "./index246.js";
+import { getOverflowAncestors as V, isElement as b, getWindow as E, getComputedStyle as y, getDocumentElement as C, isHTMLElement as R, isWebKit as U, getNodeName as W, isOverflowElement as S, getNodeScroll as D, isTableElement as nt, isContainingBlock as K, getContainingBlock as it, getParentNode as z, isLastTraversableNode as X } from "./index247.js";
+function j(t) {
+  const e = y(t);
+  let n = parseFloat(e.width) || 0, o = parseFloat(e.height) || 0;
+  const s = R(t), c = s ? t.offsetWidth : n, i = s ? t.offsetHeight : o, r = N(n) !== c || N(o) !== i;
+  return r && (n = c, o = i), {
+    width: n,
+    height: o,
+    $: r
+  };
+}
+function $(t) {
+  return b(t) ? t : t.contextElement;
+}
+function F(t) {
+  const e = $(t);
+  if (!R(e))
+    return x(1);
+  const n = e.getBoundingClientRect(), {
+    width: o,
+    height: s,
+    $: c
+  } = j(e);
+  let i = (c ? N(n.width) : n.width) / o, r = (c ? N(n.height) : n.height) / s;
+  return (!i || !Number.isFinite(i)) && (i = 1), (!r || !Number.isFinite(r)) && (r = 1), {
+    x: i,
+    y: r
+  };
+}
+const st = /* @__PURE__ */ x(0);
+function G(t) {
+  const e = E(t);
+  return !U() || !e.visualViewport ? st : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function rt(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== E(t) ? !1 : e;
+}
+function L(t, e, n, o) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const s = t.getBoundingClientRect(), c = $(t);
+  let i = x(1);
+  e && (o ? b(o) && (i = F(o)) : i = F(t));
+  const r = rt(c, n, o) ? G(c) : x(0);
+  let l = (s.left + r.x) / i.x, f = (s.top + r.y) / i.y, u = s.width / i.x, h = s.height / i.y;
+  if (c) {
+    const w = E(c), g = o && b(o) ? E(o) : o;
+    let v = w, a = v.frameElement;
+    for (; a && o && g !== v; ) {
+      const p = F(a), d = a.getBoundingClientRect(), m = y(a), O = d.left + (a.clientLeft + parseFloat(m.paddingLeft)) * p.x, B = d.top + (a.clientTop + parseFloat(m.paddingTop)) * p.y;
+      l *= p.x, f *= p.y, u *= p.x, h *= p.y, l += O, f += B, v = E(a), a = v.frameElement;
+    }
   }
-  return t;
+  return q({
+    width: u,
+    height: h,
+    x: l,
+    y: f
+  });
 }
-const tt = async (o, i, m) => {
-  const {
-    placement: n = "bottom",
-    strategy: r = "absolute",
-    middleware: e = [],
-    platform: l
-  } = m, a = e.filter(Boolean), g = await (l.isRTL == null ? void 0 : l.isRTL(i));
-  let x = await l.getElementRects({
-    reference: o,
-    floating: i,
-    strategy: r
-  }), {
-    x: d,
-    y: c
-  } = _(x, n, g), f = n, t = {}, s = 0;
-  for (let w = 0; w < a.length; w++) {
-    const {
-      name: u,
-      fn: p
-    } = a[w], {
-      x: h,
-      y,
-      data: P,
-      reset: v
-    } = await p({
-      x: d,
-      y: c,
-      initialPlacement: n,
-      placement: f,
-      strategy: r,
-      middlewareData: t,
-      rects: x,
-      platform: l,
-      elements: {
-        reference: o,
-        floating: i
-      }
-    });
-    d = h ?? d, c = y ?? c, t = {
-      ...t,
-      [u]: {
-        ...t[u],
-        ...P
-      }
-    }, v && s <= 50 && (s++, typeof v == "object" && (v.placement && (f = v.placement), v.rects && (x = v.rects === !0 ? await l.getElementRects({
-      reference: o,
-      floating: i,
-      strategy: r
-    }) : v.rects), {
-      x: d,
-      y: c
-    } = _(x, f, g)), w = -1);
+const ct = [":popover-open", ":modal"];
+function J(t) {
+  return ct.some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+function lt(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: o,
+    strategy: s
+  } = t;
+  const c = s === "fixed", i = C(o), r = e ? J(e.floating) : !1;
+  if (o === i || r && c)
+    return n;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, f = x(1);
+  const u = x(0), h = R(o);
+  if ((h || !h && !c) && ((W(o) !== "body" || S(i)) && (l = D(o)), R(o))) {
+    const w = L(o);
+    f = F(o), u.x = w.x + o.clientLeft, u.y = w.y + o.clientTop;
   }
   return {
-    x: d,
-    y: c,
-    placement: f,
-    strategy: r,
-    middlewareData: t
+    width: n.width * f.x,
+    height: n.height * f.y,
+    x: n.x * f.x - l.scrollLeft * f.x + u.x,
+    y: n.y * f.y - l.scrollTop * f.y + u.y
   };
-};
-async function W(o, i) {
-  var m;
-  i === void 0 && (i = {});
-  const {
-    x: n,
-    y: r,
-    platform: e,
-    rects: l,
-    elements: a,
-    strategy: g
-  } = o, {
-    boundary: x = "clippingAncestors",
-    rootBoundary: d = "viewport",
-    elementContext: c = "floating",
-    altBoundary: f = !1,
-    padding: t = 0
-  } = j(i, o), s = z(t), u = a[f ? c === "floating" ? "reference" : "floating" : c], p = $(await e.getClippingRect({
-    element: (m = await (e.isElement == null ? void 0 : e.isElement(u))) == null || m ? u : u.contextElement || await (e.getDocumentElement == null ? void 0 : e.getDocumentElement(a.floating)),
-    boundary: x,
-    rootBoundary: d,
-    strategy: g
-  })), h = c === "floating" ? {
-    ...l.floating,
-    x: n,
+}
+function ft(t) {
+  return Array.from(t.getClientRects());
+}
+function Q(t) {
+  return L(C(t)).left + D(t).scrollLeft;
+}
+function ut(t) {
+  const e = C(t), n = D(t), o = t.ownerDocument.body, s = T(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth), c = T(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
+  let i = -n.scrollLeft + Q(t);
+  const r = -n.scrollTop;
+  return y(o).direction === "rtl" && (i += T(e.clientWidth, o.clientWidth) - s), {
+    width: s,
+    height: c,
+    x: i,
     y: r
-  } : l.reference, y = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(a.floating)), P = await (e.isElement == null ? void 0 : e.isElement(y)) ? await (e.getScale == null ? void 0 : e.getScale(y)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, v = $(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: a,
-    rect: h,
-    offsetParent: y,
-    strategy: g
-  }) : h);
+  };
+}
+function ht(t, e) {
+  const n = E(t), o = C(t), s = n.visualViewport;
+  let c = o.clientWidth, i = o.clientHeight, r = 0, l = 0;
+  if (s) {
+    c = s.width, i = s.height;
+    const f = U();
+    (!f || f && e === "fixed") && (r = s.offsetLeft, l = s.offsetTop);
+  }
   return {
-    top: (p.top - v.top + s.top) / P.y,
-    bottom: (v.bottom - p.bottom + s.bottom) / P.y,
-    left: (p.left - v.left + s.left) / P.x,
-    right: (v.right - p.right + s.right) / P.x
+    width: c,
+    height: i,
+    x: r,
+    y: l
   };
 }
-const et = (o) => ({
-  name: "arrow",
-  options: o,
-  async fn(i) {
-    const {
-      x: m,
-      y: n,
-      placement: r,
-      rects: e,
-      platform: l,
-      elements: a,
-      middlewareData: g
-    } = i, {
-      element: x,
-      padding: d = 0
-    } = j(o, i) || {};
-    if (x == null)
-      return {};
-    const c = z(d), f = {
-      x: m,
-      y: n
-    }, t = H(r), s = I(t), w = await l.getDimensions(x), u = t === "y", p = u ? "top" : "left", h = u ? "bottom" : "right", y = u ? "clientHeight" : "clientWidth", P = e.reference[s] + e.reference[t] - f[t] - e.floating[s], v = f[t] - e.reference[t], D = await (l.getOffsetParent == null ? void 0 : l.getOffsetParent(x));
-    let O = D ? D[y] : 0;
-    (!O || !await (l.isElement == null ? void 0 : l.isElement(D))) && (O = a.floating[y] || e.floating[s]);
-    const E = P / 2 - v / 2, S = O / 2 - w[s] / 2 - 1, T = X(c[p], S), L = X(c[h], S), b = T, V = O - w[s] - L, A = O / 2 - w[s] / 2 + E, R = B(b, A, V), k = !g.arrow && F(r) != null && A !== R && e.reference[s] / 2 - (A < b ? T : L) - w[s] / 2 < 0, C = k ? A < b ? A - b : A - V : 0;
-    return {
-      [t]: f[t] + C,
-      data: {
-        [t]: R,
-        centerOffset: A - R - C,
-        ...k && {
-          alignmentOffset: C
-        }
-      },
-      reset: k
+function at(t, e) {
+  const n = L(t, !0, e === "fixed"), o = n.top + t.clientTop, s = n.left + t.clientLeft, c = R(t) ? F(t) : x(1), i = t.clientWidth * c.x, r = t.clientHeight * c.y, l = s * c.x, f = o * c.y;
+  return {
+    width: i,
+    height: r,
+    x: l,
+    y: f
+  };
+}
+function _(t, e, n) {
+  let o;
+  if (e === "viewport")
+    o = ht(t, n);
+  else if (e === "document")
+    o = ut(C(t));
+  else if (b(e))
+    o = at(e, n);
+  else {
+    const s = G(t);
+    o = {
+      ...e,
+      x: e.x - s.x,
+      y: e.y - s.y
     };
   }
-}), nt = function(o) {
-  return o === void 0 && (o = {}), {
-    name: "flip",
-    options: o,
-    async fn(i) {
-      var m, n;
-      const {
-        placement: r,
-        middlewareData: e,
-        rects: l,
-        initialPlacement: a,
-        platform: g,
-        elements: x
-      } = i, {
-        mainAxis: d = !0,
-        crossAxis: c = !0,
-        fallbackPlacements: f,
-        fallbackStrategy: t = "bestFit",
-        fallbackAxisSideDirection: s = "none",
-        flipAlignment: w = !0,
-        ...u
-      } = j(o, i);
-      if ((m = e.arrow) != null && m.alignmentOffset)
-        return {};
-      const p = M(r), h = M(a) === a, y = await (g.isRTL == null ? void 0 : g.isRTL(x.floating)), P = f || (h || !w ? [G(a)] : J(a));
-      !f && s !== "none" && P.push(...K(a, w, s, y));
-      const v = [a, ...P], D = await W(i, u), O = [];
-      let E = ((n = e.flip) == null ? void 0 : n.overflows) || [];
-      if (d && O.push(D[p]), c) {
-        const b = N(r, l, y);
-        O.push(D[b[0]], D[b[1]]);
-      }
-      if (E = [...E, {
-        placement: r,
-        overflows: O
-      }], !O.every((b) => b <= 0)) {
-        var S, T;
-        const b = (((S = e.flip) == null ? void 0 : S.index) || 0) + 1, V = v[b];
-        if (V)
-          return {
-            data: {
-              index: b,
-              overflows: E
-            },
-            reset: {
-              placement: V
-            }
-          };
-        let A = (T = E.filter((R) => R.overflows[0] <= 0).sort((R, k) => R.overflows[1] - k.overflows[1])[0]) == null ? void 0 : T.placement;
-        if (!A)
-          switch (t) {
-            case "bestFit": {
-              var L;
-              const R = (L = E.map((k) => [k.placement, k.overflows.filter((C) => C > 0).reduce((C, q) => C + q, 0)]).sort((k, C) => k[1] - C[1])[0]) == null ? void 0 : L[0];
-              R && (A = R);
-              break;
-            }
-            case "initialPlacement":
-              A = a;
-              break;
-          }
-        if (r !== A)
-          return {
-            reset: {
-              placement: A
-            }
-          };
-      }
-      return {};
-    }
+  return q(o);
+}
+function Y(t, e) {
+  const n = z(t);
+  return n === e || !b(n) || X(n) ? !1 : y(n).position === "fixed" || Y(n, e);
+}
+function dt(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let o = V(t, [], !1).filter((r) => b(r) && W(r) !== "body"), s = null;
+  const c = y(t).position === "fixed";
+  let i = c ? z(t) : t;
+  for (; b(i) && !X(i); ) {
+    const r = y(i), l = K(i);
+    !l && r.position === "fixed" && (s = null), (c ? !l && !s : !l && r.position === "static" && !!s && ["absolute", "fixed"].includes(s.position) || S(i) && !l && Y(t, i)) ? o = o.filter((u) => u !== i) : s = r, i = z(i);
+  }
+  return e.set(t, o), o;
+}
+function gt(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: o,
+    strategy: s
+  } = t;
+  const i = [...n === "clippingAncestors" ? dt(e, this._c) : [].concat(n), o], r = i[0], l = i.reduce((f, u) => {
+    const h = _(e, u, s);
+    return f.top = T(h.top, f.top), f.right = I(h.right, f.right), f.bottom = I(h.bottom, f.bottom), f.left = T(h.left, f.left), f;
+  }, _(e, r, s));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
   };
-};
-async function U(o, i) {
+}
+function pt(t) {
   const {
-    placement: m,
-    platform: n,
-    elements: r
-  } = o, e = await (n.isRTL == null ? void 0 : n.isRTL(r.floating)), l = M(m), a = F(m), g = Y(m) === "y", x = ["left", "top"].includes(l) ? -1 : 1, d = e && g ? -1 : 1, c = j(i, o);
-  let {
-    mainAxis: f,
-    crossAxis: t,
-    alignmentAxis: s
-  } = typeof c == "number" ? {
-    mainAxis: c,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: 0,
-    crossAxis: 0,
-    alignmentAxis: null,
-    ...c
+    width: e,
+    height: n
+  } = j(t);
+  return {
+    width: e,
+    height: n
   };
-  return a && typeof s == "number" && (t = a === "end" ? s * -1 : s), g ? {
-    x: t * d,
-    y: f * x
-  } : {
-    x: f * x,
-    y: t * d
+}
+function mt(t, e, n) {
+  const o = R(e), s = C(e), c = n === "fixed", i = L(t, !0, c, e);
+  let r = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = x(0);
+  if (o || !o && !c)
+    if ((W(e) !== "body" || S(s)) && (r = D(e)), o) {
+      const h = L(e, !0, c, e);
+      l.x = h.x + e.clientLeft, l.y = h.y + e.clientTop;
+    } else
+      s && (l.x = Q(s));
+  const f = i.left + r.scrollLeft - l.x, u = i.top + r.scrollTop - l.y;
+  return {
+    x: f,
+    y: u,
+    width: i.width,
+    height: i.height
   };
 }
-const it = function(o) {
-  return o === void 0 && (o = 0), {
-    name: "offset",
-    options: o,
-    async fn(i) {
-      var m, n;
-      const {
-        x: r,
-        y: e,
-        placement: l,
-        middlewareData: a
-      } = i, g = await U(i, o);
-      return l === ((m = a.offset) == null ? void 0 : m.placement) && (n = a.arrow) != null && n.alignmentOffset ? {} : {
-        x: r + g.x,
-        y: e + g.y,
-        data: {
-          ...g,
-          placement: l
-        }
-      };
+function k(t, e) {
+  return !R(t) || y(t).position === "fixed" ? null : e ? e(t) : t.offsetParent;
+}
+function Z(t, e) {
+  const n = E(t);
+  if (!R(t) || J(t))
+    return n;
+  let o = k(t, e);
+  for (; o && nt(o) && y(o).position === "static"; )
+    o = k(o, e);
+  return o && (W(o) === "html" || W(o) === "body" && y(o).position === "static" && !K(o)) ? n : o || it(t) || n;
+}
+const wt = async function(t) {
+  const e = this.getOffsetParent || Z, n = this.getDimensions;
+  return {
+    reference: mt(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      ...await n(t.floating)
     }
   };
-}, ot = function(o) {
-  return o === void 0 && (o = {}), {
-    name: "shift",
-    options: o,
-    async fn(i) {
-      const {
-        x: m,
-        y: n,
-        placement: r
-      } = i, {
-        mainAxis: e = !0,
-        crossAxis: l = !1,
-        limiter: a = {
-          fn: (u) => {
-            let {
-              x: p,
-              y: h
-            } = u;
-            return {
-              x: p,
-              y: h
-            };
-          }
-        },
-        ...g
-      } = j(o, i), x = {
-        x: m,
-        y: n
-      }, d = await W(i, g), c = Y(M(r)), f = Q(c);
-      let t = x[f], s = x[c];
-      if (e) {
-        const u = f === "y" ? "top" : "left", p = f === "y" ? "bottom" : "right", h = t + d[u], y = t - d[p];
-        t = B(h, t, y);
-      }
-      if (l) {
-        const u = c === "y" ? "top" : "left", p = c === "y" ? "bottom" : "right", h = s + d[u], y = s - d[p];
-        s = B(h, s, y);
+};
+function yt(t) {
+  return y(t).direction === "rtl";
+}
+const vt = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: lt,
+  getDocumentElement: C,
+  getClippingRect: gt,
+  getOffsetParent: Z,
+  getElementRects: wt,
+  getClientRects: ft,
+  getDimensions: pt,
+  getScale: F,
+  isElement: b,
+  isRTL: yt
+};
+function xt(t, e) {
+  let n = null, o;
+  const s = C(t);
+  function c() {
+    var r;
+    clearTimeout(o), (r = n) == null || r.disconnect(), n = null;
+  }
+  function i(r, l) {
+    r === void 0 && (r = !1), l === void 0 && (l = 1), c();
+    const {
+      left: f,
+      top: u,
+      width: h,
+      height: w
+    } = t.getBoundingClientRect();
+    if (r || e(), !h || !w)
+      return;
+    const g = A(u), v = A(s.clientWidth - (f + h)), a = A(s.clientHeight - (u + w)), p = A(f), m = {
+      rootMargin: -g + "px " + -v + "px " + -a + "px " + -p + "px",
+      threshold: T(0, I(1, l)) || 1
+    };
+    let O = !0;
+    function B(M) {
+      const H = M[0].intersectionRatio;
+      if (H !== l) {
+        if (!O)
+          return i();
+        H ? i(!1, H) : o = setTimeout(() => {
+          i(!1, 1e-7);
+        }, 100);
       }
-      const w = a.fn({
-        ...i,
-        [f]: t,
-        [c]: s
+      O = !1;
+    }
+    try {
+      n = new IntersectionObserver(B, {
+        ...m,
+        // Handle <iframe>s
+        root: s.ownerDocument
       });
-      return {
-        ...w,
-        data: {
-          x: w.x - m,
-          y: w.y - n
-        }
-      };
+    } catch {
+      n = new IntersectionObserver(B, m);
     }
+    n.observe(t);
+  }
+  return i(!0), c;
+}
+function Ot(t, e, n, o) {
+  o === void 0 && (o = {});
+  const {
+    ancestorScroll: s = !0,
+    ancestorResize: c = !0,
+    elementResize: i = typeof ResizeObserver == "function",
+    layoutShift: r = typeof IntersectionObserver == "function",
+    animationFrame: l = !1
+  } = o, f = $(t), u = s || c ? [...f ? V(f) : [], ...V(e)] : [];
+  u.forEach((d) => {
+    s && d.addEventListener("scroll", n, {
+      passive: !0
+    }), c && d.addEventListener("resize", n);
+  });
+  const h = f && r ? xt(f, n) : null;
+  let w = -1, g = null;
+  i && (g = new ResizeObserver((d) => {
+    let [m] = d;
+    m && m.target === f && g && (g.unobserve(e), cancelAnimationFrame(w), w = requestAnimationFrame(() => {
+      var O;
+      (O = g) == null || O.observe(e);
+    })), n();
+  }), f && !l && g.observe(f), g.observe(e));
+  let v, a = l ? L(t) : null;
+  l && p();
+  function p() {
+    const d = L(t);
+    a && (d.x !== a.x || d.y !== a.y || d.width !== a.width || d.height !== a.height) && n(), a = d, v = requestAnimationFrame(p);
+  }
+  return n(), () => {
+    var d;
+    u.forEach((m) => {
+      s && m.removeEventListener("scroll", n), c && m.removeEventListener("resize", n);
+    }), h == null || h(), (d = g) == null || d.disconnect(), g = null, l && cancelAnimationFrame(v);
+  };
+}
+const Et = P, Lt = tt, Tt = et, Ft = (t, e, n) => {
+  const o = /* @__PURE__ */ new Map(), s = {
+    platform: vt,
+    ...n
+  }, c = {
+    ...s.platform,
+    _c: o
   };
+  return ot(t, e, {
+    ...s,
+    platform: c
+  });
 };
 export {
-  et as arrow,
-  tt as computePosition,
-  W as detectOverflow,
-  nt as flip,
-  it as offset,
-  $ as rectToClientRect,
-  ot as shift
+  Tt as arrow,
+  Ot as autoUpdate,
+  Ft as computePosition,
+  At as detectOverflow,
+  Lt as flip,
+  V as getOverflowAncestors,
+  Nt as offset,
+  vt as platform,
+  Et as shift
 };
 //# sourceMappingURL=index214.js.map