@pol-studios/hooks 1.0.0

package/dist/chunk-OF7JZIAL.js

@@ -0,0 +1,39 @@
+// src/storage/providers.tsx
+import { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var localStorageContext = createContext({});
+function LocalStorageProvider({
+  children,
+  value
+}) {
+  return /* @__PURE__ */ jsx(localStorageContext.Provider, { value, children });
+}
+var indexDbContext = createContext(
+  {}
+);
+function IndexDbProvider({
+  children,
+  value
+}) {
+  return /* @__PURE__ */ jsx(indexDbContext.Provider, { value: { services: value }, children });
+}
+
+// src/storage/useLocalStorageService.ts
+import { useContext } from "react";
+function useLocalStorageService() {
+  const context = useContext(localStorageContext);
+  if (context === null) {
+    throw new Error(
+      "useLocalStorageService should be used inside of LocalStorageProvider"
+    );
+  }
+  return context;
+}
+
+export {
+  localStorageContext,
+  LocalStorageProvider,
+  indexDbContext,
+  IndexDbProvider,
+  useLocalStorageService
+};

package/dist/chunk-QGM4M3NI.js

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-RX4FIJI6.js

@@ -0,0 +1,130 @@
+// src/state/usePartialState.ts
+import { useState } from "react";
+function usePartialState(initialState) {
+  const [state, setState] = useState(initialState);
+  const patch = (newProps) => {
+    setState((prev) => {
+      return { ...prev, ...newProps };
+    });
+  };
+  return { state, patch, setState };
+}
+
+// src/state/useQueuedState.ts
+import { useCallback, useRef, useState as useState2 } from "react";
+function useQueuedState(initialState) {
+  const [state, setState] = useState2(initialState);
+  const queue = useRef([]);
+  const processing = useRef(false);
+  const processQueue = useCallback(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 = useCallback((updateFn) => {
+    queue.current.push(updateFn);
+    processQueue();
+  }, [processQueue]);
+  return [state, enqueue];
+}
+
+// src/state/useDelayedValue.ts
+import { useEffect, useState as useState3 } from "react";
+function useDelayedValue(value, delayInMs) {
+  const [delayedValue, setDelayedValue] = useState3(value);
+  useEffect(() => {
+    const timeout = setTimeout(() => {
+      setDelayedValue(value);
+    }, delayInMs);
+    return () => {
+      clearTimeout(timeout);
+    };
+  }, [value]);
+  return delayedValue;
+}
+var useDelayedState = useDelayedValue;
+
+// src/state/useChangeTracking.ts
+import { useLayoutEffect, useState as useState4 } from "react";
+function useChangeTracking(initialValue) {
+  const [value, setValue] = useState4(initialValue);
+  const [propertiesChanged, setPropertiesChanged] = useState4(
+    /* @__PURE__ */ new Set()
+  );
+  useLayoutEffect(() => {
+    setValue(initialValue);
+    setPropertiesChanged(/* @__PURE__ */ new Set());
+  }, [initialValue]);
+  function update(newProps) {
+    setValue((prev) => {
+      const updatedObject = { ...prev, ...newProps };
+      setPropertiesChanged((prev2) => {
+        const updatedProperties = new Set(prev2);
+        if (initialValue) {
+          Object.keys(newProps).forEach((propertyName) => {
+            const originalValue = initialValue[propertyName];
+            const newValue = updatedObject[propertyName];
+            if (originalValue !== newValue) {
+              updatedProperties.add(propertyName);
+            } else {
+              updatedProperties.delete(propertyName);
+            }
+          });
+        }
+        return updatedProperties;
+      });
+      return updatedObject;
+    });
+  }
+  return { initialValue, update, value, propertiesChanged };
+}
+
+// src/state/useForceUpdate.ts
+import { useState as useState5, useCallback as useCallback2 } from "react";
+function useForceUpdate() {
+  const [, setState] = useState5(0);
+  return useCallback2(() => setState((prev) => prev + 1), []);
+}
+
+// src/state/ChangeTrackingContext.tsx
+import { createContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var defaultValue = {
+  initialValue: {},
+  value: {},
+  onChange: (newValue) => {
+  },
+  propertiesChanged: /* @__PURE__ */ new Set()
+};
+var ChangeTrackingContext = createContext(defaultValue);
+function ChangeTrackingProvider({ children, initialValue }) {
+  return /* @__PURE__ */ jsx(
+    ChangeTrackingContext.Provider,
+    {
+      value: {
+        initialValue,
+        value: null,
+        propertiesChanged: /* @__PURE__ */ new Set(),
+        onChange: (newValue) => {
+        }
+      },
+      children
+    }
+  );
+}
+
+export {
+  usePartialState,
+  useQueuedState,
+  useDelayedValue,
+  useDelayedState,
+  useChangeTracking,
+  useForceUpdate,
+  ChangeTrackingContext,
+  ChangeTrackingProvider
+};

package/dist/chunk-VVFZ7HTT.js

@@ -0,0 +1,133 @@
+// src/toast/useToast.ts
+import * as React from "react";
+var TOAST_LIMIT = 1;
+var TOAST_REMOVE_DELAY = 1e6;
+var count = 0;
+function genId() {
+  count = (count + 1) % Number.MAX_VALUE;
+  return count.toString();
+}
+var toastTimeouts = /* @__PURE__ */ new Map();
+var addToRemoveQueue = (toastId) => {
+  if (toastTimeouts.has(toastId)) {
+    return;
+  }
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId);
+    dispatch({
+      type: "REMOVE_TOAST",
+      toastId
+    });
+  }, TOAST_REMOVE_DELAY);
+  toastTimeouts.set(toastId, timeout);
+};
+var reducer = (state, action) => {
+  switch (action.type) {
+    case "ADD_TOAST":
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT)
+      };
+    case "UPDATE_TOAST":
+      return {
+        ...state,
+        toasts: state.toasts.map((t) => t.id === action.toast.id ? { ...t, ...action.toast } : t)
+      };
+    case "DISMISS_TOAST": {
+      const { toastId } = action;
+      if (toastId) {
+        addToRemoveQueue(toastId);
+      } else {
+        state.toasts.forEach((toast2) => {
+          addToRemoveQueue(toast2.id);
+        });
+      }
+      return {
+        ...state,
+        toasts: state.toasts.map(
+          (t) => t.id === toastId || toastId === void 0 ? {
+            ...t,
+            open: false
+          } : t
+        )
+      };
+    }
+    case "REMOVE_TOAST":
+      if (action.toastId === void 0) {
+        return {
+          ...state,
+          toasts: []
+        };
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId)
+      };
+  }
+};
+var listeners = [];
+var memoryState = { toasts: [] };
+function dispatch(action) {
+  memoryState = reducer(memoryState, action);
+  listeners.forEach((listener) => {
+    listener(memoryState);
+  });
+}
+function toast({ ...props }) {
+  const id = genId();
+  const update = (props2) => dispatch({
+    type: "UPDATE_TOAST",
+    toast: { ...props2, id }
+  });
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id });
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open) dismiss();
+      }
+    }
+  });
+  return {
+    id,
+    dismiss,
+    update
+  };
+}
+function useToast() {
+  const [state, setState] = React.useState(memoryState);
+  React.useEffect(() => {
+    listeners.push(setState);
+    return () => {
+      const index = listeners.indexOf(setState);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  }, [state]);
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId) => dispatch({ type: "DISMISS_TOAST", toastId })
+  };
+}
+var useToast_default = useToast;
+
+// src/toast/types.ts
+var actionTypes = {
+  ADD_TOAST: "ADD_TOAST",
+  UPDATE_TOAST: "UPDATE_TOAST",
+  DISMISS_TOAST: "DISMISS_TOAST",
+  REMOVE_TOAST: "REMOVE_TOAST"
+};
+
+export {
+  reducer,
+  toast,
+  useToast,
+  useToast_default,
+  actionTypes
+};

