@pol-studios/hooks 1.0.0

package/dist/chunk-GKXIKVGH.js

@@ -0,0 +1,157 @@
+import {
+  isUsable
+} from "./chunk-MMIPLCL4.js";
+
+// src/scroll/useScrollPosition.ts
+import { useState, useEffect, useMemo } from "react";
+function useScrollPosition(elementRef) {
+  const [scrollY, setScrollY] = useState(0);
+  const [scrollHeight, setHeight] = useState(0);
+  useEffect(() => {
+    if (isUsable(elementRef)) {
+      const element = elementRef.current;
+      if (element === null) return;
+      const handleScroll = () => {
+        const newScrollPosition = element.scrollTop;
+        setScrollY(newScrollPosition);
+        setHeight(element.scrollHeight);
+      };
+      element.addEventListener("scroll", handleScroll);
+      return () => {
+        element.removeEventListener("scroll", handleScroll);
+      };
+    } else {
+      const handleScroll = () => {
+        setScrollY(window.scrollY);
+        setHeight(document.body.scrollHeight - window.innerHeight);
+      };
+      window.addEventListener("scroll", handleScroll);
+      return () => {
+        window.removeEventListener("scroll", handleScroll);
+      };
+    }
+  }, [elementRef]);
+  return useMemo(() => {
+    return { scrollY, scrollHeight };
+  }, [scrollY, scrollHeight]);
+}
+
+// src/scroll/useScrollDirection.ts
+import { useState as useState2, useEffect as useEffect2 } from "react";
+function useScrollDirection(elementRef, threshold) {
+  const [isUserScrollingUp, setIsUserScrollingUp] = useState2(true);
+  const [lastScrollTop, setLastScrollTop] = useState2(0);
+  useEffect2(() => {
+    if (elementRef.current === null) return;
+    const element = elementRef.current;
+    const handleScroll = () => {
+      const currentScrollTop = window.pageYOffset || document.documentElement.scrollTop;
+      if (currentScrollTop > lastScrollTop) {
+        if (currentScrollTop > threshold && isUserScrollingUp) {
+          setIsUserScrollingUp(false);
+        }
+      } else {
+        if (currentScrollTop < threshold && !isUserScrollingUp) {
+          setIsUserScrollingUp(true);
+        }
+      }
+      setLastScrollTop(currentScrollTop <= 0 ? 0 : currentScrollTop);
+    };
+    element.addEventListener("scroll", handleScroll);
+    return () => {
+      element.removeEventListener("scroll", handleScroll);
+    };
+  }, [lastScrollTop, isUserScrollingUp, threshold, elementRef]);
+  return isUserScrollingUp;
+}
+
+// src/scroll/useScrollRestoration.ts
+import { debounce } from "lodash";
+import { useCallback, useEffect as useEffect3, useState as useState3 } from "react";
+function useScrollRestoration(scrollAreaId, ref) {
+  const key = `sp-${scrollAreaId}`;
+  const item = ref ? ref.current : window;
+  const [savedPosition] = useState3(() => parseInt(sessionStorage.getItem(key) || ""));
+  const saveScrollPosition = useCallback(
+    debounce(() => {
+      if (item !== window) {
+        sessionStorage.setItem(key, item.scrollTop.toString());
+      } else {
+        sessionStorage.setItem(key, window.scrollY.toString());
+      }
+    }, 200),
+    [ref, scrollAreaId]
+  );
+  useEffect3(() => {
+    if (savedPosition && item) {
+      if (item !== window) {
+        item.scrollTop = savedPosition;
+      } else {
+        window.scrollTo(0, savedPosition);
+      }
+    }
+  }, [ref]);
+  useEffect3(() => {
+    if (isUsable(scrollAreaId) === false || scrollAreaId === "" || item === null)
+      return;
+    item.addEventListener("scroll", saveScrollPosition);
+    return () => {
+      item?.removeEventListener("scroll", saveScrollPosition);
+    };
+  }, [ref, scrollAreaId]);
+  return savedPosition;
+}
+
+// src/scroll/useHideOnScroll.ts
+import { useMotionValue } from "framer-motion";
+import { useRef, useState as useState4, useEffect as useEffect4 } from "react";
+function useHideOnScroll({ height, scrollRef, initialPercentVisible = 1 }) {
+  const scrollY = useScrollPosition(scrollRef).scrollY;
+  const element = scrollRef ? scrollRef.current : window;
+  const clientHeight = scrollRef ? scrollRef.current?.clientHeight : document.body.scrollHeight;
+  const percentVisible = useMotionValue(initialPercentVisible);
+  const [totalScrolled, setTotalScrolled] = useState4(0);
+  const [baseLine, setBaseLine] = useState4(scrollY);
+  const componentReady = useRef(false);
+  useEffect4(() => {
+    componentReady.current = false;
+    new Promise((resolve) => setTimeout(resolve, 1e3)).then(() => {
+      componentReady.current = true;
+    });
+  }, [element]);
+  const [scrollStartTime, setScrollStartTime] = useState4(null);
+  useEffect4(() => {
+    if (element === null) return;
+    if (componentReady.current === false) return;
+    const amountScrolled = baseLine - scrollY;
+    if (Math.abs(totalScrolled - amountScrolled) < 5) return;
+    const isScrollingUp = amountScrolled > 0;
+    const isAtBottom = scrollY >= (clientHeight ?? 0) - window.innerHeight;
+    if (isScrollingUp && amountScrolled > -height && isAtBottom == false) {
+      const percentScrolled = amountScrolled / height;
+      const newOpacity = Math.min(1, Math.max(0, percentVisible.get() + percentScrolled));
+      percentVisible.set(newOpacity);
+    } else if (!isScrollingUp && amountScrolled < 0 && totalScrolled < height && scrollY > height * 5) {
+      const percentScrolled = Math.abs(amountScrolled) / height;
+      const newOpacity = Math.max(0, Math.min(1, percentVisible.get() - percentScrolled));
+      percentVisible.set(newOpacity);
+    }
+    if (isScrollingUp || amountScrolled === 0) {
+      setScrollStartTime(null);
+    } else if (scrollStartTime === null && Math.abs(amountScrolled) >= height) {
+      setScrollStartTime((/* @__PURE__ */ new Date()).getTime());
+    }
+    setBaseLine(scrollY);
+    setTotalScrolled((x) => x + amountScrolled);
+  }, [scrollY]);
+  return percentVisible.get() ?? 1;
+}
+var useHidingOnScroll = useHideOnScroll;
+
+export {
+  useScrollPosition,
+  useScrollDirection,
+  useScrollRestoration,
+  useHideOnScroll,
+  useHidingOnScroll
+};

