@develemit/web-hooks 0.2.0 → 0.3.1

package/dist/service-worker.cjs

@@ -0,0 +1,148 @@
+"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, onError }, { reload = () => window.location.reload() } = {}) {
+  let registration;
+  let disposed = false;
+  let applying = false;
+  const cleanups = [];
+  const controlledAtStart = hasController();
+  let activatedUnasked = false;
+  const reloadOnce = () => {
+    if (reloaded) return;
+    reloaded = true;
+    reload();
+  };
+  const onControllerChange = () => {
+    if (applying) return reloadOnce();
+    if (!controlledAtStart || activatedUnasked) return;
+    activatedUnasked = true;
+    onUpdateAvailable();
+  };
+  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((error) => {
+    if (disposed) return;
+    try {
+      onError?.(error);
+    } catch {
+    }
+  });
+  return {
+    applyUpdate() {
+      if (activatedUnasked) return reloadOnce();
+      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, onError }) {
+  const [supported, setSupported] = (0, import_react.useState)(true);
+  const [updateAvailable, setUpdateAvailable] = (0, import_react.useState)(false);
+  const onErrorRef = (0, import_react.useRef)(onError);
+  onErrorRef.current = onError;
+  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),
+      onError: (error) => onErrorRef.current?.(error)
+    });
+    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,24 @@
+interface UseServiceWorkerOptions {
+    url: string;
+    scope?: string;
+    enabled?: boolean;
+    onError?: (error: unknown) => void;
+}
+interface ServiceWorkerState$1 {
+    supported: boolean;
+    updateAvailable: boolean;
+    applyUpdate: () => void;
+}
+declare function useServiceWorker({ url, scope, enabled, onError }: 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,24 @@
+interface UseServiceWorkerOptions {
+    url: string;
+    scope?: string;
+    enabled?: boolean;
+    onError?: (error: unknown) => void;
+}
+interface ServiceWorkerState$1 {
+    supported: boolean;
+    updateAvailable: boolean;
+    applyUpdate: () => void;
+}
+declare function useServiceWorker({ url, scope, enabled, onError }: 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-UVJBJETY.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@develemit/web-hooks",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Shared React behavior hooks for develemit web apps: drawer swipe, focus trap, escape key and clipboard.",
   "license": "MIT",
   "author": "Emit Dutcher",
@@ -79,6 +79,36 @@
       "types": "./dist/auto-grow.d.ts",
       "import": "./dist/auto-grow.js",
       "require": "./dist/auto-grow.cjs"
+    },
+    "./pwa": {
+      "types": "./dist/pwa.d.ts",
+      "import": "./dist/pwa.js",
+      "require": "./dist/pwa.cjs"
+    },
+    "./online-status": {
+      "types": "./dist/online-status.d.ts",
+      "import": "./dist/online-status.js",
+      "require": "./dist/online-status.cjs"
+    },
+    "./service-worker": {
+      "types": "./dist/service-worker.d.ts",
+      "import": "./dist/service-worker.js",
+      "require": "./dist/service-worker.cjs"
+    },
+    "./share": {
+      "types": "./dist/share.d.ts",
+      "import": "./dist/share.js",
+      "require": "./dist/share.cjs"
+    },
+    "./keyboard-inset": {
+      "types": "./dist/keyboard-inset.d.ts",
+      "import": "./dist/keyboard-inset.js",
+      "require": "./dist/keyboard-inset.cjs"
+    },
+    "./push": {
+      "types": "./dist/push.d.ts",
+      "import": "./dist/push.js",
+      "require": "./dist/push.cjs"
     }
   },
   "main": "./dist/index.cjs",