package/dist/chunk-XIISC67B.js

@@ -0,0 +1,67 @@
+import {
+  isDevEnvironment
+} from "./chunk-MMIPLCL4.js";
+
+// src/debug/useRenderCount.ts
+import { useEffect, useRef } from "react";
+var useRenderCount = () => {
+  const renderCountRef = useRef(0);
+  useEffect(() => {
+    renderCountRef.current += 1;
+  });
+  return renderCountRef.current;
+};
+var useRenderCount_default = useRenderCount;
+
+// src/debug/useRenderHookCount.ts
+import { useState, useEffect as useEffect2 } from "react";
+var useRenderHookCount = (hook) => {
+  const [count, setCount] = useState(0);
+  useEffect2(() => {
+    setCount((prevCount) => prevCount + 1);
+  }, [hook]);
+  return count;
+};
+var useRenderHookCount_default = useRenderHookCount;
+
+// src/debug/useStateTracker.ts
+import { useEffect as useEffect3 } from "react";
+function useStateTracker(state) {
+  if (isDevEnvironment() === false) {
+    return;
+  }
+  useEffect3(() => {
+    console.log("State changed:", state);
+  }, [state]);
+}
+
+// src/debug/useTrackedState.ts
+import { useMemo, useState as useState2 } from "react";
+function useTrackedState(initialValue, hookName) {
+  const [state, setState] = useState2(initialValue);
+  const setTrackedState = useMemo(
+    () => (newValue) => {
+      setState((oldValue) => {
+        const stack = new Error().stack;
+        if (newValue !== oldValue) {
+          console.log(
+            `${hookName} changed from ${JSON.stringify(oldValue)} to ${JSON.stringify(newValue)} from ${stack}`
+          );
+          return newValue;
+        } else {
+          console.log(`${hookName} did not change from ${JSON.stringify(oldValue)} to ${JSON.stringify(newValue)}`);
+          return oldValue;
+        }
+      });
+    },
+    [setState, hookName]
+  );
+  return [state, setTrackedState];
+}
+
+export {
+  useRenderCount_default,
+  useRenderHookCount_default,
+  useStateTracker,
+  useTrackedState
+};

