@dxos/react-hooks 0.8.3 → 0.8.4-main.1c7ec43d41

package/README.md

@@ -3,4 +3,5 @@
 TypeScript types for DXOS UI and its themes.
 
 Ref
+
 - https://github.com/jaredLunde/react-hook

package/dist/lib/browser/index.mjs

@@ -1,35 +1,51 @@
-// packages/ui/primitives/react-hooks/src/useAsyncEffect.ts
+// 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
+  ]);
 };
 
-// packages/ui/primitives/react-hooks/src/useAsyncState.ts
-import { useEffect as useEffect2, useState } from "react";
+// src/useAsyncState.ts
+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;
-    queueMicrotask(async () => {
+    const t = setTimeout(async () => {
       const data = await cb();
       if (!disposed) {
         setValue(data);
@@ -37,6 +53,7 @@ var useAsyncState = (cb, deps = []) => {
     });
     return () => {
       disposed = true;
+      clearTimeout(t);
     };
   }, deps);
   return [
@@ -45,50 +62,102 @@ var useAsyncState = (cb, deps = []) => {
   ];
 };
 
-// packages/ui/primitives/react-hooks/src/useControlledState.ts
-import { useEffect as useEffect3, useState as useState2 } from "react";
-var useControlledState = (controlledValue, ...deps) => {
-  const [value, setValue] = useState2(controlledValue);
-  useEffect3(() => {
-    if (controlledValue !== void 0) {
-      setValue(controlledValue);
+// src/useControlledState.ts
+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
+  ]);
+  return valueRef;
+};
+
+// src/useControlledState.ts
+var useControlledState = (valueProp, onChange) => {
+  const [value, setControlledValue] = useState4(valueProp);
+  useEffect4(() => {
+    setControlledValue(valueProp);
+  }, [
+    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";
+}
 
-// packages/ui/primitives/react-hooks/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 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);
     }
-    console.groupEnd();
     lastDeps.current = deps;
-  }, deps);
+  }, [
+    ...deps,
+    active
+  ]);
 };
 
-// packages/ui/primitives/react-hooks/src/useDefaultValue.ts
-import { useEffect as useEffect5, useState as useState3, useMemo } from "react";
+// src/useDefaultValue.ts
+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,
@@ -97,22 +166,20 @@ var useDefaultValue = (reactiveValue, getDefaultValue) => {
   return value;
 };
 
