react-simplikit 0.0.53 → 0.2.0

package/dist/hooks/useImpressionRef/useImpressionRef.mjs

@@ -6,10 +6,6 @@ import { useVisibilityEvent } from "../useVisibilityEvent/useVisibilityEvent.mjs
 import { useRef } from "react";
 //#region src/hooks/useImpressionRef/useImpressionRef.ts
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (IntersectionObserver, Visibility API).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useImpressionRef` is a React hook that measures the time a specific DOM element is visible on the screen and executes callbacks when the element enters or exits the viewport.
 * It uses `IntersectionObserver` and the `Visibility API` to track the element's visibility.
@@ -41,10 +37,16 @@ function useImpressionRef({ onImpressionStart = () => {}, onImpressionEnd = () =
 	const impressionStartHandler = usePreservedCallback(onImpressionStart);
 	const impressionEndHandler = usePreservedCallback(onImpressionEnd);
 	const isIntersectingRef = useRef(false);
+	const hasImpressionStartedRef = useRef(false);
 	const impressionEventHandler = useDebouncedCallback({
 		timeThreshold,
 		onChange: (impressed) => {
-			(impressed ? impressionStartHandler : impressionEndHandler)();
+			if (impressed) {
+				hasImpressionStartedRef.current = true;
+				impressionStartHandler();
+				return;
+			}
+			if (hasImpressionStartedRef.current) impressionEndHandler();
 		},
 		leading: true
 	});

package/dist/hooks/useInputState/useInputState.cjs

@@ -4,19 +4,25 @@ let react = require("react");
 /**
 * @description
 * `useInputState` is a React hook that manages an input state with optional value transformation.
+* The returned `onChange` handler works with both `<input>` and `<textarea>` elements.
 *
 * @param {string} [initialValue=""] - The initial value of the input. Defaults to an empty string (`""`).
 * @param {(value: string) => string} [transformValue=(v: string) => v] - A function to transform the input value.
 *   Defaults to an identity function that returns the input unchanged.
 *
-* @returns {[value: string, onChange: ChangeEventHandler<HTMLInputElement>]} A tuple containing:
+* @returns {[value: string, onChange: ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>]} A tuple containing:
 * - value `string` - The current state value;
-* - onChange `ChangeEventHandler<HTMLInputElement>` - A function to update the state;
+* - onChange `ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>` - A function to update the state;
 *
 * @example
 * function Example() {
 *   const [value, onChange] = useInputState('');
-*   return <input type="text" value={value} onChange={onChange} />;
+*   return (
+*     <>
+*       <input type="text" value={value} onChange={onChange} />
+*       <textarea value={value} onChange={onChange} />
+*     </>
+*   );
 * }
 */
 function useInputState(initialValue = "", transformValue = echo) {

package/dist/hooks/useInputState/useInputState.d.cts

@@ -1,24 +1,31 @@
 
 import { ChangeEventHandler } from "react";
 //#region src/hooks/useInputState/useInputState.d.ts
+type InputLikeElement = HTMLInputElement | HTMLTextAreaElement;
 /**
  * @description
  * `useInputState` is a React hook that manages an input state with optional value transformation.
+ * The returned `onChange` handler works with both `<input>` and `<textarea>` elements.
  *
  * @param {string} [initialValue=""] - The initial value of the input. Defaults to an empty string (`""`).
  * @param {(value: string) => string} [transformValue=(v: string) => v] - A function to transform the input value.
  *   Defaults to an identity function that returns the input unchanged.
  *
- * @returns {[value: string, onChange: ChangeEventHandler<HTMLInputElement>]} A tuple containing:
+ * @returns {[value: string, onChange: ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>]} A tuple containing:
  * - value `string` - The current state value;
- * - onChange `ChangeEventHandler<HTMLInputElement>` - A function to update the state;
+ * - onChange `ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>` - A function to update the state;
  *
  * @example
  * function Example() {
  *   const [value, onChange] = useInputState('');
- *   return <input type="text" value={value} onChange={onChange} />;
+ *   return (
+ *     <>
+ *       <input type="text" value={value} onChange={onChange} />
+ *       <textarea value={value} onChange={onChange} />
+ *     </>
+ *   );
  * }
  */
-declare function useInputState(initialValue?: string, transformValue?: (value: string) => string): readonly [string, ChangeEventHandler<HTMLInputElement>];
+declare function useInputState(initialValue?: string, transformValue?: (value: string) => string): readonly [string, ChangeEventHandler<InputLikeElement>];
 //#endregion
 export { useInputState };

package/dist/hooks/useInputState/useInputState.d.mts

@@ -1,24 +1,31 @@
 
 import { ChangeEventHandler } from "react";
 //#region src/hooks/useInputState/useInputState.d.ts
+type InputLikeElement = HTMLInputElement | HTMLTextAreaElement;
 /**
  * @description
  * `useInputState` is a React hook that manages an input state with optional value transformation.
+ * The returned `onChange` handler works with both `<input>` and `<textarea>` elements.
  *
  * @param {string} [initialValue=""] - The initial value of the input. Defaults to an empty string (`""`).
  * @param {(value: string) => string} [transformValue=(v: string) => v] - A function to transform the input value.
  *   Defaults to an identity function that returns the input unchanged.
  *
- * @returns {[value: string, onChange: ChangeEventHandler<HTMLInputElement>]} A tuple containing:
+ * @returns {[value: string, onChange: ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>]} A tuple containing:
  * - value `string` - The current state value;
- * - onChange `ChangeEventHandler<HTMLInputElement>` - A function to update the state;
+ * - onChange `ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>` - A function to update the state;
  *
  * @example
  * function Example() {
  *   const [value, onChange] = useInputState('');
- *   return <input type="text" value={value} onChange={onChange} />;
+ *   return (
+ *     <>
+ *       <input type="text" value={value} onChange={onChange} />
+ *       <textarea value={value} onChange={onChange} />
+ *     </>
+ *   );
  * }
  */
-declare function useInputState(initialValue?: string, transformValue?: (value: string) => string): readonly [string, ChangeEventHandler<HTMLInputElement>];
+declare function useInputState(initialValue?: string, transformValue?: (value: string) => string): readonly [string, ChangeEventHandler<InputLikeElement>];
 //#endregion
 export { useInputState };

package/dist/hooks/useInputState/useInputState.mjs

@@ -4,19 +4,25 @@ import { useCallback, useState } from "react";
 /**
 * @description
 * `useInputState` is a React hook that manages an input state with optional value transformation.
+* The returned `onChange` handler works with both `<input>` and `<textarea>` elements.
 *
 * @param {string} [initialValue=""] - The initial value of the input. Defaults to an empty string (`""`).
 * @param {(value: string) => string} [transformValue=(v: string) => v] - A function to transform the input value.
 *   Defaults to an identity function that returns the input unchanged.
 *
-* @returns {[value: string, onChange: ChangeEventHandler<HTMLInputElement>]} A tuple containing:
+* @returns {[value: string, onChange: ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>]} A tuple containing:
 * - value `string` - The current state value;
-* - onChange `ChangeEventHandler<HTMLInputElement>` - A function to update the state;
+* - onChange `ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>` - A function to update the state;
 *
 * @example
 * function Example() {
 *   const [value, onChange] = useInputState('');
-*   return <input type="text" value={value} onChange={onChange} />;
+*   return (
+*     <>
+*       <input type="text" value={value} onChange={onChange} />
+*       <textarea value={value} onChange={onChange} />
+*     </>
+*   );
 * }
 */
 function useInputState(initialValue = "", transformValue = echo) {

package/dist/hooks/useIntersectionObserver/useIntersectionObserver.cjs

@@ -4,10 +4,6 @@ const require_useRefEffect = require("../useRefEffect/useRefEffect.cjs");
 let react = require("react");
 //#region src/hooks/useIntersectionObserver/useIntersectionObserver.ts
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (IntersectionObserver).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useIntersectionObserver` is a React hook that detects whether a specific DOM element is visible on the screen.
 * It uses the `IntersectionObserver` API to execute a callback when the element enters or exits the viewport.
