@develemit/web-hooks 0.1.0 → 0.3.0

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/service-worker.cjs

@@ -0,0 +1,128 @@
+"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/service-worker/index.ts
+var service_worker_exports = {};
+__export(service_worker_exports, {
+  deriveUpdateState: () => deriveUpdateState,
+  unregisterAll: () => unregisterAll,
+  useServiceWorker: () => useServiceWorker
+});
+module.exports = __toCommonJS(service_worker_exports);
+
+// src/service-worker/use-service-worker.ts
+var import_react = require("react");
+
+// src/service-worker/update-state.ts
+function deriveUpdateState({ hasController: hasController2, waiting, installingState }) {
+  if (!hasController2) return false;
+  return waiting || installingState === "installed";
+}
+
+// src/service-worker/register.ts
+var reloaded = false;
+function isServiceWorkerSupported() {
+  return typeof navigator !== "undefined" && "serviceWorker" in navigator;
+}
+var hasController = () => Boolean(navigator.serviceWorker.controller);
+async function unregisterAll() {
+  if (!isServiceWorkerSupported()) return;
+  try {
+    const registrations = await navigator.serviceWorker.getRegistrations();
+    await Promise.all(registrations.map((r) => r.unregister()));
+  } catch {
+  }
+}
+function registerServiceWorker({ url, scope, onUpdateAvailable }, { reload = () => window.location.reload() } = {}) {
+  let registration;
+  let disposed = false;
+  let applying = false;
+  const cleanups = [];
+  const controlledAtStart = hasController();
+  const onControllerChange = () => {
+    if (!(applying || controlledAtStart) || reloaded) return;
+    reloaded = true;
+    reload();
+  };
+  navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+  cleanups.push(() => navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange));
+  const watchInstalling = (reg) => {
+    const worker = reg.installing;
+    if (!worker) return;
+    const onState = () => {
+      if (deriveUpdateState({ hasController: hasController(), waiting: false, installingState: worker.state })) {
+        onUpdateAvailable();
+      }
+    };
+    worker.addEventListener("statechange", onState);
+    cleanups.push(() => worker.removeEventListener("statechange", onState));
+  };
+  navigator.serviceWorker.register(url, scope === void 0 ? void 0 : { scope }).then((reg) => {
+    if (disposed) return;
+    registration = reg;
+    if (deriveUpdateState({ hasController: hasController(), waiting: Boolean(reg.waiting) })) {
+      onUpdateAvailable();
+    }
+    const onUpdateFound = () => watchInstalling(reg);
+    reg.addEventListener("updatefound", onUpdateFound);
+    cleanups.push(() => reg.removeEventListener("updatefound", onUpdateFound));
+  }).catch(() => {
+  });
+  return {
+    applyUpdate() {
+      const waiting = registration?.waiting;
+      if (!waiting) return;
+      applying = true;
+      waiting.postMessage({ type: "SKIP_WAITING" });
+    },
+    dispose() {
+      disposed = true;
+      cleanups.splice(0).forEach((fn) => fn());
+    }
+  };
+}
+
+// src/service-worker/use-service-worker.ts
+function useServiceWorker({ url, scope, enabled = true }) {
+  const [supported, setSupported] = (0, import_react.useState)(true);
+  const [updateAvailable, setUpdateAvailable] = (0, import_react.useState)(false);
+  const handle = (0, import_react.useRef)(void 0);
+  (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    if (!isServiceWorkerSupported()) {
+      setSupported(false);
+      return;
+    }
+    const registered = registerServiceWorker({ url, scope, onUpdateAvailable: () => setUpdateAvailable(true) });
+    handle.current = registered;
+    return () => {
+      registered.dispose();
+      handle.current = void 0;
+    };
+  }, [url, scope, enabled]);
+  const applyUpdate = (0, import_react.useCallback)(() => handle.current?.applyUpdate(), []);
+  return { supported, updateAvailable, applyUpdate };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deriveUpdateState,
+  unregisterAll,
+  useServiceWorker
+});

package/dist/service-worker.d.cts

