@pol-studios/hooks 1.0.0

package/dist/_utils/index.js

@@ -0,0 +1,29 @@
+import {
+  dateReviver,
+  downloadFile,
+  getFile,
+  getFilePost,
+  hasCameraAsync,
+  isDev,
+  isDevEnvironment,
+  isIphone,
+  isPwaLaunched,
+  isUsable,
+  parseWithDate,
+  withComponentMemo
+} from "../chunk-MMIPLCL4.js";
+import "../chunk-QGM4M3NI.js";
+export {
+  dateReviver,
+  downloadFile,
+  getFile,
+  getFilePost,
+  hasCameraAsync,
+  isDev,
+  isDevEnvironment,
+  isIphone,
+  isPwaLaunched,
+  isUsable,
+  parseWithDate,
+  withComponentMemo
+};

package/dist/chunk-AIS4L5ID.js

@@ -0,0 +1,151 @@
+import {
+  isPwaLaunched
+} from "./chunk-MMIPLCL4.js";
+
+// src/device/useDevice.ts
+import { useMemo } from "react";
+
+// src/device/useWindowDimensions.ts
+import { useState, useEffect } from "react";
+function getWindowDimensions() {
+  return {
+    width: window.innerWidth,
+    height: window.innerHeight
+  };
+}
+function useWindowDimensions() {
+  const [windowDimensions, setWindowDimensions] = useState(getWindowDimensions());
+  useEffect(() => {
+    function handleResize() {
+      const resize = getWindowDimensions();
+      setWindowDimensions(resize);
+    }
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
+  return windowDimensions;
+}
+
+// src/device/useMobile.ts
+import React from "react";
+var MOBILE_BREAKPOINT = 768;
+function useMobile() {
+  const [isMobile, setIsMobile] = React.useState(
+    void 0
+  );
+  React.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+    const onChange = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    };
+    mql.addEventListener("change", onChange);
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    return () => mql.removeEventListener("change", onChange);
+  }, []);
+  return !!isMobile;
+}
+var useIsMobile = useMobile;
+
+// src/device/useDevice.ts
+function useDevice() {
+  const { width, height } = useWindowDimensions();
+  const isMobile = useMobile();
+  const isPwa = isPwaLaunched();
+  return useMemo(() => {
+    return { isMobile, width, height, isPwa };
+  }, [isMobile, width, height, isPwa]);
+}
+
+// src/device/useTheme.ts
+import { useState as useState2, useEffect as useEffect2, useLayoutEffect } from "react";
+function useTheme() {
+  const [isDarkTheme, setIsDarkTheme] = useState2(false);
+  useLayoutEffect(() => {
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    if (mq.matches) {
+      setIsDarkTheme(true);
+    } else {
+      setIsDarkTheme(false);
+    }
+    mq.addEventListener("change", (evt) => {
+      setIsDarkTheme(evt.matches);
+    });
+  }, []);
+  useEffect2(() => {
+    if (isDarkTheme) {
+      document.documentElement.classList.add("dark");
+    } else {
+      document.documentElement.classList.remove("dark");
+    }
+  }, [isDarkTheme]);
+  return isDarkTheme;
+}
+var useThemeDetector = useTheme;
+
+// src/device/useDimensions.ts
+import { useEffect as useEffect3, useRef } from "react";
+function useDimensions(ref) {
+  const dimensions = useRef({ width: 0, height: 0 });
+  useEffect3(() => {
+    if (ref.current) {
+      dimensions.current.width = ref.current.offsetWidth;
+      dimensions.current.height = ref.current.offsetHeight;
+    }
+  }, [ref]);
+  return dimensions.current;
+}
+
+// src/device/useReducedMotion.ts
+import { useEffect as useEffect4, useState as useState3 } from "react";
+function useReducedMotion() {
+  const [prefersReducedMotion, setPrefersReducedMotion] = useState3(() => {
+    if (typeof window !== "undefined") {
+      const stored = localStorage.getItem("pol-reduced-motion");
+      if (stored === "true") return true;
+      if (stored === "false") return false;
+      return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+    }
+    return false;
+  });
+  useEffect4(() => {
+    if (typeof window === "undefined") return;
+    const mediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
+    const handleChange = () => {
+      const stored = localStorage.getItem("pol-reduced-motion");
+      if (stored === null) {
+        setPrefersReducedMotion(mediaQuery.matches);
+      }
+    };
+    if (mediaQuery.addEventListener) {
+      mediaQuery.addEventListener("change", handleChange);
+      return () => mediaQuery.removeEventListener("change", handleChange);
+    } else {
+      mediaQuery.addListener(handleChange);
+      return () => mediaQuery.removeListener(handleChange);
+    }
+  }, []);
+  return prefersReducedMotion;
+}
+function setReducedMotionPreference(enabled) {
+  if (typeof window === "undefined") return;
+  if (enabled === null) {
+    localStorage.removeItem("pol-reduced-motion");
+  } else {
+    localStorage.setItem("pol-reduced-motion", enabled ? "true" : "false");
+  }
+  window.dispatchEvent(new CustomEvent("pol-reduced-motion-changed", {
+    detail: { enabled }
+  }));
+}
+
+export {
+  useWindowDimensions,
+  useMobile,
+  useIsMobile,
+  useDevice,
+  useTheme,
+  useThemeDetector,
+  useDimensions,
+  useReducedMotion,
+  setReducedMotionPreference
+};

