@fluidattacks/design 8.1.0 → 8.2.0

package/dist/node_modules/@floating-ui/react/dist/floating-ui.react.utils.js

@@ -0,0 +1,161 @@
+import { isShadowRoot as b, isHTMLElement as g } from "../../utils/dist/floating-ui.utils.dom.js";
+import * as a from "react";
+import { useLayoutEffect as v } from "react";
+import { tabbable as c } from "../../../tabbable/dist/index.esm.js";
+function m() {
+  const t = navigator.userAgentData;
+  return t != null && t.platform ? t.platform : navigator.platform;
+}
+function p() {
+  const t = navigator.userAgentData;
+  return t && Array.isArray(t.brands) ? t.brands.map((n) => {
+    let {
+      brand: e,
+      version: r
+    } = n;
+    return e + "/" + r;
+  }).join(" ") : navigator.userAgent;
+}
+function C() {
+  return /apple/i.test(navigator.vendor);
+}
+function N() {
+  return m().toLowerCase().startsWith("mac") && !navigator.maxTouchPoints;
+}
+function h() {
+  return p().includes("jsdom/");
+}
+const s = "data-floating-ui-focusable", E = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function x(t) {
+  let n = t.activeElement;
+  for (; ((e = n) == null || (e = e.shadowRoot) == null ? void 0 : e.activeElement) != null; ) {
+    var e;
+    n = n.shadowRoot.activeElement;
+  }
+  return n;
+}
+function T(t, n) {
+  if (!t || !n)
+    return !1;
+  const e = n.getRootNode == null ? void 0 : n.getRootNode();
+  if (t.contains(n))
+    return !0;
+  if (e && b(e)) {
+    let r = n;
+    for (; r; ) {
+      if (t === r)
+        return !0;
+      r = r.parentNode || r.host;
+    }
+  }
+  return !1;
+}
+function P(t) {
+  return "composedPath" in t ? t.composedPath()[0] : t.target;
+}
+function u(t) {
+  return t?.ownerDocument || document;
+}
+function F(t) {
+  return g(t) && t.matches(E);
+}
+function M(t) {
+  if (!t || h()) return !0;
+  try {
+    return t.matches(":focus-visible");
+  } catch {
+    return !0;
+  }
+}
+function B(t) {
+  return t ? t.hasAttribute(s) ? t : t.querySelector("[" + s + "]") || t : null;
+}
+function U(t, n) {
+  const e = ["mouse", "pen"];
+  return e.push("", void 0), e.includes(t);
+}
+var A = typeof document < "u", R = function() {
+}, y = A ? v : R;
+const w = {
+  ...a
+};
+function j(t) {
+  const n = a.useRef(t);
+  return y(() => {
+    n.current = t;
+  }), n;
+}
+const S = w.useInsertionEffect, L = S || ((t) => t());
+function q(t) {
+  const n = a.useRef(() => {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("Cannot call an event handler while rendering.");
+  });
+  return L(() => {
+    n.current = t;
+  }), a.useCallback(function() {
+    for (var e = arguments.length, r = new Array(e), o = 0; o < e; o++)
+      r[o] = arguments[o];
+    return n.current == null ? void 0 : n.current(...r);
+  }, []);
+}
+const f = () => ({
+  getShadowRoot: !0,
+  displayCheck: (
+    // JSDOM does not support the `tabbable` library. To solve this we can
+    // check if `ResizeObserver` is a real function (not polyfilled), which
+    // determines if the current environment is JSDOM-like.
+    typeof ResizeObserver == "function" && ResizeObserver.toString().includes("[native code]") ? "full" : "none"
+  )
+});
+function d(t, n) {
+  const e = c(t, f()), r = e.length;
+  if (r === 0) return;
+  const o = x(u(t)), i = e.indexOf(o), l = i === -1 ? n === 1 ? 0 : r - 1 : i + n;
+  return e[l];
+}
+function z(t) {
+  return d(u(t).body, 1) || t;
+}
+function V(t) {
+  return d(u(t).body, -1) || t;
+}
+function H(t, n) {
+  const e = n || t.currentTarget, r = t.relatedTarget;
+  return !r || !T(e, r);
+}
+function J(t) {
+  c(t, f()).forEach((e) => {
+    e.dataset.tabindex = e.getAttribute("tabindex") || "", e.setAttribute("tabindex", "-1");
+  });
+}
+function W(t) {
+  t.querySelectorAll("[data-tabindex]").forEach((e) => {
+    const r = e.dataset.tabindex;
+    delete e.dataset.tabindex, r ? e.setAttribute("tabindex", r) : e.removeAttribute("tabindex");
+  });
+}
+export {
+  x as activeElement,
+  T as contains,
+  J as disableFocusInside,
+  W as enableFocusInside,
+  u as getDocument,
+  B as getFloatingFocusElement,
+  z as getNextTabbable,
+  m as getPlatform,
+  V as getPreviousTabbable,
+  f as getTabbableOptions,
+  P as getTarget,
+  p as getUserAgent,
+  h as isJSDOM,
+  N as isMac,
+  U as isMouseLikePointerType,
+  H as isOutsideEvent,
+  C as isSafari,
+  F as isTypeableElement,
+  M as matchesFocusVisible,
+  q as useEffectEvent,
+  j as useLatestRef,
+  y as useModernLayoutEffect
+};

