@layers-app/shared 0.4.8 → 0.4.10

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

@@ -0,0 +1,143 @@
+import { isShadowRoot as b, isHTMLElement as v } from "../../utils/dist/floating-ui.utils.dom.js";
+import * as a from "react";
+import { useLayoutEffect as E } from "react";
+import { tabbable as c } from "../../../tabbable/dist/index.esm.js";
+function N() {
+  return /apple/i.test(navigator.vendor);
+}
+const s = "data-floating-ui-focusable", g = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
+function p(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 m(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 o = n;
+    for (; o; ) {
+      if (t === o)
+        return !0;
+      o = o.parentNode || o.host;
+    }
+  }
+  return !1;
+}
+function L(t) {
+  return "composedPath" in t ? t.composedPath()[0] : t.target;
+}
+function P(t, n) {
+  if (n == null)
+    return !1;
+  if ("composedPath" in t)
+    return t.composedPath().includes(n);
+  const e = t;
+  return e.target != null && n.contains(e.target);
+}
+function C(t) {
+  return t.matches("html,body");
+}
+function u(t) {
+  return t?.ownerDocument || document;
+}
+function F(t) {
+  return v(t) && t.matches(g);
+}
+function O(t) {
+  return t ? t.hasAttribute(s) ? t : t.querySelector("[" + s + "]") || t : null;
+}
+function h(t, n, e) {
+  return e === void 0 && (e = !0), t.filter((r) => {
+    var i;
+    return r.parentId === n && (!e || ((i = r.context) == null ? void 0 : i.open));
+  }).flatMap((r) => [r, ...h(t, r.id, e)]);
+}
+function M(t) {
+  return "nativeEvent" in t;
+}
+function B(t, n) {
+  return ["mouse", "pen"].includes(t);
+}
+var x = typeof document < "u", T = function() {
+}, D = x ? E : T;
+const R = {
+  ...a
+}, w = R.useInsertionEffect, A = w || ((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 A(() => {
+    n.current = t;
+  }), a.useCallback(function() {
+    for (var e = arguments.length, o = new Array(e), r = 0; r < e; r++)
+      o[r] = arguments[r];
+    return n.current == null ? void 0 : n.current(...o);
+  }, []);
+}
+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()), o = e.length;
+  if (o === 0) return;
+  const r = p(u(t)), i = e.indexOf(r), l = i === -1 ? n === 1 ? 0 : o - 1 : i + n;
+  return e[l];
+}
+function z(t) {
+  return d(u(t).body, 1) || t;
+}
+function U(t) {
+  return d(u(t).body, -1) || t;
+}
+function H(t, n) {
+  const e = n || t.currentTarget, o = t.relatedTarget;
+  return !o || !m(e, o);
+}
+function V(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 o = e.dataset.tabindex;
+    delete e.dataset.tabindex, o ? e.setAttribute("tabindex", o) : e.removeAttribute("tabindex");
+  });
+}
+export {
+  p as activeElement,
+  m as contains,
+  V as disableFocusInside,
+  W as enableFocusInside,
+  u as getDocument,
+  O as getFloatingFocusElement,
+  z as getNextTabbable,
+  h as getNodeChildren,
+  U as getPreviousTabbable,
+  f as getTabbableOptions,
+  L as getTarget,
+  P as isEventTargetWithin,
+  B as isMouseLikePointerType,
+  H as isOutsideEvent,
+  M as isReactEvent,
+  C as isRootElement,
+  N as isSafari,
+  F as isTypeableElement,
+  q as useEffectEvent,
+  D as useModernLayoutEffect
+};

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

