@siberiacancode/reactuse 0.3.10 → 0.3.13

package/dist/types/hooks/time.d.ts

@@ -1,4 +1,5 @@
 export * from './useInterval/useInterval';
+export * from './useProgress/useProgress';
 export * from './useStopwatch/useStopwatch';
 export * from './useTime/useTime';
 export * from './useTimeout/useTimeout';

package/dist/types/hooks/useActiveElement/useActiveElement.d.ts

@@ -1,13 +1,14 @@
 import { HookTarget } from '../../utils/helpers';
 import { StateRef } from '../useRefState/useRefState';
 /** The use active element return type */
-export type UseActiveElementReturn<ActiveElement extends HTMLElement = HTMLElement> = ActiveElement | null;
+export interface UseActiveElementReturn<ActiveElement extends HTMLElement = HTMLElement> {
+    value: ActiveElement | null;
+}
 export interface UseActiveElement {
     (): UseActiveElementReturn;
     <Target extends Element, ActiveElement extends HTMLElement = HTMLElement>(target?: never): {
         ref: StateRef<Target>;
-        value: UseActiveElementReturn<ActiveElement>;
-    };
+    } & UseActiveElementReturn<ActiveElement>;
     <ActiveElement extends HTMLElement = HTMLElement>(target: HookTarget): UseActiveElementReturn<ActiveElement>;
 }
 /**

package/dist/types/hooks/useAutoScroll/useAutoScroll.d.ts

@@ -9,7 +9,9 @@ export interface UseAutoScrollOptions {
 }
 export interface UseAutoScroll {
     (target: HookTarget, options?: UseAutoScrollOptions): void;
-    <Target extends HTMLElement>(options?: UseAutoScrollOptions): StateRef<Target>;
+    <Target extends HTMLElement>(options?: UseAutoScrollOptions): {
+        ref: StateRef<Target>;
+    };
 }
 /**
  * @name useAutoScroll
@@ -28,9 +30,9 @@ export interface UseAutoScroll {
  * @overload
  * @template Target
  * @param {boolean} [options.enabled] Whether auto-scrolling is enabled
- * @returns {StateRef<Target>} A React ref to attach to the list element
+ * @returns {{ ref: StateRef<Target> }} A React ref to attach to the list element
  *
  * @example
- * const ref = useAutoScroll();
+ * const { ref } = useAutoScroll();
  */
 export declare const useAutoScroll: UseAutoScroll;

package/dist/types/hooks/useClickOutside/useClickOutside.d.ts

@@ -2,7 +2,9 @@ import { HookTarget } from '../../utils/helpers';
 import { StateRef } from '../useRefState/useRefState';
 export interface UseClickOutside {
     (target: HookTarget, callback: (event: Event) => void): void;
-    <Target extends Element>(callback: (event: Event) => void, target?: never): StateRef<Target>;
+    <Target extends Element>(callback: (event: Event) => void, target?: never): {
+        ref: StateRef<Target>;
+    };
 }
 /**
  * @name useClickOutside
@@ -21,10 +23,10 @@ export interface UseClickOutside {
  * @overload
  * @template Target The target element(s)
  * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
- * @returns {StateRef<Target>} A ref to attach to the target element
+ * @returns {{ ref: StateRef<Target> }} A ref to attach to the target element
  *
  * @example
- * const ref = useClickOutside<HTMLDivElement>(() => console.log('click outside'));
+ * const { ref } = useClickOutside<HTMLDivElement>(() => console.log('click outside'));
  *
  * @see {@link https://siberiacancode.github.io/reactuse/functions/hooks/useClickOutside.html}
  */

package/dist/types/hooks/useDoubleClick/useDoubleClick.d.ts

