@siberiacancode/reactuse 0.0.113 → 0.0.115

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

@@ -0,0 +1,38 @@
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+export type DoubleClickEvents = MouseEvent | TouchEvent;
+export interface UseDoubleClickOptions {
+    threshold?: number;
+    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): {
+        ref: StateRef<Target>;
+        clicked: boolean;
+    };
+}
+/**
+ * @name useDoubleClick
+ * @description - Hook that defines the logic when double clicking an element
+ * @category Sensors
+ *
+ * @overload
+ * @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
+ *
+ * @example
+ * useDoubleClick(ref, () => console.log('double clicked'));
+ *
+ * @overload
+ * @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
+ *
+ * @example
+ * const ref = useDoubleClick(() => console.log('double clicked'));
+ */
+export declare const useDoubleClick: UseDoubleClick;

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

@@ -5,11 +5,11 @@ export type UseEventListenerOptions = boolean | AddEventListenerOptions;
 /** The use event listener return type */
 export type UseEventListenerReturn<Target extends Element> = StateRef<Target>;
 export interface UseEventListener {
-    <Event extends keyof WindowEventMap = keyof WindowEventMap>(target: Window, event: Event | Event[], listener: (this: Window, event: WindowEventMap[Event]) => void, options?: UseEventListenerOptions): void;
-    <Event extends keyof DocumentEventMap = keyof DocumentEventMap>(target: Document, event: Event | Event[], listener: (this: Document, event: DocumentEventMap[Event]) => void, options?: UseEventListenerOptions): void;
-    <Event extends keyof HTMLElementEventMap = keyof HTMLElementEventMap>(target: HookTarget, event: Event | Event[], listener: (this: Element, event: HTMLElementEventMap[Event]) => void, options?: UseEventListenerOptions): void;
-    <Target extends Element, Event extends keyof HTMLElementEventMap = keyof HTMLElementEventMap>(event: Event | Event[], listener: (this: Target, event: HTMLElementEventMap[Event]) => void, options?: UseEventListenerOptions, target?: never): UseEventListenerReturn<Target>;
-    <Target extends Element, Event extends keyof MediaQueryListEventMap = keyof MediaQueryListEventMap>(event: Event | Event[], listener: (this: Target, event: MediaQueryListEventMap[Event]) => void, options?: UseEventListenerOptions, target?: never): UseEventListenerReturn<Target>;
+    <Event extends keyof WindowEventMap = keyof WindowEventMap>(target: HookTarget, event: Event, listener: (this: Window, event: WindowEventMap[Event]) => void, options?: UseEventListenerOptions): void;
+    <Event extends keyof DocumentEventMap = keyof DocumentEventMap>(target: HookTarget, event: Event, listener: (this: Document, event: DocumentEventMap[Event]) => void, options?: UseEventListenerOptions): void;
+    <Event extends keyof HTMLElementEventMap = keyof HTMLElementEventMap>(target: HookTarget, event: Event, listener: (this: Element, event: HTMLElementEventMap[Event]) => void, options?: UseEventListenerOptions): void;
+    <Target extends Element, Event extends keyof HTMLElementEventMap = keyof HTMLElementEventMap>(event: Event, listener: (this: Target, event: HTMLElementEventMap[Event]) => void, options?: UseEventListenerOptions, target?: never): UseEventListenerReturn<Target>;
+    <Target extends Element, Event extends keyof MediaQueryListEventMap = keyof MediaQueryListEventMap>(event: Event, listener: (this: Target, event: MediaQueryListEventMap[Event]) => void, options?: UseEventListenerOptions, target?: never): UseEventListenerReturn<Target>;
 }
 /**
  * @name useEventListener

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

@@ -1,38 +1,40 @@
-import { MouseEventHandler, RefObject, TouchEventHandler } from 'react';
-export type UseLongPressTarget = (() => Element) | Element | RefObject<Element | null | undefined>;
-export type LongPressReactEvents<Target extends Element = Element> = MouseEventHandler<Target> | TouchEventHandler<Target>;
+import { HookTarget } from '../../utils/helpers';
+import { StateRef } from '../useRefState/useRefState';
+export type LongPressEvents = MouseEvent | TouchEvent;
 export interface UseLongPressOptions {
     threshold?: number;
-    onCancel?: (event: LongPressReactEvents) => void;
-    onFinish?: (event: LongPressReactEvents) => void;
-    onStart?: (event: LongPressReactEvents) => void;
+    onCancel?: (event: LongPressEvents) => void;
+    onFinish?: (event: LongPressEvents) => void;
+    onStart?: (event: LongPressEvents) => void;
 }
-export interface UseLongPressBind {
-    /** The callback function to be invoked on mouse down */
-    onMouseDown: MouseEventHandler<Element>;
-    /** The callback function to be invoked on mouse up */
-    onMouseUp: MouseEventHandler<Element>;
-    /** The callback function to be invoked on touch end */
-    onTouchEnd: TouchEventHandler<Element>;
-    /** The callback function to be invoked on touch start */
-    onTouchStart: TouchEventHandler<Element>;
+export interface UseLongPress {
+    (target: HookTarget, callback: (event: LongPressEvents) => void, options?: UseLongPressOptions): boolean;
+    <Target extends Element>(callback: (event: LongPressEvents) => void, options?: UseLongPressOptions, target?: never): {
+        ref: StateRef<Target>;
+        pressed: boolean;
+    };
 }
