@prokodo/ui 0.0.26 → 0.0.28

package/dist/node_modules/.pnpm/@floating-ui_react-dom@2.1.2_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.js

@@ -1,170 +1,250 @@
-import { offset as H, computePosition as I, flip as J, shift as K } from "../../../../../@floating-ui_dom@1.7.0/node_modules/@floating-ui/dom/dist/floating-ui.dom.js";
-import { autoUpdate as oe, platform as fe } from "../../../../../@floating-ui_dom@1.7.0/node_modules/@floating-ui/dom/dist/floating-ui.dom.js";
-import * as r from "react";
-import { useLayoutEffect as N, useEffect as Q } from "react";
-import * as T from "react-dom";
-var w = typeof document < "u" ? N : Q;
-function h(e, t) {
-  if (e === t)
-    return !0;
-  if (typeof e != typeof t)
-    return !1;
-  if (typeof e == "function" && e.toString() === t.toString())
-    return !0;
-  let n, f, c;
-  if (e && t && typeof e == "object") {
-    if (Array.isArray(e)) {
-      if (n = e.length, n !== t.length) return !1;
-      for (f = n; f-- !== 0; )
-        if (!h(e[f], t[f]))
-          return !1;
-      return !0;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { offset as offset$1, computePosition, flip as flip$1, shift as shift$1 } from "../../../../../@floating-ui_dom@1.7.0/node_modules/@floating-ui/dom/dist/floating-ui.dom.js";
+import { autoUpdate, platform } from "../../../../../@floating-ui_dom@1.7.0/node_modules/@floating-ui/dom/dist/floating-ui.dom.js";
+import * as React from "react";
+import { useLayoutEffect, useEffect } from "react";
+import * as ReactDOM from "react-dom";
+var index = typeof document !== "undefined" ? useLayoutEffect : useEffect;
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (typeof a === "function" && a.toString() === b.toString()) {
+    return true;
+  }
+  let length;
+  let i;
+  let keys;
+  if (a && b && typeof a === "object") {
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length !== b.length) return false;
+      for (i = length; i-- !== 0; ) {
+        if (!deepEqual(a[i], b[i])) {
+          return false;
+        }
+      }
+      return true;
     }
-    if (c = Object.keys(e), n = c.length, n !== Object.keys(t).length)
-      return !1;
-    for (f = n; f-- !== 0; )
-      if (!{}.hasOwnProperty.call(t, c[f]))
-        return !1;
-    for (f = n; f-- !== 0; ) {
-      const p = c[f];
-      if (!(p === "_owner" && e.$$typeof) && !h(e[p], t[p]))
-        return !1;
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) {
+      return false;
     }
-    return !0;
+    for (i = length; i-- !== 0; ) {
+      if (!{}.hasOwnProperty.call(b, keys[i])) {
+        return false;
+      }
+    }
+    for (i = length; i-- !== 0; ) {
+      const key = keys[i];
+      if (key === "_owner" && a.$$typeof) {
+        continue;
+      }
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
   }
-  return e !== e && t !== t;
+  return a !== a && b !== b;
 }
-function A(e) {
-  return typeof window > "u" ? 1 : (e.ownerDocument.defaultView || window).devicePixelRatio || 1;
+__name(deepEqual, "deepEqual");
+function getDPR(element) {
+  if (typeof window === "undefined") {
+    return 1;
+  }
+  const win = element.ownerDocument.defaultView || window;
+  return win.devicePixelRatio || 1;
 }
-function v(e, t) {
-  const n = A(e);
-  return Math.round(t * n) / n;
+__name(getDPR, "getDPR");
+function roundByDPR(element, value) {
+  const dpr = getDPR(element);
+  return Math.round(value * dpr) / dpr;
 }
-function k(e) {
-  const t = r.useRef(e);
-  return w(() => {
-    t.current = e;
-  }), t;
+__name(roundByDPR, "roundByDPR");
+function useLatestRef(value) {
+  const ref = React.useRef(value);
+  index(() => {
+    ref.current = value;
+  });
+  return ref;
 }
-function Z(e) {
-  e === void 0 && (e = {});
+__name(useLatestRef, "useLatestRef");
+function useFloating(options) {
+  if (options === void 0) {
+    options = {};
+  }
   const {
-    placement: t = "bottom",
-    strategy: n = "absolute",
-    middleware: f = [],
-    platform: c,
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2,
     elements: {
-      reference: p,
-      floating: q
+      reference: externalReference,
+      floating: externalFloating
     } = {},
-    transform: D = !0,
-    whileElementsMounted: _,
-    open: x
-  } = e, [s, $] = r.useState({
+    transform = true,
+    whileElementsMounted,
+    open
+  } = options;
+  const [data, setData] = React.useState({
     x: 0,
     y: 0,
-    strategy: n,
-    placement: t,
+    strategy,
+    placement,
     middlewareData: {},
-    isPositioned: !1
-  }), [M, B] = r.useState(f);
-  h(M, f) || B(f);
-  const [U, V] = r.useState(null), [W, z] = r.useState(null), C = r.useCallback((o) => {
-    o !== a.current && (a.current = o, V(o));
-  }, []), F = r.useCallback((o) => {
-    o !== d.current && (d.current = o, z(o));
-  }, []), i = p || U, u = q || W, a = r.useRef(null), d = r.useRef(null), y = r.useRef(s), G = _ != null, P = k(_), S = k(c), O = k(x), g = r.useCallback(() => {
-    if (!a.current || !d.current)
+    isPositioned: false
+  });
+  const [latestMiddleware, setLatestMiddleware] = React.useState(middleware);
+  if (!deepEqual(latestMiddleware, middleware)) {
+    setLatestMiddleware(middleware);
+  }
+  const [_reference, _setReference] = React.useState(null);
+  const [_floating, _setFloating] = React.useState(null);
+  const setReference = React.useCallback((node) => {
+    if (node !== referenceRef.current) {
+      referenceRef.current = node;
+      _setReference(node);
+    }
+  }, []);
+  const setFloating = React.useCallback((node) => {
+    if (node !== floatingRef.current) {
+      floatingRef.current = node;
+      _setFloating(node);
+    }
+  }, []);
+  const referenceEl = externalReference || _reference;
+  const floatingEl = externalFloating || _floating;
+  const referenceRef = React.useRef(null);
+  const floatingRef = React.useRef(null);
+  const dataRef = React.useRef(data);
+  const hasWhileElementsMounted = whileElementsMounted != null;
+  const whileElementsMountedRef = useLatestRef(whileElementsMounted);
+  const platformRef = useLatestRef(platform2);
+  const openRef = useLatestRef(open);
+  const update = React.useCallback(() => {
+    if (!referenceRef.current || !floatingRef.current) {
       return;
-    const o = {
-      placement: t,
-      strategy: n,
-      middleware: M
+    }
+    const config = {
+      placement,
+      strategy,
+      middleware: latestMiddleware
     };
-    S.current && (o.platform = S.current), I(a.current, d.current, o).then((R) => {
-      const m = {
-        ...R,
+    if (platformRef.current) {
+      config.platform = platformRef.current;
+    }
+    computePosition(referenceRef.current, floatingRef.current, config).then((data2) => {
+      const fullData = {
+        ...data2,
         // 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: O.current !== !1
+        isPositioned: openRef.current !== false
       };
-      E.current && !h(y.current, m) && (y.current = m, T.flushSync(() => {
-        $(m);
-      }));
+      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
+        dataRef.current = fullData;
+        ReactDOM.flushSync(() => {
+          setData(fullData);
+        });
+      }
     });
-  }, [M, t, n, S, O]);
-  w(() => {
-    x === !1 && y.current.isPositioned && (y.current.isPositioned = !1, $((o) => ({
-      ...o,
-      isPositioned: !1
-    })));
-  }, [x]);
-  const E = r.useRef(!1);
-  w(() => (E.current = !0, () => {
-    E.current = !1;
-  }), []), w(() => {
-    if (i && (a.current = i), u && (d.current = u), i && u) {
-      if (P.current)
-        return P.current(i, u, g);
-      g();
+  }, [latestMiddleware, placement, strategy, platformRef, openRef]);
+  index(() => {
+    if (open === false && dataRef.current.isPositioned) {
+      dataRef.current.isPositioned = false;
+      setData((data2) => ({
+        ...data2,
+        isPositioned: false
+      }));
     }
-  }, [i, u, g, P, G]);
-  const j = r.useMemo(() => ({
-    reference: a,
-    floating: d,
-    setReference: C,
-    setFloating: F
-  }), [C, F]), l = r.useMemo(() => ({
-    reference: i,
-    floating: u
-  }), [i, u]), L = r.useMemo(() => {
-    const o = {
-      position: n,
+  }, [open]);
+  const isMountedRef = React.useRef(false);
+  index(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  index(() => {
+    if (referenceEl) referenceRef.current = referenceEl;
+    if (floatingEl) floatingRef.current = floatingEl;
+    if (referenceEl && floatingEl) {
+      if (whileElementsMountedRef.current) {
+        return whileElementsMountedRef.current(referenceEl, floatingEl, update);
+      }
+      update();
+    }
+  }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
+  const refs = React.useMemo(() => ({
+    reference: referenceRef,
+    floating: floatingRef,
+    setReference,
+    setFloating
+  }), [setReference, setFloating]);
+  const elements = React.useMemo(() => ({
+    reference: referenceEl,
+    floating: floatingEl
+  }), [referenceEl, floatingEl]);
+  const floatingStyles = React.useMemo(() => {
+    const initialStyles = {
+      position: strategy,
       left: 0,
       top: 0
     };
-    if (!l.floating)
-      return o;
-    const R = v(l.floating, s.x), m = v(l.floating, s.y);
-    return D ? {
-      ...o,
-      transform: "translate(" + R + "px, " + m + "px)",
-      ...A(l.floating) >= 1.5 && {
-        willChange: "transform"
-      }
-    } : {
-      position: n,
-      left: R,
-      top: m
+    if (!elements.floating) {
+      return initialStyles;
+    }
+    const x = roundByDPR(elements.floating, data.x);
+    const y = roundByDPR(elements.floating, data.y);
+    if (transform) {
+      return {
+        ...initialStyles,
+        transform: "translate(" + x + "px, " + y + "px)",
+        ...getDPR(elements.floating) >= 1.5 && {
+          willChange: "transform"
+        }
+      };
+    }
+    return {
+      position: strategy,
+      left: x,
+      top: y
     };
-  }, [n, D, l.floating, s.x, s.y]);
-  return r.useMemo(() => ({
-    ...s,
-    update: g,
-    refs: j,
-    elements: l,
-    floatingStyles: L
-  }), [s, g, j, l, L]);
+  }, [strategy, transform, elements.floating, data.x, data.y]);
+  return React.useMemo(() => ({
+    ...data,
+    update,
+    refs,
+    elements,
+    floatingStyles
+  }), [data, update, refs, elements, floatingStyles]);
 }
-const b = (e, t) => ({
-  ...H(e),
-  options: [e, t]
-}), ee = (e, t) => ({
-  ...K(e),
-  options: [e, t]
-}), te = (e, t) => ({
-  ...J(e),
-  options: [e, t]
-});
+__name(useFloating, "useFloating");
+const offset = /* @__PURE__ */ __name((options, deps) => ({
+  ...offset$1(options),
+  options: [options, deps]
+}), "offset");
+const shift = /* @__PURE__ */ __name((options, deps) => ({
+  ...shift$1(options),
+  options: [options, deps]
+}), "shift");
+const flip = /* @__PURE__ */ __name((options, deps) => ({
+  ...flip$1(options),
+  options: [options, deps]
+}), "flip");
 export {
-  oe as autoUpdate,
-  I as computePosition,
-  te as flip,
-  b as offset,
-  fe as platform,
-  ee as shift,
-  Z as useFloating
+  autoUpdate,
+  computePosition,
+  flip,
+  offset,
+  platform,
+  shift,
+  useFloating
 };