@tedi-design-system/react 17.0.0 → 17.1.0-rc.10

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

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