bitboss-ui 2.0.168 → 2.0.169

package/dist/index304.js

@@ -1,384 +1,4 @@
-import { evaluate as $, getSide as j, getSideAxis as B, getOppositePlacement as K, getExpandedPlacements as N, getOppositeAxisPlacements as Q, getAlignmentSides as U, clamp as Y, getPaddingObject as I, rectToClientRect as _, getAlignment as X, getOppositeAxis as Z, getAlignmentAxis as W, getAxisLength as q, min as z } from "./index305.js";
-function H(o, i, m) {
-  let {
-    reference: n,
-    floating: r
-  } = o;
-  const e = B(i), l = W(i), s = q(l), g = j(i), x = e === "y", d = n.x + n.width / 2 - r.width / 2, c = n.y + n.height / 2 - r.height / 2, f = n[s] / 2 - r[s] / 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 (X(i)) {
-    case "start":
-      t[l] -= f * (m && x ? -1 : 1);
-      break;
-    case "end":
-      t[l] += f * (m && x ? -1 : 1);
-      break;
-  }
-  return t;
-}
-const nt = async (o, i, m) => {
-  const {
-    placement: n = "bottom",
-    strategy: r = "absolute",
-    middleware: e = [],
-    platform: l
-  } = m, s = 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
-  } = H(x, n, g), f = n, t = {}, a = 0;
-  for (let w = 0; w < s.length; w++) {
-    const {
-      name: u,
-      fn: y
-    } = s[w], {
-      x: h,
-      y: v,
-      data: b,
-      reset: p
-    } = await y({
-      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 = v ?? c, t = {
-      ...t,
-      [u]: {
-        ...t[u],
-        ...b
-      }
-    }, p && a <= 50 && (a++, typeof p == "object" && (p.placement && (f = p.placement), p.rects && (x = p.rects === !0 ? await l.getElementRects({
-      reference: o,
-      floating: i,
-      strategy: r
-    }) : p.rects), {
-      x: d,
-      y: c
-    } = H(x, f, g)), w = -1);
-  }
-  return {
-    x: d,
-    y: c,
-    placement: f,
-    strategy: r,
-    middlewareData: t
-  };
-};
-async function G(o, i) {
-  var m;
-  i === void 0 && (i = {});
-  const {
-    x: n,
-    y: r,
-    platform: e,
-    rects: l,
-    elements: s,
-    strategy: g
-  } = o, {
-    boundary: x = "clippingAncestors",
-    rootBoundary: d = "viewport",
-    elementContext: c = "floating",
-    altBoundary: f = !1,
-    padding: t = 0
-  } = $(i, o), a = I(t), u = s[f ? c === "floating" ? "reference" : "floating" : c], y = _(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(s.floating)),
-    boundary: x,
-    rootBoundary: d,
-    strategy: g
-  })), h = c === "floating" ? {
-    x: n,
-    y: r,
-    width: l.floating.width,
-    height: l.floating.height
-  } : l.reference, v = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(s.floating)), b = await (e.isElement == null ? void 0 : e.isElement(v)) ? await (e.getScale == null ? void 0 : e.getScale(v)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, p = _(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: s,
-    rect: h,
-    offsetParent: v,
-    strategy: g
-  }) : h);
-  return {
-    top: (y.top - p.top + a.top) / b.y,
-    bottom: (p.bottom - y.bottom + a.bottom) / b.y,
-    left: (y.left - p.left + a.left) / b.x,
-    right: (p.right - y.right + a.right) / b.x
-  };
-}
-const it = (o) => ({
-  name: "arrow",
-  options: o,
-  async fn(i) {
-    const {
-      x: m,
-      y: n,
-      placement: r,
-      rects: e,
-      platform: l,
-      elements: s,
-      middlewareData: g
-    } = i, {
-      element: x,
-      padding: d = 0
-    } = $(o, i) || {};
-    if (x == null)
-      return {};
-    const c = I(d), f = {
-      x: m,
-      y: n
-    }, t = W(r), a = q(t), w = await l.getDimensions(x), u = t === "y", y = u ? "top" : "left", h = u ? "bottom" : "right", v = u ? "clientHeight" : "clientWidth", b = e.reference[a] + e.reference[t] - f[t] - e.floating[a], p = f[t] - e.reference[t], T = await (l.getOffsetParent == null ? void 0 : l.getOffsetParent(x));
-    let S = T ? T[v] : 0;
-    (!S || !await (l.isElement == null ? void 0 : l.isElement(T))) && (S = s.floating[v] || e.floating[a]);
-    const V = b / 2 - p / 2, D = S / 2 - w[a] / 2 - 1, R = z(c[y], D), F = z(c[h], D), E = R, M = S - w[a] - F, A = S / 2 - w[a] / 2 + V, L = Y(E, A, M), O = !g.arrow && X(r) != null && A !== L && e.reference[a] / 2 - (A < E ? R : F) - w[a] / 2 < 0, P = O ? A < E ? A - E : A - M : 0;
-    return {
-      [t]: f[t] + P,
-      data: {
-        [t]: L,
-        centerOffset: A - L - P,
-        ...O && {
-          alignmentOffset: P
-        }
-      },
-      reset: O
-    };
-  }
-}), ot = 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: s,
-        platform: g,
-        elements: x
-      } = i, {
-        mainAxis: d = !0,
-        crossAxis: c = !0,
-        fallbackPlacements: f,
-        fallbackStrategy: t = "bestFit",
-        fallbackAxisSideDirection: a = "none",
-        flipAlignment: w = !0,
-        ...u
-      } = $(o, i);
-      if ((m = e.arrow) != null && m.alignmentOffset)
-        return {};
-      const y = j(r), h = B(s), v = j(s) === s, b = await (g.isRTL == null ? void 0 : g.isRTL(x.floating)), p = f || (v || !w ? [K(s)] : N(s)), T = a !== "none";
-      !f && T && p.push(...Q(s, w, a, b));
-      const S = [s, ...p], V = await G(i, u), D = [];
-      let R = ((n = e.flip) == null ? void 0 : n.overflows) || [];
-      if (d && D.push(V[y]), c) {
-        const A = U(r, l, b);
-        D.push(V[A[0]], V[A[1]]);
-      }
-      if (R = [...R, {
-        placement: r,
-        overflows: D
-      }], !D.every((A) => A <= 0)) {
-        var F, E;
-        const A = (((F = e.flip) == null ? void 0 : F.index) || 0) + 1, L = S[A];
-        if (L)
-          return {
-            data: {
-              index: A,
-              overflows: R
-            },
-            reset: {
-              placement: L
-            }
-          };
-        let O = (E = R.filter((P) => P.overflows[0] <= 0).sort((P, k) => P.overflows[1] - k.overflows[1])[0]) == null ? void 0 : E.placement;
-        if (!O)
-          switch (t) {
-            case "bestFit": {
-              var M;
-              const P = (M = R.filter((k) => {
-                if (T) {
-                  const C = B(k.placement);
-                  return C === h || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  C === "y";
-                }
-                return !0;
-              }).map((k) => [k.placement, k.overflows.filter((C) => C > 0).reduce((C, J) => C + J, 0)]).sort((k, C) => k[1] - C[1])[0]) == null ? void 0 : M[0];
-              P && (O = P);
-              break;
-            }
-            case "initialPlacement":
-              O = s;
-              break;
-          }
-        if (r !== O)
-          return {
-            reset: {
-              placement: O
-            }
-          };
-      }
-      return {};
-    }
-  };
-};
-async function tt(o, i) {
-  const {
-    placement: m,
-    platform: n,
-    elements: r
-  } = o, e = await (n.isRTL == null ? void 0 : n.isRTL(r.floating)), l = j(m), s = X(m), g = B(m) === "y", x = ["left", "top"].includes(l) ? -1 : 1, d = e && g ? -1 : 1, c = $(i, o);
-  let {
-    mainAxis: f,
-    crossAxis: t,
-    alignmentAxis: a
-  } = typeof c == "number" ? {
-    mainAxis: c,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: 0,
-    crossAxis: 0,
-    alignmentAxis: null,
-    ...c
-  };
-  return s && typeof a == "number" && (t = s === "end" ? a * -1 : a), g ? {
-    x: t * d,
-    y: f * x
-  } : {
-    x: f * x,
-    y: t * d
-  };
-}
-const st = 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: s
-      } = i, g = await tt(i, o);
-      return l === ((m = s.offset) == null ? void 0 : m.placement) && (n = s.arrow) != null && n.alignmentOffset ? {} : {
-        x: r + g.x,
-        y: e + g.y,
-        data: {
-          ...g,
-          placement: l
-        }
-      };
-    }
-  };
-}, at = 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: s = {
-          fn: (u) => {
-            let {
-              x: y,
-              y: h
-            } = u;
-            return {
-              x: y,
-              y: h
-            };
-          }
-        },
-        ...g
-      } = $(o, i), x = {
-        x: m,
-        y: n
-      }, d = await G(i, g), c = B(j(r)), f = Z(c);
-      let t = x[f], a = x[c];
-      if (e) {
-        const u = f === "y" ? "top" : "left", y = f === "y" ? "bottom" : "right", h = t + d[u], v = t - d[y];
-        t = Y(h, t, v);
-      }
-      if (l) {
-        const u = c === "y" ? "top" : "left", y = c === "y" ? "bottom" : "right", h = a + d[u], v = a - d[y];
-        a = Y(h, a, v);
-      }
-      const w = s.fn({
-        ...i,
-        [f]: t,
-        [c]: a
-      });
-      return {
-        ...w,
-        data: {
-          x: w.x - m,
-          y: w.y - n
-        }
-      };
-    }
-  };
-};
+var e = { exports: {} };
 export {
-  it as arrow,
-  nt as computePosition,
-  G as detectOverflow,
-  ot as flip,
-  st as offset,
-  _ as rectToClientRect,
-  at as shift
+  e as __module
 };

