reactives-hooks 0.1.0

package/dist/index.mjs

@@ -0,0 +1,792 @@
+import { useLayoutEffect, useEffect, useState, useCallback, useRef, useMemo } from 'react';
+
+function useToggle(initialValue = false) {
+  const [value, setValue] = useState(initialValue);
+  const toggle = useCallback((newValue) => {
+    setValue((prev) => typeof newValue === "boolean" ? newValue : !prev);
+  }, []);
+  return [value, toggle];
+}
+function useBoolean(initialValue = false) {
+  const [value, setValue] = useState(initialValue);
+  const setTrue = useCallback(() => setValue(true), []);
+  const setFalse = useCallback(() => setValue(false), []);
+  const toggle = useCallback(() => setValue((prev) => !prev), []);
+  return { value, setTrue, setFalse, toggle, setValue };
+}
+function useCounter(initialValue = 0, options = {}) {
+  const { min, max } = options;
+  const [count, setCount] = useState(initialValue);
+  const clamp = useCallback(
+    (value) => {
+      let clamped = value;
+      if (min !== void 0) clamped = Math.max(min, clamped);
+      if (max !== void 0) clamped = Math.min(max, clamped);
+      return clamped;
+    },
+    [min, max]
+  );
+  const increment = useCallback((delta = 1) => setCount((prev) => clamp(prev + delta)), [clamp]);
+  const decrement = useCallback((delta = 1) => setCount((prev) => clamp(prev - delta)), [clamp]);
+  const set = useCallback((value) => setCount(clamp(value)), [clamp]);
+  const reset = useCallback(() => setCount(initialValue), [initialValue]);
+  return [count, { increment, decrement, set, reset }];
+}
+function useMap(initialValue = []) {
+  const [map, setMap] = useState(() => new Map(initialValue));
+  const actions = {
+    set: useCallback((key, value) => {
+      setMap((prev) => {
+        const next = new Map(prev);
+        next.set(key, value);
+        return next;
+      });
+    }, []),
+    setAll: useCallback((entries) => {
+      setMap((prev) => {
+        const next = new Map(prev);
+        for (const [key, value] of entries) {
+          next.set(key, value);
+        }
+        return next;
+      });
+    }, []),
+    delete: useCallback((key) => {
+      setMap((prev) => {
+        const next = new Map(prev);
+        next.delete(key);
+        return next;
+      });
+    }, []),
+    clear: useCallback(() => {
+      setMap(/* @__PURE__ */ new Map());
+    }, []),
+    reset: useCallback(() => {
+      setMap(new Map(initialValue));
+    }, [])
+  };
+  return [map, actions];
+}
+function useSet(initialValue = []) {
+  const [set, setSet] = useState(() => new Set(initialValue));
+  const actions = {
+    add: useCallback((value) => {
+      setSet((prev) => /* @__PURE__ */ new Set([...prev, value]));
+    }, []),
+    delete: useCallback((value) => {
+      setSet((prev) => {
+        const next = new Set(prev);
+        next.delete(value);
+        return next;
+      });
+    }, []),
+    clear: useCallback(() => {
+      setSet(/* @__PURE__ */ new Set());
+    }, []),
+    reset: useCallback(() => {
+      setSet(new Set(initialValue));
+    }, []),
+    toggle: useCallback((value) => {
+      setSet((prev) => {
+        const next = new Set(prev);
+        if (next.has(value)) {
+          next.delete(value);
+        } else {
+          next.add(value);
+        }
+        return next;
+      });
+    }, [])
+  };
+  return [set, actions];
+}
+function usePrevious(value) {
+  const ref = useRef(void 0);
+  useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+function useStateHistory(initialValue) {
+  const [value, setValue] = useState(initialValue);
+  const historyRef = useRef([initialValue]);
+  const pointerRef = useRef(0);
+  const set = useCallback((newValue) => {
+    const pointer = pointerRef.current;
+    const newHistory = historyRef.current.slice(0, pointer + 1);
+    newHistory.push(newValue);
+    historyRef.current = newHistory;
+    pointerRef.current = newHistory.length - 1;
+    setValue(newValue);
+  }, []);
+  const undo = useCallback(() => {
+    if (pointerRef.current > 0) {
+      pointerRef.current -= 1;
+      setValue(historyRef.current[pointerRef.current]);
+    }
+  }, []);
+  const redo = useCallback(() => {
+    if (pointerRef.current < historyRef.current.length - 1) {
+      pointerRef.current += 1;
+      setValue(historyRef.current[pointerRef.current]);
+    }
+  }, []);
+  return {
+    value,
+    set,
+    undo,
+    redo,
+    canUndo: pointerRef.current > 0,
+    canRedo: pointerRef.current < historyRef.current.length - 1,
+    history: historyRef.current
+  };
+}
+function getStoredValue(key, initialValue) {
+  if (typeof window === "undefined") return initialValue;
+  try {
+    const item = window.localStorage.getItem(key);
+    return item ? JSON.parse(item) : initialValue;
+  } catch {
+    return initialValue;
+  }
+}
+function useLocalStorage(key, initialValue) {
+  const [storedValue, setStoredValue] = useState(() => getStoredValue(key, initialValue));
+  const setValue = useCallback(
+    (value) => {
+      setStoredValue((prev) => {
+        const nextValue = value instanceof Function ? value(prev) : value;
+        if (typeof window !== "undefined") {
+          window.localStorage.setItem(key, JSON.stringify(nextValue));
+        }
+        return nextValue;
+      });
+    },
+    [key]
+  );
+  const removeValue = useCallback(() => {
+    setStoredValue(initialValue);
+    if (typeof window !== "undefined") {
+      window.localStorage.removeItem(key);
+    }
+  }, [key, initialValue]);
+  useEffect(() => {
+    const handleStorageChange = (e) => {
+      if (e.key === key && e.newValue !== null) {
+        try {
+          setStoredValue(JSON.parse(e.newValue));
+        } catch {
+        }
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => window.removeEventListener("storage", handleStorageChange);
+  }, [key]);
+  return [storedValue, setValue, removeValue];
+}
+function getStoredValue2(key, initialValue) {
+  if (typeof window === "undefined") return initialValue;
+  try {
+    const item = window.sessionStorage.getItem(key);
+    return item ? JSON.parse(item) : initialValue;
+  } catch {
+    return initialValue;
+  }
+}
+function useSessionStorage(key, initialValue) {
+  const [storedValue, setStoredValue] = useState(() => getStoredValue2(key, initialValue));
+  const setValue = useCallback(
+    (value) => {
+      setStoredValue((prev) => {
+        const nextValue = value instanceof Function ? value(prev) : value;
+        if (typeof window !== "undefined") {
+          window.sessionStorage.setItem(key, JSON.stringify(nextValue));
+        }
+        return nextValue;
+      });
+    },
+    [key]
+  );
+  const removeValue = useCallback(() => {
+    setStoredValue(initialValue);
+    if (typeof window !== "undefined") {
+      window.sessionStorage.removeItem(key);
+    }
+  }, [key, initialValue]);
+  return [storedValue, setValue, removeValue];
+}
+function useEventListener(eventName, handler, element, options) {
+  const savedHandler = useRef(handler);
+  useEffect(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+  useEffect(() => {
+    const target = element?.current ?? window;
+    if (!target?.addEventListener) return;
+    const listener = (event) => savedHandler.current(event);
+    target.addEventListener(eventName, listener, options);
+    return () => target.removeEventListener(eventName, listener, options);
+  }, [eventName, element, options]);
+}
+function useClickOutside(handler) {
+  const ref = useRef(null);
+  const savedHandler = useRef(handler);
+  useEffect(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+  useEffect(() => {
+    const listener = (event) => {
+      if (!ref.current || ref.current.contains(event.target)) return;
+      savedHandler.current(event);
+    };
+    document.addEventListener("mousedown", listener);
+    document.addEventListener("touchstart", listener);
+    return () => {
+      document.removeEventListener("mousedown", listener);
+      document.removeEventListener("touchstart", listener);
+    };
+  }, []);
+  return ref;
+}
+function useHover() {
+  const [isHovered, setIsHovered] = useState(false);
+  const ref = useRef(null);
+  const handleMouseEnter = useCallback(() => setIsHovered(true), []);
+  const handleMouseLeave = useCallback(() => setIsHovered(false), []);
+  const callbackRef = useCallback(
+    (node) => {
+      if (ref.current) {
+        ref.current.removeEventListener("mouseenter", handleMouseEnter);
+        ref.current.removeEventListener("mouseleave", handleMouseLeave);
+      }
+      ref.current = node;
+      if (node) {
+        node.addEventListener("mouseenter", handleMouseEnter);
+        node.addEventListener("mouseleave", handleMouseLeave);
+      }
+    },
+    [handleMouseEnter, handleMouseLeave]
+  );
+  return [callbackRef, isHovered];
+}
+function useIntersectionObserver(options = {}) {
+  const { threshold = 0, root = null, rootMargin = "0px", freezeOnceVisible = false } = options;
+  const ref = useRef(null);
+  const [entry, setEntry] = useState(null);
+  const frozen = entry?.isIntersecting && freezeOnceVisible;
+  useEffect(() => {
+    const node = ref.current;
+    if (!node || frozen) return;
+    const observer = new IntersectionObserver(
+      ([observerEntry]) => {
+        if (observerEntry) setEntry(observerEntry);
+      },
+      { threshold, root, rootMargin }
+    );
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [threshold, root, rootMargin, frozen]);
+  return {
+    ref,
+    isIntersecting: entry?.isIntersecting ?? false,
+    entry
+  };
+}
+function useResizeObserver() {
+  const ref = useRef(null);
+  const [size, setSize] = useState({ width: 0, height: 0 });
+  useEffect(() => {
+    const node = ref.current;
+    if (!node) return;
+    const observer = new ResizeObserver(([resizeEntry]) => {
+      if (resizeEntry) {
+        const { width, height } = resizeEntry.contentRect;
+        setSize({ width, height });
+      }
+    });
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, []);
+  return [ref, size];
+}
+function useMutationObserver(callback, options = { childList: true, subtree: true }) {
+  const ref = useRef(null);
+  const savedCallback = useRef(callback);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    const node = ref.current;
+    if (!node) return;
+    const observer = new MutationObserver((...args) => savedCallback.current(...args));
+    observer.observe(node, options);
+    return () => observer.disconnect();
+  }, [options]);
+  return ref;
+}
+function useMediaQuery(query) {
+  const [matches, setMatches] = useState(() => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia(query).matches;
+  });
+  useEffect(() => {
+    const mql = window.matchMedia(query);
+    const handler = (e) => setMatches(e.matches);
+    setMatches(mql.matches);
+    mql.addEventListener("change", handler);
+    return () => mql.removeEventListener("change", handler);
+  }, [query]);
+  return matches;
+}
+function useWindowSize() {
+  const [size, setSize] = useState(() => ({
+    width: typeof window !== "undefined" ? window.innerWidth : 0,
+    height: typeof window !== "undefined" ? window.innerHeight : 0
+  }));
+  useEffect(() => {
+    const handleResize = () => {
+      setSize({ width: window.innerWidth, height: window.innerHeight });
+    };
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+  return size;
+}
+function useScroll(element) {
+  const [position, setPosition] = useState({ x: 0, y: 0 });
+  useEffect(() => {
+    const target = element?.current ?? window;
+    const handleScroll = () => {
+      if ("scrollX" in target) {
+        setPosition({ x: target.scrollX ?? 0, y: target.scrollY ?? 0 });
+      } else if (target instanceof HTMLElement) {
+        setPosition({ x: target.scrollLeft, y: target.scrollTop });
+      }
+    };
+    handleScroll();
+    target.addEventListener("scroll", handleScroll, { passive: true });
+    return () => target.removeEventListener("scroll", handleScroll);
+  }, [element]);
+  return position;
+}
+function useMouse() {
+  const [position, setPosition] = useState({ x: 0, y: 0 });
+  useEffect(() => {
+    const handleMouseMove = (e) => {
+      setPosition({ x: e.clientX, y: e.clientY });
+    };
+    window.addEventListener("mousemove", handleMouseMove);
+    return () => window.removeEventListener("mousemove", handleMouseMove);
+  }, []);
+  return position;
+}
+function useNetwork() {
+  const [state, setState] = useState(() => ({
+    online: typeof navigator !== "undefined" ? navigator.onLine : true
+  }));
+  useEffect(() => {
+    const connection = navigator.connection;
+    const updateNetworkInfo = () => {
+      setState({
+        online: navigator.onLine,
+        downlink: connection?.downlink,
+        effectiveType: connection?.effectiveType,
+        rtt: connection?.rtt,
+        saveData: connection?.saveData
+      });
+    };
+    updateNetworkInfo();
+    window.addEventListener("online", updateNetworkInfo);
+    window.addEventListener("offline", updateNetworkInfo);
+    connection?.addEventListener?.("change", updateNetworkInfo);
+    return () => {
+      window.removeEventListener("online", updateNetworkInfo);
+      window.removeEventListener("offline", updateNetworkInfo);
+      connection?.removeEventListener?.("change", updateNetworkInfo);
+    };
+  }, []);
+  return state;
+}
+function useDebounceValue(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+}
+function useDebounceCallback(callback, delay) {
+  const callbackRef = useRef(callback);
+  const timerRef = useRef(null);
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, []);
+  return useCallback(
+    (...args) => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      timerRef.current = setTimeout(() => callbackRef.current(...args), delay);
+    },
+    [delay]
+  );
+}
+function useThrottleValue(value, interval) {
+  const [throttledValue, setThrottledValue] = useState(value);
+  const lastUpdated = useRef(Date.now());
+  useEffect(() => {
+    const now = Date.now();
+    const elapsed = now - lastUpdated.current;
+    if (elapsed >= interval) {
+      lastUpdated.current = now;
+      setThrottledValue(value);
+    } else {
+      const timer = setTimeout(() => {
+        lastUpdated.current = Date.now();
+        setThrottledValue(value);
+      }, interval - elapsed);
+      return () => clearTimeout(timer);
+    }
+  }, [value, interval]);
+  return throttledValue;
+}
+function useThrottleCallback(callback, interval) {
+  const callbackRef = useRef(callback);
+  const lastCalledRef = useRef(0);
+  const timerRef = useRef(null);
+  useEffect(() => {
+    callbackRef.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, []);
+  return useCallback(
+    (...args) => {
+      const now = Date.now();
+      const elapsed = now - lastCalledRef.current;
+      if (elapsed >= interval) {
+        lastCalledRef.current = now;
+        callbackRef.current(...args);
+      } else if (!timerRef.current) {
+        timerRef.current = setTimeout(() => {
+          lastCalledRef.current = Date.now();
+          timerRef.current = null;
+          callbackRef.current(...args);
+        }, interval - elapsed);
+      }
+    },
+    [interval]
+  );
+}
+function useMount(callback) {
+  useEffect(() => {
+    callback();
+  }, []);
+}
+function useUnmount(callback) {
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useEffect(() => {
+    return () => callbackRef.current();
+  }, []);
+}
+function useUpdateEffect(effect, deps) {
+  const isFirst = useRef(true);
+  useEffect(() => {
+    if (isFirst.current) {
+      isFirst.current = false;
+      return;
+    }
+    return effect();
+  }, deps);
+}
+function useIsMounted() {
+  const isMounted = useRef(false);
+  useEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  return useCallback(() => isMounted.current, []);
+}
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const objA = a;
+  const objB = b;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(objB, key)) return false;
+    if (!deepEqual(objA[key], objB[key])) return false;
+  }
+  return true;
+}
+function useDeepCompareMemoize(deps) {
+  const ref = useRef(deps);
+  if (!deepEqual(deps, ref.current)) {
+    ref.current = deps;
+  }
+  return ref.current;
+}
+function useDeepCompareEffect(effect, deps) {
+  useEffect(effect, useDeepCompareMemoize(deps));
+}
+function useScrollLock(locked) {
+  useEffect(() => {
+    if (!locked) return;
+    const originalOverflow = document.body.style.overflow;
+    const originalPaddingRight = document.body.style.paddingRight;
+    const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+    document.body.style.overflow = "hidden";
+    if (scrollbarWidth > 0) {
+      document.body.style.paddingRight = `${scrollbarWidth}px`;
+    }
+    return () => {
+      document.body.style.overflow = originalOverflow;
+      document.body.style.paddingRight = originalPaddingRight;
+    };
+  }, [locked]);
+}
+function useDarkMode(defaultTheme = "system") {
+  const [theme, setThemeState] = useState(() => {
+    if (typeof window === "undefined") return defaultTheme;
+    return localStorage.getItem("theme") ?? defaultTheme;
+  });
+  const [systemDark, setSystemDark] = useState(() => {
+    if (typeof window === "undefined") return false;
+    return window.matchMedia("(prefers-color-scheme: dark)").matches;
+  });
+  useEffect(() => {
+    const mql = window.matchMedia("(prefers-color-scheme: dark)");
+    const handler = (e) => setSystemDark(e.matches);
+    mql.addEventListener("change", handler);
+    return () => mql.removeEventListener("change", handler);
+  }, []);
+  const isDark = theme === "system" ? systemDark : theme === "dark";
+  const setTheme = useCallback((newTheme) => {
+    setThemeState(newTheme);
+    localStorage.setItem("theme", newTheme);
+  }, []);
+  const toggle = useCallback(() => {
+    setTheme(isDark ? "light" : "dark");
+  }, [isDark, setTheme]);
+  useEffect(() => {
+    document.documentElement.classList.toggle("dark", isDark);
+  }, [isDark]);
+  return { isDark, theme, setTheme, toggle };
+}
+function useFullscreen() {
+  const ref = useRef(null);
+  const [isFullscreen, setIsFullscreen] = useState(false);
+  useEffect(() => {
+    const handler = () => setIsFullscreen(!!document.fullscreenElement);
+    document.addEventListener("fullscreenchange", handler);
+    return () => document.removeEventListener("fullscreenchange", handler);
+  }, []);
+  const enter = useCallback(async () => {
+    const element = ref.current;
+    if (element) await element.requestFullscreen();
+  }, []);
+  const exit = useCallback(async () => {
+    if (document.fullscreenElement) await document.exitFullscreen();
+  }, []);
+  const toggle = useCallback(async () => {
+    if (isFullscreen) await exit();
+    else await enter();
+  }, [isFullscreen, enter, exit]);
+  return { ref, isFullscreen, enter, exit, toggle };
+}
+function useCopyToClipboard() {
+  const [copiedText, setCopiedText] = useState(null);
+  const copy = useCallback(async (text) => {
+    if (!navigator?.clipboard) {
+      return false;
+    }
+    try {
+      await navigator.clipboard.writeText(text);
+      setCopiedText(text);
+      return true;
+    } catch {
+      setCopiedText(null);
+      return false;
+    }
+  }, []);
+  return { copiedText, copy };
+}
+function parseKeyCombo(combo) {
+  const parts = combo.toLowerCase().split("+");
+  return {
+    key: parts[parts.length - 1],
+    ctrl: parts.includes("ctrl") || parts.includes("control"),
+    shift: parts.includes("shift"),
+    alt: parts.includes("alt"),
+    meta: parts.includes("meta") || parts.includes("cmd")
+  };
+}
+function useHotkeys(keyCombo, callback, enabled = true) {
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useEffect(() => {
+    if (!enabled) return;
+    const parsed = parseKeyCombo(keyCombo);
+    const handler = (event) => {
+      const matches = event.key.toLowerCase() === parsed.key && event.ctrlKey === parsed.ctrl && event.shiftKey === parsed.shift && event.altKey === parsed.alt && event.metaKey === parsed.meta;
+      if (matches) {
+        event.preventDefault();
+        callbackRef.current(event);
+      }
+    };
+    window.addEventListener("keydown", handler);
+    return () => window.removeEventListener("keydown", handler);
+  }, [keyCombo, enabled]);
+}
+function useAsync(asyncFunction, immediate = true) {
+  const [state, setState] = useState({
+    data: null,
+    loading: immediate,
+    error: null
+  });
+  const execute = useCallback(async () => {
+    setState({ data: null, loading: true, error: null });
+    try {
+      const data = await asyncFunction();
+      setState({ data, loading: false, error: null });
+    } catch (error) {
+      setState({ data: null, loading: false, error });
+    }
+  }, [asyncFunction]);
+  useEffect(() => {
+    if (immediate) {
+      execute();
+    }
+  }, [execute, immediate]);
+  return { ...state, execute };
+}
+function useFetch(url, options = {}) {
+  const { enabled = true, ...fetchOptions } = options;
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(enabled);
+  const [error, setError] = useState(null);
+  const abortControllerRef = useRef(null);
+  const fetchData = useCallback(async () => {
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = new AbortController();
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        signal: abortControllerRef.current.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const json = await response.json();
+      setData(json);
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        setError(err);
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [url]);
+  useEffect(() => {
+    if (!enabled) return;
+    fetchData();
+    return () => abortControllerRef.current?.abort();
+  }, [fetchData, enabled]);
+  return { data, loading, error, refetch: fetchData };
+}
+function useInfiniteScroll(loadMore, hasMore, options = {}) {
+  const { threshold = 0, rootMargin = "100px" } = options;
+  const sentinelRef = useRef(null);
+  const [loading, setLoading] = useState(false);
+  const loadingRef = useRef(false);
+  const handleLoadMore = useCallback(async () => {
+    if (loadingRef.current || !hasMore) return;
+    loadingRef.current = true;
+    setLoading(true);
+    try {
+      await loadMore();
+    } finally {
+      loadingRef.current = false;
+      setLoading(false);
+    }
+  }, [loadMore, hasMore]);
+  useEffect(() => {
+    const node = sentinelRef.current;
+    if (!node || !hasMore) return;
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (entry?.isIntersecting) {
+          handleLoadMore();
+        }
+      },
+      { threshold, rootMargin }
+    );
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [handleLoadMore, hasMore, threshold, rootMargin]);
+  const reset = useCallback(() => {
+    loadingRef.current = false;
+    setLoading(false);
+  }, []);
+  return { sentinelRef, loading, reset };
+}
+function usePagination(options) {
+  const { totalItems, pageSize: initialPageSize = 10, initialPage = 1 } = options;
+  const [page, setPageState] = useState(initialPage);
+  const [pageSize, setPageSizeState] = useState(initialPageSize);
+  const totalPages = useMemo(
+    () => Math.max(1, Math.ceil(totalItems / pageSize)),
+    [totalItems, pageSize]
+  );
+  const setPage = useCallback(
+    (newPage) => {
+      setPageState(Math.min(Math.max(1, newPage), totalPages));
+    },
+    [totalPages]
+  );
+  const setPageSize = useCallback((newSize) => {
+    setPageSizeState(newSize);
+    setPageState(1);
+  }, []);
+  const next = useCallback(() => setPage(page + 1), [page, setPage]);
+  const prev = useCallback(() => setPage(page - 1), [page, setPage]);
+  const startIndex = (page - 1) * pageSize;
+  const endIndex = Math.min(startIndex + pageSize - 1, totalItems - 1);
+  return {
+    page,
+    pageSize,
+    totalPages,
+    hasNext: page < totalPages,
+    hasPrev: page > 1,
+    next,
+    prev,
+    setPage,
+    setPageSize,
+    startIndex,
+    endIndex
+  };
+}
+
+export { useAsync, useBoolean, useClickOutside, useCopyToClipboard, useCounter, useDarkMode, useDebounceCallback, useDebounceValue, useDeepCompareEffect, useEventListener, useFetch, useFullscreen, useHotkeys, useHover, useInfiniteScroll, useIntersectionObserver, useIsMounted, useIsomorphicLayoutEffect, useLocalStorage, useMap, useMediaQuery, useMount, useMouse, useMutationObserver, useNetwork, usePagination, usePrevious, useResizeObserver, useScroll, useScrollLock, useSessionStorage, useSet, useStateHistory, useThrottleCallback, useThrottleValue, useToggle, useUnmount, useUpdateEffect, useWindowSize };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map