lkd-web-kit 0.0.11 → 0.0.13

package/dist/node_modules/@floating-ui/react/dist/floating-ui.react.mjs

@@ -0,0 +1,188 @@
+import * as D from "../../../../_virtual/index.mjs";
+import { r as o } from "../../../../_virtual/index.mjs";
+import { isElement as R } from "../../utils/dist/floating-ui.utils.dom.mjs";
+import { getOverflowAncestors as _ } from "../../utils/dist/floating-ui.utils.dom.mjs";
+import "../../../../_virtual/index3.mjs";
+import { useFloating as N } from "../../react-dom/dist/floating-ui.react-dom.mjs";
+import { arrow as ee, flip as ne, inline as te, limitShift as oe, offset as re, shift as se, size as ce } from "../../react-dom/dist/floating-ui.react-dom.mjs";
+function W(e) {
+  return o.useMemo(() => e.every((n) => n == null) ? null : (n) => {
+    e.forEach((r) => {
+      typeof r == "function" ? r(n) : r != null && (r.current = n);
+    });
+  }, e);
+}
+const P = {
+  ...D
+}, O = P.useInsertionEffect, b = O || ((e) => e());
+function $(e) {
+  const n = o.useRef(() => {
+    if (process.env.NODE_ENV !== "production")
+      throw new Error("Cannot call an event handler while rendering.");
+  });
+  return b(() => {
+    n.current = e;
+  }), o.useCallback(function() {
+    for (var r = arguments.length, t = new Array(r), c = 0; c < r; c++)
+      t[c] = arguments[c];
+    return n.current == null ? void 0 : n.current(...t);
+  }, []);
+}
+var I = typeof document < "u" ? o.useLayoutEffect : o.useEffect;
+let F = !1, A = 0;
+const w = () => (
+  // Ensure the id is unique with multiple independent versions of Floating UI
+  // on <React 18
+  "floating-ui-" + Math.random().toString(36).slice(2, 6) + A++
+);
+function V() {
+  const [e, n] = o.useState(() => F ? w() : void 0);
+  return I(() => {
+    e == null && n(w());
+  }, []), o.useEffect(() => {
+    F = !0;
+  }, []), e;
+}
+const B = P.useId, T = B || V;
+let M;
+process.env.NODE_ENV !== "production" && (M = /* @__PURE__ */ new Set());
+function U() {
+  for (var e, n = arguments.length, r = new Array(n), t = 0; t < n; t++)
+    r[t] = arguments[t];
+  const c = "Floating UI: " + r.join(" ");
+  if (!((e = M) != null && e.has(c))) {
+    var l;
+    (l = M) == null || l.add(c), console.error(c);
+  }
+}
+function j() {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    emit(n, r) {
+      var t;
+      (t = e.get(n)) == null || t.forEach((c) => c(r));
+    },
+    on(n, r) {
+      e.set(n, [...e.get(n) || [], r]);
+    },
+    off(n, r) {
+      var t;
+      e.set(n, ((t = e.get(n)) == null ? void 0 : t.filter((c) => c !== r)) || []);
+    }
+  };
+}
+const z = /* @__PURE__ */ o.createContext(null), H = /* @__PURE__ */ o.createContext(null), L = () => {
+  var e;
+  return ((e = o.useContext(z)) == null ? void 0 : e.id) || null;
+}, q = () => o.useContext(H);
+function y(e) {
+  const {
+    open: n = !1,
+    onOpenChange: r,
+    elements: t
+  } = e, c = T(), l = o.useRef({}), [m] = o.useState(() => j()), p = L() != null;
+  if (process.env.NODE_ENV !== "production") {
+    const s = t.reference;
+    s && !R(s) && U("Cannot pass a virtual element to the `elements.reference` option,", "as it must be a real DOM element. Use `refs.setPositionReference()`", "instead.");
+  }
+  const [C, S] = o.useState(t.reference), u = $((s, a, g) => {
+    l.current.openEvent = s ? a : void 0, m.emit("openchange", {
+      open: s,
+      event: a,
+      reason: g,
+      nested: p
+    }), r?.(s, a, g);
+  }), i = o.useMemo(() => ({
+    setPositionReference: S
+  }), []), d = o.useMemo(() => ({
+    reference: C || t.reference || null,
+    floating: t.floating || null,
+    domReference: t.reference
+  }), [C, t.reference, t.floating]);
+  return o.useMemo(() => ({
+    dataRef: l,
+    open: n,
+    onOpenChange: u,
+    elements: d,
+    events: m,
+    floatingId: c,
+    refs: i
+  }), [n, u, d, m, c, i]);
+}
+function X(e) {
+  e === void 0 && (e = {});
+  const {
+    nodeId: n
+  } = e, r = y({
+    ...e,
+    elements: {
+      reference: null,
+      floating: null,
+      ...e.elements
+    }
+  }), t = e.rootContext || r, c = t.elements, [l, m] = o.useState(null), [p, C] = o.useState(null), u = c?.domReference || l, i = o.useRef(null), d = q();
+  I(() => {
+    u && (i.current = u);
+  }, [u]);
+  const s = N({
+    ...e,
+    elements: {
+      ...c,
+      ...p && {
+        reference: p
+      }
+    }
+  }), a = o.useCallback((f) => {
+    const h = R(f) ? {
+      getBoundingClientRect: () => f.getBoundingClientRect(),
+      contextElement: f
+    } : f;
+    C(h), s.refs.setReference(h);
+  }, [s.refs]), g = o.useCallback((f) => {
+    (R(f) || f === null) && (i.current = f, m(f)), (R(s.refs.reference.current) || s.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
+    // `null` to support `positionReference` + an unstable `reference`
+    // callback ref.
+    f !== null && !R(f)) && s.refs.setReference(f);
+  }, [s.refs]), E = o.useMemo(() => ({
+    ...s.refs,
+    setReference: g,
+    setPositionReference: a,
+    domReference: i
+  }), [s.refs, g, a]), v = o.useMemo(() => ({
+    ...s.elements,
+    domReference: u
+  }), [s.elements, u]), x = o.useMemo(() => ({
+    ...s,
+    ...t,
+    refs: E,
+    elements: v,
+    nodeId: n
+  }), [s, E, v, n, t]);
+  return I(() => {
+    t.dataRef.current.floatingContext = x;
+    const f = d?.nodesRef.current.find((h) => h.id === n);
+    f && (f.context = x);
+  }), o.useMemo(() => ({
+    ...s,
+    context: x,
+    refs: E,
+    elements: v
+  }), [s, E, v, x]);
+}
+export {
+  ee as arrow,
+  ne as flip,
+  _ as getOverflowAncestors,
+  te as inline,
+  oe as limitShift,
+  re as offset,
+  se as shift,
+  ce as size,
+  X as useFloating,
+  L as useFloatingParentNodeId,
+  y as useFloatingRootContext,
+  q as useFloatingTree,
+  T as useId,
+  W as useMergeRefs
+};
+//# sourceMappingURL=floating-ui.react.mjs.map