@dxos/react-hooks 0.8.4-main.b97322e → 0.8.4-main.bc2380dfbc

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

@@ -1,34 +1,50 @@
 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";
-import { log } from "@dxos/log";
-var useAsyncEffect = (callback, destructor, deps) => {
-  const [effectDestructor, effectDeps] = typeof destructor === "function" ? [
-    destructor,
-    deps
-  ] : [
-    void 0,
-    destructor
-  ];
+var useAsyncEffect = (cb, deps) => {
   useEffect(() => {
-    let mounted = true;
-    let value;
-    const asyncResult = callback(() => mounted);
-    void Promise.resolve(asyncResult).then((result) => {
-      value = result;
-    }).catch(log.catch);
+    const controller = new AbortController();
+    let cleanup;
+    const t = setTimeout(async () => {
+      if (!controller.signal.aborted) {
+        cleanup = await cb(controller);
+      }
+    });
     return () => {
-      mounted = false;
-      effectDestructor?.(value);
+      clearTimeout(t);
+      controller.abort();
+      cleanup?.();
     };
-  }, effectDeps);
+  }, 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 () => {
@@ -49,55 +65,102 @@ 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/useDebugReactDeps.ts
-import { useEffect as useEffect4, useRef } from "react";
-var useDebugReactDeps = (deps = []) => {
-  const lastDeps = useRef([]);
-  useEffect4(() => {
-    console.group("deps changed", {
-      old: lastDeps.current.length,
-      new: deps.length
-    });
+// src/useDebugDeps.ts
+import { useEffect as useEffect5, useRef as useRef3 } from "react";
+import { log } from "@dxos/log";
+var __dxlog_file = "/__w/dxos/dxos/packages/ui/react-primitives/react-hooks/src/useDebugDeps.ts";
+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++) {
-      console.log(i, lastDeps.current[i] === deps[i] ? "SAME" : "CHANGED", {
-        previous: lastDeps.current[i],
-        current: deps[i]
-      });
+      if (lastDeps.current[i] !== deps[i] || i > lastDeps.current.length) {
+        diff[i] = {
+          previous: lastDeps.current[i],
+          current: deps[i]
+        };
+      }
+    }
+    if (Object.keys(diff).length > 0) {
+      log.warn(`Updated: ${label} [${lastDeps.current.length}/${deps.length}]`, diff, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 24, S: void 0 });
     }
-    console.groupEnd();
     lastDeps.current = deps;
-  }, deps);
+  }, [
+    ...deps,
+    active
+  ]);
 };
 
 // src/useDefaultValue.ts
-import { useEffect as useEffect5, useState as useState3, useMemo } 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,
@@ -108,30 +171,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 { useEffect as useEffect6, useRef as useRef2 } from "react";
-var useDynamicRef = (value) => {
-  const ref = useRef2(value);
-  useEffect6(() => {
-    ref.current = value;
-  }, [
-    value
-  ]);
-  return ref;
-};
-
 // 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);
@@ -142,38 +193,61 @@ var useFileDownload = () => {
 };
 
 // src/useForwardedRef.ts