@@ -0,0 +1,212 @@
+import { computePosition as I, offset as J, flip as K, shift as N, arrow as L } from "../../dom/dist/floating-ui.dom.js";
+import { autoUpdate as ie, platform as le } from "../../dom/dist/floating-ui.dom.js";
+import * as f from "react";
+import { useLayoutEffect as Q } from "react";
+import * as T from "react-dom";
+var X = typeof document < "u", Y = function() {
+}, R = X ? Q : Y;
+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 q(e) {
+  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function A(e, n) {
+  const t = q(e);
+  return Math.round(n * t) / t;
+}
+function D(e) {
+  const n = f.useRef(e);
+  return R(() => {
+    n.current = e;
+  }), n;
+}
+function te(e) {
+  e === void 0 && (e = {});
+  const {
+    placement: n = "bottom",
+    strategy: t = "absolute",
+    middleware: r = [],
+    platform: s,
+    elements: {
+      reference: p,
+      floating: B
+    } = {},
+    transform: E = !0,
+    whileElementsMounted: $,
+    open: x
+  } = e, [u, C] = f.useState({
+    x: 0,
+    y: 0,
+    strategy: t,
+    placement: n,
+    middlewareData: {},
+    isPositioned: !1
+  }), [M, U] = f.useState(r);
+  h(M, r) || U(r);
+  const [V, W] = f.useState(null), [z, G] = f.useState(null), O = f.useCallback((o) => {
+    o !== a.current && (a.current = o, W(o));
+  }, []), _ = f.useCallback((o) => {
+    o !== m.current && (m.current = o, G(o));
+  }, []), i = p || V, l = B || z, a = f.useRef(null), m = f.useRef(null), y = f.useRef(u), H = $ != null, P = D($), S = D(s), v = D(x), g = f.useCallback(() => {
+    if (!a.current || !m.current)
+      return;
+    const o = {
+      placement: n,
+      strategy: t,
+      middleware: M
+    };
+    S.current && (o.platform = S.current), I(a.current, m.current, o).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
+      };
+      k.current && !h(y.current, d) && (y.current = d, T.flushSync(() => {
+        C(d);
+      }));
+    });
+  }, [M, n, t, S, v]);
+  R(() => {
+    x === !1 && y.current.isPositioned && (y.current.isPositioned = !1, C((o) => ({
+      ...o,
+      isPositioned: !1
+    })));
+  }, [x]);
+  const k = f.useRef(!1);
+  R(() => (k.current = !0, () => {
+    k.current = !1;
+  }), []), R(() => {
+    if (i && (a.current = i), l && (m.current = l), i && l) {
+      if (P.current)
+        return P.current(i, l, g);
+      g();
+    }
+  }, [i, l, g, P, H]);
+  const F = f.useMemo(() => ({
+    reference: a,
+    floating: m,
+    setReference: O,
+    setFloating: _
+  }), [O, _]), c = f.useMemo(() => ({
+    reference: i,
+    floating: l
+  }), [i, l]), j = f.useMemo(() => {
+    const o = {
+      position: t,
+      left: 0,
+      top: 0
+    };
+    if (!c.floating)
+      return o;
+    const w = A(c.floating, u.x), d = A(c.floating, u.y);
+    return E ? {
+      ...o,
+      transform: "translate(" + w + "px, " + d + "px)",
+      ...q(c.floating) >= 1.5 && {
+        willChange: "transform"
+      }
+    } : {
+      position: t,
+      left: w,
+      top: d
+    };
+  }, [t, E, c.floating, u.x, u.y]);
+  return f.useMemo(() => ({
+    ...u,
+    update: g,
+    refs: F,
+    elements: c,
+    floatingStyles: j
+  }), [u, g, F, c, j]);
+}
+const Z = (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 ? L({
+        element: r.current,
+        padding: s
+      }).fn(t) : {} : r ? L({
+        element: r,
+        padding: s
+      }).fn(t) : {};
+    }
+  };
+}, ne = (e, n) => {
+  const t = J(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+}, re = (e, n) => {
+  const t = N(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+}, fe = (e, n) => {
+  const t = K(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+}, oe = (e, n) => {
+  const t = Z(e);
+  return {
+    name: t.name,
+    fn: t.fn,
+    options: [e, n]
+  };
+};
+export {
+  oe as arrow,
+  ie as autoUpdate,
+  I as computePosition,
+  fe as flip,
+  ne as offset,
+  le as platform,
+  re as shift,
+  te 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,127 @@
+const m = Math.min, h = Math.max, S = Math.round, w = Math.floor, C = (t) => ({
+  x: t,
+  y: t
+}), p = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function j(t, n, e) {
+  return h(t, m(n, e));
+}
+function L(t, n) {
+  return typeof t == "function" ? t(n) : t;
+}
+function g(t) {
+  return t.split("-")[0];
+}
+function a(t) {
+  return t.split("-")[1];
+}
+function x(t) {
+  return t === "x" ? "y" : "x";
+}
+function b(t) {
+  return t === "y" ? "height" : "width";
+}
+function d(t) {
+  const n = t[0];
+  return n === "t" || n === "b" ? "y" : "x";
+}
+function A(t) {
+  return x(d(t));
+}
+function E(t, n, e) {
+  e === void 0 && (e = !1);
+  const r = a(t), i = A(t), o = b(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 R(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 f = ["left", "right"], l = ["right", "left"], P = ["top", "bottom"], y = ["bottom", "top"];
+function O(t, n, e) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return e ? n ? l : f : n ? f : l;
+    case "left":
+    case "right":
+      return n ? P : y;
+    default:
+      return [];
+  }
+}
+function T(t, n, e, r) {
+  const i = a(t);
+  let o = O(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 p[n] + t.slice(n.length);
+}
+function M(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function k(t) {
+  return typeof t != "number" ? M(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function q(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 {
+  j as clamp,
+  C as createCoords,
+  L as evaluate,
+  M as expandPaddingObject,
+  w as floor,
+  a as getAlignment,
+  A as getAlignmentAxis,
+  E as getAlignmentSides,
+  b as getAxisLength,
+  R as getExpandedPlacements,
+  s as getOppositeAlignmentPlacement,
+  x as getOppositeAxis,
+  T as getOppositeAxisPlacements,
+  u as getOppositePlacement,
+  k as getPaddingObject,
+  g as getSide,
+  d as getSideAxis,
+  h as max,
+  m as min,
+  q as rectToClientRect,
+  S as round
+};