@caspeco/casper-ui-library 10.4.0 → 10.5.0

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

@@ -1,246 +1,157 @@
-import { getSideAxis as S, getAlignmentAxis as N, getSide as F, getAlignment as U, evaluate as Y, getPaddingObject as W, rectToClientRect as V, getOppositePlacement as $, getExpandedPlacements as q, getOppositeAxisPlacements as z, getAlignmentSides as G, getAxisLength as H } from "../../utils/dist/floating-ui.utils.js";
-function X(c, i, p) {
-  let {
-    reference: e,
-    floating: l
-  } = c;
-  const t = S(i), o = N(i), n = H(o), d = F(i), g = t === "y", r = e.x + e.width / 2 - l.width / 2, a = e.y + e.height / 2 - l.height / 2, f = e[n] / 2 - l[n] / 2;
-  let s;
-  switch (d) {
-    case "top":
-      s = {
-        x: r,
-        y: e.y - l.height
-      };
-      break;
-    case "bottom":
-      s = {
-        x: r,
-        y: e.y + e.height
-      };
-      break;
-    case "right":
-      s = {
-        x: e.x + e.width,
-        y: a
-      };
-      break;
-    case "left":
-      s = {
-        x: e.x - l.width,
-        y: a
-      };
-      break;
-    default:
-      s = {
-        x: e.x,
-        y: e.y
-      };
-  }
-  switch (U(i)) {
-    case "start":
-      s[o] -= f * (p && g ? -1 : 1);
-      break;
-    case "end":
-      s[o] += f * (p && g ? -1 : 1);
-      break;
-  }
-  return s;
+import { evaluate as e, getAlignment as t, getAlignmentAxis as n, getAlignmentSides as r, getAxisLength as i, getExpandedPlacements as a, getOppositeAxisPlacements as o, getOppositePlacement as s, getPaddingObject as c, getSide as l, getSideAxis as u, rectToClientRect as d } from "../../utils/dist/floating-ui.utils.js";
+//#region ../../node_modules/@floating-ui/core/dist/floating-ui.core.mjs
+function f(e, r, a) {
+	let { reference: o, floating: s } = e, c = u(r), d = n(r), f = i(d), p = l(r), m = c === "y", h = o.x + o.width / 2 - s.width / 2, g = o.y + o.height / 2 - s.height / 2, _ = o[f] / 2 - s[f] / 2, v;
+	switch (p) {
+		case "top":
+			v = {
+				x: h,
+				y: o.y - s.height
+			};
+			break;
+		case "bottom":
+			v = {
+				x: h,
+				y: o.y + o.height
+			};
+			break;
+		case "right":
+			v = {
+				x: o.x + o.width,
+				y: g
+			};
+			break;
+		case "left":
+			v = {
+				x: o.x - s.width,
+				y: g
+			};
+			break;
+		default: v = {
+			x: o.x,
+			y: o.y
+		};
+	}
+	let y = t(r);
+	return y && (v[d] += _ * (y === "end" ? 1 : -1) * (a && m ? -1 : 1)), v;
 }
-async function J(c, i) {
-  var p;
-  i === void 0 && (i = {});
-  const {
-    x: e,
-    y: l,
-    platform: t,
-    rects: o,
-    elements: n,
-    strategy: d
-  } = c, {
-    boundary: g = "clippingAncestors",
-    rootBoundary: r = "viewport",
-    elementContext: a = "floating",
-    altBoundary: f = !1,
-    padding: s = 0
-  } = Y(i, c), m = W(s), b = n[f ? a === "floating" ? "reference" : "floating" : a], v = V(await t.getClippingRect({
-    element: (p = await (t.isElement == null ? void 0 : t.isElement(b))) == null || p ? b : b.contextElement || await (t.getDocumentElement == null ? void 0 : t.getDocumentElement(n.floating)),
-    boundary: g,
-    rootBoundary: r,
-    strategy: d
-  })), A = a === "floating" ? {
-    x: e,
-    y: l,
-    width: o.floating.width,
-    height: o.floating.height
-  } : o.reference, P = await (t.getOffsetParent == null ? void 0 : t.getOffsetParent(n.floating)), w = await (t.isElement == null ? void 0 : t.isElement(P)) ? await (t.getScale == null ? void 0 : t.getScale(P)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, h = V(t.convertOffsetParentRelativeRectToViewportRelativeRect ? await t.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: n,
-    rect: A,
-    offsetParent: P,
-    strategy: d
-  }) : A);
-  return {
-    top: (v.top - h.top + m.top) / w.y,
-    bottom: (h.bottom - v.bottom + m.bottom) / w.y,
-    left: (v.left - h.left + m.left) / w.x,
-    right: (h.right - v.right + m.right) / w.x
-  };
+async function p(t, n) {
+	n === void 0 && (n = {});
+	let { x: r, y: i, platform: a, rects: o, elements: s, strategy: l } = t, { boundary: u = "clippingAncestors", rootBoundary: f = "viewport", elementContext: p = "floating", altBoundary: m = !1, padding: h = 0 } = e(n, t), g = c(h), _ = s[m ? p === "floating" ? "reference" : "floating" : p], v = d(await a.getClippingRect({
+		element: await (a.isElement == null ? void 0 : a.isElement(_)) ?? !0 ? _ : _.contextElement || await (a.getDocumentElement == null ? void 0 : a.getDocumentElement(s.floating)),
+		boundary: u,
+		rootBoundary: f,
+		strategy: l
+	})), y = p === "floating" ? {
+		x: r,
+		y: i,
+		width: o.floating.width,
+		height: o.floating.height
+	} : o.reference, b = await (a.getOffsetParent == null ? void 0 : a.getOffsetParent(s.floating)), x = await (a.isElement == null ? void 0 : a.isElement(b)) && await (a.getScale == null ? void 0 : a.getScale(b)) || {
+		x: 1,
+		y: 1
+	}, S = d(a.convertOffsetParentRelativeRectToViewportRelativeRect ? await a.convertOffsetParentRelativeRectToViewportRelativeRect({
+		elements: s,
+		rect: y,
+		offsetParent: b,
+		strategy: l
+	}) : y);
+	return {
+		top: (v.top - S.top + g.top) / x.y,
+		bottom: (S.bottom - v.bottom + g.bottom) / x.y,
+		left: (v.left - S.left + g.left) / x.x,
+		right: (S.right - v.right + g.right) / x.x
+	};
 }
-const K = 50, Z = async (c, i, p) => {
-  const {
-    placement: e = "bottom",
-    strategy: l = "absolute",
-    middleware: t = [],
-    platform: o
-  } = p, n = o.detectOverflow ? o : {
-    ...o,
-    detectOverflow: J
-  }, d = await (o.isRTL == null ? void 0 : o.isRTL(i));
-  let g = await o.getElementRects({
-    reference: c,
-    floating: i,
-    strategy: l
-  }), {
-    x: r,
-    y: a
-  } = X(g, e, d), f = e, s = 0;
-  const m = {};
-  for (let y = 0; y < t.length; y++) {
-    const b = t[y];
-    if (!b)
-      continue;
-    const {
-      name: v,
-      fn: A
-    } = b, {
-      x: P,
-      y: w,
-      data: h,
-      reset: x
-    } = await A({
-      x: r,
-      y: a,
-      initialPlacement: e,
-      placement: f,
-      strategy: l,
-      middlewareData: m,
-      rects: g,
-      platform: n,
-      elements: {
-        reference: c,
-        floating: i
-      }
-    });
-    r = P ?? r, a = w ?? a, m[v] = {
-      ...m[v],
-      ...h
-    }, x && s < K && (s++, typeof x == "object" && (x.placement && (f = x.placement), x.rects && (g = x.rects === !0 ? await o.getElementRects({
-      reference: c,
-      floating: i,
-      strategy: l
-    }) : x.rects), {
-      x: r,
-      y: a
-    } = X(g, f, d)), y = -1);
-  }
-  return {
-    x: r,
-    y: a,
-    placement: f,
-    strategy: l,
-    middlewareData: m
-  };
-}, ee = function(c) {
-  return c === void 0 && (c = {}), {
-    name: "flip",
-    options: c,
-    async fn(i) {
-      var p, e;
-      const {
-        placement: l,
-        middlewareData: t,
-        rects: o,
-        initialPlacement: n,
-        platform: d,
-        elements: g
-      } = i, {
-        mainAxis: r = !0,
-        crossAxis: a = !0,
-        fallbackPlacements: f,
-        fallbackStrategy: s = "bestFit",
-        fallbackAxisSideDirection: m = "none",
-        flipAlignment: y = !0,
-        ...b
-      } = Y(c, i);
-      if ((p = t.arrow) != null && p.alignmentOffset)
-        return {};
-      const v = F(l), A = S(n), P = F(n) === n, w = await (d.isRTL == null ? void 0 : d.isRTL(g.floating)), h = f || (P || !y ? [$(n)] : q(n)), x = m !== "none";
-      !f && x && h.push(...z(n, y, m, w));
-      const _ = [n, ...h], D = await d.detectOverflow(i, b), T = [];
-      let C = ((e = t.flip) == null ? void 0 : e.overflows) || [];
-      if (r && T.push(D[v]), a) {
-        const O = G(l, o, w);
-        T.push(D[O[0]], D[O[1]]);
-      }
-      if (C = [...C, {
-        placement: l,
-        overflows: T
-      }], !T.every((O) => O <= 0)) {
-        var j, B;
-        const O = (((j = t.flip) == null ? void 0 : j.index) || 0) + 1, L = _[O];
-        if (L && (!(a === "alignment" ? A !== S(L) : !1) || // We leave the current main axis only if every placement on that axis
-        // overflows the main axis.
-        C.every((u) => S(u.placement) === A ? u.overflows[0] > 0 : !0)))
-          return {
-            data: {
-              index: O,
-              overflows: C
-            },
-            reset: {
-              placement: L
-            }
-          };
-        let E = (B = C.filter((k) => k.overflows[0] <= 0).sort((k, u) => k.overflows[1] - u.overflows[1])[0]) == null ? void 0 : B.placement;
-        if (!E)
-          switch (s) {
-            case "bestFit": {
-              var M;
-              const k = (M = C.filter((u) => {
-                if (x) {
-                  const R = S(u.placement);
-                  return R === A || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  R === "y";
-                }
-                return !0;
-              }).map((u) => [u.placement, u.overflows.filter((R) => R > 0).reduce((R, I) => R + I, 0)]).sort((u, R) => u[1] - R[1])[0]) == null ? void 0 : M[0];
-              k && (E = k);
-              break;
-            }
-            case "initialPlacement":
-              E = n;
-              break;
-          }
-        if (l !== E)
-          return {
-            reset: {
-              placement: E
-            }
-          };
-      }
-      return {};
-    }
-  };
-};
-export {
-  Z as computePosition,
-  J as detectOverflow,
-  ee as flip,
-  V as rectToClientRect
+var m = 50, h = async (e, t, n) => {
+	let { placement: r = "bottom", strategy: i = "absolute", middleware: a = [], platform: o } = n, s = o.detectOverflow ? o : {
+		...o,
+		detectOverflow: p
+	}, c = await (o.isRTL == null ? void 0 : o.isRTL(t)), l = await o.getElementRects({
+		reference: e,
+		floating: t,
+		strategy: i
+	}), { x: u, y: d } = f(l, r, c), h = r, g = 0, _ = {};
+	for (let n = 0; n < a.length; n++) {
+		let p = a[n];
+		if (!p) continue;
+		let { name: v, fn: y } = p, { x: b, y: x, data: S, reset: C } = await y({
+			x: u,
+			y: d,
+			initialPlacement: r,
+			placement: h,
+			strategy: i,
+			middlewareData: _,
+			rects: l,
+			platform: s,
+			elements: {
+				reference: e,
+				floating: t
+			}
+		});
+		u = b ?? u, d = x ?? d, _[v] = {
+			..._[v],
+			...S
+		}, C && g < m && (g++, typeof C == "object" && (C.placement && (h = C.placement), C.rects && (l = C.rects === !0 ? await o.getElementRects({
+			reference: e,
+			floating: t,
+			strategy: i
+		}) : C.rects), {x: u, y: d} = f(l, h, c)), n = -1);
+	}
+	return {
+		x: u,
+		y: d,
+		placement: h,
+		strategy: i,
+		middlewareData: _
+	};
+}, g = function(t) {
+	return t === void 0 && (t = {}), {
+		name: "flip",
+		options: t,
+		async fn(n) {
+			var i;
+			let { placement: c, middlewareData: d, rects: f, initialPlacement: p, platform: m, elements: h } = n, { mainAxis: g = !0, crossAxis: _ = !0, fallbackPlacements: v, fallbackStrategy: y = "bestFit", fallbackAxisSideDirection: b = "none", flipAlignment: x = !0, ...S } = e(t, n);
+			if ((i = d.arrow) != null && i.alignmentOffset) return {};
+			let C = l(c), w = u(p), T = l(p) === p, E = await (m.isRTL == null ? void 0 : m.isRTL(h.floating)), D = v || (T || !x ? [s(p)] : a(p)), O = b !== "none";
+			!v && O && D.push(...o(p, x, b, E));
+			let k = [p, ...D], A = await m.detectOverflow(n, S), j = [], M = d.flip?.overflows || [];
+			if (g && j.push(A[C]), _) {
+				let e = r(c, f, E);
+				j.push(A[e[0]], A[e[1]]);
+			}
+			if (M = [...M, {
+				placement: c,
+				overflows: j
+			}], !j.every((e) => e <= 0)) {
+				let e = (d.flip?.index || 0) + 1, t = k[e];
+				if (t && (_ !== "alignment" || w === u(t) || M.every((e) => u(e.placement) !== w || e.overflows[0] > 0))) return {
+					data: {
+						index: e,
+						overflows: M
+					},
+					reset: { placement: t }
+				};
+				let n = M.filter((e) => e.overflows[0] <= 0).sort((e, t) => e.overflows[1] - t.overflows[1])[0]?.placement;
+				if (!n) switch (y) {
+					case "bestFit": {
+						let e = M.filter((e) => {
+							if (O) {
+								let t = u(e.placement);
+								return t === w || t === "y";
+							}
+							return !0;
+						}).map((e) => [e.placement, e.overflows.filter((e) => e > 0).reduce((e, t) => e + t, 0)]).sort((e, t) => e[1] - t[1])[0]?.[0];
+						e && (n = e);
+						break;
+					}
+					case "initialPlacement": n = p;
+				}
+				if (c !== n) return { reset: { placement: n } };
+			}
+			return {};
+		}
+	};
 };
+//#endregion
+export { h as computePosition, p as detectOverflow, g as flip, d as rectToClientRect };