@develemit/web-hooks 0.1.0 → 0.2.0

package/dist/outside-press.cjs

@@ -0,0 +1,66 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/outside-press/index.ts
+var outside_press_exports = {};
+__export(outside_press_exports, {
+  isOutside: () => isOutside,
+  isPrimaryPress: () => isPrimaryPress,
+  useOutsidePress: () => useOutsidePress
+});
+module.exports = __toCommonJS(outside_press_exports);
+
+// src/outside-press/outside-press.ts
+function isOutside(target, elements) {
+  if (!target) return false;
+  if (!target.isConnected) return false;
+  return !elements.some((el) => el?.contains(target));
+}
+function isPrimaryPress(event) {
+  return !(event.pointerType === "mouse" && event.button !== 0);
+}
+
+// src/outside-press/use-outside-press.ts
+var import_react = require("react");
+function useOutsidePress(refs, onOutsidePress, { enabled = true } = {}) {
+  const refsRef = (0, import_react.useRef)(refs);
+  const handlerRef = (0, import_react.useRef)(onOutsidePress);
+  (0, import_react.useEffect)(() => {
+    refsRef.current = refs;
+    handlerRef.current = onOutsidePress;
+  });
+  (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    function onPointerDown(event) {
+      if (!isPrimaryPress(event)) return;
+      const list = Array.isArray(refsRef.current) ? refsRef.current : [refsRef.current];
+      const elements = list.map((ref) => ref.current);
+      if (isOutside(event.target, elements)) handlerRef.current(event);
+    }
+    document.addEventListener("pointerdown", onPointerDown, true);
+    return () => document.removeEventListener("pointerdown", onPointerDown, true);
+  }, [enabled]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isOutside,
+  isPrimaryPress,
+  useOutsidePress
+});

package/dist/outside-press.d.cts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+
+declare function isOutside(target: Node | null, elements: (Element | null)[]): boolean;
+declare function isPrimaryPress(event: {
+    button?: number;
+    pointerType?: string;
+}): boolean;
+
+type ElementRef = RefObject<Element | null>;
+interface UseOutsidePressOptions {
+    enabled?: boolean;
+}
+declare function useOutsidePress(refs: ElementRef | ElementRef[], onOutsidePress: (event: PointerEvent) => void, { enabled }?: UseOutsidePressOptions): void;
+
+export { type UseOutsidePressOptions, isOutside, isPrimaryPress, useOutsidePress };

package/dist/outside-press.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+
+declare function isOutside(target: Node | null, elements: (Element | null)[]): boolean;
+declare function isPrimaryPress(event: {
+    button?: number;
+    pointerType?: string;
+}): boolean;
+
+type ElementRef = RefObject<Element | null>;
+interface UseOutsidePressOptions {
+    enabled?: boolean;
+}
+declare function useOutsidePress(refs: ElementRef | ElementRef[], onOutsidePress: (event: PointerEvent) => void, { enabled }?: UseOutsidePressOptions): void;
+
+export { type UseOutsidePressOptions, isOutside, isPrimaryPress, useOutsidePress };

package/dist/outside-press.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  isOutside,
+  isPrimaryPress,
+  useOutsidePress
+} from "./chunk-3UGRXQIA.js";
+export {
+  isOutside,
+  isPrimaryPress,
+  useOutsidePress
+};

package/dist/scroll-lock.cjs