package/dist/chunk-BHNC4MM6.js

@@ -0,0 +1,29 @@
+// src/form/OnValueChangedContext.tsx
+import { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var OnValueChangedContext = createContext({
+  trigger: "change"
+});
+var OnValueChangedContextProvider = ({
+  children,
+  trigger
+}) => {
+  return /* @__PURE__ */ jsx(
+    OnValueChangedContext.Provider,
+    {
+      value: {
+        trigger
+      },
+      children
+    }
+  );
+};
+var OnValueChangedTriggerContext = OnValueChangedContext;
+var OnValueChangedTriggerContextProvider = OnValueChangedContextProvider;
+
+export {
+  OnValueChangedContext,
+  OnValueChangedContextProvider,
+  OnValueChangedTriggerContext,
+  OnValueChangedTriggerContextProvider
+};

package/dist/chunk-BKB34ZQJ.js

@@ -0,0 +1,41 @@
+import {
+  getFilePost
+} from "./chunk-MMIPLCL4.js";
+
+// src/file/useFileDialog.ts
+import { useCallback } from "react";
+function useFileDialog() {
+  const openFileDialog = useCallback(() => {
+    return new Promise((resolve) => {
+      const fileInput = document.createElement("input");
+      fileInput.type = "file";
+      fileInput.style.display = "none";
+      document.body.appendChild(fileInput);
+      fileInput.onchange = () => {
+        resolve(fileInput.files);
+        document.body.removeChild(fileInput);
+      };
+      fileInput.click();
+    });
+  }, []);
+  return { openFileDialog };
+}
+
+// src/file/useDownload.ts
+import { useCallback as useCallback2 } from "react";
+function useDownload() {
+  const download = useCallback2(
+    async ({ url, fileName, queryParams }) => {
+      await getFilePost(url, fileName, queryParams);
+    },
+    []
+  );
+  return download;
+}
+var useDownloadApiFile = useDownload;
+
+export {
+  useFileDialog,
+  useDownload,
+  useDownloadApiFile
+};

package/dist/chunk-EVE7TM7O.js

@@ -0,0 +1,67 @@
+// src/lifecycle/useMounted.ts
+import { useCallback, useEffect, useRef } from "react";
+function useMounted() {
+  const isMounted = useRef(false);
+  useEffect(() => {
+    isMounted.current = true;
+    return () => {
+      isMounted.current = false;
+    };
+  }, []);
+  return useCallback(() => isMounted.current, []);
+}
+
+// src/lifecycle/useAfterMountedEffect.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+function useAfterMountedEffect(effect, deps) {
+  const isMounted = useRef2(false);
+  const strictModeFirstRun = useRef2(true);
+  useEffect2(() => {
+    if (process.env.NODE_ENV !== "production" && strictModeFirstRun.current) {
+      strictModeFirstRun.current = false;
+      return;
+    }
+    if (isMounted.current) {
+      effect();
+    }
+    isMounted.current = true;
+  }, deps);
+}
+
+// src/lifecycle/useOnScreen.ts
+import { useEffect as useEffect3, useRef as useRef3, useState } from "react";
+function useOnScreen(ref, rootMargin = "0px") {
+  const [isIntersecting, setIntersecting] = useState(false);
+  const observerRef = useRef3(null);
+  useEffect3(() => {
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+    }
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        setIntersecting(entry.isIntersecting);
+      },
+      {
+        rootMargin,
+        threshold: 0.1
+        // Trigger when 10% of element is visible
+      }
+    );
+    observerRef.current = observer;
+    if (ref.current) {
+      observer.observe(ref.current);
+    }
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, [ref, rootMargin]);
+  return isIntersecting;
+}
+
+export {
+  useMounted,
+  useAfterMountedEffect,
+  useOnScreen
+};

package/dist/chunk-EZXGO56T.js

