@siberiacancode/reactuse 0.0.114 → 0.0.116

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

@@ -0,0 +1,37 @@
+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): StateRef<Target>;
+}
+/**
+ * @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'));
+ *
+ * @see {@link https://siberiacancode.github.io/reactuse/functions/hooks/useDoubleClick.html}
+ */
+export declare const useDoubleClick: UseDoubleClick;

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/useWindowFocus/useWindowFocus.d.ts

@@ -7,5 +7,7 @@
  *
  * @example
  * const focused = useWindowFocus();
+ *
+ * @see {@link https://siberiacancode.github.io/reactuse/functions/hooks/useWindowFocus.html}
  */
 export declare const useWindowFocus: () => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siberiacancode/reactuse",
-  "version": "0.0.114",
+  "version": "0.0.116",
   "description": "The ultimate collection of react hooks",
   "author": {
     "name": "SIBERIA CAN CODE 🧊",