@@ -0,0 +1,107 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scroll-lock/index.ts
+var scroll_lock_exports = {};
+__export(scroll_lock_exports, {
+  lockScroll: () => lockScroll,
+  unlockScroll: () => unlockScroll,
+  useScrollLock: () => useScrollLock
+});
+module.exports = __toCommonJS(scroll_lock_exports);
+
+// src/scroll-lock/use-scroll-lock.ts
+var import_react = require("react");
+
+// src/scroll-lock/lock-styles.ts
+var LOCKED_PROPERTIES = [
+  "position",
+  "top",
+  "left",
+  "right",
+  "width",
+  "overflow",
+  "paddingRight"
+];
+function computeLockStyles({ scrollY, scrollbarWidth, existingPaddingRight }) {
+  const styles = {
+    position: "fixed",
+    top: `-${scrollY}px`,
+    left: "0",
+    right: "0",
+    width: "100%",
+    overflow: "hidden"
+  };
+  if (scrollbarWidth > 0) styles.paddingRight = `${existingPaddingRight + scrollbarWidth}px`;
+  return styles;
+}
+
+// src/scroll-lock/scroll-lock.ts
+var count = 0;
+var saved = null;
+function applyFirstLock() {
+  const { body, documentElement } = document;
+  const inline = {};
+  for (const property of LOCKED_PROPERTIES) inline[property] = body.style[property];
+  saved = { scrollY: window.scrollY, inline };
+  const styles = computeLockStyles({
+    scrollY: saved.scrollY,
+    scrollbarWidth: Math.max(0, window.innerWidth - documentElement.clientWidth),
+    existingPaddingRight: parseFloat(getComputedStyle(body).paddingRight) || 0
+  });
+  Object.assign(body.style, styles);
+}
+function restoreLastLock() {
+  if (!saved) return;
+  const { scrollY, inline } = saved;
+  saved = null;
+  Object.assign(document.body.style, inline);
+  window.scrollTo(0, scrollY);
+}
+function lockScroll() {
+  if (count === 0) applyFirstLock();
+  count += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    count -= 1;
+    if (count === 0) restoreLastLock();
+  };
+}
+function unlockScroll() {
+  if (count === 0) return;
+  count -= 1;
+  if (count === 0) restoreLastLock();
+}
+
+// src/scroll-lock/use-scroll-lock.ts
+function useScrollLock(active = true) {
+  (0, import_react.useEffect)(() => {
+    if (!active) return;
+    return lockScroll();
+  }, [active]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lockScroll,
+  unlockScroll,
+  useScrollLock
+});

package/dist/scroll-lock.d.cts

@@ -0,0 +1,8 @@
+declare function useScrollLock(active?: boolean): void;
+
+/** Locks page scroll. Locks are counted; the returned release is safe to call twice. */
+declare function lockScroll(): () => void;
+/** Releases one lock taken with `lockScroll()` that was not released through its own function. */
+declare function unlockScroll(): void;
+
+export { lockScroll, unlockScroll, useScrollLock };

package/dist/scroll-lock.d.ts

@@ -0,0 +1,8 @@
+declare function useScrollLock(active?: boolean): void;
+
+/** Locks page scroll. Locks are counted; the returned release is safe to call twice. */
+declare function lockScroll(): () => void;
+/** Releases one lock taken with `lockScroll()` that was not released through its own function. */
+declare function unlockScroll(): void;
+
+export { lockScroll, unlockScroll, useScrollLock };

package/dist/scroll-lock.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  lockScroll,
+  unlockScroll,
+  useScrollLock
+} from "./chunk-6KCRVSLS.js";
+export {
+  lockScroll,
+  unlockScroll,
+  useScrollLock
+};

package/dist/storage-state.cjs