package/dist/debug/index.js

@@ -0,0 +1,14 @@
+import {
+  useRenderCount_default,
+  useRenderHookCount_default,
+  useStateTracker,
+  useTrackedState
+} from "../chunk-XIISC67B.js";
+import "../chunk-MMIPLCL4.js";
+import "../chunk-QGM4M3NI.js";
+export {
+  useRenderCount_default as useRenderCount,
+  useRenderHookCount_default as useRenderHookCount,
+  useStateTracker,
+  useTrackedState
+};

package/dist/device/index.js

@@ -0,0 +1,24 @@
+import {
+  setReducedMotionPreference,
+  useDevice,
+  useDimensions,
+  useIsMobile,
+  useMobile,
+  useReducedMotion,
+  useTheme,
+  useThemeDetector,
+  useWindowDimensions
+} from "../chunk-AIS4L5ID.js";
+import "../chunk-MMIPLCL4.js";
+import "../chunk-QGM4M3NI.js";
+export {
+  setReducedMotionPreference,
+  useDevice,
+  useDimensions,
+  useIsMobile,
+  useMobile,
+  useReducedMotion,
+  useTheme,
+  useThemeDetector,
+  useWindowDimensions
+};

package/dist/file/index.js

@@ -0,0 +1,12 @@
+import {
+  useDownload,
+  useDownloadApiFile,
+  useFileDialog
+} from "../chunk-BKB34ZQJ.js";
+import "../chunk-MMIPLCL4.js";
+import "../chunk-QGM4M3NI.js";
+export {
+  useDownload,
+  useDownloadApiFile,
+  useFileDialog
+};

package/dist/form/index.js

@@ -0,0 +1,13 @@
+import {
+  OnValueChangedContext,
+  OnValueChangedContextProvider,
+  OnValueChangedTriggerContext,
+  OnValueChangedTriggerContextProvider
+} from "../chunk-BHNC4MM6.js";
+import "../chunk-QGM4M3NI.js";
+export {
+  OnValueChangedContext,
+  OnValueChangedContextProvider,
+  OnValueChangedTriggerContext,
+  OnValueChangedTriggerContextProvider
+};

package/dist/index.js

