preact-missing-hooks 4.1.0 → 4.3.0

package/llm.package.json

@@ -0,0 +1,348 @@
+{
+  "name": "preact-missing-hooks",
+  "version": "4.2.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": "A hook that provides a transition state and a function to start a transition. It is used to defer non-urgent updates to avoid blocking the UI during high-priority updates.",
+      "hook": true,
+      "params": "options?: { timeoutMs?: number }",
+      "returns": "Array containing a boolean indicating if a transition is in progress and a function to start a transition"
+    },
+    "useMutationObserver": {
+      "type": "function",
+      "description": "A hook that observes DOM mutations on a given element and calls a callback when mutations occur. It is useful for reacting to changes in the DOM structure or attributes.",
+      "hook": true,
+      "params": "element: Element, callback: (mutations: MutationRecord[]) => void, options?: MutationObserverInit",
+      "returns": "void"
+    },
+    "UseMutationObserverOptions": {
+      "type": "type",
+      "description": "An interface defining the options for the useMutationObserver hook. It extends MutationObserverInit and includes additional properties specific to the hook.",
+      "hook": false,
+      "params": "N/A",
+      "returns": "N/A"
+    },
+    "useEventBus": {
+      "type": "function",
+      "description": "A hook that provides a simple event bus for component communication. It allows components to emit and listen to events without prop drilling.",
+      "hook": true,
+      "params": "N/A",
+      "returns": "Object with emit and on methods for event handling"
+    },
+    "useWrappedChildren": {
+      "type": "function",
+      "description": "A hook that wraps child components with additional functionality or styling. It is useful for applying consistent behavior or appearance to a group of child components.",
+      "hook": true,
+      "params": "children: ReactNode, wrapper: (child: ReactNode) => ReactNode",
+      "returns": "ReactNode"
+    },
+    "InjectableProps": {
+      "type": "type",
+      "description": "An interface defining the props that can be injected into a component. It is used to specify the properties that can be dynamically added to a component.",
+      "hook": false,
+      "params": "N/A",
+      "returns": "N/A"
+    },
+    "usePreferredTheme": {
+      "type": "function",
+      "description": "A hook that provides the user's preferred theme (light or dark) based on system preferences or user settings. It is useful for implementing theme-aware components.",
+      "hook": true,
+      "params": "N/A",
+      "returns": "String representing the preferred theme ('light' or 'dark')"
+    },
+    "PreferredTheme": {
+      "type": "type",
+      "description": "A type alias for the possible theme values ('light' or 'dark'). It is used to ensure type safety when working with theme-related values.",
+      "hook": false,
+      "params": "N/A",
+      "returns": "N/A"
+    },
+    "useNetworkState": {
+      "type": "function",
+      "description": "React hook that returns the current network state of the device, including connection type, effective connection type, and whether the device is online or offline. It uses the browser's Network Information API to provide real-time updates when the network conditions change.",
+      "hook": true,
+      "params": "options?: { refreshRate?: number }",
+      "returns": "NetworkState: { online: boolean, since: number, downlink: number, downlinkMax: number, effectiveType: EffectiveConnectionType, rtt: number, saveData: boolean, type: ConnectionType }",
+      "example": "const { online, type, effectiveType } = useNetworkState()"
+    },
+    "EffectiveConnectionType": {
+      "type": "type",
+      "description": "TypeScript type representing the effective connection type as defined by the Network Information API. It includes values like 'slow-2g', '2g', '3g', '4g' that indicate the effective network speed the browser detects.",
+      "hook": false,
+      "example": "'slow-2g' | '2g' | '3g' | '4g'"
+    },
+    "ConnectionType": {
+      "type": "type",
+      "description": "TypeScript type representing the connection type as defined by the Network Information API. It includes values like 'bluetooth', 'cellular', 'ethernet', 'wifi', 'wimax', 'none', 'unknown', 'other' that indicate the physical connection type.",
+      "hook": false,
+      "example": "'bluetooth' | 'cellular' | 'ethernet' | 'wifi' | 'wimax' | 'none' | 'unknown' | 'other'"
+    },
+    "NetworkState": {
+      "type": "type",
+      "description": "TypeScript type representing the complete network state object returned by useNetworkState hook. It includes online status, timestamps, bandwidth information, effective connection type, round-trip time, data saver status, and connection type.",
+      "hook": false,
+      "example": "{ online: boolean, since: number, downlink: number, downlinkMax: number, effectiveType: EffectiveConnectionType, rtt: number, saveData: boolean, type: ConnectionType }"
+    },
+    "useClipboard": {
+      "type": "function",
+      "description": "React hook that provides access to the system clipboard, allowing reading and writing of clipboard content. It returns an object with methods to read and write text to the clipboard, handling browser compatibility and permissions.",
+      "hook": true,
+      "params": "options?: UseClipboardOptions",
+      "returns": "UseClipboardReturn: { readText: () => Promise<string>, writeText: (text: string) => Promise<void> }",
+      "example": "const { readText, writeText } = useClipboard()"
+    },
+    "UseClipboardOptions": {
+      "type": "type",
+      "description": "TypeScript type representing the options object for the useClipboard hook. Currently it may include configuration options for clipboard behavior, though the exact properties depend on the implementation.",
+      "hook": false,
+      "example": "{}"
+    },
+    "UseClipboardReturn": {
+      "type": "type",
+      "description": "TypeScript type representing the return value of the useClipboard hook. It includes readText and writeText methods that return promises for asynchronous clipboard operations.",
+      "hook": false,
+      "example": "{ readText: () => Promise<string>, writeText: (text: string) => Promise<void> }"
+    },
+    "useRageClick": {
+      "type": "function",
+      "description": "React hook that detects rapid, repeated clicks on an element, commonly known as rage clicks. It helps identify user frustration by tracking multiple clicks in quick succession and provides a callback when such behavior is detected.",
+      "hook": true,
+      "params": "options?: { threshold?: number, timeWindow?: number, callback?: (event: MouseEvent) => void }",
+      "returns": "void",
+      "example": "useRageClick({ threshold: 3, timeWindow: 1000, callback: (event) => console.log('Rage click detected!') })"
+    },
+    "RageClickPayload": {
+      "type": "type",
+      "description": "Interface describing the payload structure for rage click events, typically containing timestamp, element info, and click count. Used when tracking rapid repeated clicks for UX analysis or error reporting.",
+      "hook": false
+    },
+    "UseRageClickOptions": {
+      "type": "type",
+      "description": "Configuration options for the useRageClick hook, including threshold for clicks per second, timeout duration, and callback handler. Allows customization of rage click detection sensitivity and behavior.",
+      "hook": false
+    },
+    "useThreadedWorker": {
+      "type": "function",
+      "description": "Hook that creates and manages a Web Worker thread for offloading heavy computations or operations. Returns worker instance and control methods for communication and lifecycle management.",
+      "hook": true,
+      "params": "options: UseThreadedWorkerOptions",
+      "returns": "UseThreadedWorkerReturn",
+      "example": "const { worker, postMessage, terminate } = useThreadedWorker({ worker: myWorker });"
+    },
+    "ThreadedWorkerMode": {
+      "type": "type",
+      "description": "Enumeration defining worker modes: 'shared' for SharedWorker instances or 'dedicated' for standard Web Workers. Determines how worker threads are instantiated and shared across components.",
+      "hook": false
+    },
+    "UseThreadedWorkerOptions": {
+      "type": "type",
+      "description": "Configuration object for useThreadedWorker hook containing worker script URL or blob, mode selection, and optional initialization parameters. Defines how the worker thread should be created and configured.",
+      "hook": false
+    },
+    "RunOptions": {
+      "type": "type",
+      "description": "Options object for controlling execution behavior of threaded operations, including timeout settings, retry logic, and error handling strategies. Used to customize how tasks run in worker threads.",
+      "hook": false
+    },
+    "UseThreadedWorkerReturn": {
+      "type": "type",
+      "description": "Return type from useThreadedWorker hook containing worker instance, message posting method, event listeners, and cleanup functions. Provides complete interface for interacting with the managed worker thread.",
+      "hook": false
+    },
+    "useIndexedDB": {
+      "type": "function",
+      "description": "Hook for managing IndexedDB database operations including opening connections, reading, writing, and deleting data. Provides reactive state management for database changes and error handling.",
+      "hook": true,
+      "params": "dbName: string, options?: { version?: number, objectStores?: string[] }",
+      "returns": "{ db: IDBDatabase | null, error: Error | null, isOpen: boolean, close: () => void }",
+      "example": "const { db, isOpen, error } = useIndexedDB('myDatabase');"
+    },
+    "IndexedDBConfig": {
+      "type": "type",
+      "description": "Configuration object for IndexedDB operations, specifying database name, version, and store schema. Use when setting up persistent client-side storage with custom store structures.",
+      "hook": false,
+      "params": "{ dbName: string, version?: number, stores: { name: string, keyPath?: string, autoIncrement?: boolean }[] }"
+    },
+    "IDBController": {
+      "type": "class",
+      "description": "Controller class managing IndexedDB instance lifecycle, providing methods to open, close, and interact with the database. Use when you need programmatic control over IndexedDB operations beyond basic hooks.",
+      "hook": false,
+      "params": "constructor(config: IndexedDBConfig)",
+      "returns": "IDBController instance with open(), close(), getStore(), and transaction methods"
+    },
+    "UseIndexedDBReturn": {
+      "type": "type",
+      "description": "Return type from useIndexedDB hook containing database instance, store references, and utility methods. Use to access structured data operations and transaction capabilities within React components.",
+      "hook": false,
+      "params": "{ db: IDBDatabase, stores: Record<string, IDBObjectStore>, transaction: (stores: string[], mode?: IDBTransactionMode) => IDBTransaction }"
+    },
+    "useWebRTCIP": {
+      "type": "function",
+      "description": "Hook that retrieves local WebRTC IP addresses by creating a peer connection and parsing ICE candidates. Use when you need to detect client IP addresses for WebRTC signaling or network diagnostics.",
+      "hook": true,
+      "params": "options?: UseWebRTCIPOptions",
+      "returns": "UseWebRTCIPReturn containing ipAddresses: string[] and loading: boolean"
+    },
+    "UseWebRTCIPOptions": {
+      "type": "type",
+      "description": "Configuration options for useWebRTCIP hook, allowing customization of timeout duration and STUN/TURN server configuration. Use to control how long the hook waits for ICE gathering and which servers to use.",
+      "hook": false,
+      "params": "{ timeout?: number, iceServers?: RTCIceServer[] }"
+    },
+    "UseWebRTCIPReturn": {
+      "type": "type",
+      "description": "Return object from useWebRTCIP hook containing detected IP addresses and loading state. Use to access the gathered IP addresses and determine when the operation is complete.",
+      "hook": false,
+      "params": "{ ipAddresses: string[], loading: boolean }"
+    },
+    "useWasmCompute": {
+      "type": "function",
+      "description": "Hook that loads and executes WebAssembly modules for high-performance computation in the browser. Use when you need to run CPU-intensive tasks like image processing, cryptography, or numerical computations without blocking the main thread.",
+      "hook": true,
+      "params": "options: UseWasmComputeOptions",
+      "returns": "Promise resolving to Wasm module instance with exported functions"
+    },
+    "UseWasmComputeOptions": {
+      "type": "type",
+      "description": "Configuration object for useWasmCompute hook specifying WASM module source, imports, and execution parameters. Use to configure memory limits, import objects, and execution environment for WebAssembly modules.",
+      "hook": false,
+      "params": "{ moduleUrl: string, imports?: Record<string, any>, memorySize?: number }"
+    },
+    "UseWasmComputeReturn": {
+      "type": "type",
+      "description": "Type definition for the return value of a WASM compute function. Represents the structured result of a WebAssembly-based computation, typically containing status, data, and error information.",
+      "hook": false
+    },
+    "useWorkerNotifications": {
+      "type": "function",
+      "description": "React hook that subscribes to notifications from a Web Worker. Provides real-time updates from background processing tasks, allowing components to react to worker events without manual event listener management.",
+      "hook": true,
+      "params": "options: UseWorkerNotificationsOptions",
+      "returns": "UseWorkerNotificationsReturn",
+      "example": "const { notifications, error } = useWorkerNotifications({ worker: myWorker })"
+    },
+    "WorkerEventType": {
+      "type": "type",
+      "description": "Enumeration of possible event types that can be emitted by a Web Worker. Defines the standard set of notification categories for worker-to-main-thread communication, enabling type-safe event handling.",
+      "hook": false
+    },
+    "WorkerNotificationEvent": {
+      "type": "type",
+      "description": "Type definition for a worker notification event object. Contains metadata about a specific event from a Web Worker, including type, timestamp, and payload data for structured communication.",
+      "hook": false
+    },
+    "UseWorkerNotificationsOptions": {
+      "type": "type",
+      "description": "Configuration object type for the useWorkerNotifications hook. Specifies parameters like the worker instance, event filters, and optional callback handlers for customizing notification subscription behavior.",
+      "hook": false
+    },
+    "UseWorkerNotificationsReturn": {
+      "type": "type",
+      "description": "Return type for the useWorkerNotifications hook. Provides an object containing the current notifications array, error state, and optional methods for managing the subscription to worker events.",
+      "hook": false
+    },
+    "useLLMMetadata": {
+      "type": "function",
+      "description": "React hook that retrieves metadata about the underlying LLVM/WebAssembly compilation environment. Provides information about the current runtime capabilities, version, and available features for debugging and optimization.",
+      "hook": true,
+      "returns": "object containing metadata properties",
+      "example": "const metadata = useLLMMetadata()"
+    },
+    "OGType": {
+      "type": "type",
+      "description": "Type definition for Open Graph metadata types. Represents the standardized vocabulary for social media sharing metadata, used to control how content appears when shared on platforms like Facebook and Twitter.",
+      "hook": false
+    },
+    "LLMConfig": {
+      "type": "type",
+      "description": "Configuration object for setting up an LLM client, including model details, API keys, and connection parameters. Use this to define how the LLM should behave and connect.",
+      "hook": false,
+      "params": "Optional: { model: string, apiKey: string, endpoint: string, temperature?: number, maxTokens?: number }",
+      "returns": "A typed configuration object for LLM initialization",
+      "sideEffect": false,
+      "example": "const config: LLMConfig = { model: 'gpt-4', apiKey: 'your-key', endpoint: 'https://api.openai.com/v1' }"
+    },
+    "LLMPayload": {
+      "type": "type",
+      "description": "Payload structure for sending requests to an LLM, containing the prompt, conversation context, and optional parameters. Use this to format data sent to the LLM service.",
+      "hook": false,
+      "params": "Optional: { prompt: string, messages?: Message[], temperature?: number, maxTokens?: number, stream?: boolean }",
+      "returns": "A typed payload object for LLM requests",
+      "sideEffect": false,
+      "example": "const payload: LLMPayload = { prompt: 'Translate to French:', messages: [{ role: 'user', content: 'Hello world' }] }"
+    }
+  },
+  "hooks": [
+    "useTransition",
+    "useMutationObserver",
+    "useEventBus",
+    "useWrappedChildren",
+    "usePreferredTheme",
+    "useNetworkState",
+    "useClipboard",
+    "useRageClick",
+    "useThreadedWorker",
+    "useIndexedDB",
+    "useWebRTCIP",
+    "useWasmCompute",
+    "useWorkerNotifications",
+    "useLLMMetadata"
+  ],
+  "frameworks": [
+    "preact",
+    "react"
+  ],
+  "generatedBy": "hayagriva-llm@1.2.0",
+  "mode": "ai",
+  "summary": "Preact-Missing-Hooks is a lightweight, extendable collection of missing React-like hooks for Preact, offering both familiar hooks and fresh, powerful new ones designed specifically for modern Preact apps.",
+  "sideEffects": [],
+  "keywords": [
+    "preact",
+    "hooks",
+    "react-hooks",
+    "useTransition",
+    "useMutationObserver",
+    "useEventBus",
+    "useWrappedChildren",
+    "usePreferredTheme",
+    "useNetworkState",
+    "useClipboard",
+    "useRageClick",
+    "useThreadedWorker",
+    "useIndexedDB",
+    "useWebRTCIP",
+    "useWasmCompute",
+    "useWorkerNotifications",
+    "typescript",
+    "modern-web"
+  ],
+  "whenToUse": "Choose Preact-Missing-Hooks when building modern Preact applications that need advanced, React-like hooks not natively available in Preact, or when you want to leverage powerful new hooks for tasks like clipboard management, WebRTC IP detection, WebAssembly computation, IndexedDB access, or rage-click detection. It's ideal for developers seeking a lightweight, extendable hook library that works seamlessly with both Preact and React.",
+  "reasonToUse": [
+    "Provides missing React-like hooks for Preact",
+    "Offers powerful new hooks for modern web features",
+    "Lightweight and extendable",
+    "Framework-agnostic (works with Preact and React)",
+    "Production-ready with TypeScript support"
+  ],
+  "useCases": [
+    "Building a Preact app that needs React's useTransition functionality",
+    "Managing clipboard operations in a Preact component",
+    "Detecting user rage clicks and reporting to error tracking tools",
+    "Running WebAssembly computations in a Web Worker",
+    "Accessing IndexedDB with a clean, React-like hook API",
+    "Observing DOM mutations reactively",
+    "Wrapping children components to inject additional props",
+    "Detecting user's preferred theme for dark/light mode support",
+    "Monitoring network state changes for offline/online handling",
+    "Tracking worker notifications and task execution in real-time"
+  ],
+  "documentation": "See README",
+  "relatedPackages": [
+    "preact",
+    "react",
+    "react-hooks",
+    "preact/hooks"
+  ]
+}