@@ -15,7 +11,7 @@ let react = require("react");
 * @param {(entry: IntersectionObserverEntry) => void} callback - A callback function that is executed when the visibility of the element changes.
 *   You can check `entry.isIntersecting` to determine if the element is in view.
 * @param {IntersectionObserverInit} options - Options for the `IntersectionObserver`.
-* @param {boolean} [options.root] - The element that is used as the viewport for checking visibility of the target.
+* @param {Element | Document | null} [options.root] - The element that is used as the viewport for checking visibility of the target.
 * @param {string} [options.rootMargin] - Margin around the root.
 * @param {number | number[]} [options.threshold] - Either a single number or an array of numbers which indicate at what percentage of the target's visibility the observer's callback should be executed.
 *

package/dist/hooks/useIntersectionObserver/useIntersectionObserver.d.cts

@@ -1,10 +1,6 @@
 
 //#region src/hooks/useIntersectionObserver/useIntersectionObserver.d.ts
 /**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (IntersectionObserver).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
  * @description
  * `useIntersectionObserver` is a React hook that detects whether a specific DOM element is visible on the screen.
  * It uses the `IntersectionObserver` API to execute a callback when the element enters or exits the viewport.
@@ -12,7 +8,7 @@
  * @param {(entry: IntersectionObserverEntry) => void} callback - A callback function that is executed when the visibility of the element changes.
  *   You can check `entry.isIntersecting` to determine if the element is in view.
  * @param {IntersectionObserverInit} options - Options for the `IntersectionObserver`.
- * @param {boolean} [options.root] - The element that is used as the viewport for checking visibility of the target.
+ * @param {Element | Document | null} [options.root] - The element that is used as the viewport for checking visibility of the target.
  * @param {string} [options.rootMargin] - Margin around the root.
  * @param {number | number[]} [options.threshold] - Either a single number or an array of numbers which indicate at what percentage of the target's visibility the observer's callback should be executed.
  *

package/dist/hooks/useIntersectionObserver/useIntersectionObserver.d.mts

@@ -1,10 +1,6 @@
 
 //#region src/hooks/useIntersectionObserver/useIntersectionObserver.d.ts
 /**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (IntersectionObserver).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
  * @description
  * `useIntersectionObserver` is a React hook that detects whether a specific DOM element is visible on the screen.
  * It uses the `IntersectionObserver` API to execute a callback when the element enters or exits the viewport.
@@ -12,7 +8,7 @@
  * @param {(entry: IntersectionObserverEntry) => void} callback - A callback function that is executed when the visibility of the element changes.
  *   You can check `entry.isIntersecting` to determine if the element is in view.
  * @param {IntersectionObserverInit} options - Options for the `IntersectionObserver`.
- * @param {boolean} [options.root] - The element that is used as the viewport for checking visibility of the target.
+ * @param {Element | Document | null} [options.root] - The element that is used as the viewport for checking visibility of the target.
  * @param {string} [options.rootMargin] - Margin around the root.
  * @param {number | number[]} [options.threshold] - Either a single number or an array of numbers which indicate at what percentage of the target's visibility the observer's callback should be executed.
  *

package/dist/hooks/useIntersectionObserver/useIntersectionObserver.mjs

@@ -4,10 +4,6 @@ import { useRefEffect } from "../useRefEffect/useRefEffect.mjs";
 import { useMemo } from "react";
 //#region src/hooks/useIntersectionObserver/useIntersectionObserver.ts
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (IntersectionObserver).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useIntersectionObserver` is a React hook that detects whether a specific DOM element is visible on the screen.
 * It uses the `IntersectionObserver` API to execute a callback when the element enters or exits the viewport.
@@ -15,7 +11,7 @@ import { useMemo } from "react";
 * @param {(entry: IntersectionObserverEntry) => void} callback - A callback function that is executed when the visibility of the element changes.
 *   You can check `entry.isIntersecting` to determine if the element is in view.
 * @param {IntersectionObserverInit} options - Options for the `IntersectionObserver`.
-* @param {boolean} [options.root] - The element that is used as the viewport for checking visibility of the target.
+* @param {Element | Document | null} [options.root] - The element that is used as the viewport for checking visibility of the target.
 * @param {string} [options.rootMargin] - Margin around the root.
 * @param {number | number[]} [options.threshold] - Either a single number or an array of numbers which indicate at what percentage of the target's visibility the observer's callback should be executed.
 *

package/dist/hooks/useList/useList.cjs

@@ -8,15 +8,18 @@ let react = require("react");
 * A React hook that manages an array as state.
 * Provides efficient state management and stable action functions.
 *
-* @param {T[]} initialState - Initial array state
+* @template T - The type of the values held in the list.
 *
-* @returns {UseListReturn<T>} A tuple containing the array state and actions to manipulate it
-* - `push` - Appends a value to the end of the list
-* - `insertAt` - Inserts a value at the specified index
-* - `updateAt` - Updates the value at the specified index
-* - `removeAt` - Removes the value at the specified index
-* - `setAll` - Replaces the entire list with a new array
-* - `reset` - Resets the list to its initial state
+* @param {T[]} [initialState=[]] - Initial array state.
+*
+* @returns {UseListReturn<T>} A tuple containing the array state and actions to manipulate it.
+* - list `ReadonlyArray<T>` - The current array state;
+* - actions.push `(value: T) => void` - Appends a value to the end of the list;
+* - actions.insertAt `(index: number, value: T) => void` - Inserts a value at the specified index;
+* - actions.updateAt `(index: number, value: T) => void` - Updates the value at the specified index;
+* - actions.removeAt `(index: number) => void` - Removes the value at the specified index;
+* - actions.setAll `(values: T[]) => void` - Replaces the entire list with a new array;
+* - actions.reset `() => void` - Resets the list to its initial state;
 *
 * @example
 * ```tsx

package/dist/hooks/useList/useList.d.cts

@@ -14,15 +14,18 @@ type UseListReturn<T> = [ReadonlyArray<T>, ListActions<T>];
  * A React hook that manages an array as state.
  * Provides efficient state management and stable action functions.
  *
- * @param {T[]} initialState - Initial array state
- *
- * @returns {UseListReturn<T>} A tuple containing the array state and actions to manipulate it
- * - `push` - Appends a value to the end of the list
- * - `insertAt` - Inserts a value at the specified index
- * - `updateAt` - Updates the value at the specified index
- * - `removeAt` - Removes the value at the specified index
- * - `setAll` - Replaces the entire list with a new array
- * - `reset` - Resets the list to its initial state
+ * @template T - The type of the values held in the list.
+ *
+ * @param {T[]} [initialState=[]] - Initial array state.
+ *
+ * @returns {UseListReturn<T>} A tuple containing the array state and actions to manipulate it.
+ * - list `ReadonlyArray<T>` - The current array state;
+ * - actions.push `(value: T) => void` - Appends a value to the end of the list;
+ * - actions.insertAt `(index: number, value: T) => void` - Inserts a value at the specified index;
+ * - actions.updateAt `(index: number, value: T) => void` - Updates the value at the specified index;
+ * - actions.removeAt `(index: number) => void` - Removes the value at the specified index;
+ * - actions.setAll `(values: T[]) => void` - Replaces the entire list with a new array;
+ * - actions.reset `() => void` - Resets the list to its initial state;
  *
  * @example
  * ```tsx

package/dist/hooks/useList/useList.d.mts

@@ -14,15 +14,18 @@ type UseListReturn<T> = [ReadonlyArray<T>, ListActions<T>];
  * A React hook that manages an array as state.
  * Provides efficient state management and stable action functions.
  *
- * @param {T[]} initialState - Initial array state
- *
- * @returns {UseListReturn<T>} A tuple containing the array state and actions to manipulate it
- * - `push` - Appends a value to the end of the list
- * - `insertAt` - Inserts a value at the specified index
- * - `updateAt` - Updates the value at the specified index
- * - `removeAt` - Removes the value at the specified index
- * - `setAll` - Replaces the entire list with a new array
- * - `reset` - Resets the list to its initial state
+ * @template T - The type of the values held in the list.
+ *
+ * @param {T[]} [initialState=[]] - Initial array state.
+ *
+ * @returns {UseListReturn<T>} A tuple containing the array state and actions to manipulate it.
+ * - list `ReadonlyArray<T>` - The current array state;
+ * - actions.push `(value: T) => void` - Appends a value to the end of the list;
+ * - actions.insertAt `(index: number, value: T) => void` - Inserts a value at the specified index;
+ * - actions.updateAt `(index: number, value: T) => void` - Updates the value at the specified index;
+ * - actions.removeAt `(index: number) => void` - Removes the value at the specified index;
+ * - actions.setAll `(values: T[]) => void` - Replaces the entire list with a new array;
+ * - actions.reset `() => void` - Resets the list to its initial state;
  *
  * @example
  * ```tsx

package/dist/hooks/useList/useList.mjs

@@ -8,15 +8,18 @@ import { useMemo, useState } from "react";
 * A React hook that manages an array as state.
 * Provides efficient state management and stable action functions.
 *
-* @param {T[]} initialState - Initial array state
+* @template T - The type of the values held in the list.
 *
-* @returns {UseListReturn<T>} A tuple containing the array state and actions to manipulate it
-* - `push` - Appends a value to the end of the list
-* - `insertAt` - Inserts a value at the specified index
-* - `updateAt` - Updates the value at the specified index
-* - `removeAt` - Removes the value at the specified index
-* - `setAll` - Replaces the entire list with a new array
-* - `reset` - Resets the list to its initial state
+* @param {T[]} [initialState=[]] - Initial array state.
+*
+* @returns {UseListReturn<T>} A tuple containing the array state and actions to manipulate it.
+* - list `ReadonlyArray<T>` - The current array state;
+* - actions.push `(value: T) => void` - Appends a value to the end of the list;
+* - actions.insertAt `(index: number, value: T) => void` - Inserts a value at the specified index;
+* - actions.updateAt `(index: number, value: T) => void` - Updates the value at the specified index;
+* - actions.removeAt `(index: number) => void` - Removes the value at the specified index;
+* - actions.setAll `(values: T[]) => void` - Replaces the entire list with a new array;
+* - actions.reset `() => void` - Resets the list to its initial state;
 *
 * @example
 * ```tsx

package/dist/hooks/useLoading/useLoading.cjs

@@ -7,12 +7,9 @@ let react = require("react");
 * It provides a state to track whether an asynchronous operation is in progress and a function to handle the loading state automatically.
 *
 * @returns {[loading: boolean, startLoading: <T>(promise: Promise<T>) => Promise<T>]} A tuple containing:
-* - loading `boolean` - Represents the current loading state.
-*    : The initial value is `false`.
-*    : It is set to `true` when an asynchronous task is in progress;
+* - loading `boolean` - Represents the current loading state. The initial value is `false`. It is set to `true` when an asynchronous task is in progress;
 *
-* - startLoading `<T>(promise: Promise<T>) => Promise<T>` - A function that executes asynchronous tasks while managing the loading state.
-*    : This function takes a `Promise` as an argument and automatically resets the `isLoading` state to `false` when the `Promise` completes;
+* - startLoading `<T>(promise: Promise<T>) => Promise<T>` - A function that executes asynchronous tasks while managing the loading state. This function takes a `Promise` as an argument and automatically resets the `isLoading` state to `false` when the `Promise` completes;
 *
 * @example
 * function ConfirmButton() {
@@ -48,6 +45,7 @@ function useLoading() {
 	return (0, react.useMemo)(() => [loading, startTransition], [loading, startTransition]);
 }
 function useIsMountedRef() {
+	"use no memo";
 	const ref = (0, react.useRef)({ isMounted: true }).current;
 	(0, react.useEffect)(function trackMountedState() {
 		ref.isMounted = true;

package/dist/hooks/useLoading/useLoading.d.cts

@@ -6,12 +6,9 @@
  * It provides a state to track whether an asynchronous operation is in progress and a function to handle the loading state automatically.
  *
  * @returns {[loading: boolean, startLoading: <T>(promise: Promise<T>) => Promise<T>]} A tuple containing:
- * - loading `boolean` - Represents the current loading state.
- *    : The initial value is `false`.
- *    : It is set to `true` when an asynchronous task is in progress;
+ * - loading `boolean` - Represents the current loading state. The initial value is `false`. It is set to `true` when an asynchronous task is in progress;
  *
- * - startLoading `<T>(promise: Promise<T>) => Promise<T>` - A function that executes asynchronous tasks while managing the loading state.
- *    : This function takes a `Promise` as an argument and automatically resets the `isLoading` state to `false` when the `Promise` completes;
+ * - startLoading `<T>(promise: Promise<T>) => Promise<T>` - A function that executes asynchronous tasks while managing the loading state. This function takes a `Promise` as an argument and automatically resets the `isLoading` state to `false` when the `Promise` completes;
  *
  * @example
  * function ConfirmButton() {

package/dist/hooks/useLoading/useLoading.d.mts

@@ -6,12 +6,9 @@
  * It provides a state to track whether an asynchronous operation is in progress and a function to handle the loading state automatically.
  *
  * @returns {[loading: boolean, startLoading: <T>(promise: Promise<T>) => Promise<T>]} A tuple containing:
- * - loading `boolean` - Represents the current loading state.
- *    : The initial value is `false`.
- *    : It is set to `true` when an asynchronous task is in progress;
+ * - loading `boolean` - Represents the current loading state. The initial value is `false`. It is set to `true` when an asynchronous task is in progress;
  *
- * - startLoading `<T>(promise: Promise<T>) => Promise<T>` - A function that executes asynchronous tasks while managing the loading state.
- *    : This function takes a `Promise` as an argument and automatically resets the `isLoading` state to `false` when the `Promise` completes;
+ * - startLoading `<T>(promise: Promise<T>) => Promise<T>` - A function that executes asynchronous tasks while managing the loading state. This function takes a `Promise` as an argument and automatically resets the `isLoading` state to `false` when the `Promise` completes;
  *
  * @example
  * function ConfirmButton() {

package/dist/hooks/useLoading/useLoading.mjs

@@ -7,12 +7,9 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 * It provides a state to track whether an asynchronous operation is in progress and a function to handle the loading state automatically.
 *
 * @returns {[loading: boolean, startLoading: <T>(promise: Promise<T>) => Promise<T>]} A tuple containing:
-* - loading `boolean` - Represents the current loading state.
-*    : The initial value is `false`.
-*    : It is set to `true` when an asynchronous task is in progress;
+* - loading `boolean` - Represents the current loading state. The initial value is `false`. It is set to `true` when an asynchronous task is in progress;
 *
-* - startLoading `<T>(promise: Promise<T>) => Promise<T>` - A function that executes asynchronous tasks while managing the loading state.
-*    : This function takes a `Promise` as an argument and automatically resets the `isLoading` state to `false` when the `Promise` completes;
+* - startLoading `<T>(promise: Promise<T>) => Promise<T>` - A function that executes asynchronous tasks while managing the loading state. This function takes a `Promise` as an argument and automatically resets the `isLoading` state to `false` when the `Promise` completes;
 *
 * @example
 * function ConfirmButton() {
@@ -48,6 +45,7 @@ function useLoading() {
 	return useMemo(() => [loading, startTransition], [loading, startTransition]);
 }
 function useIsMountedRef() {
+	"use no memo";
 	const ref = useRef({ isMounted: true }).current;
 	useEffect(function trackMountedState() {
 		ref.isMounted = true;

package/dist/hooks/useLongPress/useLongPress.cjs

@@ -3,10 +3,6 @@ const require_usePreservedCallback = require("../usePreservedCallback/usePreserv
 let react = require("react");
 //#region src/hooks/useLongPress/useLongPress.ts
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (DOM events, window.setTimeout).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useLongPress` is a React hook that detects when an element is pressed and held for a specified duration.
 * It handles both mouse and touch events, making it work consistently across desktop and mobile devices.

package/dist/hooks/useLongPress/useLongPress.d.cts

@@ -12,10 +12,6 @@ type UseLongPressOptions<E extends HTMLElement> = {
   onLongPressEnd?: Handler<E>;
 };
 /**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (DOM events, window.setTimeout).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
  * @description
  * `useLongPress` is a React hook that detects when an element is pressed and held for a specified duration.
  * It handles both mouse and touch events, making it work consistently across desktop and mobile devices.

package/dist/hooks/useLongPress/useLongPress.d.mts

@@ -12,10 +12,6 @@ type UseLongPressOptions<E extends HTMLElement> = {
   onLongPressEnd?: Handler<E>;
 };
 /**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (DOM events, window.setTimeout).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
  * @description
  * `useLongPress` is a React hook that detects when an element is pressed and held for a specified duration.
  * It handles both mouse and touch events, making it work consistently across desktop and mobile devices.

package/dist/hooks/useLongPress/useLongPress.mjs

@@ -3,10 +3,6 @@ import { usePreservedCallback } from "../usePreservedCallback/usePreservedCallba
 import { useCallback, useRef } from "react";
 //#region src/hooks/useLongPress/useLongPress.ts
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (DOM events, window.setTimeout).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useLongPress` is a React hook that detects when an element is pressed and held for a specified duration.
 * It handles both mouse and touch events, making it work consistently across desktop and mobile devices.

package/dist/hooks/useOutsideClickEffect/useOutsideClickEffect.cjs

@@ -3,10 +3,6 @@ const require_usePreservedCallback = require("../usePreservedCallback/usePreserv
 let react = require("react");
 //#region src/hooks/useOutsideClickEffect/useOutsideClickEffect.ts
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (DOM events, document).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useOutsideClickEffect` is a React hook that triggers a callback when a click event occurs outside the specified container(s).
 * It is useful for closing modals, dropdowns, tooltips, and other UI components when clicking outside.

package/dist/hooks/useOutsideClickEffect/useOutsideClickEffect.d.cts

@@ -2,10 +2,6 @@
 //#region src/hooks/useOutsideClickEffect/useOutsideClickEffect.d.ts
 type OneOrMore<T> = T | T[];
 /**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (DOM events, document).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
  * @description
  * `useOutsideClickEffect` is a React hook that triggers a callback when a click event occurs outside the specified container(s).
  * It is useful for closing modals, dropdowns, tooltips, and other UI components when clicking outside.

package/dist/hooks/useOutsideClickEffect/useOutsideClickEffect.d.mts

@@ -2,10 +2,6 @@
 //#region src/hooks/useOutsideClickEffect/useOutsideClickEffect.d.ts
 type OneOrMore<T> = T | T[];
 /**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (DOM events, document).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
  * @description
  * `useOutsideClickEffect` is a React hook that triggers a callback when a click event occurs outside the specified container(s).
  * It is useful for closing modals, dropdowns, tooltips, and other UI components when clicking outside.

package/dist/hooks/useOutsideClickEffect/useOutsideClickEffect.mjs

@@ -3,10 +3,6 @@ import { usePreservedCallback } from "../usePreservedCallback/usePreservedCallba
 import { useEffect, useRef } from "react";
 //#region src/hooks/useOutsideClickEffect/useOutsideClickEffect.ts
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (DOM events, document).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useOutsideClickEffect` is a React hook that triggers a callback when a click event occurs outside the specified container(s).
 * It is useful for closing modals, dropdowns, tooltips, and other UI components when clicking outside.

package/dist/hooks/usePreservedReference/usePreservedReference.cjs

@@ -42,6 +42,7 @@ let react = require("react");
 * }
 */
 function usePreservedReference(value, areValuesEqual = areDeeplyEqual) {
+	"use no memo";
 	const ref = (0, react.useRef)(value);
 	return (0, react.useMemo)(() => {
 		if (!areValuesEqual(ref.current, value)) ref.current = value;

package/dist/hooks/usePreservedReference/usePreservedReference.mjs

@@ -42,6 +42,7 @@ import { useMemo, useRef } from "react";
 * }
 */
 function usePreservedReference(value, areValuesEqual = areDeeplyEqual) {
+	"use no memo";
 	const ref = useRef(value);
 	return useMemo(() => {
 		if (!areValuesEqual(ref.current, value)) ref.current = value;

package/dist/hooks/useRefEffect/useRefEffect.cjs

@@ -28,6 +28,7 @@ let react = require("react");
 * }
 */
 function useRefEffect(callback, deps) {
+	"use no memo";
 	const preservedCallback = require_usePreservedCallback.usePreservedCallback(callback);
 	const cleanupCallbackRef = (0, react.useRef)(() => {});
 	return (0, react.useCallback)((element) => {

package/dist/hooks/useRefEffect/useRefEffect.mjs

@@ -28,6 +28,7 @@ import { useCallback, useRef } from "react";
 * }
 */
 function useRefEffect(callback, deps) {
+	"use no memo";
 	const preservedCallback = usePreservedCallback(callback);
 	const cleanupCallbackRef = useRef(() => {});
 	return useCallback((element) => {

package/dist/hooks/useSet/useSet.cjs

@@ -8,8 +8,17 @@ let react = require("react");
 * A React hook that manages a Set as state.
 * Provides efficient state management and stable action functions.
 *
-* @param {SetOrValues<T>} initialState - Initial Set state (Set object or array of values)
-* @returns {UseSetReturn<T>} A tuple containing the Set state and actions to manipulate it
+* @template T - The type of the values held in the set.
+*
+* @param {SetOrValues<T>} [initialState=new Set()] - Initial Set state (Set object or array of values).
+*
+* @returns {UseSetReturn<T>} A tuple containing the Set state and actions to manipulate it.
+* - [0] `Omit<Set<T>, 'add' | 'clear' | 'delete'>` - The current Set state with mutation methods hidden;
+* - [1].add `(value: T) => void` - Adds a value to the set;
+* - [1].remove `(value: T) => void` - Removes a value from the set;
+* - [1].toggle `(value: T) => void` - Adds the value if absent, removes it if present;
+* - [1].setAll `(values: Set<T> | T[]) => void` - Replaces all values in the set;
+* - [1].reset `() => void` - Resets the set to its initial state;
 *
 * @example
 * ```tsx

package/dist/hooks/useSet/useSet.d.cts

@@ -14,8 +14,17 @@ type UseSetReturn<T> = [Omit<Set<T>, 'add' | 'clear' | 'delete'>, SetActions<T>]
  * A React hook that manages a Set as state.
  * Provides efficient state management and stable action functions.
  *
- * @param {SetOrValues<T>} initialState - Initial Set state (Set object or array of values)
- * @returns {UseSetReturn<T>} A tuple containing the Set state and actions to manipulate it
+ * @template T - The type of the values held in the set.
+ *
+ * @param {SetOrValues<T>} [initialState=new Set()] - Initial Set state (Set object or array of values).
+ *
+ * @returns {UseSetReturn<T>} A tuple containing the Set state and actions to manipulate it.
+ * - [0] `Omit<Set<T>, 'add' | 'clear' | 'delete'>` - The current Set state with mutation methods hidden;
+ * - [1].add `(value: T) => void` - Adds a value to the set;
+ * - [1].remove `(value: T) => void` - Removes a value from the set;
+ * - [1].toggle `(value: T) => void` - Adds the value if absent, removes it if present;
+ * - [1].setAll `(values: Set<T> | T[]) => void` - Replaces all values in the set;
+ * - [1].reset `() => void` - Resets the set to its initial state;
  *
  * @example
  * ```tsx