@dxos/react-hooks 0.8.4-main.dedc0f3 → 0.8.4-main.e00bdcdb52

package/dist/lib/node-esm/index.mjs

@@ -1,5 +1,9 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 
+// src/index.ts
+import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { useSize, useScroller } from "mini-virtual-list";
+
 // src/useAsyncEffect.ts
 import { useEffect } from "react";
 var useAsyncEffect = (cb, deps) => {
@@ -19,10 +23,28 @@ var useAsyncEffect = (cb, deps) => {
   }, deps ?? []);
 };
 
+// src/useAtomState.ts
+import { Atom, useAtomSet, useAtomValue } from "@effect-atom/atom-react";
+import { useMemo, useState } from "react";
+var useAtomState = (initialValue) => {
+  const [atom] = useState(() => Atom.make(initialValue));
+  const value = useAtomValue(atom);
+  const set = useAtomSet(atom);
+  return useMemo(() => ({
+    atom,
+    value,
+    set
+  }), [
+    atom,
+    value,
+    set
+  ]);
+};
+
 // src/useAsyncState.ts
-import { useEffect as useEffect2, useState } from "react";
+import { useEffect as useEffect2, useState as useState2 } from "react";
 var useAsyncState = (cb, deps = []) => {
-  const [value, setValue] = useState();
+  const [value, setValue] = useState2();
   useEffect2(() => {
     let disposed = false;
     const t = setTimeout(async () => {
@@ -43,58 +65,101 @@ var useAsyncState = (cb, deps = []) => {
 };
 
 // src/useControlledState.ts
-import { useEffect as useEffect3, useState as useState2 } from "react";
-var useControlledState = (controlledValue, onChange, ...deps) => {
-  const [value, setValue] = useState2(controlledValue);
-  useEffect3(() => {
-    if (controlledValue !== void 0) {
-      setValue(controlledValue);
+import { useCallback as useCallback2, useEffect as useEffect4, useRef as useRef2, useState as useState4 } from "react";
+
+// src/useDynamicRef.ts
+import { useCallback, useEffect as useEffect3, useRef, useState as useState3 } from "react";
+var useStateWithRef = (valueProp) => {
+  const [value, setValue] = useState3(valueProp);
+  const valueRef = useRef(valueProp);
+  const setter = useCallback((value2) => {
+    if (typeof value2 === "function") {
+      setValue((current) => {
+        valueRef.current = value2(current);
+        return valueRef.current;
+      });
+    } else {
+      valueRef.current = value2;
+      setValue(value2);
     }
+  }, []);
+  return [
+    value,
+    setter,
+    valueRef
+  ];
+};
+var useDynamicRef = (value) => {
+  const valueRef = useRef(value);
+  useEffect3(() => {
+    valueRef.current = value;
   }, [
-    controlledValue,
-    ...deps
+    value
   ]);
-  useEffect3(() => {
-    onChange?.(value);
+  return valueRef;
+};
+
+// src/useControlledState.ts
+var useControlledState = (valueProp, onChange) => {
+  const [value, setControlledValue] = useState4(valueProp);
+  useEffect4(() => {
+    setControlledValue(valueProp);
   }, [
-    value,
-    onChange
+    valueProp
+  ]);
+  const onChangeRef = useRef2(onChange);
+  const valueRef = useDynamicRef(valueProp);
+  const setValue = useCallback2((nextValue) => {
+    const value2 = isFunction(nextValue) ? nextValue(valueRef.current) : nextValue;
+    setControlledValue(value2);
+    onChangeRef.current?.(value2);
+  }, [
+    valueRef,
+    onChangeRef
   ]);
   return [
     value,
     setValue
   ];
 };
+function isFunction(value) {
+  return typeof value === "function";
+}
 
 // src/useDebugDeps.ts
-import { useEffect as useEffect4, useRef } from "react";
-var useDebugDeps = (deps = []) => {
-  const lastDeps = useRef([]);
-  useEffect4(() => {
-    console.group("deps changed", {
-      previous: lastDeps.current.length,
-      current: deps.length
-    });
+import { useEffect as useEffect5, useRef as useRef3 } from "react";
+import { log } from "@dxos/log";
+var useDebugDeps = (deps = [], label = "useDebugDeps", active = true) => {
+  const lastDeps = useRef3([]);
+  useEffect5(() => {
+    if (!active) {
+      return;
+    }
+    const diff = {};
     for (let i = 0; i < Math.max(lastDeps.current.length ?? 0, deps.length ?? 0); i++) {
-      if (lastDeps.current[i] !== deps[i]) {
-        console.log("changed", {
-          index: i,
+      if (lastDeps.current[i] !== deps[i] || i > lastDeps.current.length) {
+        diff[i] = {
           previous: lastDeps.current[i],
           current: deps[i]
-        });
+        };
       }
     }
-    console.groupEnd();
+    if (Object.keys(diff).length > 0) {
+      log.warn(`Updated: ${label} [${lastDeps.current.length}/${deps.length}]`, diff);
+    }
     lastDeps.current = deps;
-  }, deps);
+  }, [
+    ...deps,
+    active
+  ]);
 };
 
 // src/useDefaultValue.ts
-import { useEffect as useEffect5, useMemo, useState as useState3 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo2, useState as useState5 } from "react";
 var useDefaultValue = (reactiveValue, getDefaultValue) => {
-  const stableDefaultValue = useMemo(getDefaultValue, []);
-  const [value, setValue] = useState3(reactiveValue ?? stableDefaultValue);
-  useEffect5(() => {
+  const stableDefaultValue = useMemo2(getDefaultValue, []);
+  const [value, setValue] = useState5(reactiveValue ?? stableDefaultValue);
+  useEffect6(() => {
     setValue(reactiveValue ?? stableDefaultValue);
   }, [
     reactiveValue,
@@ -105,51 +170,18 @@ var useDefaultValue = (reactiveValue, getDefaultValue) => {
 
 // src/useDefaults.ts
 import defaultsDeep from "lodash.defaultsdeep";
-import { useMemo as useMemo2 } from "react";
+import { useMemo as useMemo3 } from "react";
 var useDefaults = (value, defaults) => {
-  return useMemo2(() => defaultsDeep({}, defaults, value), [
+  return useMemo3(() => defaultsDeep({}, defaults, value), [
     value,
     defaults
   ]);
 };
 
-// src/useDynamicRef.ts
-import { useCallback } from "@preact-signals/safe-react/react";
-import { useEffect as useEffect6, useRef as useRef2, useState as useState4 } from "react";
-var useStateWithRef = (value$) => {
-  const [value, setValue] = useState4(value$);
-  const valueRef = useRef2(value$);
-  const setter = useCallback((value2) => {
-    if (typeof value2 === "function") {
-      setValue((current) => {
-        valueRef.current = value2(current);
-        return valueRef.current;
-      });
-    } else {
-      valueRef.current = value2;
-      setValue(value2);
-    }
-  }, []);
-  return [
-    value,
-    setter,
-    valueRef
-  ];
-};
-var useDynamicRef = (value) => {
-  const valueRef = useRef2(value);
-  useEffect6(() => {
-    valueRef.current = value;
-  }, [
-    value
-  ]);
-  return valueRef;
-};
-
 // src/useFileDownload.ts
-import { useMemo as useMemo3 } from "react";
+import { useMemo as useMemo4 } from "react";
 var useFileDownload = () => {
-  return useMemo3(() => (data, filename) => {
+  return useMemo4(() => (data, filename) => {
     const url = typeof data === "string" ? data : URL.createObjectURL(data);
     const element = document.createElement("a");
     element.setAttribute("href", url);
@@ -160,38 +192,61 @@ var useFileDownload = () => {
 };
 
 // src/useForwardedRef.ts
-import { useEffect as useEffect7, useRef as useRef3 } from "react";
-var useForwardedRef = (ref) => {
-  const innerRef = useRef3(null);
+import { useEffect as useEffect7, useMemo as useMemo5, useRef as useRef4 } from "react";
+var useForwardedRef = (forwardedRef) => {
+  const localRef = useRef4(null);
   useEffect7(() => {
-    if (!ref) {
-      return;
-    }
-    if (typeof ref === "function") {
-      ref(innerRef.current);
-    } else {
-      ref.current = innerRef.current;
+    setRef(forwardedRef, localRef.current);
+  }, [
+    forwardedRef
+  ]);
+  return localRef;
+};
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+}
+var mergeRefs = (refs) => {
+  return (value) => {
+    const cleanups = [];
+    for (const ref of refs) {
+      const cleanup = setRef(ref, value);
+      cleanups.push(typeof cleanup === "function" ? cleanup : () => setRef(ref, null));
     }
-  });
-  return innerRef;
+    return () => {
+      for (const cleanup of cleanups) {
+        cleanup();
+      }
+    };
+  };
+};
+var useMergeRefs = (refs) => {
+  return useMemo5(() => mergeRefs(refs), [
+    ...refs
+  ]);
 };
 
 // src/useId.ts
 import alea from "alea";
-import { useMemo as useMemo4 } from "react";
+import { useMemo as useMemo6 } from "react";
 var Alea = alea;
 var prng = new Alea("@dxos/react-hooks");
 var randomString = (n = 4) => prng().toString(16).slice(2, n + 2);
-var useId = (namespace, propsId, opts) => useMemo4(() => makeId(namespace, propsId, opts), [
-  propsId
-]);
+var useId = (namespace, propsId, opts) => {
+  return useMemo6(() => makeId(namespace, propsId, opts), [
+    propsId
+  ]);
+};
 var makeId = (namespace, propsId, opts) => propsId ?? `${namespace}-${randomString(opts?.n ?? 4)}`;
 
 // src/useIsFocused.ts
-import { useEffect as useEffect8, useRef as useRef4, useState as useState5 } from "react";
+import { useEffect as useEffect8, useRef as useRef5, useState as useState6 } from "react";
 var useIsFocused = (inputRef) => {
-  const [isFocused, setIsFocused] = useState5(void 0);
-  const isFocusedRef = useRef4(isFocused);
+  const [isFocused, setIsFocused] = useState6(void 0);
+  const isFocusedRef = useRef5(isFocused);
   isFocusedRef.current = isFocused;
   useEffect8(() => {
     const input = inputRef.current;
@@ -217,7 +272,7 @@ var useIsFocused = (inputRef) => {
 };
 
 // src/useMediaQuery.ts
-import { useEffect as useEffect9, useState as useState6 } from "react";
+import { useEffect as useEffect9, useState as useState7 } from "react";
 var breakpointMediaQueries = {
   sm: "(min-width: 640px)",
   md: "(min-width: 768px)",
@@ -226,7 +281,7 @@ var breakpointMediaQueries = {
   "2xl": "(min-width: 1536px)"
 };
 var useMediaQuery = (query, options = {}) => {
-  const { ssr = true, fallback } = options;
+  const { ssr = false, fallback } = options;
   const queries = (Array.isArray(query) ? query : [
     query
   ]).map((query2) => query2 in breakpointMediaQueries ? breakpointMediaQueries[query2] : query2);
@@ -234,7 +289,7 @@ var useMediaQuery = (query, options = {}) => {
     fallback
   ];
   fallbackValues = fallbackValues.filter((v) => v != null);
-  const [value, setValue] = useState6(() => {
+  const [value, setValue] = useState7(() => {
     return queries.map((query2, index) => ({
       media: query2,
       matches: ssr ? !!fallbackValues[index] : document.defaultView?.matchMedia(query2).matches
@@ -282,9 +337,9 @@ var useMediaQuery = (query, options = {}) => {
 };
 
 // src/useMulticastObservable.ts
-import { useMemo as useMemo5, useSyncExternalStore } from "react";
+import { useMemo as useMemo7, useSyncExternalStore } from "react";
 var useMulticastObservable = (observable) => {
-  const subscribeFn = useMemo5(() => (listener) => {
+  const subscribeFn = useMemo7(() => (listener) => {
     const subscription = observable.subscribe(listener);
     return () => subscription.unsubscribe();
   }, [
@@ -294,28 +349,28 @@ var useMulticastObservable = (observable) => {
 };
 
 // src/useRefCallback.ts
-import { useState as useState7 } from "react";
+import { useState as useState8 } from "react";
 var useRefCallback = () => {
-  const [value, setValue] = useState7(null);
+  const [value, setValue] = useState8(null);
   return {
     refCallback: (value2) => setValue(value2),
     value
   };
 };
 
-// src/useResize.ts
-import { useLayoutEffect, useMemo as useMemo6 } from "react";
-var useResize = (handler, deps = [], delay = 800) => {
-  const debouncedHandler = useMemo6(() => {
+// src/useViewportResize.ts
+import { useLayoutEffect, useMemo as useMemo8 } from "react";
+var useViewportResize = (cb, deps = [], delay = 800) => {
+  const debouncedHandler = useMemo8(() => {
     let timeout;
     return (event) => {
       clearTimeout(timeout);
       timeout = setTimeout(() => {
-        handler(event);
+        cb(event);
       }, delay);
     };
   }, [
-    handler,
+    cb,
     delay
   ]);
   return useLayoutEffect(() => {
@@ -328,39 +383,16 @@ var useResize = (handler, deps = [], delay = 800) => {
   ]);
 };
 
-// src/useSignals.ts
-import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
-import { computed, effect } from "@preact-signals/safe-react";
-import { useRef as useRef5 } from "@preact-signals/safe-react/react";
-import { useEffect as useEffect10, useMemo as useMemo7 } from "react";
-var useSignalsEffect = (cb, deps) => {
-  const callback = useRef5(cb);
-  callback.current = cb;
-  useEffect10(() => {
-    return effect(() => {
-      return callback.current();
-    });
-  }, deps ?? []);
-};
-var useSignalsMemo = (cb, deps) => {
-  var _effect = _useSignals();
-  try {
-    return useMemo7(() => computed(cb), deps ?? []).value;
-  } finally {
-    _effect.f();
-  }
-};
-
 // src/useTimeout.ts
-import { useEffect as useEffect11, useRef as useRef6 } from "react";
+import { useEffect as useEffect10, useRef as useRef6 } from "react";
 var useTimeout = (callback, delay = 0, deps = []) => {
   const callbackRef = useRef6(callback);
-  useEffect11(() => {
+  useEffect10(() => {
     callbackRef.current = callback;
   }, [
     callback
   ]);
-  useEffect11(() => {
+  useEffect10(() => {
     if (delay == null) {
       return;
     }
@@ -373,12 +405,12 @@ var useTimeout = (callback, delay = 0, deps = []) => {
 };
 var useInterval = (callback, delay = 0, deps = []) => {
   const callbackRef = useRef6(callback);
-  useEffect11(() => {
+  useEffect10(() => {
     callbackRef.current = callback;
   }, [
     callback
   ]);
-  useEffect11(() => {
+  useEffect10(() => {
     if (delay == null) {
       return;
     }
@@ -395,49 +427,17 @@ var useInterval = (callback, delay = 0, deps = []) => {
   ]);
 };
 
-// src/useTrackProps.ts
-import { useEffect as useEffect12, useRef as useRef7 } from "react";
-import { log } from "@dxos/log";
-var __dxlog_file = "/__w/dxos/dxos/packages/ui/primitives/react-hooks/src/useTrackProps.ts";
-var useTrackProps = (props, componentName = "Component", active = true) => {
-  const prevProps = useRef7(props);
-  useEffect12(() => {
-    const changes = Object.entries(props).filter(([key]) => props[key] !== prevProps.current[key]);
-    if (changes.length > 0) {
-      if (active) {
-        log.info("props changed", {
-          componentName,
-          keys: changes.map(([key]) => key).join(","),
-          props: Object.fromEntries(changes.map(([key]) => [
-            key,
-            {
-              from: prevProps.current[key],
-              to: props[key]
-            }
-          ]))
-        }, {
-          F: __dxlog_file,
-          L: 22,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
-      }
-    }
-    prevProps.current = props;
-  });
-};
-
 // src/useTransitions.ts
-import { useEffect as useEffect13, useRef as useRef8, useState as useState8 } from "react";
-var isFunction = (functionToCheck) => {
+import { useEffect as useEffect11, useRef as useRef7, useState as useState9 } from "react";
+var isFunction2 = (functionToCheck) => {
   return functionToCheck instanceof Function;
 };
 var useDidTransition = (currentValue, fromValue, toValue) => {
-  const [hasTransitioned, setHasTransitioned] = useState8(false);
-  const previousValue = useRef8(currentValue);
-  useEffect13(() => {
-    const toValueValid = isFunction(toValue) ? toValue(currentValue) : toValue === currentValue;
-    const fromValueValid = isFunction(fromValue) ? fromValue(previousValue.current) : fromValue === previousValue.current;
+  const [hasTransitioned, setHasTransitioned] = useState9(false);
+  const previousValue = useRef7(currentValue);
+  useEffect11(() => {
+    const toValueValid = isFunction2(toValue) ? toValue(currentValue) : toValue === currentValue;
+    const fromValueValid = isFunction2(fromValue) ? fromValue(previousValue.current) : fromValue === previousValue.current;
     if (fromValueValid && toValueValid && !hasTransitioned) {
       setHasTransitioned(true);
     } else if ((!fromValueValid || !toValueValid) && hasTransitioned) {
@@ -453,15 +453,15 @@ var useDidTransition = (currentValue, fromValue, toValue) => {
   return hasTransitioned;
 };
 var useOnTransition = (currentValue, fromValue, toValue, callback) => {
-  const dirty = useRef8(false);
+  const dirty = useRef7(false);
   const hasTransitioned = useDidTransition(currentValue, fromValue, toValue);
-  useEffect13(() => {
+  useEffect11(() => {
     dirty.current = false;
   }, [
     currentValue,
     dirty
   ]);
-  useEffect13(() => {
+  useEffect11(() => {
     if (hasTransitioned && !dirty.current) {
       callback();
       dirty.current = true;
@@ -474,9 +474,13 @@ var useOnTransition = (currentValue, fromValue, toValue, callback) => {
 };
 export {
   makeId,
+  mergeRefs,
   randomString,
+  setRef,
   useAsyncEffect,
   useAsyncState,
+  useAtomState,
+  useComposedRefs,
   useControlledState,
   useDebugDeps,
   useDefaultValue,
@@ -489,14 +493,14 @@ export {
   useInterval,
   useIsFocused,
   useMediaQuery,
+  useMergeRefs,
   useMulticastObservable,
   useOnTransition,
   useRefCallback,
-  useResize,
-  useSignalsEffect,
-  useSignalsMemo,
+  useScroller,
+  useSize,
   useStateWithRef,
   useTimeout,
-  useTrackProps
+  useViewportResize
 };
 //# sourceMappingURL=index.mjs.map