package/llm.package.txt

@@ -0,0 +1,103 @@
+Package: preact-missing-hooks
+Version: 4.2.0
+
+Description:
+A lightweight, extendable collection of missing React-like hooks for Preact — plus fresh, powerful new ones designed specifically for modern Preact apps.
+
+Summary:
+Preact-Missing-Hooks is a lightweight, extendable collection of missing React-like hooks for Preact, offering both familiar hooks and fresh, powerful new ones designed specifically for modern Preact apps.
+
+When to use:
+Choose Preact-Missing-Hooks when building modern Preact applications that need advanced, React-like hooks not natively available in Preact, or when you want to leverage powerful new hooks for tasks like clipboard management, WebRTC IP detection, WebAssembly computation, IndexedDB access, or rage-click detection. It's ideal for developers seeking a lightweight, extendable hook library that works seamlessly with both Preact and React.
+
+Reason to use:
+- Provides missing React-like hooks for Preact
+- Offers powerful new hooks for modern web features
+- Lightweight and extendable
+- Framework-agnostic (works with Preact and React)
+- Production-ready with TypeScript support
+
+Use cases:
+- Building a Preact app that needs React's useTransition functionality
+- Managing clipboard operations in a Preact component
+- Detecting user rage clicks and reporting to error tracking tools
+- Running WebAssembly computations in a Web Worker
+- Accessing IndexedDB with a clean, React-like hook API
+- Observing DOM mutations reactively
+- Wrapping children components to inject additional props
+- Detecting user's preferred theme for dark/light mode support
+- Monitoring network state changes for offline/online handling
+- Tracking worker notifications and task execution in real-time
+
+Keywords:
+preact, hooks, react-hooks, useTransition, useMutationObserver, useEventBus, useWrappedChildren, usePreferredTheme, useNetworkState, useClipboard, useRageClick, useThreadedWorker, useIndexedDB, useWebRTCIP, useWasmCompute, useWorkerNotifications, typescript, modern-web
+
+
+Documentation:
+See README
+
+Related packages:
+preact, react, react-hooks, preact/hooks
+
+Exports:
+- ConnectionType : TypeScript type representing the connection type as defined by the Network Information API. It includes values like 'bluetooth', 'cellular', 'ethernet', 'wifi', 'wimax', 'none', 'unknown', 'other' that indicate the physical connection type. — e.g. 'bluetooth' | 'cellular' | 'ethernet' | 'wifi' | 'wimax' | 'none' | 'unknown' | 'other'
+- EffectiveConnectionType : TypeScript type representing the effective connection type as defined by the Network Information API. It includes values like 'slow-2g', '2g', '3g', '4g' that indicate the effective network speed the browser detects. — e.g. 'slow-2g' | '2g' | '3g' | '4g'
+- IDBController : Controller class managing IndexedDB instance lifecycle, providing methods to open, close, and interact with the database. Use when you need programmatic control over IndexedDB operations beyond basic hooks. — params: constructor(config: IndexedDBConfig) — returns: IDBController instance with open(), close(), getStore(), and transaction methods
+- IndexedDBConfig : Configuration object for IndexedDB operations, specifying database name, version, and store schema. Use when setting up persistent client-side storage with custom store structures. — params: { dbName: string, version?: number, stores: { name: string, keyPath?: string, autoIncrement?: boolean }[] }
+- InjectableProps : An interface defining the props that can be injected into a component. It is used to specify the properties that can be dynamically added to a component. — params: N/A — returns: N/A
+- LLMConfig : Configuration object for setting up an LLM client, including model details, API keys, and connection parameters. Use this to define how the LLM should behave and connect. — params: Optional: { model: string, apiKey: string, endpoint: string, temperature?: number, maxTokens?: number } — returns: A typed configuration object for LLM initialization — e.g. const config: LLMConfig = { model: 'gpt-4', apiKey: 'your-key', endpoint: 'https://api.openai.com/v1' }
+- LLMPayload : Payload structure for sending requests to an LLM, containing the prompt, conversation context, and optional parameters. Use this to format data sent to the LLM service. — params: Optional: { prompt: string, messages?: Message[], temperature?: number, maxTokens?: number, stream?: boolean } — returns: A typed payload object for LLM requests — e.g. const payload: LLMPayload = { prompt: 'Translate to French:', messages: [{ role: 'user', content: 'Hello world' }] }
+- NetworkState : TypeScript type representing the complete network state object returned by useNetworkState hook. It includes online status, timestamps, bandwidth information, effective connection type, round-trip time, data saver status, and connection type. — e.g. { online: boolean, since: number, downlink: number, downlinkMax: number, effectiveType: EffectiveConnectionType, rtt: number, saveData: boolean, type: ConnectionType }
+- OGType : Type definition for Open Graph metadata types. Represents the standardized vocabulary for social media sharing metadata, used to control how content appears when shared on platforms like Facebook and Twitter.
+- PreferredTheme : A type alias for the possible theme values ('light' or 'dark'). It is used to ensure type safety when working with theme-related values. — params: N/A — returns: N/A
+- RageClickPayload : Interface describing the payload structure for rage click events, typically containing timestamp, element info, and click count. Used when tracking rapid repeated clicks for UX analysis or error reporting.
+- RunOptions : Options object for controlling execution behavior of threaded operations, including timeout settings, retry logic, and error handling strategies. Used to customize how tasks run in worker threads.
+- ThreadedWorkerMode : Enumeration defining worker modes: 'shared' for SharedWorker instances or 'dedicated' for standard Web Workers. Determines how worker threads are instantiated and shared across components.
+- useClipboard (Hook) : React hook that provides access to the system clipboard, allowing reading and writing of clipboard content. It returns an object with methods to read and write text to the clipboard, handling browser compatibility and permissions. — params: options?: UseClipboardOptions — returns: UseClipboardReturn: { readText: () => Promise<string>, writeText: (text: string) => Promise<void> } — e.g. const { readText, writeText } = useClipboard()
+- UseClipboardOptions : TypeScript type representing the options object for the useClipboard hook. Currently it may include configuration options for clipboard behavior, though the exact properties depend on the implementation. — e.g. {}
+- UseClipboardReturn : TypeScript type representing the return value of the useClipboard hook. It includes readText and writeText methods that return promises for asynchronous clipboard operations. — e.g. { readText: () => Promise<string>, writeText: (text: string) => Promise<void> }
+- useEventBus (Hook) : A hook that provides a simple event bus for component communication. It allows components to emit and listen to events without prop drilling. — params: N/A — returns: Object with emit and on methods for event handling
+- useIndexedDB (Hook) : Hook for managing IndexedDB database operations including opening connections, reading, writing, and deleting data. Provides reactive state management for database changes and error handling. — params: dbName: string, options?: { version?: number, objectStores?: string[] } — returns: { db: IDBDatabase | null, error: Error | null, isOpen: boolean, close: () => void } — e.g. const { db, isOpen, error } = useIndexedDB('myDatabase');
+- UseIndexedDBReturn : Return type from useIndexedDB hook containing database instance, store references, and utility methods. Use to access structured data operations and transaction capabilities within React components. — params: { db: IDBDatabase, stores: Record<string, IDBObjectStore>, transaction: (stores: string[], mode?: IDBTransactionMode) => IDBTransaction }
+- useLLMMetadata (Hook) : React hook that retrieves metadata about the underlying LLVM/WebAssembly compilation environment. Provides information about the current runtime capabilities, version, and available features for debugging and optimization. — returns: object containing metadata properties — e.g. const metadata = useLLMMetadata()
+- useMutationObserver (Hook) : A hook that observes DOM mutations on a given element and calls a callback when mutations occur. It is useful for reacting to changes in the DOM structure or attributes. — params: element: Element, callback: (mutations: MutationRecord[]) => void, options?: MutationObserverInit — returns: void
+- UseMutationObserverOptions : An interface defining the options for the useMutationObserver hook. It extends MutationObserverInit and includes additional properties specific to the hook. — params: N/A — returns: N/A
+- useNetworkState (Hook) : React hook that returns the current network state of the device, including connection type, effective connection type, and whether the device is online or offline. It uses the browser's Network Information API to provide real-time updates when the network conditions change. — params: options?: { refreshRate?: number } — returns: NetworkState: { online: boolean, since: number, downlink: number, downlinkMax: number, effectiveType: EffectiveConnectionType, rtt: number, saveData: boolean, type: ConnectionType } — e.g. const { online, type, effectiveType } = useNetworkState()
+- usePreferredTheme (Hook) : A hook that provides the user's preferred theme (light or dark) based on system preferences or user settings. It is useful for implementing theme-aware components. — params: N/A — returns: String representing the preferred theme ('light' or 'dark')
+- useRageClick (Hook) : React hook that detects rapid, repeated clicks on an element, commonly known as rage clicks. It helps identify user frustration by tracking multiple clicks in quick succession and provides a callback when such behavior is detected. — params: options?: { threshold?: number, timeWindow?: number, callback?: (event: MouseEvent) => void } — returns: void — e.g. useRageClick({ threshold: 3, timeWindow: 1000, callback: (event) => console.log('Rage click detected!') })
+- UseRageClickOptions : Configuration options for the useRageClick hook, including threshold for clicks per second, timeout duration, and callback handler. Allows customization of rage click detection sensitivity and behavior.
+- useThreadedWorker (Hook) : Hook that creates and manages a Web Worker thread for offloading heavy computations or operations. Returns worker instance and control methods for communication and lifecycle management. — params: options: UseThreadedWorkerOptions — returns: UseThreadedWorkerReturn — e.g. const { worker, postMessage, terminate } = useThreadedWorker({ worker: myWorker });
+- UseThreadedWorkerOptions : Configuration object for useThreadedWorker hook containing worker script URL or blob, mode selection, and optional initialization parameters. Defines how the worker thread should be created and configured.
+- UseThreadedWorkerReturn : Return type from useThreadedWorker hook containing worker instance, message posting method, event listeners, and cleanup functions. Provides complete interface for interacting with the managed worker thread.
+- useTransition (Hook) : A hook that provides a transition state and a function to start a transition. It is used to defer non-urgent updates to avoid blocking the UI during high-priority updates. — params: options?: { timeoutMs?: number } — returns: Array containing a boolean indicating if a transition is in progress and a function to start a transition
+- useWasmCompute (Hook) : Hook that loads and executes WebAssembly modules for high-performance computation in the browser. Use when you need to run CPU-intensive tasks like image processing, cryptography, or numerical computations without blocking the main thread. — params: options: UseWasmComputeOptions — returns: Promise resolving to Wasm module instance with exported functions
+- UseWasmComputeOptions : Configuration object for useWasmCompute hook specifying WASM module source, imports, and execution parameters. Use to configure memory limits, import objects, and execution environment for WebAssembly modules. — params: { moduleUrl: string, imports?: Record<string, any>, memorySize?: number }
+- UseWasmComputeReturn : Type definition for the return value of a WASM compute function. Represents the structured result of a WebAssembly-based computation, typically containing status, data, and error information.
+- useWebRTCIP (Hook) : Hook that retrieves local WebRTC IP addresses by creating a peer connection and parsing ICE candidates. Use when you need to detect client IP addresses for WebRTC signaling or network diagnostics. — params: options?: UseWebRTCIPOptions — returns: UseWebRTCIPReturn containing ipAddresses: string[] and loading: boolean
+- UseWebRTCIPOptions : Configuration options for useWebRTCIP hook, allowing customization of timeout duration and STUN/TURN server configuration. Use to control how long the hook waits for ICE gathering and which servers to use. — params: { timeout?: number, iceServers?: RTCIceServer[] }
+- UseWebRTCIPReturn : Return object from useWebRTCIP hook containing detected IP addresses and loading state. Use to access the gathered IP addresses and determine when the operation is complete. — params: { ipAddresses: string[], loading: boolean }
+- useWorkerNotifications (Hook) : React hook that subscribes to notifications from a Web Worker. Provides real-time updates from background processing tasks, allowing components to react to worker events without manual event listener management. — params: options: UseWorkerNotificationsOptions — returns: UseWorkerNotificationsReturn — e.g. const { notifications, error } = useWorkerNotifications({ worker: myWorker })
+- UseWorkerNotificationsOptions : Configuration object type for the useWorkerNotifications hook. Specifies parameters like the worker instance, event filters, and optional callback handlers for customizing notification subscription behavior.
+- UseWorkerNotificationsReturn : Return type for the useWorkerNotifications hook. Provides an object containing the current notifications array, error state, and optional methods for managing the subscription to worker events.
+- useWrappedChildren (Hook) : A hook that wraps child components with additional functionality or styling. It is useful for applying consistent behavior or appearance to a group of child components. — params: children: ReactNode, wrapper: (child: ReactNode) => ReactNode — returns: ReactNode
+- WorkerEventType : Enumeration of possible event types that can be emitted by a Web Worker. Defines the standard set of notification categories for worker-to-main-thread communication, enabling type-safe event handling.
+- WorkerNotificationEvent : Type definition for a worker notification event object. Contains metadata about a specific event from a Web Worker, including type, timestamp, and payload data for structured communication.
+
+Hooks:
+- useTransition
+- useMutationObserver
+- useEventBus
+- useWrappedChildren
+- usePreferredTheme
+- useNetworkState
+- useClipboard
+- useRageClick
+- useThreadedWorker
+- useIndexedDB
+- useWebRTCIP
+- useWasmCompute
+- useWorkerNotifications
+- useLLMMetadata
+
+Frameworks:
+preact, react

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "preact-missing-hooks",
-  "version": "4.1.0",
+  "version": "4.3.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",
@@ -90,7 +90,8 @@
   },
   "scripts": {
     "build": "microbundle --alias react=preact/compat && npm run build:react && node scripts/generate-entry.cjs",
-    "build:react": "microbundle -i src/index.ts -o dist/react.js --alias preact=react,preact/hooks=react --no-sourcemap",
+    "llm:generate": "hayagriva-llm generate",
+    "build:react": "rollup -c scripts/rollup.react.config.cjs",
     "dev": "microbundle watch",
     "prepublishOnly": "npm run build",
     "test": "vitest run",
@@ -102,7 +103,8 @@
     "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
     "format:check": "prettier --check \"src/**/*.{ts,tsx,json,md}\"",
     "prepare": "husky",
-    "size": "npm run build && size-limit"
+    "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"
   },
   "size-limit": [
     {
@@ -142,7 +144,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/prakhardubey2002/Preact-Missing-Hooks"
+    "url": "git+https://github.com/prakhardubey2002/Preact-Missing-Hooks.git"
   },
   "dependencies": {
     "preact": ">=10.0.0"
@@ -154,9 +156,11 @@
     "@testing-library/preact": "^3.2.4",
     "@testing-library/react": "^16.0.1",
     "@types/jest": "^29.5.14",
+    "@types/react": "^18.3.0",
     "eslint": "^9.15.0",
     "eslint-config-prettier": "^9.1.0",
     "fake-indexeddb": "^6.0.2",
+    "hayagriva-llm": "^1.2.0",
     "husky": "^9.1.7",
     "jsdom": "^26.1.0",
     "microbundle": "^0.15.1",

package/scripts/rollup.react.config.cjs

@@ -0,0 +1,34 @@
+/**
+ * Rollup config for the React build (preact aliased to react).
+ * Uses rollup-plugin-typescript2 with clean: true to avoid EPERM cache
+ * rename issues on Windows.
+ */
+const path = require("path");
+const alias = require("@rollup/plugin-alias");
+const { nodeResolve } = require("@rollup/plugin-node-resolve");
+const commonjs = require("@rollup/plugin-commonjs");
+const typescript = require("rollup-plugin-typescript2");
+
+module.exports = {
+  input: path.join(__dirname, "..", "src", "index.ts"),
+  output: {
+    file: path.join(__dirname, "..", "dist", "react.js"),
+    format: "cjs",
+    sourcemap: false,
+  },
+  external: ["react", "react-dom"],
+  plugins: [
+    alias({
+      entries: [
+        { find: "preact/hooks", replacement: "react" },
+        { find: "preact", replacement: "react" },
+      ],
+    }),
+    nodeResolve(),
+    commonjs(),
+    typescript({
+      clean: true,
+      tsconfig: path.join(__dirname, "..", "tsconfig.json"),
+    }),
+  ],
+};