-// packages/ui/primitives/react-hooks/src/useDynamicRef.ts
-import { useEffect as useEffect6, useRef as useRef2 } from "react";
-var useDynamicRef = (value) => {
-  const ref = useRef2(value);
-  useEffect6(() => {
-    ref.current = value;
-  }, [
-    value
+// src/useDefaults.ts
+import defaultsDeep from "lodash.defaultsdeep";
+import { useMemo as useMemo3 } from "react";
+var useDefaults = (value, defaults) => {
+  return useMemo3(() => defaultsDeep({}, defaults, value), [
+    value,
+    defaults
   ]);
-  return ref;
 };
 
-// packages/ui/primitives/react-hooks/src/useFileDownload.ts
-import { useMemo as useMemo2 } from "react";
+// src/useFileDownload.ts
+import { useMemo as useMemo4 } from "react";
 var useFileDownload = () => {
-  return useMemo2(() => (data, filename) => {
+  return useMemo4(() => (data, filename) => {
     const url = typeof data === "string" ? data : URL.createObjectURL(data);
     const element = document.createElement("a");
     element.setAttribute("href", url);
@@ -122,39 +189,62 @@ var useFileDownload = () => {
   }, []);
 };
 
-// packages/ui/primitives/react-hooks/src/useForwardedRef.ts
-import { useRef as useRef3, useEffect as useEffect7 } from "react";
-var useForwardedRef = (ref) => {
-  const innerRef = useRef3(null);
+// src/useForwardedRef.ts
+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
+  ]);
 };
 
-// packages/ui/primitives/react-hooks/src/useId.ts
+// src/useId.ts
 import alea from "alea";
-import { useMemo as useMemo3 } 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) => useMemo3(() => 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)}`;
 
-// packages/ui/primitives/react-hooks/src/useIsFocused.ts
-import { useEffect as useEffect8, useRef as useRef4, useState as useState4 } from "react";
+// src/useIsFocused.ts
+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;
@@ -179,8 +269,8 @@ var useIsFocused = (inputRef) => {
   return isFocused;
 };
 
-// packages/ui/primitives/react-hooks/src/useMediaQuery.ts
-import { useEffect as useEffect9, useState as useState5 } from "react";
+// src/useMediaQuery.ts
+import { useEffect as useEffect9, useState as useState7 } from "react";
 var breakpointMediaQueries = {
   sm: "(min-width: 640px)",
   md: "(min-width: 768px)",
@@ -189,7 +279,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);
@@ -197,7 +287,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
@@ -244,10 +334,10 @@ var useMediaQuery = (query, options = {}) => {
   return value.map((item) => !!item.matches);
 };
 
-// packages/ui/primitives/react-hooks/src/useMulticastObservable.ts
-import { useMemo as useMemo4, useSyncExternalStore } from "react";
+// src/useMulticastObservable.ts
+import { useMemo as useMemo7, useSyncExternalStore } from "react";
 var useMulticastObservable = (observable) => {
-  const subscribeFn = useMemo4(() => (listener) => {
+  const subscribeFn = useMemo7(() => (listener) => {
     const subscription = observable.subscribe(listener);
     return () => subscription.unsubscribe();
   }, [
@@ -256,29 +346,29 @@ var useMulticastObservable = (observable) => {
   return useSyncExternalStore(subscribeFn, () => observable.get());
 };
 
-// packages/ui/primitives/react-hooks/src/useRefCallback.ts
-import { useState as useState6 } from "react";
+// src/useRefCallback.ts
+import { useState as useState8 } from "react";
 var useRefCallback = () => {
-  const [value, setValue] = useState6(null);
+  const [value, setValue] = useState8(null);
   return {
     refCallback: (value2) => setValue(value2),
     value
   };
 };
 
-// packages/ui/primitives/react-hooks/src/useResize.ts
-import { useLayoutEffect, useMemo as useMemo5 } from "react";
-var useResize = (handler, deps = [], delay = 800) => {
-  const debouncedHandler = useMemo5(() => {
+// 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(() => {
@@ -291,49 +381,61 @@ var useResize = (handler, deps = [], delay = 800) => {
   ]);
 };
 
-// packages/ui/primitives/react-hooks/src/useTrackProps.ts
-import { useRef as useRef5, useEffect as useEffect10 } from "react";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/ui/primitives/react-hooks/src/useTrackProps.ts";
-var useTrackProps = (props, componentName = "Component", active = true) => {
-  const prevProps = useRef5(props);
+// src/useTimeout.ts
+import { useEffect as useEffect10, useRef as useRef6 } from "react";
+var useTimeout = (callback, delay = 0, deps = []) => {
+  const callbackRef = useRef6(callback);
   useEffect10(() => {
-    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
+  ]);
+  useEffect10(() => {
+    if (delay == null) {
+      return;
     }
-    prevProps.current = props;
-  });
+    const t = setTimeout(() => callbackRef.current?.(), delay);
+    return () => clearTimeout(t);
+  }, [
+    delay,
+    ...deps
+  ]);
+};
+var useInterval = (callback, delay = 0, deps = []) => {
+  const callbackRef = useRef6(callback);
+  useEffect10(() => {
+    callbackRef.current = callback;
+  }, [
+    callback
+  ]);
+  useEffect10(() => {
+    if (delay == null) {
+      return;
+    }
+    const i = setInterval(async () => {
+      const result = await callbackRef.current?.();
+      if (result === false) {
+        clearInterval(i);
+      }
+    }, delay);
+    return () => clearInterval(i);
+  }, [
+    delay,
+    ...deps
+  ]);
 };
 
-// packages/ui/primitives/react-hooks/src/useTransitions.ts
-import { useRef as useRef6, useEffect as useEffect11, useState as useState7 } from "react";
-var isFunction = (functionToCheck) => {
+// src/useTransitions.ts
+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 previousValue = useRef6(currentValue);
+  const [hasTransitioned, setHasTransitioned] = useState9(false);
+  const previousValue = useRef7(currentValue);
   useEffect11(() => {
-    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) {
@@ -349,7 +451,7 @@ var useDidTransition = (currentValue, fromValue, toValue) => {
   return hasTransitioned;
 };
 var useOnTransition = (currentValue, fromValue, toValue, callback) => {
-  const dirty = useRef6(false);
+  const dirty = useRef7(false);
   const hasTransitioned = useDidTransition(currentValue, fromValue, toValue);
   useEffect11(() => {
     dirty.current = false;
@@ -370,23 +472,33 @@ var useOnTransition = (currentValue, fromValue, toValue, callback) => {
 };
 export {
   makeId,
+  mergeRefs,
   randomString,
+  setRef,
   useAsyncEffect,
   useAsyncState,
+  useAtomState,
+  useComposedRefs,
   useControlledState,
-  useDebugReactDeps,
+  useDebugDeps,
   useDefaultValue,
+  useDefaults,
   useDidTransition,
   useDynamicRef,
   useFileDownload,
   useForwardedRef,
   useId,
+  useInterval,
   useIsFocused,
   useMediaQuery,
+  useMergeRefs,
   useMulticastObservable,
   useOnTransition,
   useRefCallback,
-  useResize,
-  useTrackProps
+  useScroller,
+  useSize,
+  useStateWithRef,
+  useTimeout,
+  useViewportResize
 };
 //# sourceMappingURL=index.mjs.map