-export type UseLongPressReturn = [UseLongPressBind, boolean];
 /**
  * @name useLongPress
  * @description - Hook that defines the logic when long pressing an element
  * @category Sensors
  *
+ * @overload
+ * @param {HookTarget} target The target element to be long pressed
+ * @param {(event: LongPressEvents) => void} callback The callback function to be invoked on long press
+ * @param {UseLongPressOptions} [options] The options for the long press
+ * @returns {boolean} The long pressing state
+ *
+ * @example
+ * const pressed = useLongPress(ref, () => console.log('callback'));
+ *
+ * @overload
  * @template Target The target element
- * @param {Target} target The target element to be long pressed
- * @param {(event: Event) => void} callback The callback function to be invoked on long press
- * @param {number} [options.threshold=400] The threshold time in milliseconds
- * @param {(event: Event) => void} [options.onStart] The callback function to be invoked on long press start
- * @param {(event: Event) => void} [options.onFinish] The callback function to be invoked on long press finish
- * @param {(event: Event) => void} [options.onCancel] The callback function to be invoked on long press cancel
- * @returns {UseLongPressReturn<Target>} The ref of the target element
+ * @param {(event: LongPressEvents) => void} callback The callback function to be invoked on long press
+ * @param {UseLongPressOptions} [options] The options for the long press
+ * @returns {boolean} The long pressing state
  *
  * @example
- * const [bind, longPressing] = useLongPress(() => console.log('callback'));
+ * const { ref, pressed } = useLongPress(() => console.log('callback'));
  */
-export declare const useLongPress: (callback: (event: LongPressReactEvents) => void, options?: UseLongPressOptions) => UseLongPressReturn;
+export declare const useLongPress: UseLongPress;

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

@@ -0,0 +1,69 @@
+/** The use speech recognition hook options type */
+interface UseSpeechRecognitionOptions {
+    /** If true, recognition continues even after pauses in speech. Default is false */
+    continuous?: SpeechRecognition['continuous'];
+    /** A list of grammar rules */
+    grammars?: SpeechRecognition['grammars'];
+    /** If true, interim (non-final) results are provided as the user speaks */
+    interimResults?: SpeechRecognition['interimResults'];
+    /** The language in which recognition should occur. Must be a valid BCP 47 language tag (e.g., "en-US", "ru-RU") */
+    language?: SpeechRecognition['lang'];
+    /** The maximum number of alternative transcripts returned for a given recognition result. Must be a positive integer */
+    maxAlternatives?: SpeechRecognition['maxAlternatives'];
+    /** Callback invoked when speech recognition ends */
+    onEnd?: () => void;
+    /** Callback invoked when an error occurs during recognition */
+    onError?: (error: SpeechRecognitionErrorEvent) => void;
+    /** Callback invoked when recognition produces a result */
+    onResult?: (event: SpeechRecognitionEvent) => void;
+    /** Callback invoked when speech recognition starts */
+    onStart?: () => void;
+}
+/** The return type of the useSpeechRecognition hook. */
+interface UseSpeechRecognitionReturn {
+    /** The error state */
+    error: SpeechRecognitionErrorEvent | null;
+    /** The final transcript */
+    final: boolean;
+    /** Whether the hook is currently listening for speech */
+    listening: boolean;
+    /** The speech recognition instance */
+    recognition: SpeechRecognition;
+    /** Whether the current browser supports the Web Speech API */
+    supported: boolean;
+    /** The current transcript */
+    transcript: string;
+    /** Begins speech recognition */
+    start: () => void;
+    /** Ends speech recognition, finalizing results */
+    stop: () => void;
+    /** Toggles the listening state */
+    toggle: (value?: boolean) => void;
+}
+export declare const getSpeechRecognition: () => {
+    new (): SpeechRecognition;
+    prototype: SpeechRecognition;
+};
+/**
+ * @name useSpeechRecognition
+ * @description - Hook that provides a streamlined interface for incorporating speech-to-text functionality
+ * @category Sensors
+ *
+ * @browserapi window.SpeechRecognition https://developer.mozilla.org/en-US/docs/Web/API/SpeechRecognition
+ *
+ * @param {boolean} [options.continuous=false] Whether recognition should continue after pauses
+ * @param {boolean} [options.interimResults=false] Whether interim results should be provided
+ * @param {string} [options.language="en-US"] The language for recognition, as a valid BCP 47 tag
+ * @param {number} [options.maxAlternatives=1] The maximum number of alternative transcripts to return
+ * @param {SpeechGrammarList} [options.grammars] A list of grammar rules
+ * @param {() => void} [options.onStart] Callback invoked when speech recognition starts
+ * @param {() => void} [options.onEnd] Callback invoked when speech recognition ends
+ * @param {(error: SpeechRecognitionErrorEvent) => void} [options.onError] Callback invoked when an error occurs during recognition
+ * @param {(event: SpeechRecognitionEvent) => void} [options.onResult] Callback invoked when recognition produces a result
+ * @returns {UseSpeechRecognitionReturn} An object containing the speech recognition functionality
+ *
+ * @example
+ * const { supported, value, recognition, listening, error, start, stop, toggle  } = useSpeechRecognition();
+ */
+export declare const useSpeechRecognition: (options?: UseSpeechRecognitionOptions) => UseSpeechRecognitionReturn;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siberiacancode/reactuse",
-  "version": "0.0.113",
+  "version": "0.0.115",
   "description": "The ultimate collection of react hooks",
   "author": {
     "name": "SIBERIA CAN CODE 🧊",
@@ -67,6 +67,7 @@
     "@siberiacancode/vitest": "^2.1.0",
     "@testing-library/dom": "^10.4.0",
     "@testing-library/react": "^16.2.0",
+    "@types/dom-speech-recognition": "^0.0.4",
     "@types/react": "^18.3.18",
     "@types/react-dom": "^18.3.5",
     "@types/web-bluetooth": "^0.0.21",