@tedi-design-system/react 16.2.0-rc.1 → 17.0.0-rc.2

package/external/@floating-ui/core/dist/floating-ui.core.es.js

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