@@ -9,8 +9,10 @@ export interface UseDoubleClickOptions {
     onSingleClick?: (event: DoubleClickEvents) => void;
 }
 export interface UseDoubleClick {
-    (target: HookTarget, callback: (event: DoubleClickEvents) => void, options?: UseDoubleClickOptions): boolean;
-    <Target extends Element>(callback: (event: DoubleClickEvents) => void, options?: UseDoubleClickOptions, target?: never): StateRef<Target>;
+    (target: HookTarget, callback: (event: DoubleClickEvents) => void, options?: UseDoubleClickOptions): void;
+    <Target extends Element>(callback: (event: DoubleClickEvents) => void, options?: UseDoubleClickOptions, target?: never): {
+        ref: StateRef<Target>;
+    };
 }
 export declare const DEFAULT_THRESHOLD_TIME = 300;
 /**
@@ -23,7 +25,7 @@ export declare const DEFAULT_THRESHOLD_TIME = 300;
  * @param {HookTarget} target The target element to be double clicked
  * @param {(event: DoubleClickEvents) => void} callback The callback function to be invoked on double click
  * @param {UseDoubleClickOptions} [options] The options for the double click
- * @returns {boolean} The double clicking state
+ * @returns {void} The double clicking state
  *
  * @example
  * useDoubleClick(ref, () => console.log('double clicked'));
@@ -32,10 +34,10 @@ export declare const DEFAULT_THRESHOLD_TIME = 300;
  * @template Target The target element
  * @param {(event: DoubleClickEvents) => void} callback The callback function to be invoked on double click
  * @param {UseDoubleClickOptions} [options] The options for the double click
- * @returns {boolean} The double clicking state
+ * @returns {{ ref: StateRef<Target> }} The double clicking state
  *
  * @example
- * const ref = useDoubleClick(() => console.log('double clicked'));
+ * const { ref } = useDoubleClick(() => console.log('double clicked'));
  *
  * @see {@link https://siberiacancode.github.io/reactuse/functions/hooks/useDoubleClick.html}
  */

package/dist/types/hooks/useFocusTrap/useFocusTrap.d.ts