package/dist/chunk-IFSEJVAF.js

@@ -0,0 +1,135 @@
+import {
+  useLocalStorageService
+} from "./chunk-OF7JZIAL.js";
+
+// src/network/useOnline.ts
+import { useEffect, useState } from "react";
+import { onlineManager } from "@tanstack/react-query";
+function useOnline() {
+  const [isOnline, setIsOnline] = useState(() => onlineManager.isOnline());
+  const [wasOffline, setWasOffline] = useState(false);
+  useEffect(() => {
+    const unsubscribe = onlineManager.subscribe((online) => {
+      const wasOfflineBefore = !isOnline;
+      setIsOnline(online);
+      if (wasOfflineBefore && online) {
+        setWasOffline(true);
+        setTimeout(() => setWasOffline(false), 2e3);
+      }
+    });
+    return unsubscribe;
+  }, [isOnline]);
+  return {
+    isOnline,
+    isOffline: !isOnline,
+    wasOffline
+  };
+}
+var useNetworkStatus = useOnline;
+
+// src/network/useMutationQueue.ts
+import { useEffect as useEffect2, useRef, useState as useState2, useCallback } from "react";
+var QUEUE_STORAGE_KEY = "pol-offline-mutation-queue";
+var MAX_RETRIES = 3;
+function useMutationQueue() {
+  const { isOnline } = useOnline();
+  const localStorageService = useLocalStorageService();
+  const [queuedMutations, setQueuedMutations] = useState2([]);
+  const isProcessingRef = useRef(false);
+  useEffect2(() => {
+    try {
+      const stored = localStorageService.getItem(QUEUE_STORAGE_KEY);
+      if (stored) {
+      }
+    } catch (error) {
+    }
+  }, [localStorageService]);
+  useEffect2(() => {
+    try {
+      localStorageService.setItem(
+        QUEUE_STORAGE_KEY,
+        JSON.stringify({ count: queuedMutations.length })
+      );
+    } catch (error) {
+    }
+  }, [queuedMutations.length, localStorageService]);
+  const processQueue = useCallback(async () => {
+    if (!isOnline || isProcessingRef.current) return;
+    isProcessingRef.current = true;
+    try {
+      let mutationsToProcess = [];
+      setQueuedMutations((prev) => {
+        mutationsToProcess = [...prev];
+        return prev;
+      });
+      for (const queuedMutation of mutationsToProcess) {
+        try {
+          await queuedMutation.mutationFn();
+          setQueuedMutations(
+            (prev) => prev.filter((m) => m.id !== queuedMutation.id)
+          );
+        } catch (error) {
+          const updatedMutation = {
+            ...queuedMutation,
+            retryCount: queuedMutation.retryCount + 1,
+            error
+          };
+          if (updatedMutation.retryCount >= MAX_RETRIES) {
+            setQueuedMutations(
+              (prev) => prev.filter((m) => m.id !== queuedMutation.id)
+            );
+          } else {
+            setQueuedMutations(
+              (prev) => prev.map((m) => m.id === queuedMutation.id ? updatedMutation : m)
+            );
+          }
+        }
+      }
+    } finally {
+      isProcessingRef.current = false;
+    }
+  }, [isOnline]);
+  useEffect2(() => {
+    if (isOnline && queuedMutations.length > 0 && !isProcessingRef.current) {
+      processQueue();
+    }
+  }, [isOnline, queuedMutations.length, processQueue]);
+  const queueMutation = (mutationKey, mutationFn, variables) => {
+    const queuedMutation = {
+      id: crypto.randomUUID(),
+      mutationKey,
+      mutationFn,
+      variables,
+      timestamp: Date.now(),
+      retryCount: 0
+    };
+    setQueuedMutations((prev) => [...prev, queuedMutation]);
+    if (isOnline && !isProcessingRef.current) {
+      processQueue();
+    }
+  };
+  const removeQueuedMutation = (id) => {
+    setQueuedMutations((prev) => prev.filter((m) => m.id !== id));
+  };
+  const clearQueue = () => {
+    setQueuedMutations([]);
+    try {
+      localStorageService.removeItem(QUEUE_STORAGE_KEY);
+    } catch (error) {
+    }
+  };
+  return {
+    queuedMutations,
+    queueMutation,
+    removeQueuedMutation,
+    clearQueue,
+    processQueue,
+    queueCount: queuedMutations.length
+  };
+}
+
+export {
+  useOnline,
+  useNetworkStatus,
+  useMutationQueue
+};