package/dist/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js

@@ -0,0 +1,228 @@
+import { computePosition as I, flip as J, offset as K, shift as N, size as Q, autoPlacement as T, arrow as z } from "../../dom/dist/floating-ui.dom.js";
+import { autoUpdate as me, platform as de } from "../../dom/dist/floating-ui.dom.js";
+import * as o from "react";
+import { useLayoutEffect as X } from "react";
+import * as Y from "react-dom";
+var Z = typeof document < "u", b = function() {
+}, R = Z ? X : b;
+function h(e, n) {
+  if (e === n)
+    return !0;
+  if (typeof e != typeof n)
+    return !1;
+  if (typeof e == "function" && e.toString() === n.toString())
+    return !0;
+  let t, r, s;
+  if (e && n && typeof e == "object") {
+    if (Array.isArray(e)) {
+      if (t = e.length, t !== n.length) return !1;
+      for (r = t; r-- !== 0; )
+        if (!h(e[r], n[r]))
+          return !1;
+      return !0;
+    }
+    if (s = Object.keys(e), t = s.length, t !== Object.keys(n).length)
+      return !1;
+    for (r = t; r-- !== 0; )
+      if (!{}.hasOwnProperty.call(n, s[r]))
+        return !1;
+    for (r = t; r-- !== 0; ) {
+      const p = s[r];
+      if (!(p === "_owner" && e.$$typeof) && !h(e[p], n[p]))
+        return !1;
+    }
+    return !0;
+  }
+  return e !== e && n !== n;
+}
+function A(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function L(e, n) {
+  const t = A(e);
+  return Math.round(n * t) / t;
+}
+function k(e) {
+  const n = o.useRef(e);
+  return R(() => {
+    n.current = e;
+  }), n;
+}
+function re(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: n = "bottom",
+    strategy: t = "absolute",
+    middleware: r = [],
+    platform: s,
+    elements: {
+      reference: p,
+      floating: q
+    } = {},
+    transform: D = !0,
+    whileElementsMounted: E,
+    open: P
+  } = e, [u, C] = o.useState({
+    x: 0,
+    y: 0,
+    strategy: t,
+    placement: n,
+    middlewareData: {},
+    isPositioned: !1
+  }), [x, B] = o.useState(r);
+  h(x, r) || B(r);
+  const [U, V] = o.useState(null), [W, G] = o.useState(null), O = o.useCallback((f) => {
+    f !== c.current && (c.current = f, V(f));
+  }, []), _ = o.useCallback((f) => {
+    f !== m.current && (m.current = f, G(f));
+  }, []), i = p || U, l = q || W, c = o.useRef(null), m = o.useRef(null), y = o.useRef(u), H = E != null, M = k(E), S = k(s), v = k(P), g = o.useCallback(() => {
+    if (!c.current || !m.current)
+      return;
+    const f = {
+      placement: n,
+      strategy: t,
+      middleware: x
+    };
+    S.current && (f.platform = S.current), I(c.current, m.current, f).then((w) => {
+      const d = {
+        ...w,
+        // The floating element's position may be recomputed while it's closed
+        // but still mounted (such as when transitioning out). To ensure
+        // `isPositioned` will be `false` initially on the next open, avoid
+        // setting it to `true` when `open === false` (must be specified).
+        isPositioned: v.current !== !1
+      };
+      $.current && !h(y.current, d) && (y.current = d, Y.flushSync(() => {
+        C(d);
+      }));
+    });
+  }, [x, n, t, S, v]);
+  R(() => {
+    P === !1 && y.current.isPositioned && (y.current.isPositioned = !1, C((f) => ({
+      ...f,
+      isPositioned: !1
+    })));
+  }, [P]);
+  const $ = o.useRef(!1);
+  R(() => ($.current = !0, () => {
+    $.current = !1;
+  }), []), R(() => {
+    if (i && (c.current = i), l && (m.current = l), i && l) {
+      if (M.current)
+        return M.current(i, l, g);
+      g();
+    }
+  }, [i, l, g, M, H]);
+  const F = o.useMemo(() => ({
+    reference: c,
+    floating: m,
+    setReference: O,
+    setFloating: _
+  }), [O, _]), a = o.useMemo(() => ({
+    reference: i,
+    floating: l
+  }), [i, l]), j = o.useMemo(() => {
+    const f = {
+      position: t,
+      left: 0,
+      top: 0
+    };
+    if (!a.floating)
+      return f;
+    const w = L(a.floating, u.x), d = L(a.floating, u.y);
+    return D ? {
+      ...f,
+      transform: "translate(" + w + "px, " + d + "px)",
+      ...A(a.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: t,
+      left: w,
+      top: d
+    };
+  }, [t, D, a.floating, u.x, u.y]);
+  return o.useMemo(() => ({
+    ...u,
+    update: g,
+    refs: F,
+    elements: a,
+    floatingStyles: j
+  }), [u, g, F, a, j]);
+}
+const ee = (e) => {
+  function n(t) {
+    return {}.hasOwnProperty.call(t, "current");
+  }
+  return {
+    name: "arrow",
+    options: e,
+    fn(t) {
+      const {
+        element: r,
+        padding: s
+      } = typeof e == "function" ? e(t) : e;
+      return r && n(r) ? r.current != null ? z({
+        element: r.current,
+        padding: s
+      }).fn(t) : {} : r ? z({
+        element: r,
+        padding: s
+      }).fn(t) : {};
+    }
+  };
+}, oe = (e, n) => {
+  const t = K(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+}, fe = (e, n) => {
+  const t = N(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+}, se = (e, n) => {
+  const t = J(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+}, ue = (e, n) => {
+  const t = Q(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+}, ie = (e, n) => {
+  const t = T(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+}, le = (e, n) => {
+  const t = ee(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+};
+export {
+  le as arrow,
+  ie as autoPlacement,
+  me as autoUpdate,
+  I as computePosition,
+  se as flip,
+  oe as offset,
+  de as platform,
+  fe as shift,
+  ue as size,
+  re as useFloating
+};

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js

@@ -0,0 +1,136 @@
+function u() {
+  return typeof window < "u";
+}
+function a(t) {
+  return m(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function i(t) {
+  var n;
+  return (t == null || (n = t.ownerDocument) == null ? void 0 : n.defaultView) || window;
+}
+function L(t) {
+  var n;
+  return (n = (m(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : n.documentElement;
+}
+function m(t) {
+  return u() ? t instanceof Node || t instanceof i(t).Node : !1;
+}
+function h(t) {
+  return u() ? t instanceof Element || t instanceof i(t).Element : !1;
+}
+function g(t) {
+  return u() ? t instanceof HTMLElement || t instanceof i(t).HTMLElement : !1;
+}
+function p(t) {
+  return !u() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof i(t).ShadowRoot;
+}
+function y(t) {
+  const {
+    overflow: n,
+    overflowX: r,
+    overflowY: c,
+    display: e
+  } = b(t);
+  return /auto|scroll|overlay|hidden|clip/.test(n + c + r) && e !== "inline" && e !== "contents";
+}
+function _(t) {
+  return /^(table|td|th)$/.test(a(t));
+}
+function T(t) {
+  try {
+    if (t.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return t.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const v = /transform|translate|scale|rotate|perspective|filter/, C = /paint|layout|strict|content/, o = (t) => !!t && t !== "none";
+let s;
+function D(t) {
+  const n = h(t) ? b(t) : t;
+  return o(n.transform) || o(n.translate) || o(n.scale) || o(n.rotate) || o(n.perspective) || !R() && (o(n.backdropFilter) || o(n.filter)) || v.test(n.willChange || "") || C.test(n.contain || "");
+}
+function W(t) {
+  let n = f(t);
+  for (; g(n) && !N(n); ) {
+    if (D(n))
+      return n;
+    if (T(n))
+      return null;
+    n = f(n);
+  }
+  return null;
+}
+function R() {
+  return s == null && (s = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), s;
+}
+function N(t) {
+  return /^(html|body|#document)$/.test(a(t));
+}
+function b(t) {
+  return i(t).getComputedStyle(t);
+}
+function $(t) {
+  return h(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function f(t) {
+  if (a(t) === "html")
+    return t;
+  const n = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    p(t) && t.host || // Fallback.
+    L(t)
+  );
+  return p(n) ? n.host : n;
+}
+function S(t) {
+  const n = f(t);
+  return N(n) ? t.ownerDocument ? t.ownerDocument.body : t.body : g(n) && y(n) ? n : S(n);
+}
+function w(t, n, r) {
+  var c;
+  n === void 0 && (n = []), r === void 0 && (r = !0);
+  const e = S(t), E = e === ((c = t.ownerDocument) == null ? void 0 : c.body), l = i(e);
+  if (E) {
+    const d = k(l);
+    return n.concat(l, l.visualViewport || [], y(e) ? e : [], d && r ? w(d) : []);
+  } else
+    return n.concat(e, w(e, [], r));
+}
+function k(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+export {
+  b as getComputedStyle,
+  W as getContainingBlock,
+  L as getDocumentElement,
+  k as getFrameElement,
+  S as getNearestOverflowAncestor,
+  a as getNodeName,
+  $ as getNodeScroll,
+  w as getOverflowAncestors,
+  f as getParentNode,
+  i as getWindow,
+  D as isContainingBlock,
+  h as isElement,
+  g as isHTMLElement,
+  N as isLastTraversableNode,
+  m as isNode,
+  y as isOverflowElement,
+  p as isShadowRoot,
+  _ as isTableElement,
+  T as isTopLayer,
+  R as isWebKit
+};

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

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