@@ -27,7 +27,7 @@ export interface UseFocusTrap {
  * @overload
  * @param {HookTarget} target The target element for focus trap
  * @param {boolean} [active=true] Whether focus trap is active
- * @returns {UseFocusTrapReturn} Object with control methods and state
+ * @returns {UseFocusTrapReturn} Object with the focus trap state and methods
  *
  * @example
  * const { active, disable, toggle, enable } = useFocusTrap(ref, true);
@@ -35,7 +35,7 @@ export interface UseFocusTrap {
  * @overload
  * @template Target The target element type
  * @param {boolean} [active=true] Whether focus trap is active
- * @returns {UseFocusTrapReturn & { ref: StateRef<Target> }} Object with ref and controls
+ * @returns {UseFocusTrapReturn & { ref: StateRef<Target> }} Object with the focus trap state and methods
  *
  * @example
  * const { ref, active, disable, toggle, enable } = useFocusTrap(true);

package/dist/types/hooks/useHash/useHash.d.ts

@@ -9,7 +9,12 @@ export interface UseHashOptions {
     onChange?: (hash: string) => void;
 }
 /** The use hash return type */
-type UseHashReturn = [string, (value: string) => void];
+interface UseHashReturn {
+    /** The hash value */
+    value: string;
+    /** The function to set the hash value */
+    set: (value: string) => void;
+}
 export interface UseHash {
     (initialValue?: string, options?: UseHashOptions): UseHashReturn;
     (options?: UseHashOptions): UseHashReturn;
@@ -31,7 +36,7 @@ export interface UseHash {
  * @returns {UseHashReturn} An array containing the hash value and a function to set the hash value
  *
  * @example
- * const [hash, setHash] = useHash("initial");
+ * const { value, set } = useHash("initial");
  *
  * @overload
  * @param {string} [initialValue] The initial hash value if no hash exists
@@ -39,7 +44,7 @@ export interface UseHash {
  * @returns {UseHashReturn} An array containing the hash value and a function to set the hash value
  *
  * @example
- * const [hash, setHash] = useHash("initial", (newHash) => console.log('callback'));
+ * const { value, set } = useHash("initial", (newHash) => console.log('callback'));
  *
  * @overload
  * @param {UseHashOptions} [options] Configuration options
@@ -49,14 +54,14 @@ export interface UseHash {
  * @returns {UseHashReturn} An array containing the hash value and a function to set the hash value
  *
  * @example
- * const [hash, setHash] = useHash();
+ * const { value, set } = useHash();
  *
  * @overload
  * @param {(hash: string) => void} [callback] Callback function called when hash changes
  * @returns {UseHashReturn} An array containing the hash value and a function to set the hash value
  *
  * @example
- * const [hash, setHash] = useHash((newHash) => console.log('callback'));
+ * const { value, set } = useHash((newHash) => console.log('callback'));
  */
 export declare const useHash: UseHash;
 export {};

package/dist/types/hooks/useHover/useHover.d.ts

@@ -9,18 +9,20 @@ export interface UseHoverOptions {
     /** The on leave callback */
     onLeave?: (event: Event) => void;
 }
+/** The use hover return type */
 export interface UseHoverReturn {
+    /** The value of the hover */
     value: boolean;
 }
 export interface UseHover {
-    (target: HookTarget, callback?: (event: Event) => void): boolean;
-    (target: HookTarget, options?: UseHoverOptions): boolean;
-    <Target extends Element>(callback?: (event: Event) => void, target?: never): {
+    (target: HookTarget, callback?: (event: Event) => void): UseHoverReturn;
+    (target: HookTarget, options?: UseHoverOptions): UseHoverReturn;
+    <Target extends Element>(callback?: (event: Event) => void, target?: never): UseHoverReturn & {
         ref: StateRef<Target>;
-    } & UseHoverReturn;
-    <Target extends Element>(options?: UseHoverOptions, target?: never): {
+    };
+    <Target extends Element>(options?: UseHoverOptions, target?: never): UseHoverReturn & {
         ref: StateRef<Target>;
-    } & UseHoverReturn;
+    };
 }
 /**
  * @name useHover

package/dist/types/hooks/useInfiniteScroll/useInfiniteScroll.d.ts

@@ -7,11 +7,17 @@ export interface UseInfiniteScrollOptions {
     /** The distance in pixels to trigger the callback */
     distance?: number;
 }
+/** The use infinite scroll return type */
+export interface UseInfiniteScrollReturn {
+    /** The loading state of the infinite scroll */
+    loading: boolean;
+    /** The ref to attach to the element */
+    ref: StateRef<Element>;
+}
 export interface UseInfiniteScroll {
-    (target: HookTarget, callback: (event: Event) => void, options?: UseInfiniteScrollOptions): boolean;
-    <Target extends Element>(callback: (event: Event) => void, options?: UseInfiniteScrollOptions, target?: never): {
+    (target: HookTarget, callback: (event: Event) => void, options?: UseInfiniteScrollOptions): UseInfiniteScrollReturn;
+    <Target extends Element>(callback: (event: Event) => void, options?: UseInfiniteScrollOptions, target?: never): UseInfiniteScrollReturn & {
         ref: StateRef<Target>;
-        loading: boolean;
     };
 }
 /**
@@ -25,7 +31,7 @@ export interface UseInfiniteScroll {
  * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
  * @param {number} [options.distance=10] The distance in pixels to trigger the callback
  * @param {string} [options.direction='bottom'] The direction to trigger the callback
- * @returns {{ ref: StateRef<Target>, loading: boolean }} An object containing the ref and loading
+ * @returns {UseInfiniteScrollReturn & { ref: StateRef<Target> }} An object containing the ref and loading
  *
  * @example
  * const { ref, loading } = useInfiniteScroll(() => console.log('infinite scroll'));
@@ -35,9 +41,9 @@ export interface UseInfiniteScroll {
  * @param {(event: Event) => void} callback The callback to execute when a click outside the target is detected
  * @param {number} [options.distance=10] The distance in pixels to trigger the callback
  * @param {string} [options.direction='bottom'] The direction to trigger the callback
- * @returns {boolean} A loading indicator of the infinite scroll
+ * @returns {UseInfiniteScrollReturn} An object containing the ref and loading
  *
  * @example
- * const loading = useInfiniteScroll(ref, () => console.log('infinite scroll'));
+ * const { loading } = useInfiniteScroll(ref, () => console.log('infinite scroll'));
  */
 export declare const useInfiniteScroll: UseInfiniteScroll;

package/dist/types/hooks/useKeyPress/useKeyPress.d.ts

@@ -4,10 +4,16 @@ import { StateRef } from '../useRefState/useRefState';
 export type UseKeyPressKey = string | string[];
 /** The callback function to be invoked when key is pressed */
 export type UseKeyPressCallback = (pressed: boolean, event: KeyboardEvent) => void;
+/** The use key press return type */
+export interface UseKeyPressReturn {
+    /** The pressed state of the key */
+    pressed: boolean;
+    /** The ref to attach to the element */
+    ref: StateRef<Element>;
+}
 export interface UseKeyPress {
-    (target: HookTarget | Window, key: UseKeyPressKey, callback?: UseKeyPressCallback): boolean;
-    <Target extends Element>(key: UseKeyPressKey, callback?: UseKeyPressCallback, target?: never): {
-        pressed: boolean;
+    (target: HookTarget | Window, key: UseKeyPressKey, callback?: UseKeyPressCallback): UseKeyPressReturn;
+    <Target extends Element>(key: UseKeyPressKey, callback?: UseKeyPressCallback, target?: never): UseKeyPressReturn & {
         ref: StateRef<Target>;
     };
 }
@@ -21,7 +27,7 @@ export interface UseKeyPress {
  * @param {HookTarget} [target=window] The target to attach the event listeners to
  * @param {UseKeyPressKey} key The key or keys to listen for
  * @param {(pressed: boolean, event: KeyboardEvent) => void} [callback] Callback function invoked when key is pressed
- * @returns {boolean} The pressed state of the key
+ * @returns {UseKeyPressReturn} An object containing the pressed state and ref
  *
  * @example
  * const isKeyPressed = useKeyPress(ref, 'a');

package/dist/types/hooks/useKeysPressed/useKeysPressed.d.ts

@@ -5,16 +5,16 @@ export interface UseKeysPressedOptions {
     /** Enable or disable the event listeners */
     enabled?: boolean;
 }
-export interface UseKeysPressed {
-    (target: HookTarget | Window, options?: UseKeysPressedOptions): Array<{
+export interface UseKeysPressedReturn {
+    /** The array of currently pressed keys */
+    value: Array<{
         key: string;
         code: string;
     }>;
-    <Target extends Element>(options?: UseKeysPressedOptions): {
-        value: Array<{
-            key: string;
-            code: string;
-        }>;
+}
+export interface UseKeysPressed {
+    (target: HookTarget | Window, options?: UseKeysPressedOptions): UseKeysPressedReturn;
+    <Target extends Element>(options?: UseKeysPressedOptions): UseKeysPressedReturn & {
         ref: StateRef<Target>;
     };
 }
@@ -27,15 +27,15 @@ export interface UseKeysPressed {
  * @overload
  * @param {HookTarget | Window} target DOM element or ref to attach keyboard listeners to
  * @param {UseKeysPressedOptions} [options.enabled=true] Enable or disable the event listeners
- * @returns {Array<{ key: string; code: string }>} Array of currently pressed keys with their key and code values
+ * @returns {UseKeysPressedReturn} Object containing the array of currently pressed keys
  *
  * @example
- * const pressedKeys = useKeysPressed(ref);
+ * const { value } = useKeysPressed(ref);
  *
  * @overload
  * @template Target - Type of the target DOM element
  * @param {UseKeysPressedOptions} [options] - Optional configuration options
- * @returns {{ keys: Array<{ key: string; code: string }>; ref: StateRef<Target> }} Object containing pressed keys array and ref to attach to a DOM element
+ * @returns {UseKeysPressedReturn & { ref: StateRef<Target> }} Object containing the array of currently pressed keys and ref to attach to the element
  *
  * @example
  * const { value, ref } = useKeysPressed();

package/dist/types/hooks/useLongPress/useLongPress.d.ts

@@ -7,12 +7,18 @@ export interface UseLongPressOptions {
     onFinish?: (event: LongPressEvents) => void;
     onStart?: (event: LongPressEvents) => void;
 }
+/** The use long press return type */
+export interface UseLongPressReturn {
+    /** The long pressing state */
+    pressed: boolean;
+    /** The ref to attach to the element */
+    ref: StateRef<Element>;
+}
 export interface UseLongPress {
-    (target: HookTarget, callback: (event: LongPressEvents) => void, options?: UseLongPressOptions): boolean;
+    (target: HookTarget, callback: (event: LongPressEvents) => void, options?: UseLongPressOptions): UseLongPressReturn;
     <Target extends Element>(callback: (event: LongPressEvents) => void, options?: UseLongPressOptions, target?: never): {
         ref: StateRef<Target>;
-        pressed: boolean;
-    };
+    } & UseLongPressReturn;
 }
 /**
  * @name useLongPress

package/dist/types/hooks/usePostMessage/usePostMessage.d.ts

@@ -1,3 +1,6 @@
+/** The origin of the message */
+export type UsePostMessageOrigin = string | '*' | string[];
+/** The return type of the usePostMessage hook */
 export type UsePostMessageReturn<Message> = (message: Message) => void;
 /**
  * @name usePostMessage
@@ -7,11 +10,11 @@ export type UsePostMessageReturn<Message> = (message: Message) => void;
  *
  * @overload
  * @template Message The message data type
- * @param {string | string[]} origin The origin of the message
+ * @param {UsePostMessageOrigin} origin The origin of the message
  * @param {(message: Message) => Message} callback callback to get received message
  * @returns {(message: Message) => void} An object containing the current message
  *
  * @example
  * const postMessage = usePostMessage();
  */
-export declare const usePostMessage: <Message>(origin: string | "*" | string[], callback: (message: Message, event: MessageEvent<Message>) => void) => UsePostMessageReturn<Message>;
+export declare const usePostMessage: <Message>(origin: UsePostMessageOrigin, callback: (message: Message, event: MessageEvent<Message>) => void) => UsePostMessageReturn<Message>;

package/dist/types/hooks/useProgress/useProgress.d.ts

@@ -0,0 +1,51 @@
+/** The use progress options type */
+export interface UseProgressOptions {
+    /** Start progress immediately */
+    immediately?: boolean;
+    /** Maximum progress value */
+    maximum?: number;
+    /** Additional random amount for each auto increment */
+    rate?: number;
+    /** Auto-increment frequency in milliseconds */
+    speed?: number;
+}
+/** The use progress return type */
+export interface UseProgressReturn {
+    /** Whether progress is currently active */
+    active: boolean;
+    /** Current progress value in range 0..1, null means hidden */
+    value: number;
+    /** Complete progress to 100% */
+    done: (force?: boolean) => number | null;
+    /** Increment progress with easing behavior */
+    inc: (amount?: number) => number | null;
+    /** Remove progress and stop timers */
+    remove: () => void;
+    /** Start progress and auto incrementing */
+    start: (from?: number | null) => number;
+}
+/**
+ * @name useProgress
+ * @description - Hook that creates a lightweight progress bar state with NProgress-like behavior
+ * @category Time
+ * @usage medium
+ *
+ * @param {number} [initialProgress] Initial progress value in range 0..1
+ * @param {boolean} [options.active] Controls progress externally (true -> start, false -> done)
+ * @param {number} [options.maximum=0.95] Maximum value when progress starts
+ * @param {number} [options.speed=250] Auto increment interval in milliseconds
+ * @param {number} [options.rate=0.02] Additional random increment amount on each tick
+ * @param {number} [options.doneResetDelay=250] Delay before reset to null after done
+ * @returns {UseProgressReturn} Current progress state and control methods
+ *
+ * @example
+ * const { value, active, start, done, inc, set, remove } = useProgress(0.2);
+ */
+export declare const useProgress: (initialValue?: number, options?: UseProgressOptions) => {
+    value: number;
+    active: boolean;
+    start: (from?: number) => void;
+    done: () => void;
+    inc: (amount?: number) => void;
+    remove: () => void;
+};

package/dist/types/hooks/useSticky/useSticky.d.ts

@@ -12,10 +12,10 @@ export interface UseStickyOptions {
     root?: HookTarget;
 }
 export interface UseSticky {
-    (target: HookTarget, options?: UseStickyOptions): boolean;
-    <Target extends Element>(options?: UseStickyOptions, target?: never): {
+    (target: HookTarget, options?: UseStickyOptions): UseStickyReturn;
+    <Target extends Element>(options?: UseStickyOptions, target?: never): UseStickyReturn & {
         ref: StateRef<Target>;
-    } & UseStickyReturn;
+    };
 }
 /**
  * @name UseSticky
@@ -30,12 +30,12 @@ export interface UseSticky {
  * @returns {UseStickyReturn} The state of the sticky
  *
  * @example
- * const stuck  = useSticky(ref);
+ * const { stuck } = useSticky(ref);
  *
  * @overload
  * @param {UseStickyAxis} [options.axis='vertical'] The axis of motion of the sticky component
  * @param {UseStickyRoot} [options.root=document] The element that contains your sticky component
- * @returns {{ stickyRef: StateRef<Target> } & UseStickyReturn} The state of the sticky
+ * @returns {{ ref: StateRef<Target> } & UseStickyReturn} The state of the sticky
  *
  * @example
  * const { stuck, ref } = useSticky();

package/package.json

@@ -1,89 +1,89 @@
-{
-  "name": "@siberiacancode/reactuse",
-  "version": "0.3.10",
-  "description": "The ultimate collection of react hooks",
-  "author": {
-    "name": "SIBERIA CAN CODE 🧊",
-    "url": "https://github.com/siberiacancode"
-  },
-  "license": "MIT",
-  "homepage": "https://siberiacancode.github.io/reactuse/",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/siberiacancode/reactuse.git",
-    "directory": "packages/core"
-  },
-  "bugs": "https://github.com/siberiacancode/reactuse/issues",
-  "keywords": [
-    "react",
-    "react hooks",
-    "react use",
-    "use",
-    "hooks"
-  ],
-  "sideEffects": false,
-  "exports": {
-    "types": "./dist/types/index.d.ts",
-    "import": "./dist/esm/index.mjs",
-    "require": "./dist/cjs/index.cjs"
-  },
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.mjs",
-  "types": "dist/types/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "engines": {
-    "node": ">=14"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "prepublishOnly": "pnpm unit-test run && pnpm build",
-    "build": "shx rm -rf dist && vite build",
-    "build:js": "tsc --project tsconfig.build.json && prettier --write src/bundle",
-    "lint": "eslint . --fix",
-    "lint-inspector": "npx @eslint/config-inspector@latest",
-    "format": "prettier --write .",
-    "pretty": "pnpm lint && pnpm format",
-    "unit-test": "vitest",
-    "lint-staged": "lint-staged"
-  },
-  "peerDependencies": {
-    "@types/react": "^18 || ^19",
-    "react": "^18 || ^19",
-    "react-dom": "^18 || ^19"
-  },
-  "peerDependenciesMeta": {
-    "@types/react": {
-      "optional": true
-    }
-  },
-  "dependencies": {
-    "screenfull": "^6.0.2"
-  },
-  "devDependencies": {
-    "@siberiacancode/vitest": "^2.3.0",
-    "@testing-library/dom": "^10.4.1",
-    "@testing-library/react": "^16.3.1",
-    "@types/dom-speech-recognition": "^0.0.7",
-    "@types/react": "^19.2.7",
-    "@types/react-dom": "^19.2.3",
-    "@types/web-bluetooth": "^0.0.21",
-    "@vitejs/plugin-react": "^5.1.2",
-    "core-js": "^3.47.0",
-    "react": "^19.2.3",
-    "react-dom": "^19.2.3",
-    "shx": "^0.4.0",
-    "vite": "^7.3.0",
-    "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.0.16"
-  },
-  "lint-staged": {
-    "*.{js,ts,tsx}": [
-      "eslint --fix",
-      "prettier --write"
-    ]
-  }
-}
+{
+  "name": "@siberiacancode/reactuse",
+  "version": "0.3.13",
+  "description": "The ultimate collection of react hooks",
+  "author": {
+    "name": "SIBERIA CAN CODE 🧊",
+    "url": "https://github.com/siberiacancode"
+  },
+  "license": "MIT",
+  "homepage": "https://siberiacancode.github.io/reactuse/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/siberiacancode/reactuse.git",
+    "directory": "packages/core"
+  },
+  "bugs": "https://github.com/siberiacancode/reactuse/issues",
+  "keywords": [
+    "react",
+    "react hooks",
+    "react use",
+    "use",
+    "hooks"
+  ],
+  "sideEffects": false,
+  "exports": {
+    "types": "./dist/types/index.d.ts",
+    "import": "./dist/esm/index.mjs",
+    "require": "./dist/cjs/index.cjs"
+  },
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepublishOnly": "pnpm unit-test run && pnpm build",
+    "build": "shx rm -rf dist && vite build",
+    "build:js": "tsc --project tsconfig.build.json && prettier --write src/bundle",
+    "lint": "eslint . --fix",
+    "lint-inspector": "npx @eslint/config-inspector@latest",
+    "format": "prettier --write .",
+    "pretty": "pnpm lint && pnpm format",
+    "unit-test": "vitest",
+    "lint-staged": "lint-staged"
+  },
+  "peerDependencies": {
+    "@types/react": "^18 || ^19",
+    "react": "^18 || ^19",
+    "react-dom": "^18 || ^19"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "screenfull": "^6.0.2"
+  },
+  "devDependencies": {
+    "@siberiacancode/vitest": "^2.3.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/dom-speech-recognition": "^0.0.7",
+    "@types/react": "^19.2.13",
+    "@types/react-dom": "^19.2.3",
+    "@types/web-bluetooth": "^0.0.21",
+    "@vitejs/plugin-react": "^5.1.3",
+    "core-js": "^3.48.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "shx": "^0.4.0",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18"
+  },
+  "lint-staged": {
+    "*.{js,ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  }
+}