@@ -0,0 +1,23 @@
+interface UseServiceWorkerOptions {
+    url: string;
+    scope?: string;
+    enabled?: boolean;
+}
+interface ServiceWorkerState$1 {
+    supported: boolean;
+    updateAvailable: boolean;
+    applyUpdate: () => void;
+}
+declare function useServiceWorker({ url, scope, enabled }: UseServiceWorkerOptions): ServiceWorkerState$1;
+
+declare function unregisterAll(): Promise<void>;
+
+interface UpdateStateInput {
+    hasController: boolean;
+    waiting: boolean;
+    installingState?: ServiceWorkerState | null;
+}
+/** A first install (no controller yet) is never an "update". */
+declare function deriveUpdateState({ hasController, waiting, installingState }: UpdateStateInput): boolean;
+
+export { type ServiceWorkerState$1 as ServiceWorkerState, type UpdateStateInput, type UseServiceWorkerOptions, deriveUpdateState, unregisterAll, useServiceWorker };

package/dist/service-worker.d.ts

@@ -0,0 +1,23 @@
+interface UseServiceWorkerOptions {
+    url: string;
+    scope?: string;
+    enabled?: boolean;
+}
+interface ServiceWorkerState$1 {
+    supported: boolean;
+    updateAvailable: boolean;
+    applyUpdate: () => void;
+}
+declare function useServiceWorker({ url, scope, enabled }: UseServiceWorkerOptions): ServiceWorkerState$1;
+
+declare function unregisterAll(): Promise<void>;
+
+interface UpdateStateInput {
+    hasController: boolean;
+    waiting: boolean;
+    installingState?: ServiceWorkerState | null;
+}
+/** A first install (no controller yet) is never an "update". */
+declare function deriveUpdateState({ hasController, waiting, installingState }: UpdateStateInput): boolean;
+
+export { type ServiceWorkerState$1 as ServiceWorkerState, type UpdateStateInput, type UseServiceWorkerOptions, deriveUpdateState, unregisterAll, useServiceWorker };

package/dist/service-worker.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  deriveUpdateState,
+  unregisterAll,
+  useServiceWorker
+} from "./chunk-JG3GPTMY.js";
+export {
+  deriveUpdateState,
+  unregisterAll,
+  useServiceWorker
+};

package/dist/share.cjs

@@ -0,0 +1,139 @@
+"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/share/index.ts
+var share_exports = {};
+__export(share_exports, {
+  canShareFiles: () => canShareFiles,
+  isShareCancel: () => isShareCancel,
+  shareOrCopy: () => shareOrCopy,
+  shareTextFor: () => shareTextFor,
+  useShareFeedback: () => useShareFeedback
+});
+module.exports = __toCommonJS(share_exports);
+
+// src/share/share-text.ts
+function shareTextFor({ text, url }) {
+  return [text, url].filter((part) => !!part).join("\n");
+}
+function isShareCancel(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+
+// src/clipboard/copy-text.ts
+async function copyText(text) {
+  const hasClipboardApi = typeof navigator !== "undefined" && !!navigator.clipboard?.writeText && typeof window !== "undefined" && window.isSecureContext;
+  if (hasClipboardApi) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return { ok: true };
+    } catch {
+    }
+  }
+  if (execCommandCopy(text)) return { ok: true };
+  return { ok: false, reason: hasClipboardApi ? "denied" : "unavailable" };
+}
+function execCommandCopy(text) {
+  if (typeof document === "undefined") return false;
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.readOnly = true;
+  textarea.style.position = "fixed";
+  textarea.style.top = "-1000px";
+  textarea.style.left = "-1000px";
+  textarea.style.fontSize = "16px";
+  const previouslyFocused = document.activeElement;
+  document.body.appendChild(textarea);
+  try {
+    textarea.focus({ preventScroll: true });
+    textarea.select();
+    textarea.setSelectionRange(0, text.length);
+    return document.execCommand("copy");
+  } catch {
+    return false;
+  } finally {
+    document.body.removeChild(textarea);
+    if (previouslyFocused instanceof HTMLElement && previouslyFocused !== document.body) {
+      previouslyFocused.focus({ preventScroll: true });
+    }
+  }
+}
+
+// src/share/share-or-copy.ts
+async function shareOrCopy(data) {
+  if (canShareNatively(data)) {
+    try {
+      await navigator.share(data);
+      return { status: "shared" };
+    } catch (error) {
+      if (isShareCancel(error)) return { status: "cancelled" };
+    }
+  }
+  const result = await copyText(shareTextFor(data));
+  return { status: result.ok ? "copied" : "failed" };
+}
+function canShareFiles(files) {
+  if (typeof navigator === "undefined" || typeof navigator.canShare !== "function") return false;
+  try {
+    return navigator.canShare({ files });
+  } catch {
+    return false;
+  }
+}
+function canShareNatively(data) {
+  if (typeof navigator === "undefined" || typeof navigator.share !== "function") return false;
+  if (typeof navigator.canShare !== "function") return true;
+  try {
+    return navigator.canShare(data);
+  } catch {
+    return false;
+  }
+}
+
+// src/share/use-share-feedback.ts
+var import_react = require("react");
+function useShareFeedback({ resetMs = 1500 } = {}) {
+  const [status, setStatus] = (0, import_react.useState)("idle");
+  const timerRef = (0, import_react.useRef)(void 0);
+  const clearTimer = (0, import_react.useCallback)(() => {
+    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    timerRef.current = void 0;
+  }, []);
+  (0, import_react.useEffect)(() => clearTimer, [clearTimer]);
+  const share = (0, import_react.useCallback)(
+    async (data) => {
+      const result = await shareOrCopy(data);
+      clearTimer();
+      setStatus(result.status);
+      timerRef.current = setTimeout(() => setStatus("idle"), resetMs);
+      return result;
+    },
+    [clearTimer, resetMs]
+  );
+  return { share, status };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  canShareFiles,
+  isShareCancel,
+  shareOrCopy,
+  shareTextFor,
+  useShareFeedback
+});

