@dxos/react-hooks 0.8.4-main.2e9d522 → 0.8.4-main.3c1ae3b

package/dist/lib/browser/index.mjs

@@ -1,26 +1,20 @@
 // 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/useAsyncState.ts
@@ -47,43 +41,84 @@ 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 useState3 } from "react";
+
+// src/useDynamicRef.ts
+import { useCallback, useEffect as useEffect3, useRef, useState as useState2 } from "react";
+var useStateWithRef = (valueParam) => {
+  const [value, setValue] = useState2(valueParam);
+  const valueRef = useRef(valueParam);
+  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 = (valueParam, onChange) => {
+  const [value, setControlledValue] = useState3(valueParam);
+  useEffect4(() => {
+    setControlledValue(valueParam);
   }, [
-    value,
-    onChange
+    valueParam
+  ]);
+  const onChangeRef = useRef2(onChange);
+  const valueRef = useDynamicRef(valueParam);
+  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(() => {
+// src/useDebugDeps.ts
+import { useEffect as useEffect5, useRef as useRef3 } from "react";
+var useDebugDeps = (deps = [], active = true) => {
+  const lastDeps = useRef3([]);
+  useEffect5(() => {
     console.group("deps changed", {
-      old: lastDeps.current.length,
-      new: deps.length
+      previous: lastDeps.current.length,
+      current: deps.length
     });
     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] && active) {
+        console.log("changed", {
+          index: i,
+          previous: lastDeps.current[i],
+          current: deps[i]
+        });
+      }
     }
     console.groupEnd();
     lastDeps.current = deps;
@@ -91,11 +126,11 @@ var useDebugReactDeps = (deps = []) => {
 };
 
 // src/useDefaultValue.ts
-import { useEffect as useEffect5, useState as useState3, useMemo } from "react";
+import { useEffect as useEffect6, useMemo, useState as useState4 } from "react";
 var useDefaultValue = (reactiveValue, getDefaultValue) => {
   const stableDefaultValue = useMemo(getDefaultValue, []);
-  const [value, setValue] = useState3(reactiveValue ?? stableDefaultValue);
-  useEffect5(() => {
+  const [value, setValue] = useState4(reactiveValue ?? stableDefaultValue);
+  useEffect6(() => {
     setValue(reactiveValue ?? stableDefaultValue);
   }, [
     reactiveValue,
@@ -114,18 +149,6 @@ var useDefaults = (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";
 var useFileDownload = () => {
@@ -140,38 +163,59 @@ 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 useMemo4, 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 useMemo4(() => mergeRefs(refs), [
+    ...refs
+  ]);
 };
 
 // src/useId.ts
 import alea from "alea";
-import { useMemo as useMemo4 } from "react";
+import { useMemo as useMemo5 } 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 useMemo5(() => 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 useState5 } from "react";
 var useIsFocused = (inputRef) => {
-  const [isFocused, setIsFocused] = useState4(void 0);
-  const isFocusedRef = useRef4(isFocused);
+  const [isFocused, setIsFocused] = useState5(void 0);
+  const isFocusedRef = useRef5(isFocused);
   isFocusedRef.current = isFocused;
   useEffect8(() => {
     const input = inputRef.current;
@@ -197,7 +241,7 @@ var useIsFocused = (inputRef) => {
 };
 
 // src/useMediaQuery.ts
-import { useEffect as useEffect9, useState as useState5 } from "react";
+import { useEffect as useEffect9, useState as useState6 } from "react";
 var breakpointMediaQueries = {
   sm: "(min-width: 640px)",
   md: "(min-width: 768px)",
@@ -206,7 +250,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);
@@ -214,7 +258,7 @@ var useMediaQuery = (query, options = {}) => {
     fallback
   ];
   fallbackValues = fallbackValues.filter((v) => v != null);
-  const [value, setValue] = useState5(() => {
+  const [value, setValue] = useState6(() => {
     return queries.map((query2, index) => ({
       media: query2,
       matches: ssr ? !!fallbackValues[index] : document.defaultView?.matchMedia(query2).matches
@@ -262,9 +306,9 @@ var useMediaQuery = (query, options = {}) => {
 };
 
 // src/useMulticastObservable.ts
-import { useMemo as useMemo5, useSyncExternalStore } from "react";
+import { useMemo as useMemo6, useSyncExternalStore } from "react";
 var useMulticastObservable = (observable) => {
-  const subscribeFn = useMemo5(() => (listener) => {
+  const subscribeFn = useMemo6(() => (listener) => {
     const subscription = observable.subscribe(listener);
     return () => subscription.unsubscribe();
   }, [
@@ -274,19 +318,19 @@ var useMulticastObservable = (observable) => {
 };
 
 // src/useRefCallback.ts
-import { useState as useState6 } from "react";
+import { useState as useState7 } from "react";
 var useRefCallback = () => {
-  const [value, setValue] = useState6(null);
+  const [value, setValue] = useState7(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 useMemo7 } from "react";
+var useViewportResize = (handler, deps = [], delay = 800) => {
+  const debouncedHandler = useMemo7(() => {
     let timeout;
     return (event) => {
       clearTimeout(timeout);
@@ -308,70 +352,83 @@ 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 { useEffect as useEffect10, useMemo as useMemo8, useRef as useRef6 } from "react";
+var useSignalsEffect = (cb, deps) => {
+  const callback = useRef6(cb);
+  callback.current = cb;
+  useEffect10(() => {
+    return effect(() => {
+      return callback.current();
+    });
+  }, deps ?? []);
+};
+var useSignalsMemo = (cb, deps) => {
+  var _effect = _useSignals();
+  try {
+    return useMemo8(() => computed(cb), deps ?? []).value;
+  } finally {
+    _effect.f();
+  }
+};
+
 // src/useTimeout.ts
-import { useEffect as useEffect10, useRef as useRef5 } from "react";
+import { useEffect as useEffect11, useRef as useRef7 } from "react";
 var useTimeout = (callback, delay = 0, deps = []) => {
-  const callbackRef = useRef5(callback);
-  useEffect10(() => {
+  const callbackRef = useRef7(callback);
+  useEffect11(() => {
     callbackRef.current = callback;
   }, [
     callback
   ]);
-  useEffect10(() => {
+  useEffect11(() => {
     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);
+var useInterval = (callback, delay = 0, deps = []) => {
+  const callbackRef = useRef7(callback);
   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)
-        });
-      }
+    callbackRef.current = callback;
+  }, [
+    callback
+  ]);
+  useEffect11(() => {
+    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 useEffect12, useRef as useRef8, useState as useState8 } from "react";
+var isFunction2 = (functionToCheck) => {
   return functionToCheck instanceof Function;
 };
 var useDidTransition = (currentValue, fromValue, toValue) => {
-  const [hasTransitioned, setHasTransitioned] = useState7(false);
-  const previousValue = useRef7(currentValue);
+  const [hasTransitioned, setHasTransitioned] = useState8(false);
+  const previousValue = useRef8(currentValue);
   useEffect12(() => {
-    const toValueValid = isFunction(toValue) ? toValue(currentValue) : toValue === currentValue;
-    const fromValueValid = isFunction(fromValue) ? fromValue(previousValue.current) : fromValue === previousValue.current;
+    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) {
@@ -387,7 +444,7 @@ var useDidTransition = (currentValue, fromValue, toValue) => {
   return hasTransitioned;
 };
 var useOnTransition = (currentValue, fromValue, toValue, callback) => {
-  const dirty = useRef7(false);
+  const dirty = useRef8(false);
   const hasTransitioned = useDidTransition(currentValue, fromValue, toValue);
   useEffect12(() => {
     dirty.current = false;
@@ -406,13 +463,18 @@ var useOnTransition = (currentValue, fromValue, toValue, callback) => {
     callback
   ]);
 };
+
+// src/index.ts
+import { useSize, useScroller } from "mini-virtual-list";
 export {
   makeId,
+  mergeRefs,
   randomString,
+  setRef,
   useAsyncEffect,
   useAsyncState,
   useControlledState,
-  useDebugReactDeps,
+  useDebugDeps,
   useDefaultValue,
   useDefaults,
   useDidTransition,
@@ -420,13 +482,19 @@ export {
   useFileDownload,
   useForwardedRef,
   useId,
+  useInterval,
   useIsFocused,
   useMediaQuery,
+  useMergeRefs,
   useMulticastObservable,
   useOnTransition,
   useRefCallback,
-  useResize,
+  useScroller,
+  useSignalsEffect,
+  useSignalsMemo,
+  useSize,
+  useStateWithRef,
   useTimeout,
-  useTrackProps
+  useViewportResize
 };
 //# sourceMappingURL=index.mjs.map