@siberiacancode/reactuse 0.2.32 → 0.2.34

package/dist/esm/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -5,6 +5,7 @@ export * from './useDoubleClick/useDoubleClick';
 export * from './useDropZone/useDropZone';
 export * from './useFileDialog/useFileDialog';
 export * from './useFocus/useFocus';
+export * from './useFocusTrap/useFocusTrap';
 export * from './useHover/useHover';
 export * from './useImage/useImage';
 export * from './useLongPress/useLongPress';

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

@@ -1,3 +1,4 @@
+export * from './useAsyncEffect/useAsyncEffect';
 export * from './useDidUpdate/useDidUpdate';
 export * from './useIsFirstRender/useIsFirstRender';
 export * from './useIsomorphicLayoutEffect/useIsomorphicLayoutEffect';

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

@@ -1,12 +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 UseActiveElement {
-    (): HTMLElement | null;
+    (): UseActiveElementReturn;
     <Target extends Element, ActiveElement extends HTMLElement = HTMLElement>(target?: never): {
         ref: StateRef<Target>;
-        value: ActiveElement | null;
+        value: UseActiveElementReturn<ActiveElement>;
     };
-    <ActiveElement extends HTMLElement = HTMLElement>(target: HookTarget): ActiveElement | null;
+    <ActiveElement extends HTMLElement = HTMLElement>(target: HookTarget): UseActiveElementReturn<ActiveElement>;
 }
 /**
  * @name useActiveElement

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

@@ -0,0 +1,14 @@
+import { DependencyList } from 'react';
+/**
+ * @name useAsyncEffect
+ * @description – Hook that triggers the effect callback on updates
+ * @category Lifecycle
+ * @usage medium
+
+ * @param {EffectCallback} effect The effect callback
+ * @param {DependencyList} [deps] The dependencies list for the effect
+ *
+ * @example
+ * useAsyncEffect(async () => console.log("effect runs on updates"), deps);
+ */
+export declare const useAsyncEffect: (сallback: () => Promise<any>, deps?: DependencyList) => void;

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

@@ -0,0 +1,42 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+/** The use focus trap return type */
+export interface UseFocusTrapReturn {
+    /** Whether focus trap is active */
+    active: boolean;
+    /** Disable focus trap */
+    disable: () => void;
+    /** Enable focus trap */
+    enable: () => void;
+    /** Toggle focus trap */
+    toggle: () => void;
+}
+export interface UseFocusTrap {
+    (target: HookTarget, active?: boolean): UseFocusTrapReturn;
+    <Target extends HTMLElement>(active?: boolean, target?: never): UseFocusTrapReturn & {
+        ref: StateRef<Target>;
+    };
+}
+/**
+ * @name useFocusTrap
+ * @description - Hook that traps focus within a given element
+ * @category Elements
+ * @usage medium
+ *
+ * @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
+ *
+ * @example
+ * const { active, disable, toggle, enable } = useFocusTrap(ref, true);
+ *
+ * @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
+ *
+ * @example
+ * const { ref, active, disable, toggle, enable } = useFocusTrap(true);
+ */
+export declare const useFocusTrap: UseFocusTrap;

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

@@ -1,16 +1,47 @@
+export declare const getHash: () => string;
+/** The use hash options type */
+export interface UseHashOptions {
+    /** The enabled state of the hook */
+    enabled?: boolean;
+    /** The mode of hash setting */
+    mode?: 'initial' | 'replace';
+    /** Callback function called when hash changes */
+    onChange?: (hash: string) => void;
+}
 /** The use hash return type */
 type UseHashReturn = [string, (value: string) => void];
+export interface UseHash {
+    (initialValue?: string, options?: UseHashOptions): UseHashReturn;
+    (initialValue?: string, callback?: (hash: string) => void): UseHashReturn;
+}
 /**
  * @name useHash
  * @description - Hook that manages the hash value
  * @category State
  * @usage low
  *
+ * @overload
  * @param {string} [initialValue] The initial hash value if no hash exists
+ * @param {UseHashOptions} [options] Configuration options
+ * @param {boolean} [options.enabled] The enabled state of the hook
+ * @param {'initial' | 'replace'} [options.mode] The mode of hash setting
+ * @param {(hash: string) => void} [options.onChange] 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("initial");
+ * const [hash, setHash] = useHash("initial", {
+ *   enabled: true,
+ *   mode: "replace",
+ *   onChange: (newHash) => console.log('Hash changed:', newHash)
+ * });
+ *
+ * @overload
+ * @param {string} [initialValue] The initial hash value if no hash exists
+ * @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("initial", (newHash) => console.log('Hash changed:', newHash));
  */
-export declare const useHash: (initialValue?: string, mode?: "initial" | "replace") => UseHashReturn;
+export declare const useHash: UseHash;
 export {};

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

@@ -3,7 +3,7 @@ import { StateRef } from '../useRefState/useRefState';
 /** The intersection observer callback type */
 export type UseIntersectionObserverCallback = (entry: IntersectionObserverEntry, observer: IntersectionObserver) => void;
 /** The intersection observer options type */
-export interface UseIntersectionObserverOptions extends Omit<IntersectionObserverInit, 'root'> {
+export interface UseIntersectionObserverOptions extends Omit<IntersectionObserverInit, "root"> {
     /** The enabled state of the intersection observer */
     enabled?: boolean;
     /** The callback to execute when intersection is detected */

package/package.json

@@ -1,89 +1,89 @@
-{
-  "name": "@siberiacancode/reactuse",
-  "version": "0.2.32",
-  "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.1.0",
-    "@testing-library/dom": "^10.4.1",
-    "@testing-library/react": "^16.3.0",
-    "@types/dom-speech-recognition": "^0.0.6",
-    "@types/react": "^19.1.10",
-    "@types/react-dom": "^19.1.7",
-    "@types/web-bluetooth": "^0.0.21",
-    "@vitejs/plugin-react": "^5.0.1",
-    "core-js": "^3.45.0",
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1",
-    "shx": "^0.4.0",
-    "vite": "^7.1.3",
-    "vite-plugin-dts": "^4.5.4",
-    "vitest": "^3.2.4"
-  },
-  "lint-staged": {
-    "*.{js,ts,tsx}": [
-      "eslint --fix",
-      "prettier --write"
-    ]
-  }
-}
+{
+  "name": "@siberiacancode/reactuse",
+  "version": "0.2.34",
+  "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.1.0",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.0",
+    "@types/dom-speech-recognition": "^0.0.6",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "@types/web-bluetooth": "^0.0.21",
+    "@vitejs/plugin-react": "^5.0.1",
+    "core-js": "^3.45.0",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "shx": "^0.4.0",
+    "vite": "^7.1.3",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.2.4"
+  },
+  "lint-staged": {
+    "*.{js,ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  }
+}