preact-missing-hooks 4.6.0 → 4.8.0

package/llm.package.json

@@ -1,151 +1,134 @@
 {
   "name": "preact-missing-hooks",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "description": "A lightweight, extendable collection of missing React-like hooks for Preact — plus fresh, powerful new ones designed specifically for modern Preact apps.",
   "exports": {
     "useTransition": {
       "type": "function",
-      "description": "Hook that tracks a pending state for an async operation, providing a boolean `isPending` and a `startTransition` function to wrap state updates. Useful for deferring non-urgent UI updates so the interface stays responsive during slow operations.",
+      "description": "React hook that provides a transition state to coordinate updates that may be delayed, allowing components to render fallback UI while waiting.",
       "hook": true,
-      "params": "callback: () => void",
-      "returns": "{ isPending: boolean, startTransition: (callback: () => void) => void }",
-      "example": "const [isPending, startTransition] = useTransition(); startTransition(() => { /* heavy work */ });"
+      "params": "config?: { timeoutMs?: number }",
+      "returns": "[isPending: boolean, startTransition: (callback: () => void) => void]"
     },
     "useMutationObserver": {
       "type": "function",
-      "description": "Hook that creates a MutationObserver on a DOM element and calls a callback when mutations occur. Ideal for reacting to DOM changes like attributes, child list, or subtree modifications without manual cleanup.",
+      "description": "React hook that observes DOM mutations on a target element, invoking a callback when mutations occur.",
       "hook": true,
-      "params": "target: Element, callback: (mutations: MutationRecord[]) => void, options?: MutationObserverInit",
-      "returns": "void",
-      "example": "useMutationObserver(ref.current, (m) => console.log(m), { childList: true });"
+      "params": "target: Element | null, callback: (mutations: MutationRecord[]) => void, options?: MutationObserverInit"
     },
     "useEventBus": {
       "type": "function",
-      "description": "Hook that subscribes to a PubSub event bus, returning an emitter object to publish events and an array of listeners for specific topics. Simplifies decoupled communication between components.",
+      "description": "React hook that provides access to a shared event bus for pub/sub communication between components.",
       "hook": true,
       "params": "none",
-      "returns": "{ emit: (topic: string, data: any) => void, on: (topic: string, fn: (data: any) => void) => () => void }",
-      "example": "const { emit, on } = useEventBus(); on('update', (d) => console.log(d)); emit('update', { foo: 'bar' });"
+      "returns": "{ emit: (event: string, data?: any) => void, on: (event: string, handler: (data?: any) => void) => void, off: (event: string, handler: (data?: any) => void) => void }"
     },
     "useWrappedChildren": {
       "type": "function",
-      "description": "Hook that wraps child components or elements with additional logic or styling, returning a wrapped version of the children. Useful for injecting context, props, or wrappers without altering the original structure.",
+      "description": "React hook that wraps child components with additional props or context, useful for injecting shared data.",
       "hook": true,
-      "params": "children: ReactNode, wrapper: (child: ReactNode) => ReactNode",
-      "returns": "ReactNode",
-      "example": "const wrapped = useWrappedChildren(children, (c) => <div className='wrapper'>{c}</div>);"
+      "params": "children: ReactNode, wrapperProps?: object",
+      "returns": "ReactNode"
     },
     "usePreferredTheme": {
       "type": "function",
-      "description": "Hook that detects the user's preferred color scheme (light/dark) via `prefers-color-scheme` media query and returns the current theme. Automatically updates when the system theme changes.",
+      "description": "React hook that detects and returns the user's preferred color scheme (light/dark) from system or media query.",
       "hook": true,
       "params": "none",
-      "returns": "'light' | 'dark' | 'no-preference'",
-      "example": "const theme = usePreferredTheme();"
+      "returns": "'light' | 'dark' | 'no-preference'"
     },
     "useNetworkState": {
       "type": "function",
-      "description": "Hook that tracks the browser's online/offline status and optionally network type, returning an object with `online` boolean and `networkType`. Reacts to connectivity changes for offline-aware UIs.",
+      "description": "React hook that returns the current network connection status (online/offline) and connectivity details.",
       "hook": true,
       "params": "none",
-      "returns": "{ online: boolean, networkType?: string }",
-      "example": "const { online, networkType } = useNetworkState();"
+      "returns": "{ online: boolean, since?: Date, type?: string, effectiveType?: string, downlink?: number, rtt?: number }"
     },
     "useClipboard": {
       "type": "function",
-      "description": "Hook that provides async read/write access to the system clipboard, returning `write` and `read` functions. Useful for copy/paste features without directly using the Clipboard API.",
+      "description": "React hook that provides access to the system clipboard for reading and writing text content.",
       "hook": true,
       "params": "none",
-      "returns": "{ write: (data: string) => Promise<void>, read: () => Promise<string> }",
-      "example": "const { write } = useClipboard(); write('hello');"
+      "returns": "{ text: string | null, write: (text: string) => Promise<void> }"
     },
     "useRageClick": {
       "type": "function",
-      "description": "Hook that detects rapid, repeated clicks on an element and triggers a callback, often used to implement 'rage click' UX patterns like retrying failed actions. Configurable for click count and delay.",
+      "description": "React hook that detects rapid repeated clicks on an element, useful for triggering special actions or preventing accidental triggers.",
       "hook": true,
-      "params": "callback: () => void, options?: { count?: number, delay?: number }",
-      "returns": "void",
-      "example": "useRageClick(() => retry(), { count: 3, delay: 500 });"
+      "params": "onClick: (event: MouseEvent) => void, threshold?: number",
+      "returns": "void"
     },
     "useThreadedWorker": {
       "type": "function",
-      "description": "Creates a reusable thread pool for executing CPU-intensive tasks in Web Workers. Useful for offloading heavy computations without blocking the UI thread, returning a handle to dispatch jobs and retrieve results.",
+      "description": "Creates a Web Worker from a script or function and provides a thread-safe interface to run tasks in parallel. Ideal for CPU-intensive operations that should not block the UI thread.",
       "hook": true,
-      "params": "options: { maxThreads?: number, workerUrl?: string }, callback?: (result: any) => void",
-      "returns": "WorkerPool instance with methods like dispatch() and terminate()",
+      "params": "workerSource: string | Function, options?: { autoTerminate?: boolean }",
+      "returns": "{ run: (data: any) => Promise<any>, terminate: () => void }",
       "sideEffect": false,
-      "example": "const pool = useThreadedWorker({ maxThreads: 4 }); pool.dispatch(heavyTask);"
+      "example": "const { run, terminate } = useThreadedWorker(workerScript); run({ data }).then(result => console.log(result));"
     },
     "useIndexedDB": {
       "type": "function",
-      "description": "Provides a React hook to interact with IndexedDB for client-side storage. Handles opening databases, transactions, and CRUD operations, making it easy to persist data offline with automatic error handling.",
+      "description": "Provides a reactive interface to IndexedDB for storing and retrieving structured data in the browser. Useful for offline-first apps or caching large datasets beyond localStorage limits.",
       "hook": true,
-      "params": "storeName: string, options?: { version?: number, upgrade?: (db: IDBDatabase) => void }",
-      "returns": "{ get, set, delete, clear, getAll }",
+      "params": "dbName: string, storeName: string, options?: { version?: number }",
+      "returns": "{ get: (key: string) => Promise<any>, set: (key: string, value: any) => Promise<void>, delete: (key: string) => Promise<void>, clear: () => Promise<void> }",
       "sideEffect": false,
-      "example": "const { get, set } = useIndexedDB('myStore'); set('key', data);"
+      "example": "const { get, set } = useIndexedDB('myApp', 'users'); set('user1', userData); const user = await get('user1');"
     },
     "useWebRTCIP": {
       "type": "function",
-      "description": "Detects and retrieves the client's public and local IP addresses using WebRTC. Useful for network diagnostics or peer-to-peer connections, returning an array of detected IPs with metadata about each.",
+      "description": "Detects the local IP address of the client using WebRTC without establishing a peer connection. Helpful for network-aware applications or WebRTC debugging.",
       "hook": true,
-      "params": "options?: { timeout?: number }",
-      "returns": "{ ips: string[], localIps: string[], publicIps: string[] }",
+      "params": "none",
+      "returns": "Promise<string[]>",
       "sideEffect": false,
-      "example": "const { ips } = useWebRTCIP(); console.log('Detected IPs:', ips);"
+      "example": "const ips = await useWebRTCIP(); console.log('Local IPs:', ips);"
     },
     "useWasmCompute": {
       "type": "function",
-      "description": "Loads and executes WebAssembly modules for high-performance computation. Ideal for tasks like image processing or cryptography, providing a simple interface to call exported functions with typed arrays.",
+      "description": "Loads and runs WebAssembly modules for high-performance computations in the browser. Best for heavy numeric processing or cryptographic operations where JavaScript is too slow.",
       "hook": true,
-      "params": "wasmUrl: string, imports?: Record<string, any>",
-      "returns": "WasmModule instance with methods to call exported functions",
+      "params": "wasmModule: ArrayBuffer | string, importObject?: object",
+      "returns": "{ run: (method: string, ...args: any[]) => any, free: () => void }",
       "sideEffect": false,
-      "example": "const wasm = useWasmCompute('/compute.wasm'); wasm.multiply(2, 3);"
+      "example": "const { run } = useWasmCompute(wasmBytes); const result = run('computeHash', input);"
     },
     "useWorkerNotifications": {
       "type": "function",
-      "description": "Manages push notifications from Web Workers, enabling background tasks to trigger user notifications. Useful for long-running processes that need to alert users upon completion without blocking the main thread.",
-      "hook": true,
-      "params": "workerUrl: string, notificationOptions?: NotificationOptions",
-      "returns": "{ postMessage, onNotification, requestPermission }",
-      "sideEffect": false,
-      "example": "const { postMessage } = useWorkerNotifications('/worker.js'); postMessage({ type: 'start' });"
-    },
-    "useLLMMetadata": {
-      "type": "function",
-      "description": "Extracts and processes metadata from LLVM bitcode or compiled modules. Useful for analyzing compiled code structure, retrieving function signatures, and understanding module dependencies in development tools.",
+      "description": "Registers a service worker and manages push notifications with permission handling. Useful for real-time updates or background messaging in progressive web apps.",
       "hook": true,
-      "params": "bitcode: Uint8Array, options?: { extractFunctions?: boolean }",
-      "returns": "{ functions: string[], metadata: Record<string, any> }",
+      "params": "swUrl: string, options?: { permission?: 'default' | 'granted' | 'denied' }",
+      "returns": "{ subscribe: () => Promise<boolean>, unsubscribe: () => Promise<void>, isSubscribed: boolean }",
       "sideEffect": false,
-      "example": "const { functions } = useLLMMetadata(bitcodeBuffer); console.log('Functions:', functions);"
+      "example": "const { subscribe } = useWorkerNotifications('/sw.js'); await subscribe();"
     },
     "useRefPrint": {
       "type": "function",
-      "description": "Provides a hook to manage print operations for DOM elements referenced via refs. Useful for triggering print dialogs or generating print layouts for specific components without affecting the entire page.",
+      "description": "Provides a reference to a DOM element and a method to print its contents. Useful for printing specific sections of a page without affecting the entire document.",
       "hook": true,
-      "params": "ref: React.RefObject<HTMLElement>, options?: { media?: string }",
-      "returns": "{ print, isPrinting: boolean }",
+      "params": "none",
+      "returns": "{ ref: React.RefObject<any>, print: () => void }",
       "sideEffect": false,
-      "example": "const { print } = useRefPrint(ref); print();"
+      "example": "const { ref, print } = useRefPrint(); return <div ref={ref}>Content to print</div>;"
     },
     "useRBAC": {
       "type": "function",
-      "description": "Implements Role-Based Access Control (RBAC) for React applications. Manages user roles and permissions, providing utilities to check access and conditionally render components based on defined policies.",
+      "description": "Manages role-based access control by checking user permissions against defined roles. Ideal for securing components or routes based on user authorization levels.",
       "hook": true,
-      "params": "roles: string[], permissions: string[], options?: { defaultRole?: string }",
-      "returns": "{ hasRole, hasPermission, canAccess: (resource: string) => boolean }",
+      "params": "userRoles: string[], permissions: { [role: string]: string[] }",
+      "returns": "{ hasPermission: (action: string) => boolean, roles: string[] }",
       "sideEffect": false,
-      "example": "const { canAccess } = useRBAC(userRoles, userPermissions); if (canAccess('admin')) { /* render admin UI */ }"
+      "example": "const { hasPermission } = useRBAC(user.roles, permissionMap); if (hasPermission('edit')) { /* show edit button */ }"
     },
     "usePrefetch": {
       "type": "function",
-      "description": "A custom hook that prefetches a resource or module in a Preact application, typically used to improve performance by loading data or code in advance. It accepts a URL or module identifier and returns a loading state or prefetch result, enabling developers to optimize user experience by reducing latency.",
+      "description": "Prefetches resources like scripts, styles, or API data to improve perceived performance. Best for predictive loading when user is likely to navigate to a specific route.",
       "hook": true,
-      "params": "url: string, options?: { priority?: 'high' | 'low', timeout?: number }",
-      "returns": "Promise<void> | { loading: boolean, error?: Error }",
-      "example": "const [loading, error] = usePrefetch('/api/data', { priority: 'high' });"
+      "params": "resources: string[] | { [key: string]: string }",
+      "returns": "{ loading: boolean, error: Error | null }",
+      "sideEffect": false,
+      "example": "const { loading } = usePrefetch(['/api/data', '/static/style.css']); if (loading) { /* show spinner */ }"
     }
   },
   "hooks": [
@@ -162,7 +145,6 @@
     "useWebRTCIP",
     "useWasmCompute",
     "useWorkerNotifications",
-    "useLLMMetadata",
     "useRefPrint",
     "useRBAC",
     "usePrefetch"
@@ -174,7 +156,10 @@
   "generatedBy": "hayagriva-llm@1.2.0",
   "mode": "ai",
   "summary": "Preact-Missing-Hooks is a lightweight, extendable collection of missing React-like hooks for Preact — plus fresh, powerful new ones designed specifically for modern Preact apps. It bridges the gap between Preact and React's hook ecosystem while adding innovative hooks for advanced web features like WebRTC, WebAssembly, IndexedDB, and more.",
-  "sideEffects": [],
+  "sideEffects": [
+    "reads process.env",
+    "modifies DOM"
+  ],
   "keywords": [
     "preact",
     "hooks",

package/llm.package.txt

@@ -1,5 +1,5 @@
 Package: preact-missing-hooks
-Version: 4.4.0
+Version: 4.6.0
 
 Description:
 A lightweight, extendable collection of missing React-like hooks for Preact — plus fresh, powerful new ones designed specifically for modern Preact apps.
@@ -33,6 +33,10 @@ Use cases:
 - Tracking worker notifications and task execution in real-time
 - Retrieving local WebRTC IP addresses for signaling or diagnostics
 
+Side effects:
+- reads process.env
+- modifies DOM
+
 Keywords:
 preact, hooks, react-hooks, useTransition, useMutationObserver, useEventBus, useWrappedChildren, usePreferredTheme, useNetworkState, useClipboard, useRageClick, useThreadedWorker, useIndexedDB, useWebRTCIP, useWasmCompute, useWorkerNotifications, useLLMMetadata, useRefPrint, useRBAC, usePrefetch, typescript, modern-web, web-development, frontend, ui-components
 
@@ -44,23 +48,22 @@ Related packages:
 preact, react, react-hooks, preact/hooks, preact/compat
 
 Exports:
-- useClipboard (Hook) : Hook that provides async read/write access to the system clipboard, returning `write` and `read` functions. Useful for copy/paste features without directly using the Clipboard API. — params: none — returns: { write: (data: string) => Promise<void>, read: () => Promise<string> } — e.g. const { write } = useClipboard(); write('hello');
-- useEventBus (Hook) : Hook that subscribes to a PubSub event bus, returning an emitter object to publish events and an array of listeners for specific topics. Simplifies decoupled communication between components. — params: none — returns: { emit: (topic: string, data: any) => void, on: (topic: string, fn: (data: any) => void) => () => void } — e.g. const { emit, on } = useEventBus(); on('update', (d) => console.log(d)); emit('update', { foo: 'bar' });
-- useIndexedDB (Hook) : Provides a React hook to interact with IndexedDB for client-side storage. Handles opening databases, transactions, and CRUD operations, making it easy to persist data offline with automatic error handling. — params: storeName: string, options?: { version?: number, upgrade?: (db: IDBDatabase) => void } — returns: { get, set, delete, clear, getAll } — e.g. const { get, set } = useIndexedDB('myStore'); set('key', data);
-- useLLMMetadata (Hook) : Extracts and processes metadata from LLVM bitcode or compiled modules. Useful for analyzing compiled code structure, retrieving function signatures, and understanding module dependencies in development tools. — params: bitcode: Uint8Array, options?: { extractFunctions?: boolean } — returns: { functions: string[], metadata: Record<string, any> } — e.g. const { functions } = useLLMMetadata(bitcodeBuffer); console.log('Functions:', functions);
-- useMutationObserver (Hook) : Hook that creates a MutationObserver on a DOM element and calls a callback when mutations occur. Ideal for reacting to DOM changes like attributes, child list, or subtree modifications without manual cleanup. — params: target: Element, callback: (mutations: MutationRecord[]) => void, options?: MutationObserverInit — returns: void — e.g. useMutationObserver(ref.current, (m) => console.log(m), { childList: true });
-- useNetworkState (Hook) : Hook that tracks the browser's online/offline status and optionally network type, returning an object with `online` boolean and `networkType`. Reacts to connectivity changes for offline-aware UIs. — params: none — returns: { online: boolean, networkType?: string } — e.g. const { online, networkType } = useNetworkState();
-- usePreferredTheme (Hook) : Hook that detects the user's preferred color scheme (light/dark) via `prefers-color-scheme` media query and returns the current theme. Automatically updates when the system theme changes. — params: none — returns: 'light' | 'dark' | 'no-preference' — e.g. const theme = usePreferredTheme();
-- usePrefetch (Hook) : A custom hook that prefetches a resource or module in a Preact application, typically used to improve performance by loading data or code in advance. It accepts a URL or module identifier and returns a loading state or prefetch result, enabling developers to optimize user experience by reducing latency. — params: url: string, options?: { priority?: 'high' | 'low', timeout?: number } — returns: Promise<void> | { loading: boolean, error?: Error } — e.g. const [loading, error] = usePrefetch('/api/data', { priority: 'high' });
-- useRageClick (Hook) : Hook that detects rapid, repeated clicks on an element and triggers a callback, often used to implement 'rage click' UX patterns like retrying failed actions. Configurable for click count and delay. — params: callback: () => void, options?: { count?: number, delay?: number } — returns: void — e.g. useRageClick(() => retry(), { count: 3, delay: 500 });
-- useRBAC (Hook) : Implements Role-Based Access Control (RBAC) for React applications. Manages user roles and permissions, providing utilities to check access and conditionally render components based on defined policies. — params: roles: string[], permissions: string[], options?: { defaultRole?: string } — returns: { hasRole, hasPermission, canAccess: (resource: string) => boolean } — e.g. const { canAccess } = useRBAC(userRoles, userPermissions); if (canAccess('admin')) { /* render admin UI */ }
-- useRefPrint (Hook) : Provides a hook to manage print operations for DOM elements referenced via refs. Useful for triggering print dialogs or generating print layouts for specific components without affecting the entire page. — params: ref: React.RefObject<HTMLElement>, options?: { media?: string } — returns: { print, isPrinting: boolean } — e.g. const { print } = useRefPrint(ref); print();
-- useThreadedWorker (Hook) : Creates a reusable thread pool for executing CPU-intensive tasks in Web Workers. Useful for offloading heavy computations without blocking the UI thread, returning a handle to dispatch jobs and retrieve results. — params: options: { maxThreads?: number, workerUrl?: string }, callback?: (result: any) => void — returns: WorkerPool instance with methods like dispatch() and terminate() — e.g. const pool = useThreadedWorker({ maxThreads: 4 }); pool.dispatch(heavyTask);
-- useTransition (Hook) : Hook that tracks a pending state for an async operation, providing a boolean `isPending` and a `startTransition` function to wrap state updates. Useful for deferring non-urgent UI updates so the interface stays responsive during slow operations. — params: callback: () => void — returns: { isPending: boolean, startTransition: (callback: () => void) => void } — e.g. const [isPending, startTransition] = useTransition(); startTransition(() => { /* heavy work */ });
-- useWasmCompute (Hook) : Loads and executes WebAssembly modules for high-performance computation. Ideal for tasks like image processing or cryptography, providing a simple interface to call exported functions with typed arrays. — params: wasmUrl: string, imports?: Record<string, any> — returns: WasmModule instance with methods to call exported functions — e.g. const wasm = useWasmCompute('/compute.wasm'); wasm.multiply(2, 3);
-- useWebRTCIP (Hook) : Detects and retrieves the client's public and local IP addresses using WebRTC. Useful for network diagnostics or peer-to-peer connections, returning an array of detected IPs with metadata about each. — params: options?: { timeout?: number } — returns: { ips: string[], localIps: string[], publicIps: string[] } — e.g. const { ips } = useWebRTCIP(); console.log('Detected IPs:', ips);
-- useWorkerNotifications (Hook) : Manages push notifications from Web Workers, enabling background tasks to trigger user notifications. Useful for long-running processes that need to alert users upon completion without blocking the main thread. — params: workerUrl: string, notificationOptions?: NotificationOptions — returns: { postMessage, onNotification, requestPermission } — e.g. const { postMessage } = useWorkerNotifications('/worker.js'); postMessage({ type: 'start' });
-- useWrappedChildren (Hook) : Hook that wraps child components or elements with additional logic or styling, returning a wrapped version of the children. Useful for injecting context, props, or wrappers without altering the original structure. — params: children: ReactNode, wrapper: (child: ReactNode) => ReactNode — returns: ReactNode — e.g. const wrapped = useWrappedChildren(children, (c) => <div className='wrapper'>{c}</div>);
+- useClipboard (Hook) : React hook that provides access to the system clipboard for reading and writing text content. — params: none — returns: { text: string | null, write: (text: string) => Promise<void> }
+- useEventBus (Hook) : React hook that provides access to a shared event bus for pub/sub communication between components. — params: none — returns: { emit: (event: string, data?: any) => void, on: (event: string, handler: (data?: any) => void) => void, off: (event: string, handler: (data?: any) => void) => void }
+- useIndexedDB (Hook) : Provides a reactive interface to IndexedDB for storing and retrieving structured data in the browser. Useful for offline-first apps or caching large datasets beyond localStorage limits. — params: dbName: string, storeName: string, options?: { version?: number } — returns: { get: (key: string) => Promise<any>, set: (key: string, value: any) => Promise<void>, delete: (key: string) => Promise<void>, clear: () => Promise<void> } — e.g. const { get, set } = useIndexedDB('myApp', 'users'); set('user1', userData); const user = await get('user1');
+- useMutationObserver (Hook) : React hook that observes DOM mutations on a target element, invoking a callback when mutations occur. — params: target: Element | null, callback: (mutations: MutationRecord[]) => void, options?: MutationObserverInit
+- useNetworkState (Hook) : React hook that returns the current network connection status (online/offline) and connectivity details. — params: none — returns: { online: boolean, since?: Date, type?: string, effectiveType?: string, downlink?: number, rtt?: number }
+- usePreferredTheme (Hook) : React hook that detects and returns the user's preferred color scheme (light/dark) from system or media query. — params: none — returns: 'light' | 'dark' | 'no-preference'
+- usePrefetch (Hook) : Prefetches resources like scripts, styles, or API data to improve perceived performance. Best for predictive loading when user is likely to navigate to a specific route. — params: resources: string[] | { [key: string]: string } — returns: { loading: boolean, error: Error | null } — e.g. const { loading } = usePrefetch(['/api/data', '/static/style.css']); if (loading) { /* show spinner */ }
+- useRageClick (Hook) : React hook that detects rapid repeated clicks on an element, useful for triggering special actions or preventing accidental triggers. — params: onClick: (event: MouseEvent) => void, threshold?: number — returns: void
+- useRBAC (Hook) : Manages role-based access control by checking user permissions against defined roles. Ideal for securing components or routes based on user authorization levels. — params: userRoles: string[], permissions: { [role: string]: string[] } — returns: { hasPermission: (action: string) => boolean, roles: string[] } — e.g. const { hasPermission } = useRBAC(user.roles, permissionMap); if (hasPermission('edit')) { /* show edit button */ }
+- useRefPrint (Hook) : Provides a reference to a DOM element and a method to print its contents. Useful for printing specific sections of a page without affecting the entire document. — params: none — returns: { ref: React.RefObject<any>, print: () => void } — e.g. const { ref, print } = useRefPrint(); return <div ref={ref}>Content to print</div>;
+- useThreadedWorker (Hook) : Creates a Web Worker from a script or function and provides a thread-safe interface to run tasks in parallel. Ideal for CPU-intensive operations that should not block the UI thread. — params: workerSource: string | Function, options?: { autoTerminate?: boolean } — returns: { run: (data: any) => Promise<any>, terminate: () => void } — e.g. const { run, terminate } = useThreadedWorker(workerScript); run({ data }).then(result => console.log(result));
+- useTransition (Hook) : React hook that provides a transition state to coordinate updates that may be delayed, allowing components to render fallback UI while waiting. — params: config?: { timeoutMs?: number } — returns: [isPending: boolean, startTransition: (callback: () => void) => void]
+- useWasmCompute (Hook) : Loads and runs WebAssembly modules for high-performance computations in the browser. Best for heavy numeric processing or cryptographic operations where JavaScript is too slow. — params: wasmModule: ArrayBuffer | string, importObject?: object — returns: { run: (method: string, ...args: any[]) => any, free: () => void } — e.g. const { run } = useWasmCompute(wasmBytes); const result = run('computeHash', input);
+- useWebRTCIP (Hook) : Detects the local IP address of the client using WebRTC without establishing a peer connection. Helpful for network-aware applications or WebRTC debugging. — params: none — returns: Promise<string[]> — e.g. const ips = await useWebRTCIP(); console.log('Local IPs:', ips);
+- useWorkerNotifications (Hook) : Registers a service worker and manages push notifications with permission handling. Useful for real-time updates or background messaging in progressive web apps. — params: swUrl: string, options?: { permission?: 'default' | 'granted' | 'denied' } — returns: { subscribe: () => Promise<boolean>, unsubscribe: () => Promise<void>, isSubscribed: boolean } — e.g. const { subscribe } = useWorkerNotifications('/sw.js'); await subscribe();
+- useWrappedChildren (Hook) : React hook that wraps child components with additional props or context, useful for injecting shared data. — params: children: ReactNode, wrapperProps?: object — returns: ReactNode
 
 Hooks:
 - useTransition
@@ -76,7 +79,6 @@ Hooks:
 - useWebRTCIP
 - useWasmCompute
 - useWorkerNotifications
-- useLLMMetadata
 - useRefPrint
 - useRBAC
 - usePrefetch

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "preact-missing-hooks",
-  "version": "4.6.0",
+  "version": "4.8.0",
   "description": "A lightweight, extendable collection of missing React-like hooks for Preact — plus fresh, powerful new ones designed specifically for modern Preact apps.",
   "author": "Prakhar Dubey",
   "license": "MIT",
@@ -97,6 +97,16 @@
       "import": "./dist/usePrefetch.module.js",
       "require": "./dist/usePrefetch.js"
     },
+    "./usePoll": {
+      "types": "./dist/usePoll.d.ts",
+      "import": "./dist/usePoll.module.js",
+      "require": "./dist/usePoll.js"
+    },
+    "./useDeviceData": {
+      "types": "./dist/useDeviceData.d.ts",
+      "import": "./dist/useDeviceData.module.js",
+      "require": "./dist/useDeviceData.js"
+    },
     "./react": {
       "types": "./dist/index.d.ts",
       "import": "./dist/react.module.js",
@@ -104,7 +114,7 @@
     }
   },
   "scripts": {
-    "build": "microbundle --alias react=preact/compat && npm run build:react && node scripts/generate-entry.cjs",
+    "build": "node scripts/ensure-microbundle-patch.cjs && microbundle --alias react=preact/compat && npm run build:react && node scripts/generate-entry.cjs",
     "llm:generate": "hayagriva-llm generate --mode ai --include-src --verbose",
     "build:react": "rollup -c scripts/rollup.react.config.cjs",
     "dev": "microbundle watch",
@@ -117,7 +127,7 @@
     "lint": "eslint src",
     "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
     "format:check": "prettier --check \"src/**/*.{ts,tsx,json,md}\"",
-    "prepare": "husky",
+    "prepare": "husky && node scripts/ensure-microbundle-patch.cjs",
     "clean:cache": "node -e \"try{require('fs').rmSync('node_modules/.cache',{recursive:true,force:true});console.log('Cache cleared');}catch(e){}\"",
     "size": "npm run clean:cache && npm run build && size-limit"
   },
@@ -150,6 +160,8 @@
     "useNetworkState",
     "useClipboard",
     "usePrefetch",
+    "usePoll",
+    "useDeviceData",
     "useRageClick",
     "rage click",
     "sentry",

package/scripts/ensure-microbundle-patch.cjs

@@ -0,0 +1,46 @@
+/**
+ * Patches microbundle to pass clean: true to rollup-plugin-typescript2.
+ * In rpt2, "clean" disables the RollingCache (noCache), avoiding EPERM rename
+ * failures on Windows during UMD/CJS/ESM builds.
+ */
+const fs = require("fs");
+const path = require("path");
+
+const cliPath = path.join(
+  __dirname,
+  "..",
+  "node_modules",
+  "microbundle",
+  "dist",
+  "cli.js",
+);
+
+if (!fs.existsSync(cliPath)) {
+  console.warn(
+    "ensure-microbundle-patch: microbundle not installed, skipping patch",
+  );
+  process.exit(0);
+}
+
+const src = fs.readFileSync(cliPath, "utf8");
+const marker = "clean: true,";
+
+if (src.includes(marker)) {
+  process.exit(0);
+}
+
+const needle =
+  "(useTypescript || emitDeclaration) && typescript__default['default']({";
+const replacement = `${needle} clean: true,`;
+
+if (!src.includes(needle)) {
+  console.error(
+    "ensure-microbundle-patch: microbundle cli.js format changed; update the patch script",
+  );
+  process.exit(1);
+}
+
+fs.writeFileSync(cliPath, src.replace(needle, replacement), "utf8");
+console.log(
+  "Patched microbundle (rollup-plugin-typescript2 clean:true for Windows EPERM)",
+);

package/src/index.ts

@@ -15,3 +15,5 @@ export * from "./useLLMMetadata";
 export * from "./useRefPrint";
 export * from "./useRBAC";
 export * from "./usePrefetch";
+export * from "./usePoll";
+export * from "./useDeviceData";