@@ -0,0 +1,161 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage-state/index.ts
+var storage_state_exports = {};
+__export(storage_state_exports, {
+  useStorageState: () => useStorageState
+});
+module.exports = __toCommonJS(storage_state_exports);
+
+// src/storage-state/use-storage-state.ts
+var import_react = require("react");
+
+// src/storage-state/storage-store.ts
+function getStorage(kind) {
+  try {
+    if (typeof window === "undefined") return null;
+    return kind === "session" ? window.sessionStorage : window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function readRaw(storage, key) {
+  try {
+    return storage ? storage.getItem(key) : null;
+  } catch {
+    return null;
+  }
+}
+function writeRaw(storage, key, value) {
+  try {
+    if (!storage) return false;
+    storage.setItem(key, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeRaw(storage, key) {
+  try {
+    if (!storage) return false;
+    storage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseOr(raw, parse, fallback) {
+  if (raw === null) return fallback;
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+var slot = (kind, key) => `${kind}\0${key}`;
+var memory = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Map();
+function readCurrent(kind, key) {
+  const held = memory.get(slot(kind, key));
+  if (held !== void 0) return held;
+  return readRaw(getStorage(kind), key);
+}
+function notify(id) {
+  for (const listener of [...listeners.get(id) ?? []]) listener();
+}
+function writeCurrent(kind, key, raw) {
+  const id = slot(kind, key);
+  if (writeRaw(getStorage(kind), key, raw)) memory.delete(id);
+  else memory.set(id, raw);
+  notify(id);
+}
+function removeCurrent(kind, key) {
+  const id = slot(kind, key);
+  if (removeRaw(getStorage(kind), key)) memory.delete(id);
+  else memory.set(id, null);
+  notify(id);
+}
+function onStorageEvent(event) {
+  const kinds = [];
+  if (!event.storageArea || event.storageArea === getStorage("local")) kinds.push("local");
+  if (!event.storageArea || event.storageArea === getStorage("session")) kinds.push("session");
+  for (const id of [...listeners.keys()]) {
+    const [kind, key] = id.split("\0");
+    if (!kinds.includes(kind)) continue;
+    if (event.key !== null && event.key !== key) continue;
+    memory.delete(id);
+    notify(id);
+  }
+}
+function subscribeToKey(kind, key, listener) {
+  const id = slot(kind, key);
+  const wasEmpty = listeners.size === 0;
+  let set = listeners.get(id);
+  if (!set) listeners.set(id, set = /* @__PURE__ */ new Set());
+  set.add(listener);
+  if (wasEmpty) window.addEventListener("storage", onStorageEvent);
+  return () => {
+    const current = listeners.get(id);
+    current?.delete(listener);
+    if (current?.size === 0) listeners.delete(id);
+    if (listeners.size === 0) window.removeEventListener("storage", onStorageEvent);
+  };
+}
+
+// src/storage-state/use-storage-state.ts
+function useStorageState(key, defaultValue, options = {}) {
+  const kind = options.storage ?? "local";
+  const serialize = options.serialize ?? JSON.stringify;
+  const parse = options.parse ?? JSON.parse;
+  const latest = (0, import_react.useRef)({ serialize, parse, defaultValue });
+  (0, import_react.useEffect)(() => {
+    latest.current = { serialize, parse, defaultValue };
+  });
+  const cache = (0, import_react.useRef)(null);
+  const subscribe = (0, import_react.useCallback)((onChange) => subscribeToKey(kind, key, onChange), [kind, key]);
+  const getSnapshot = (0, import_react.useCallback)(() => {
+    const raw = readCurrent(kind, key);
+    const hit = cache.current;
+    if (hit && hit.kind === kind && hit.key === key && hit.raw === raw && hit.parse === parse) return hit.value;
+    const value2 = parseOr(raw, parse, defaultValue);
+    cache.current = { kind, key, raw, parse, value: value2 };
+    return value2;
+  }, [kind, key, parse, defaultValue]);
+  const getServerSnapshot = (0, import_react.useCallback)(() => defaultValue, [defaultValue]);
+  const value = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getServerSnapshot);
+  const set = (0, import_react.useCallback)(
+    (next) => {
+      const { serialize: encode, parse: decode, defaultValue: fallback } = latest.current;
+      try {
+        const resolved = typeof next === "function" ? next(parseOr(readCurrent(kind, key), decode, fallback)) : next;
+        writeCurrent(kind, key, encode(resolved));
+      } catch {
+      }
+    },
+    [kind, key]
+  );
+  const remove = (0, import_react.useCallback)(() => removeCurrent(kind, key), [kind, key]);
+  return [value, set, remove];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useStorageState
+});

package/dist/storage-state.d.cts

@@ -0,0 +1,14 @@
+type StorageKind = 'local' | 'session';
+
+interface UseStorageStateOptions<T> {
+    /** `'local'` (default) or `'session'`. */
+    storage?: StorageKind;
+    /** Default `JSON.stringify`. */
+    serialize?: (value: T) => string;
+    /** Default `JSON.parse`. A throw returns `defaultValue`. */
+    parse?: (raw: string) => T;
+}
+type StorageStateSetter<T> = (next: T | ((prev: T) => T)) => void;
+declare function useStorageState<T>(key: string, defaultValue: T, options?: UseStorageStateOptions<T>): readonly [T, StorageStateSetter<T>, () => void];
+
+export { type StorageKind, type StorageStateSetter, type UseStorageStateOptions, useStorageState };

package/dist/storage-state.d.ts

@@ -0,0 +1,14 @@
+type StorageKind = 'local' | 'session';
+
+interface UseStorageStateOptions<T> {
+    /** `'local'` (default) or `'session'`. */
+    storage?: StorageKind;
+    /** Default `JSON.stringify`. */
+    serialize?: (value: T) => string;
+    /** Default `JSON.parse`. A throw returns `defaultValue`. */
+    parse?: (raw: string) => T;
+}
+type StorageStateSetter<T> = (next: T | ((prev: T) => T)) => void;
+declare function useStorageState<T>(key: string, defaultValue: T, options?: UseStorageStateOptions<T>): readonly [T, StorageStateSetter<T>, () => void];
+
+export { type StorageKind, type StorageStateSetter, type UseStorageStateOptions, useStorageState };

package/dist/storage-state.js

@@ -0,0 +1,7 @@
+"use client";
+import {
+  useStorageState
+} from "./chunk-5KIH2XLV.js";
+export {
+  useStorageState
+};

package/dist/unsaved-guard.cjs

@@ -0,0 +1,48 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/unsaved-guard/index.ts
+var unsaved_guard_exports = {};
+__export(unsaved_guard_exports, {
+  handleBeforeUnload: () => handleBeforeUnload,
+  useUnsavedChangesGuard: () => useUnsavedChangesGuard
+});
+module.exports = __toCommonJS(unsaved_guard_exports);
+
+// src/unsaved-guard/handle-before-unload.ts
+function handleBeforeUnload(event) {
+  event.preventDefault();
+  event.returnValue = "";
+}
+
+// src/unsaved-guard/use-unsaved-changes-guard.ts
+var import_react = require("react");
+function useUnsavedChangesGuard(dirty) {
+  (0, import_react.useEffect)(() => {
+    if (!dirty) return;
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => window.removeEventListener("beforeunload", handleBeforeUnload);
+  }, [dirty]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleBeforeUnload,
+  useUnsavedChangesGuard
+});

package/dist/unsaved-guard.d.cts

@@ -0,0 +1,5 @@
+declare function handleBeforeUnload(event: BeforeUnloadEvent): void;
+
+declare function useUnsavedChangesGuard(dirty: boolean): void;
+
+export { handleBeforeUnload, useUnsavedChangesGuard };

package/dist/unsaved-guard.d.ts

@@ -0,0 +1,5 @@
+declare function handleBeforeUnload(event: BeforeUnloadEvent): void;
+
+declare function useUnsavedChangesGuard(dirty: boolean): void;
+
+export { handleBeforeUnload, useUnsavedChangesGuard };

package/dist/unsaved-guard.js

@@ -0,0 +1,9 @@
+"use client";
+import {
+  handleBeforeUnload,
+  useUnsavedChangesGuard
+} from "./chunk-LZKAGDER.js";
+export {
+  handleBeforeUnload,
+  useUnsavedChangesGuard
+};

package/dist/visibility-polling.cjs

@@ -0,0 +1,98 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/visibility-polling/index.ts
+var visibility_polling_exports = {};
+__export(visibility_polling_exports, {
+  nextDelay: () => nextDelay,
+  useVisibilityPolling: () => useVisibilityPolling
+});
+module.exports = __toCommonJS(visibility_polling_exports);
+
+// src/visibility-polling/schedule.ts
+function nextDelay(intervalMs, jitter, random) {
+  const fraction = Math.min(1, Math.max(0, jitter));
+  return intervalMs + random() * fraction * intervalMs;
+}
+
+// src/visibility-polling/use-visibility-polling.ts
+var import_react = require("react");
+var isHidden = () => document.visibilityState === "hidden";
+function useVisibilityPolling(fn, intervalMs, { enabled = true, immediate = true, jitter = 0, runOnVisible = true } = {}) {
+  const fnRef = (0, import_react.useRef)(fn);
+  const optionsRef = (0, import_react.useRef)({ immediate, jitter, runOnVisible });
+  (0, import_react.useEffect)(() => {
+    fnRef.current = fn;
+    optionsRef.current = { immediate, jitter, runOnVisible };
+  });
+  const runningRef = (0, import_react.useRef)(false);
+  const scheduleRef = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    let active = true;
+    let timer = null;
+    function clearTimer() {
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+    }
+    function schedule() {
+      clearTimer();
+      if (!active || isHidden()) return;
+      timer = setTimeout(run, nextDelay(intervalMs, optionsRef.current.jitter, Math.random));
+    }
+    async function run() {
+      timer = null;
+      if (!active || runningRef.current || isHidden()) return;
+      runningRef.current = true;
+      try {
+        await fnRef.current();
+      } catch {
+      } finally {
+        runningRef.current = false;
+      }
+      scheduleRef.current?.();
+    }
+    function onVisibilityChange() {
+      if (isHidden()) {
+        clearTimer();
+      } else if (optionsRef.current.runOnVisible) {
+        clearTimer();
+        void run();
+      } else if (!runningRef.current) {
+        schedule();
+      }
+    }
+    scheduleRef.current = schedule;
+    if (optionsRef.current.immediate && !isHidden()) void run();
+    else schedule();
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      active = false;
+      scheduleRef.current = null;
+      clearTimer();
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    };
+  }, [enabled, intervalMs]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  nextDelay,
+  useVisibilityPolling
+});

package/dist/visibility-polling.d.cts

@@ -0,0 +1,14 @@
+declare function nextDelay(intervalMs: number, jitter: number, random: () => number): number;
+
+interface UseVisibilityPollingOptions {
+    enabled?: boolean;
+    /** Run once on mount (when visible) before the first interval. */
+    immediate?: boolean;
+    /** 0–1 fraction of the interval added at random to each delay. */
+    jitter?: number;
+    /** Run once as soon as the page becomes visible again. */
+    runOnVisible?: boolean;
+}
+declare function useVisibilityPolling(fn: () => unknown, intervalMs: number, { enabled, immediate, jitter, runOnVisible }?: UseVisibilityPollingOptions): void;
+
+export { type UseVisibilityPollingOptions, nextDelay, useVisibilityPolling };

package/dist/visibility-polling.d.ts

@@ -0,0 +1,14 @@
+declare function nextDelay(intervalMs: number, jitter: number, random: () => number): number;
+
+interface UseVisibilityPollingOptions {
+    enabled?: boolean;
+    /** Run once on mount (when visible) before the first interval. */
+    immediate?: boolean;
+    /** 0–1 fraction of the interval added at random to each delay. */
+    jitter?: number;
+    /** Run once as soon as the page becomes visible again. */
+    runOnVisible?: boolean;
+}
+declare function useVisibilityPolling(fn: () => unknown, intervalMs: number, { enabled, immediate, jitter, runOnVisible }?: UseVisibilityPollingOptions): void;
+
+export { type UseVisibilityPollingOptions, nextDelay, useVisibilityPolling };

package/dist/visibility-polling.js

@@ -0,0 +1,9 @@
+"use client";
+import {
+  nextDelay,
+  useVisibilityPolling
+} from "./chunk-UPVNSGIK.js";
+export {
+  nextDelay,
+  useVisibilityPolling
+};