package/dist/index305.js

@@ -1,128 +1,5 @@
-const l = Math.min, a = Math.max, P = Math.round, M = Math.floor, O = (t) => ({
-  x: t,
-  y: t
-}), m = {
-  left: "right",
-  right: "left",
-  bottom: "top",
-  top: "bottom"
-}, p = {
-  start: "end",
-  end: "start"
-};
-function S(t, n, e) {
-  return a(t, l(n, e));
-}
-function w(t, n) {
-  return typeof t == "function" ? t(n) : t;
-}
-function f(t) {
-  return t.split("-")[0];
-}
-function g(t) {
-  return t.split("-")[1];
-}
-function h(t) {
-  return t === "x" ? "y" : "x";
-}
-function x(t) {
-  return t === "y" ? "height" : "width";
-}
-function b(t) {
-  return ["top", "bottom"].includes(f(t)) ? "y" : "x";
-}
-function d(t) {
-  return h(b(t));
-}
-function j(t, n, e) {
-  e === void 0 && (e = !1);
-  const r = g(t), o = d(t), i = x(o);
-  let c = o === "x" ? r === (e ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
-  return n.reference[i] > n.floating[i] && (c = u(c)), [c, u(c)];
-}
-function C(t) {
-  const n = u(t);
-  return [s(t), n, s(n)];
-}
-function s(t) {
-  return t.replace(/start|end/g, (n) => p[n]);
-}
-function A(t, n, e) {
-  const r = ["left", "right"], o = ["right", "left"], i = ["top", "bottom"], c = ["bottom", "top"];
-  switch (t) {
-    case "top":
-    case "bottom":
-      return e ? n ? o : r : n ? r : o;
-    case "left":
-    case "right":
-      return n ? i : c;
-    default:
-      return [];
-  }
-}
-function L(t, n, e, r) {
-  const o = g(t);
-  let i = A(f(t), e === "start", r);
-  return o && (i = i.map((c) => c + "-" + o), n && (i = i.concat(i.map(s)))), i;
-}
-function u(t) {
-  return t.replace(/left|right|bottom|top/g, (n) => m[n]);
-}
-function y(t) {
-  return {
-    top: 0,
-    right: 0,
-    bottom: 0,
-    left: 0,
-    ...t
-  };
-}
-function E(t) {
-  return typeof t != "number" ? y(t) : {
-    top: t,
-    right: t,
-    bottom: t,
-    left: t
-  };
-}
-function R(t) {
-  const {
-    x: n,
-    y: e,
-    width: r,
-    height: o
-  } = t;
-  return {
-    width: r,
-    height: o,
-    top: e,
-    left: n,
-    right: n + r,
-    bottom: e + o,
-    x: n,
-    y: e
-  };
-}
+import o from "./index226.js";
+/* empty css         */
 export {
-  S as clamp,
-  O as createCoords,
-  w as evaluate,
-  y as expandPaddingObject,
-  M as floor,
-  g as getAlignment,
-  d as getAlignmentAxis,
-  j as getAlignmentSides,
-  x as getAxisLength,
-  C as getExpandedPlacements,
-  s as getOppositeAlignmentPlacement,
-  h as getOppositeAxis,
-  L as getOppositeAxisPlacements,
-  u as getOppositePlacement,
-  E as getPaddingObject,
-  f as getSide,
-  b as getSideAxis,
-  a as max,
-  l as min,
-  R as rectToClientRect,
-  P as round
+  o as default
 };