@@ -0,0 +1,192 @@
+import {
+  actionTypes,
+  reducer,
+  toast,
+  useToast
+} from "./chunk-VVFZ7HTT.js";
+import {
+  OnValueChangedContext,
+  OnValueChangedContextProvider,
+  OnValueChangedTriggerContext,
+  OnValueChangedTriggerContextProvider
+} from "./chunk-BHNC4MM6.js";
+import {
+  useRenderCount_default,
+  useRenderHookCount_default,
+  useStateTracker,
+  useTrackedState
+} from "./chunk-XIISC67B.js";
+import {
+  ChangeTrackingContext,
+  ChangeTrackingProvider,
+  useChangeTracking,
+  useDelayedState,
+  useDelayedValue,
+  useForceUpdate,
+  usePartialState,
+  useQueuedState
+} from "./chunk-RX4FIJI6.js";
+import {
+  useHideOnScroll,
+  useHidingOnScroll,
+  useScrollDirection,
+  useScrollPosition,
+  useScrollRestoration
+} from "./chunk-GKXIKVGH.js";
+import {
+  IndexedDBService,
+  LocalStorageService,
+  useIndexedDB,
+  useLocalStorage,
+  useLocalStorageState,
+  useQueuedLocalStorage,
+  useQueuedLocalStorageState,
+  useSessionStorage,
+  useSessionStorageState
+} from "./chunk-EZXGO56T.js";
+import {
+  setReducedMotionPreference,
+  useDevice,
+  useDimensions,
+  useIsMobile,
+  useMobile,
+  useReducedMotion,
+  useTheme,
+  useThemeDetector,
+  useWindowDimensions
+} from "./chunk-AIS4L5ID.js";
+import {
+  useMutationQueue,
+  useNetworkStatus,
+  useOnline
+} from "./chunk-IFSEJVAF.js";
+import {
+  IndexDbProvider,
+  LocalStorageProvider,
+  indexDbContext,
+  localStorageContext,
+  useLocalStorageService
+} from "./chunk-OF7JZIAL.js";
+import {
+  useAfterMountedEffect,
+  useMounted,
+  useOnScreen
+} from "./chunk-EVE7TM7O.js";
+import {
+  useDownload,
+  useDownloadApiFile,
+  useFileDialog
+} from "./chunk-BKB34ZQJ.js";
+import {
+  dateReviver,
+  downloadFile,
+  getFile,
+  getFilePost,
+  hasCameraAsync,
+  isDev,
+  isDevEnvironment,
+  isIphone,
+  isPwaLaunched,
+  isUsable,
+  parseWithDate,
+  withComponentMemo
+} from "./chunk-MMIPLCL4.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/index.ts
+import {
+  CommentProvider,
+  useComments
+} from "@pol-studios/features";
+import { useOrderManager } from "@pol-studios/features";
+import {
+  genId,
+  getDefaultCondition,
+  getDefaultValue,
+  getComparisonOptions,
+  FilterProvider,
+  useFilterContext
+} from "@pol-studios/features";
+export {
+  ChangeTrackingContext,
+  ChangeTrackingProvider,
+  CommentProvider as CommentSectionProvider,
+  FilterProvider,
+  IndexedDBService as IndexDb,
+  IndexDbProvider,
+  IndexedDBService,
+  LocalStorageProvider,
+  LocalStorageService,
+  OnValueChangedContext,
+  OnValueChangedContextProvider,
+  OnValueChangedTriggerContext,
+  OnValueChangedTriggerContextProvider,
+  actionTypes,
+  dateReviver,
+  downloadFile,
+  genId,
+  getComparisonOptions,
+  getDefaultCondition,
+  getDefaultValue,
+  getFile,
+  getFilePost,
+  hasCameraAsync,
+  indexDbContext,
+  isDev,
+  isDevEnvironment,
+  isIphone,
+  isPwaLaunched,
+  isUsable,
+  localStorageContext,
+  parseWithDate,
+  reducer,
+  setReducedMotionPreference,
+  toast,
+  useAfterMountedEffect as useAfterMount,
+  useAfterMountedEffect,
+  useChangeTracking,
+  useComments as useCommentSection,
+  useDelayedState,
+  useDelayedValue,
+  useDevice,
+  useDimensions,
+  useDownload,
+  useDownloadApiFile,
+  useFileDialog,
+  useFilterContext,
+  useForceUpdate,
+  useHideOnScroll,
+  useHidingOnScroll,
+  useIndexedDB as useIndexDbService,
+  useIndexedDB,
+  useIsMobile,
+  useLocalStorage,
+  useLocalStorageService,
+  useLocalStorageState,
+  useMobile,
+  useMounted,
+  useMutationQueue,
+  useNetworkStatus,
+  useOnScreen,
+  useOnline,
+  useOrderManager as useOrderHintOld,
+  usePartialState,
+  useQueuedLocalStorage,
+  useQueuedLocalStorageState,
+  useQueuedState,
+  useReducedMotion,
+  useRenderCount_default as useRenderCount,
+  useRenderHookCount_default as useRenderHookCount,
+  useScrollDirection,
+  useScrollPosition,
+  useScrollRestoration,
+  useSessionStorage,
+  useSessionStorageState,
+  useStateTracker,
+  useTheme,
+  useThemeDetector,
+  useToast,
+  useTrackedState,
+  useWindowDimensions,
+  withComponentMemo
+};

package/dist/lifecycle/index.js

@@ -0,0 +1,12 @@
+import {
+  useAfterMountedEffect,
+  useMounted,
+  useOnScreen
+} from "../chunk-EVE7TM7O.js";
+import "../chunk-QGM4M3NI.js";
+export {
+  useAfterMountedEffect as useAfterMount,
+  useAfterMountedEffect,
+  useMounted,
+  useOnScreen
+};

package/dist/network/index.js

@@ -0,0 +1,12 @@
+import {
+  useMutationQueue,
+  useNetworkStatus,
+  useOnline
+} from "../chunk-IFSEJVAF.js";
+import "../chunk-OF7JZIAL.js";
+import "../chunk-QGM4M3NI.js";
+export {
+  useMutationQueue,
+  useNetworkStatus,
+  useOnline
+};