package/dist/share.d.cts

@@ -0,0 +1,23 @@
+interface ShareInput {
+    title?: string;
+    text?: string;
+    url?: string;
+}
+declare function shareTextFor({ text, url }: ShareInput): string;
+declare function isShareCancel(error: unknown): boolean;
+
+type ShareResult = {
+    status: 'shared' | 'copied' | 'cancelled' | 'failed';
+};
+declare function shareOrCopy(data: ShareInput): Promise<ShareResult>;
+declare function canShareFiles(files: File[]): boolean;
+
+type ShareStatus = 'idle' | ShareResult['status'];
+declare function useShareFeedback({ resetMs }?: {
+    resetMs?: number;
+}): {
+    share: (data: ShareInput) => Promise<ShareResult>;
+    status: ShareStatus;
+};
+
+export { type ShareInput, type ShareResult, type ShareStatus, canShareFiles, isShareCancel, shareOrCopy, shareTextFor, useShareFeedback };

package/dist/share.d.ts

@@ -0,0 +1,23 @@
+interface ShareInput {
+    title?: string;
+    text?: string;
+    url?: string;
+}
+declare function shareTextFor({ text, url }: ShareInput): string;
+declare function isShareCancel(error: unknown): boolean;
+
+type ShareResult = {
+    status: 'shared' | 'copied' | 'cancelled' | 'failed';
+};
+declare function shareOrCopy(data: ShareInput): Promise<ShareResult>;
+declare function canShareFiles(files: File[]): boolean;
+
+type ShareStatus = 'idle' | ShareResult['status'];
+declare function useShareFeedback({ resetMs }?: {
+    resetMs?: number;
+}): {
+    share: (data: ShareInput) => Promise<ShareResult>;
+    status: ShareStatus;
+};
+
+export { type ShareInput, type ShareResult, type ShareStatus, canShareFiles, isShareCancel, shareOrCopy, shareTextFor, useShareFeedback };

package/dist/share.js

@@ -0,0 +1,16 @@
+"use client";
+import {
+  canShareFiles,
+  isShareCancel,
+  shareOrCopy,
+  shareTextFor,
+  useShareFeedback
+} from "./chunk-4PVVTQ5V.js";
+import "./chunk-FE3BQD2I.js";
+export {
+  canShareFiles,
+  isShareCancel,
+  shareOrCopy,
+  shareTextFor,
+  useShareFeedback
+};

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 };