@@ -0,0 +1,370 @@
+import {
+  indexDbContext,
+  useLocalStorageService
+} from "./chunk-OF7JZIAL.js";
+import {
+  useAfterMountedEffect
+} from "./chunk-EVE7TM7O.js";
+import {
+  dateReviver,
+  isUsable
+} from "./chunk-MMIPLCL4.js";
+
+// src/storage/useLocalStorage.ts
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState
+} from "react";
+function useLocalStorage(key, initialValue) {
+  const localStorageService = useLocalStorageService();
+  const [stateValue, setStateValue] = useState(initialValue);
+  const [isInitializing, setIsInitializing] = useState(true);
+  useLayoutEffect(() => {
+    setIsInitializing(true);
+    localStorageService.getItem(key).then((cachedValue) => {
+      if (isUsable(cachedValue) === false) {
+        setStateValue(initialValue);
+        setIsInitializing(false);
+        return;
+      }
+      if (cachedValue != stateValue) {
+        setStateValue(cachedValue);
+        setIsInitializing(false);
+      }
+    });
+  }, [key]);
+  const save = useRef(false);
+  const setLocalValue = useCallback(
+    (value) => {
+      save.current = true;
+      setStateValue(value);
+    },
+    [localStorageService]
+  );
+  useEffect(() => {
+    if (save.current === false) return;
+    if (isUsable(stateValue) == false) {
+      localStorageService.removeItem(key);
+    } else {
+      localStorageService.setItem(key, stateValue);
+    }
+    save.current = false;
+  }, [stateValue]);
+  const storageEventHandler = useCallback(() => {
+    localStorageService.getItem(key).then((cachedValue) => {
+      if (isUsable(cachedValue) === false) setStateValue(initialValue);
+      if (cachedValue != stateValue) {
+        setStateValue(cachedValue);
+      }
+    });
+  }, [setStateValue, key, stateValue]);
+  useEffect(() => {
+    const handler = localStorageService.addItemChangeListener(
+      key,
+      storageEventHandler
+    );
+    return () => {
+      localStorageService.removeItemChangeListener(
+        key,
+        handler
+      );
+    };
+  }, [storageEventHandler]);
+  return [stateValue, setLocalValue, isInitializing];
+}
+var useLocalStorageState = useLocalStorage;
+
+// src/storage/useSessionStorage.ts
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+function replacer(key, value) {
+  if (value instanceof Map) {
+    return { dataType: "Map", value: Array.from(value.entries()) };
+  }
+  return value;
+}
+function reviver(key, value) {
+  if (value?.dataType === "Map") {
+    return new Map(value.value);
+  }
+  return dateReviver(key, value);
+}
+function useSessionStorage(key, initialValue) {
+  const isBrowser2 = typeof window !== "undefined" && !!window.sessionStorage;
+  const [state, setState] = useState2(() => {
+    if (!isBrowser2) return initialValue;
+    try {
+      const raw = sessionStorage.getItem(key);
+      if (!isUsable(raw)) return initialValue;
+      const parsed = JSON.parse(raw, reviver);
+      return isUsable(parsed) ? parsed : initialValue;
+    } catch {
+      return initialValue;
+    }
+  });
+  const lastRawRef = useRef2(
+    isBrowser2 ? sessionStorage.getItem(key) : null
+  );
+  const timeoutRef = useRef2(null);
+  useAfterMountedEffect(() => {
+    if (!isBrowser2) return;
+    const raw = sessionStorage.getItem(key);
+    if (raw === lastRawRef.current) return;
+    lastRawRef.current = raw;
+    let next = initialValue;
+    if (isUsable(raw)) {
+      try {
+        const parsed = JSON.parse(raw, reviver);
+        if (isUsable(parsed)) next = parsed;
+      } catch {
+      }
+    }
+    setState(next);
+  }, [key]);
+  useEffect2(() => {
+    if (!isBrowser2) return;
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+    }
+    timeoutRef.current = setTimeout(() => {
+      try {
+        let serialized;
+        try {
+          serialized = isUsable(state) ? JSON.stringify(state, replacer) : null;
+        } catch {
+          serialized = null;
+        }
+        if (!serialized) {
+          sessionStorage.removeItem(key);
+          lastRawRef.current = null;
+        } else {
+          sessionStorage.setItem(key, serialized);
+          lastRawRef.current = serialized;
+        }
+      } catch (error) {
+        console.warn("Failed to save to session storage:", error);
+      }
+      timeoutRef.current = null;
+    }, 100);
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, [key, state, isBrowser2]);
+  return [state, setState];
+}
+var useSessionStorageState = useSessionStorage;
+
+// src/storage/useIndexedDB.ts
+import { useContext } from "react";
+function useIndexedDB(options) {
+  const context = useContext(indexDbContext);
+  return Array.from(context.services).find(
+    (x) => x[0].dbName === options.dbName && x[0].storeName === options.storeName
+  )[1];
+}
+
+// src/storage/useQueuedLocalStorage.ts
+import { useCallback as useCallback2, useRef as useRef3 } from "react";
+function useQueuedLocalStorage(storageKey, initialState) {
+  const [state, setState, isInitializing] = useLocalStorage(
+    storageKey,
+    initialState
+  );
+  const queue = useRef3([]);
+  const processing = useRef3(false);
+  const processQueue = useCallback2(async () => {
+    if (processing.current) return;
+    processing.current = true;
+    while (queue.current.length > 0) {
+      const updateFn = queue.current.shift();
+      setState(updateFn);
+      await new Promise(requestAnimationFrame);
+    }
+    processing.current = false;
+  }, []);
+  const enqueue = useCallback2(
+    (updateFn) => {
+      queue.current.push(updateFn);
+      processQueue();
+    },
+    [processQueue]
+  );
+  return [state, enqueue, isInitializing];
+}
+var useQueuedLocalStorageState = useQueuedLocalStorage;
+
+// src/storage/LocalStorageService.ts
+function replacer2(key, value) {
+  if (value instanceof Map) {
+    return {
+      dataType: "Map",
+      value: Array.from(value.entries())
+    };
+  } else {
+    return value;
+  }
+}
+function reviver2(key, value) {
+  if (typeof value === "object" && value !== null) {
+    if (value.dataType === "Map") {
+      return new Map(value.value);
+    }
+  }
+  return dateReviver(key, value);
+}
+var isBrowser = typeof window !== "undefined" && typeof window.addEventListener === "function" && typeof localStorage !== "undefined";
+var LocalStorageService = class {
+  constructor() {
+  }
+  addItemChangeListener(key, handler) {
+    if (!isBrowser) return () => {
+    };
+    const response = () => {
+      const newValue = localStorage.getItem(key);
+      handler({ key, newValue });
+    };
+    window.addEventListener(key, response);
+    return response;
+  }
+  removeItemChangeListener(key, handler) {
+    if (!isBrowser) return;
+    window.removeEventListener(key, handler);
+  }
+  async setItem(key, value) {
+    if (!isBrowser) return;
+    localStorage.setItem(key, JSON.stringify(value, replacer2));
+    window.dispatchEvent(new Event(key));
+  }
+  async getItem(key) {
+    if (!isBrowser) return null;
+    const storedValue = localStorage.getItem(key);
+    try {
+      return storedValue ? JSON.parse(storedValue, reviver2) : null;
+    } catch (e) {
+      console.log("error", e, storedValue);
+      localStorage.removeItem(key);
+      return null;
+    }
+  }
+  removeItem(key) {
+    if (!isBrowser) return;
+    localStorage.removeItem(key);
+    window.dispatchEvent(new Event(key));
+  }
+};
+
+// src/storage/IndexedDBService.ts
+var storeNames = ["cached-urls", "metadata"];
+var version = 5;
+var IndexedDBService = class {
+  dbName;
+  storeName;
+  db = null;
+  constructor(options) {
+    this.dbName = options.dbName;
+    this.storeName = options.storeName;
+  }
+  openDB() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, version);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        storeNames.forEach((storeName) => {
+          if (!db.objectStoreNames.contains(storeName)) {
+            db.createObjectStore(storeName);
+          }
+        });
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve(this.db);
+      };
+      request.onerror = (event) => {
+        reject(event.target.error);
+      };
+    });
+  }
+  getDB() {
+    if (this.db) {
+      return Promise.resolve(this.db);
+    } else {
+      return this.openDB();
+    }
+  }
+  async setItem(key, record) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      try {
+        const request = store.put(record, key);
+        request.onsuccess = () => {
+          resolve();
+        };
+        request.onerror = () => {
+          reject(request.error);
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  async getItem(key) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.storeName, "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get(key);
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+  async removeItem(key) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.storeName, "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.delete(key);
+      request.onsuccess = () => {
+        resolve();
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+  async getAllKeys() {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(this.storeName, "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.getAllKeys();
+      request.onsuccess = () => {
+        resolve(request.result);
+      };
+      request.onerror = () => {
+        reject(request.error);
+      };
+    });
+  }
+};
+
+export {
+  useLocalStorage,
+  useLocalStorageState,
+  useSessionStorage,
+  useSessionStorageState,
+  useIndexedDB,
+  useQueuedLocalStorage,
+  useQueuedLocalStorageState,
+  LocalStorageService,
+  IndexedDBService
+};