-import { useRef as useRef3, useEffect as useEffect7 } 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 useState4 } from "react";
+import { useEffect as useEffect8, useRef as useRef5, useState as useState6 } from "react";
 var useIsFocused = (inputRef) => {
-  const [isFocused, setIsFocused] = useState4(void 0);
-  const isFocusedRef = useRef4(isFocused);
+  const [isFocused, setIsFocused] = useState6(void 0);
+  const isFocusedRef = useRef5(isFocused);
   isFocusedRef.current = isFocused;
   useEffect8(() => {
     const input = inputRef.current;
@@ -199,7 +273,7 @@ var useIsFocused = (inputRef) => {
 };
 
 // src/useMediaQuery.ts
-import { useEffect as useEffect9, useState as useState5 } from "react";
+import { useEffect as useEffect9, useState as useState7 } from "react";
 var breakpointMediaQueries = {
   sm: "(min-width: 640px)",
   md: "(min-width: 768px)",
@@ -208,7 +282,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);
@@ -216,7 +290,7 @@ var useMediaQuery = (query, options = {}) => {
     fallback
   ];
   fallbackValues = fallbackValues.filter((v) => v != null);
-  const [value, setValue] = useState5(() => {
+  const [value, setValue] = useState7(() => {
     return queries.map((query2, index) => ({
       media: query2,
       matches: ssr ? !!fallbackValues[index] : document.defaultView?.matchMedia(query2).matches
@@ -264,9 +338,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();
   }, [
@@ -276,28 +350,28 @@ var useMulticastObservable = (observable) => {
 };
 
 // src/useRefCallback.ts
-import { useState as useState6 } from "react";
+import { useState as useState8 } from "react";
 var useRefCallback = () => {
-  const [value, setValue] = useState6(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(() => {
@@ -311,9 +385,9 @@ var useResize = (handler, deps = [], delay = 800) => {
 };
 
 // src/useTimeout.ts
-import { useEffect as useEffect10, useRef as useRef5 } from "react";
+import { useEffect as useEffect10, useRef as useRef6 } from "react";
 var useTimeout = (callback, delay = 0, deps = []) => {
-  const callbackRef = useRef5(callback);
+  const callbackRef = useRef6(callback);
   useEffect10(() => {
     callbackRef.current = callback;
   }, [
@@ -323,57 +397,48 @@ var useTimeout = (callback, delay = 0, deps = []) => {
     if (delay == null) {
       return;
     }
-    const timeout = setTimeout(() => callbackRef.current?.(), delay);
-    return () => clearTimeout(timeout);
+    const t = setTimeout(() => callbackRef.current?.(), delay);
+    return () => clearTimeout(t);
   }, [
     delay,
     ...deps
   ]);
 };
-
-// src/useTrackProps.ts
-import { useRef as useRef6, useEffect as useEffect11 } from "react";
-import { log as log2 } 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 = useRef6(props);
-  useEffect11(() => {
-    const changes = Object.entries(props).filter(([key]) => props[key] !== prevProps.current[key]);
-    if (changes.length > 0) {
-      if (active) {
-        log2.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)
-        });
-      }
+var useInterval = (callback, delay = 0, deps = []) => {
+  const callbackRef = useRef6(callback);
+  useEffect10(() => {
+    callbackRef.current = callback;
+  }, [
+    callback
+  ]);
+  useEffect10(() => {
+    if (delay == null) {
+      return;
     }
-    prevProps.current = props;
-  });
+    const i = setInterval(async () => {
+      const result = await callbackRef.current?.();
+      if (result === false) {
+        clearInterval(i);
+      }
+    }, delay);
+    return () => clearInterval(i);
+  }, [
+    delay,
+    ...deps
+  ]);
 };
 
 // src/useTransitions.ts
-import { useRef as useRef7, useEffect as useEffect12, useState as useState7 } 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] = useState7(false);
+  const [hasTransitioned, setHasTransitioned] = useState9(false);
   const previousValue = useRef7(currentValue);
-  useEffect12(() => {
-    const toValueValid = isFunction(toValue) ? toValue(currentValue) : toValue === currentValue;
-    const fromValueValid = isFunction(fromValue) ? fromValue(previousValue.current) : fromValue === previousValue.current;
+  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) {
@@ -391,13 +456,13 @@ var useDidTransition = (currentValue, fromValue, toValue) => {
 var useOnTransition = (currentValue, fromValue, toValue, callback) => {
   const dirty = useRef7(false);
   const hasTransitioned = useDidTransition(currentValue, fromValue, toValue);
-  useEffect12(() => {
+  useEffect11(() => {
     dirty.current = false;
   }, [
     currentValue,
     dirty
   ]);
-  useEffect12(() => {
+  useEffect11(() => {
     if (hasTransitioned && !dirty.current) {
       callback();
       dirty.current = true;
@@ -410,11 +475,15 @@ var useOnTransition = (currentValue, fromValue, toValue, callback) => {
 };
 export {
   makeId,
+  mergeRefs,
   randomString,
+  setRef,
   useAsyncEffect,
   useAsyncState,
+  useAtomState,
+  useComposedRefs,
   useControlledState,
-  useDebugReactDeps,
+  useDebugDeps,
   useDefaultValue,
   useDefaults,
   useDidTransition,
@@ -422,13 +491,17 @@ export {
   useFileDownload,
   useForwardedRef,
   useId,
+  useInterval,
   useIsFocused,
   useMediaQuery,
+  useMergeRefs,
   useMulticastObservable,
   useOnTransition,
   useRefCallback,
-  useResize,
+  useScroller,
+  useSize,
+  useStateWithRef,
   useTimeout,
-  useTrackProps
+  useViewportResize
 };
 //# sourceMappingURL=index.mjs.map