react-simplikit 0.0.53 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,126 @@
+# react-simplikit
+
+## 0.2.0
+
+### Minor Changes
+
+- [#446](https://github.com/toss/react-simplikit/pull/446) [`0b66d40`](https://github.com/toss/react-simplikit/commit/0b66d40e56b4a183fd1fc5dce8a685e2a0da2839) Thanks [@hyesungoh](https://github.com/hyesungoh)! - `useDebouncedCallback` and `useThrottledCallback` now accept any value type: `onChange` is typed `(newValue: T) => void` instead of `(newValue: boolean) => void`, so a debounced search query or a throttled scroll position no longer needs a cast. Existing boolean callers are unaffected.
+
+  `useDebouncedCallback` no longer drops a first call of `false`. It compared incoming values against a seed of `false`, so the very first `false` looked redundant and was never forwarded; the comparison now starts from a sentinel, as `useThrottledCallback` already did. A `false` that arrives while an initial `true` is still pending now replaces it instead of being ignored.
+
+  `useImpressionRef` no longer emits `onImpressionEnd` for an element that was never impressed.
+
+### Patch Changes
+
+- [#450](https://github.com/toss/react-simplikit/pull/450) [`a4251a3`](https://github.com/toss/react-simplikit/commit/a4251a30aafbfabc61e6cc9a80de1af86936bb2a) Thanks [@hyesungoh](https://github.com/hyesungoh)! - `useDebouncedCallback` and `useThrottledCallback` no longer forward a stale value when the caller returns to the last forwarded one. Calling with `'seo'` and then `'seoul'` right after `'seoul'` had already been forwarded used to skip the second call as a duplicate without cancelling the pending `'seo'`, so `onChange('seo')` fired anyway. The pending call is now cancelled first. For `useThrottledCallback` this only showed with `edges: ['trailing']`; the default leading edge forwards the intermediate value immediately and masked it.
+
+- [#452](https://github.com/toss/react-simplikit/pull/452) [`fd312f5`](https://github.com/toss/react-simplikit/commit/fd312f589430154d38b7d5d5998f1f20ceb0be54) Thanks [@hyesungoh](https://github.com/hyesungoh)! - JSDoc corrections that show up in editor hover. `useIntersectionObserver`'s `options.root` is typed `Element | Document | null` instead of `boolean`. `useList` and `useSet` now declare their generic parameter, their optional initial state and every member they return. `mergeProps` and `mergeRefs` mark their rest parameter as one, so the documented signature matches the implementation.
+
+- [#456](https://github.com/toss/react-simplikit/pull/456) [`65ce435`](https://github.com/toss/react-simplikit/commit/65ce435abfca276f2a22c01b6ff50dc5530831fc) Thanks [@mnxmnz](https://github.com/mnxmnz)! - Re-export the `SafeAreaInset` type from the package root. `@react-simplikit/mobile` exported it, but it was dropped when that package was absorbed into the root entry, leaving `import type { SafeAreaInset }` with no replacement.
+
+- [#435](https://github.com/toss/react-simplikit/pull/435) [`9e05182`](https://github.com/toss/react-simplikit/commit/9e051826418a852996ae851a7f8c8e53c1408852) Thanks [@hyesungoh](https://github.com/hyesungoh)! - `useDoubleClick`, `useGeolocation`, `useImpressionRef`, `useIntersectionObserver`, `useLongPress`, `useOutsideClickEffect`, `useStorageState` and `useVisibilityEvent` are no longer marked `@deprecated`. They are maintained hooks again: editors stop rendering them struck-through, and no removal is planned.
+
+## 0.1.0
+
+### Minor Changes
+
+- [#437](https://github.com/toss/react-simplikit/pull/437) [`fe2226d`](https://github.com/toss/react-simplikit/commit/fe2226d5fbfcd305ab888cef83450f7f0e1caa77) Thanks [@mnxmnz](https://github.com/mnxmnz)! - Absorb `@react-simplikit/mobile` into the root export of `react-simplikit`. Update imports from `@react-simplikit/mobile` to `react-simplikit`; the exported APIs are unchanged. The `@react-simplikit/mobile` npm package will be deprecated with a pointer to `react-simplikit` after this release.
+
+### Patch Changes
+
+- [#423](https://github.com/toss/react-simplikit/pull/423) [`36e3e4c`](https://github.com/toss/react-simplikit/commit/36e3e4ccbd9c7a45bda18f33dcb514c97f387cbb) Thanks [@Antoliny0919](https://github.com/Antoliny0919)! - The returned handler was typed as `ChangeEventHandler<HTMLInputElement>`, so passing it to a `<textarea>` raised a type error even though the runtime behavior was identical. The handler is now typed as `ChangeEventHandler<HTMLInputElement | HTMLTextAreaElement>`, so it can be attached to both `<input>` and `<textarea>` elements.
+
+- [#424](https://github.com/toss/react-simplikit/pull/424) [`1ac0166`](https://github.com/toss/react-simplikit/commit/1ac0166d8f41c1159d004bd9c8192f2e59f6efc8) Thanks [@hyesungoh](https://github.com/hyesungoh)! - fix(core): opt the remaining React Compiler-incompatible hooks out with `'use no memo'`
+
+## 0.0.53
+
+### Patch Changes
+
+- [#379](https://github.com/toss/react-simplikit/pull/379) [`e2030a2`](https://github.com/toss/react-simplikit/commit/e2030a2deac81fb247b9f601fab19d87a067cc9c) Thanks [@lumirlumir](https://github.com/lumirlumir)! - fix(usePrevious): opt out `usePrevious` hook from React Compiler
+
+- [#404](https://github.com/toss/react-simplikit/pull/404) [`cac80cb`](https://github.com/toss/react-simplikit/commit/cac80cb41897b834bb3661336faa84197c558c1e) Thanks [@bbjbc](https://github.com/bbjbc)! - fix(useThrottledCallback): invoke the callback when the first value is `false`
+
+  The hook skips redundant invocations by comparing the incoming value against the last one it forwarded, but that comparison was seeded with `false`. Because the hook takes no initial value from the caller, a first call of `false` looked redundant and was dropped — so consumers whose state starts as `true` lost the transition back to `false`. The comparison now starts from a sentinel, so the first call is always forwarded regardless of its value.
+
+## 0.0.52
+
+### Patch Changes
+
+- [#401](https://github.com/toss/react-simplikit/pull/401) [`9b93d29`](https://github.com/toss/react-simplikit/commit/9b93d299e9b105d060f2700b27ffb63001b88de3) Thanks [@hyesungoh](https://github.com/hyesungoh)! - Switched the build output from a single bundled file per package to per-module files, so bundlers can tree-shake unused exports at file granularity instead of relying on dead-code elimination inside one large bundle.
+
+  The public API and runtime behavior are unchanged. For an app importing a single hook, this cuts the amount of code a bundler has to include: `react-simplikit`'s `useToggle` drops from 5363 B to 102 B minified, and `@react-simplikit/mobile`'s `useNetworkStatus` drops from 981 B to 570 B minified.
+
+  The only user-visible change is packaging: output files are now `.mjs`/`.cjs` with `.d.mts`/`.d.cts` type declarations instead of a flat bundle, and for `react-simplikit` the `esm/` directory has been removed (`@react-simplikit/mobile` never had one — it always emitted to `dist/`). This does not affect the published `exports` map, so `import`/`require` usage is unaffected — only projects that deep-imported internal build paths (which were never part of the public `exports`) would be impacted.
+
+## 0.0.51
+
+### Patch Changes
+
+- [#351](https://github.com/toss/react-simplikit/pull/351) [`da1f51c`](https://github.com/toss/react-simplikit/commit/da1f51cc9b860dde91dcfd120605eb6a93de3b55) Thanks [@eunwoo-levi](https://github.com/eunwoo-levi)! - fix(core/hooks): call cleanup when unmount occurs before async effect resolves
+
+- [#352](https://github.com/toss/react-simplikit/pull/352) [`fa3daa5`](https://github.com/toss/react-simplikit/commit/fa3daa52d18644ac90a35fc8a79501eae7bb0269) Thanks [@eunwoo-levi](https://github.com/eunwoo-levi)! - fix(core/hooks): prevent immediate callback from re-firing when enabled is toggled
+
+## 0.0.50
+
+### Patch Changes
+
+- [#362](https://github.com/toss/react-simplikit/pull/362) [`fc9b1dc`](https://github.com/toss/react-simplikit/commit/fc9b1dcc2be7902ffe487c5868180317b9f07730) Thanks [@guesung](https://github.com/guesung)! - refactor(core): narrow types in `debounce` utility to reduce `any` usage
+
+- [#259](https://github.com/toss/react-simplikit/pull/259) [`1d9ec79`](https://github.com/toss/react-simplikit/commit/1d9ec7984899d1d8dcda16d15efa66f458c347fa) Thanks [@wo-o29](https://github.com/wo-o29)! - refactor(useCounter): extract validateValue as pure function and remove unnecessary useCallback
+
+- [#272](https://github.com/toss/react-simplikit/pull/272) [`75ab148`](https://github.com/toss/react-simplikit/commit/75ab1484a1af68a2f27fa31da8f6094f0c63d37f) Thanks [@wo-o29](https://github.com/wo-o29)! - refactor(usePrevious): remove unnecessary `undefined` from compare argument and return type
+
+## 0.0.49
+
+### Patch Changes
+
+- [#339](https://github.com/toss/react-simplikit/pull/339) [`e5f6cac`](https://github.com/toss/react-simplikit/commit/e5f6cacd0bc93c03f361d0c825424937bc141809) Thanks [@sukvvon](https://github.com/sukvvon)! - feat(core/hooks): add 'useSet' hook
+
+- [#219](https://github.com/toss/react-simplikit/pull/219) [`2a901bb`](https://github.com/toss/react-simplikit/commit/2a901bb903f4663571c7649769d3e29c9e844332) Thanks [@sukvvon](https://github.com/sukvvon)! - feat(core/hooks): add 'useIsClient' hook
+
+- [#273](https://github.com/toss/react-simplikit/pull/273) [`ffc61bb`](https://github.com/toss/react-simplikit/commit/ffc61bb998fdaf129fff12e5e7515007ca5eeb51) Thanks [@wo-o29](https://github.com/wo-o29)! - docs: Add generic type support to useRefEffect interface
+
+- [#278](https://github.com/toss/react-simplikit/pull/278) [`278b117`](https://github.com/toss/react-simplikit/commit/278b117152f8f01c54a66fc91c7c4c03fc74f7d9) Thanks [@wo-o29](https://github.com/wo-o29)! - fix: Replace array index keys with child keys in Separated
+
+- [#347](https://github.com/toss/react-simplikit/pull/347) [`9a358e2`](https://github.com/toss/react-simplikit/commit/9a358e28e5407ab93c41dec486d932bbc9c42a64) Thanks [@eunwoo-levi](https://github.com/eunwoo-levi)! - use named functions in useEffect callbacks for better stack traces
+
+- [#345](https://github.com/toss/react-simplikit/pull/345) [`35d13f8`](https://github.com/toss/react-simplikit/commit/35d13f8fb0aa12dd2c1e5aa15ae18f823ec323fd) Thanks [@eunwoo-levi](https://github.com/eunwoo-levi)! - fix useInterval to use globalThis instead of window for platform independence
+
+- [`68e7ac8`](https://github.com/toss/react-simplikit/commit/68e7ac86650026709f2be7498c830dfe5cfdc2e1) Thanks [@sukvvon](https://github.com/sukvvon)! - feat(core/hooks): add 'useList' hook
+
+- [`4b0c59e`](https://github.com/toss/react-simplikit/commit/4b0c59edb599406535a479c1f099a272c399ee99) Thanks [@sukvvon](https://github.com/sukvvon)! - feat(core/hooks): add 'useThrottledCallback' hook
+
+- [#333](https://github.com/toss/react-simplikit/pull/333) [`4254542`](https://github.com/toss/react-simplikit/commit/4254542e481374c7f0e4de6dbacdfd10f076e529) Thanks [@dlsxjzld](https://github.com/dlsxjzld)! - remove window prefix from setTimeout and clearTimeout for platform-independent
+
+## 0.0.48
+
+### Patch Changes
+
+- [#318](https://github.com/toss/react-simplikit/pull/318) [`466e3ce`](https://github.com/toss/react-simplikit/commit/466e3ceab51a499abb141bc1fe138d9109cc0df5) Thanks [@kimyouknow](https://github.com/kimyouknow)! - Fix broken package exports by moving main/types/module/exports from publishConfig to top-level package.json fields
+
+  npm does not support publishConfig field overrides for manifest fields like main, types, and exports. The previous versions (react-simplikit@0.0.47, @react-simplikit/mobile@0.0.1) were published with incorrect entry points because publishConfig overrides were not applied during `npm publish`.
+
+## 0.0.47
+
+### Patch Changes
+
+- [#316](https://github.com/toss/react-simplikit/pull/316) [`5b2eeba`](https://github.com/toss/react-simplikit/commit/5b2eeba659206cf9577dd57796a4770d07a33f62) Thanks [@kimyouknow](https://github.com/kimyouknow)! - Deprecate hooks that depend on browser-specific APIs
+
+  The following hooks are now marked as deprecated:
+
+  - `useDoubleClick`
+  - `useGeolocation`
+  - `useImpressionRef`
+  - `useIntersectionObserver`
+  - `useLongPress`
+  - `useOutsideClickEffect`
+  - `useStorageState`
+  - `useVisibilityEvent`
+
+  These hooks will be removed in a future major version as react-simplikit is now focused on platform-independent, pure state/logic hooks.
+
+## 0.0.46
+
+### Patch Changes
+
+- [#292](https://github.com/toss/react-simplikit/pull/292) [`afaafd3`](https://github.com/toss/react-simplikit/commit/afaafd397a8c23caf26d8eb3167a31a06a864b2f) Thanks [@kimyouknow](https://github.com/kimyouknow)! - verify changeset automation workflow

package/README.md

@@ -4,7 +4,7 @@
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/react-simplikit/blob/main/LICENSE)
 [![codecov](https://codecov.io/gh/toss/react-simplikit/graph/badge.svg?token=RHVOZ3J3TU)](https://codecov.io/gh/toss/react-simplikit)
 
-English | [한국어](./README-ko_kr.md)
+English | [한국어](./README-ko_kr.md) | [日本語](./README-ja_jp.md) | [简体中文](./README-zh_hans.md) | [Español](./README-es.md)
 
 A lightweight, zero-dependency React utilities library providing hooks, components, and utilities.
 
@@ -16,46 +16,6 @@ A lightweight, zero-dependency React utilities library providing hooks, componen
 - **SSR-safe** - Works with Next.js and other SSR frameworks
 - **Tree-shakeable** - Only bundle what you use
 
-## Library Direction
-
-**react-simplikit is now maintained as a Universal Hook Library providing only pure state/logic hooks.**
-
-We are repositioning react-simplikit to focus exclusively on **platform-independent hooks** that work seamlessly across web and mobile (React Native, etc.).
-
-### What's Maintained: Pure State/Logic Hooks
-
-Hooks that don't depend on specific platform APIs will continue to be actively maintained:
-
-- State management hooks like `useToggle`, `useBooleanState`, `useCounter`
-- Lifecycle hooks like `usePrevious`
-- Utility hooks like `useDebounce`, `useThrottle`
-- **Backward compatibility (BC) is preserved** for these existing pure logic hooks
-
-### What's Deprecated: Browser/Platform-Dependent Hooks
-
-The following hooks that strongly depend on browser-specific APIs are now deprecated:
-
-- `useGeolocation` - depends on `navigator.geolocation`
-- `useStorageState` - depends on `localStorage`/`sessionStorage`
-- `useIntersectionObserver` - depends on `IntersectionObserver` API
-- `useImpressionRef` - depends on `IntersectionObserver` + Visibility API
-- `useDoubleClick`, `useLongPress` - depend on DOM events + `window.setTimeout`
-- `useOutsideClickEffect` - depends on DOM events + `document`
-- `useVisibilityEvent` - depends on `document.visibilityState`
-
-These hooks:
-
-- Will not receive new features or major enhancements
-- Are marked as `@deprecated` in documentation
-- May be removed in future major versions
-
-### Package Status
-
-- react-simplikit will **not be archived**
-- Pure state/logic hooks will continue to be maintained
-- Critical bug fixes and minimal maintenance will continue
-- No new browser/platform-dependent hooks will be added
-
 ## Installation
 
 ```bash
@@ -132,7 +92,7 @@ Visit [react-simplikit.slash.page](https://react-simplikit.slash.page) for full
 
 ## Related Packages
 
-- [@react-simplikit/mobile](https://www.npmjs.com/package/@react-simplikit/mobile) - Mobile web utilities
+- [Mobile web utilities](https://react-simplikit.slash.page/mobile/intro.html) - included in `react-simplikit`
 
 ## Contributing
 

package/dist/hooks/useAsyncEffect/useAsyncEffect.cjs

@@ -22,6 +22,7 @@ let react = require("react");
 * }, [dependencies]);
 */
 function useAsyncEffect(effect, deps) {
+	"use no memo";
 	(0, react.useEffect)(() => {
 		let cleanup;
 		let isCleaned = false;

package/dist/hooks/useAsyncEffect/useAsyncEffect.mjs

@@ -22,6 +22,7 @@ import { useEffect } from "react";
 * }, [dependencies]);
 */
 function useAsyncEffect(effect, deps) {
+	"use no memo";
 	useEffect(() => {
 		let cleanup;
 		let isCleaned = false;

package/dist/hooks/useCallbackOncePerRender/useCallbackOncePerRender.cjs

@@ -38,6 +38,7 @@ let react = require("react");
 * }
 */
 function useCallbackOncePerRender(callback, deps) {
+	"use no memo";
 	const hasFired = (0, react.useRef)(false);
 	(0, react.useEffect)(() => {
 		hasFired.current = false;

package/dist/hooks/useCallbackOncePerRender/useCallbackOncePerRender.mjs

@@ -38,6 +38,7 @@ import { useEffect, useRef } from "react";
 * }
 */
 function useCallbackOncePerRender(callback, deps) {
+	"use no memo";
 	const hasFired = useRef(false);
 	useEffect(() => {
 		hasFired.current = false;

package/dist/hooks/useConditionalEffect/useConditionalEffect.cjs

@@ -40,6 +40,7 @@ let react = require("react");
 *
 */
 function useConditionalEffect(effect, deps, condition) {
+	"use no memo";
 	const prevDepsRef = (0, react.useRef)(void 0);
 	const memoizedCondition = (0, react.useCallback)(condition, deps);
 	if (deps.length === 0) console.warn("useConditionalEffect received an empty dependency array. This may indicate missing dependencies and could lead to unexpected behavior.");

package/dist/hooks/useConditionalEffect/useConditionalEffect.mjs

@@ -40,6 +40,7 @@ import { useCallback, useEffect, useRef } from "react";
 *
 */
 function useConditionalEffect(effect, deps, condition) {
+	"use no memo";
 	const prevDepsRef = useRef(void 0);
 	const memoizedCondition = useCallback(condition, deps);
 	if (deps.length === 0) console.warn("useConditionalEffect received an empty dependency array. This may indicate missing dependencies and could lead to unexpected behavior.");

package/dist/hooks/useDebouncedCallback/useDebouncedCallback.cjs

@@ -4,31 +4,49 @@ const require_usePreservedCallback = require("../usePreservedCallback/usePreserv
 let react = require("react");
 //#region src/hooks/useDebouncedCallback/useDebouncedCallback.ts
 /**
+* Marks that no value has been forwarded to `onChange` yet.
+*
+* The hook skips redundant invocations by comparing against the last forwarded value, but it
+* receives no initial value from the caller. Seeding that comparison with a real value would treat
+* the first call of that value as redundant and swallow it, so an unreachable sentinel is used instead.
+*/
+const NOT_INVOKED = Symbol("NOT_INVOKED");
+/**
 * @description
 * `useDebouncedCallback` is a React hook that returns a debounced version of the provided callback function.
 * It helps optimize event handling by delaying function execution and grouping multiple calls into one.
 *
 * Note that if both 'leading' and 'trailing' are set, the function will be called at both the start and end of the delay period. However, it must be called at least twice within debounceMs interval for this to happen, since one debounced function call cannot trigger the function twice.
 *
+* @template T - The type of the value passed to `onChange`.
 * @param {Object} options - The options object.
-* @param {Function} options.onChange - The callback function to debounce.
+* @param {(newValue: T) => void} options.onChange - The callback to debounce. A call with the same value as the last forwarded one is skipped.
 * @param {number} options.timeThreshold - The number of milliseconds to delay the function execution.
 * @param {boolean} [options.leading=false] - If `true`, the function is called at the start of the sequence.
 * @param {boolean} [options.trailing=true] - If `true`, the function is called at the end of the sequence.
 *
-* @returns {Function} A debounced function that delays invoking the callback.
+* @returns {(nextValue: T) => void} A debounced function that forwards the value to `onChange`.
 *
 * @example
+* import { useDebouncedCallback } from 'react-simplikit';
+* import { useState } from 'react';
+*
 * function SearchInput() {
 *   const [query, setQuery] = useState('');
-*   const debouncedSetQuery = useDebouncedCallback({ onChange: setQuery, timeThreshold: 100 });
-*   return <input type="text" onChange={(e) => debouncedSetQuery(e.target.value)} />;
+*   const setQueryDebounced = useDebouncedCallback({ onChange: setQuery, timeThreshold: 300 });
+*
+*   return (
+*     <>
+*       <input onChange={e => setQueryDebounced(e.target.value)} />
+*       <p>Searching for: {query}</p>
+*     </>
+*   );
 * }
 */
 function useDebouncedCallback({ onChange, timeThreshold, leading = false, trailing = true }) {
 	const handleChange = require_usePreservedCallback.usePreservedCallback(onChange);
 	const ref = (0, react.useRef)({
-		value: false,
+		value: NOT_INVOKED,
 		clearPreviousDebounce: () => {}
 	});
 	(0, react.useEffect)(function clearDebouncedOnUnmount() {
@@ -44,12 +62,12 @@ function useDebouncedCallback({ onChange, timeThreshold, leading = false, traili
 		return _edges;
 	}, [leading, trailing]);
 	return (0, react.useCallback)((nextValue) => {
+		ref.current.clearPreviousDebounce();
 		if (nextValue === ref.current.value) return;
 		const debounced = require_debounce.debounce(() => {
 			handleChange(nextValue);
 			ref.current.value = nextValue;
 		}, timeThreshold, { edges });
-		ref.current.clearPreviousDebounce();
 		debounced();
 		ref.current.clearPreviousDebounce = debounced.cancel;
 	}, [

package/dist/hooks/useDebouncedCallback/useDebouncedCallback.d.cts

@@ -11,24 +11,34 @@ type DebounceOptions = {
  *
  * Note that if both 'leading' and 'trailing' are set, the function will be called at both the start and end of the delay period. However, it must be called at least twice within debounceMs interval for this to happen, since one debounced function call cannot trigger the function twice.
  *
+ * @template T - The type of the value passed to `onChange`.
  * @param {Object} options - The options object.
- * @param {Function} options.onChange - The callback function to debounce.
+ * @param {(newValue: T) => void} options.onChange - The callback to debounce. A call with the same value as the last forwarded one is skipped.
  * @param {number} options.timeThreshold - The number of milliseconds to delay the function execution.
  * @param {boolean} [options.leading=false] - If `true`, the function is called at the start of the sequence.
  * @param {boolean} [options.trailing=true] - If `true`, the function is called at the end of the sequence.
  *
- * @returns {Function} A debounced function that delays invoking the callback.
+ * @returns {(nextValue: T) => void} A debounced function that forwards the value to `onChange`.
  *
  * @example
+ * import { useDebouncedCallback } from 'react-simplikit';
+ * import { useState } from 'react';
+ *
  * function SearchInput() {
  *   const [query, setQuery] = useState('');
- *   const debouncedSetQuery = useDebouncedCallback({ onChange: setQuery, timeThreshold: 100 });
- *   return <input type="text" onChange={(e) => debouncedSetQuery(e.target.value)} />;
+ *   const setQueryDebounced = useDebouncedCallback({ onChange: setQuery, timeThreshold: 300 });
+ *
+ *   return (
+ *     <>
+ *       <input onChange={e => setQueryDebounced(e.target.value)} />
+ *       <p>Searching for: {query}</p>
+ *     </>
+ *   );
  * }
  */
-declare function useDebouncedCallback({ onChange, timeThreshold, leading, trailing }: DebounceOptions & {
-  onChange: (newValue: boolean) => void;
+declare function useDebouncedCallback<T>({ onChange, timeThreshold, leading, trailing }: DebounceOptions & {
+  onChange: (newValue: T) => void;
   timeThreshold: number;
-}): (nextValue: boolean) => void;
+}): (nextValue: T) => void;
 //#endregion
 export { useDebouncedCallback };

package/dist/hooks/useDebouncedCallback/useDebouncedCallback.d.mts

@@ -11,24 +11,34 @@ type DebounceOptions = {
  *
  * Note that if both 'leading' and 'trailing' are set, the function will be called at both the start and end of the delay period. However, it must be called at least twice within debounceMs interval for this to happen, since one debounced function call cannot trigger the function twice.
  *
+ * @template T - The type of the value passed to `onChange`.
  * @param {Object} options - The options object.
- * @param {Function} options.onChange - The callback function to debounce.
+ * @param {(newValue: T) => void} options.onChange - The callback to debounce. A call with the same value as the last forwarded one is skipped.
  * @param {number} options.timeThreshold - The number of milliseconds to delay the function execution.
  * @param {boolean} [options.leading=false] - If `true`, the function is called at the start of the sequence.
  * @param {boolean} [options.trailing=true] - If `true`, the function is called at the end of the sequence.
  *
- * @returns {Function} A debounced function that delays invoking the callback.
+ * @returns {(nextValue: T) => void} A debounced function that forwards the value to `onChange`.
  *
  * @example
+ * import { useDebouncedCallback } from 'react-simplikit';
+ * import { useState } from 'react';
+ *
  * function SearchInput() {
  *   const [query, setQuery] = useState('');
- *   const debouncedSetQuery = useDebouncedCallback({ onChange: setQuery, timeThreshold: 100 });
- *   return <input type="text" onChange={(e) => debouncedSetQuery(e.target.value)} />;
+ *   const setQueryDebounced = useDebouncedCallback({ onChange: setQuery, timeThreshold: 300 });
+ *
+ *   return (
+ *     <>
+ *       <input onChange={e => setQueryDebounced(e.target.value)} />
+ *       <p>Searching for: {query}</p>
+ *     </>
+ *   );
  * }
  */
-declare function useDebouncedCallback({ onChange, timeThreshold, leading, trailing }: DebounceOptions & {
-  onChange: (newValue: boolean) => void;
+declare function useDebouncedCallback<T>({ onChange, timeThreshold, leading, trailing }: DebounceOptions & {
+  onChange: (newValue: T) => void;
   timeThreshold: number;
-}): (nextValue: boolean) => void;
+}): (nextValue: T) => void;
 //#endregion
 export { useDebouncedCallback };

package/dist/hooks/useDebouncedCallback/useDebouncedCallback.mjs

@@ -4,31 +4,49 @@ import { usePreservedCallback } from "../usePreservedCallback/usePreservedCallba
 import { useCallback, useEffect, useMemo, useRef } from "react";
 //#region src/hooks/useDebouncedCallback/useDebouncedCallback.ts
 /**
+* Marks that no value has been forwarded to `onChange` yet.
+*
+* The hook skips redundant invocations by comparing against the last forwarded value, but it
+* receives no initial value from the caller. Seeding that comparison with a real value would treat
+* the first call of that value as redundant and swallow it, so an unreachable sentinel is used instead.
+*/
+const NOT_INVOKED = Symbol("NOT_INVOKED");
+/**
 * @description
 * `useDebouncedCallback` is a React hook that returns a debounced version of the provided callback function.
 * It helps optimize event handling by delaying function execution and grouping multiple calls into one.
 *
 * Note that if both 'leading' and 'trailing' are set, the function will be called at both the start and end of the delay period. However, it must be called at least twice within debounceMs interval for this to happen, since one debounced function call cannot trigger the function twice.
 *
+* @template T - The type of the value passed to `onChange`.
 * @param {Object} options - The options object.
-* @param {Function} options.onChange - The callback function to debounce.
+* @param {(newValue: T) => void} options.onChange - The callback to debounce. A call with the same value as the last forwarded one is skipped.
 * @param {number} options.timeThreshold - The number of milliseconds to delay the function execution.
 * @param {boolean} [options.leading=false] - If `true`, the function is called at the start of the sequence.
 * @param {boolean} [options.trailing=true] - If `true`, the function is called at the end of the sequence.
 *
-* @returns {Function} A debounced function that delays invoking the callback.
+* @returns {(nextValue: T) => void} A debounced function that forwards the value to `onChange`.
 *
 * @example
+* import { useDebouncedCallback } from 'react-simplikit';
+* import { useState } from 'react';
+*
 * function SearchInput() {
 *   const [query, setQuery] = useState('');
-*   const debouncedSetQuery = useDebouncedCallback({ onChange: setQuery, timeThreshold: 100 });
-*   return <input type="text" onChange={(e) => debouncedSetQuery(e.target.value)} />;
+*   const setQueryDebounced = useDebouncedCallback({ onChange: setQuery, timeThreshold: 300 });
+*
+*   return (
+*     <>
+*       <input onChange={e => setQueryDebounced(e.target.value)} />
+*       <p>Searching for: {query}</p>
+*     </>
+*   );
 * }
 */
 function useDebouncedCallback({ onChange, timeThreshold, leading = false, trailing = true }) {
 	const handleChange = usePreservedCallback(onChange);
 	const ref = useRef({
-		value: false,
+		value: NOT_INVOKED,
 		clearPreviousDebounce: () => {}
 	});
 	useEffect(function clearDebouncedOnUnmount() {
@@ -44,12 +62,12 @@ function useDebouncedCallback({ onChange, timeThreshold, leading = false, traili
 		return _edges;
 	}, [leading, trailing]);
 	return useCallback((nextValue) => {
+		ref.current.clearPreviousDebounce();
 		if (nextValue === ref.current.value) return;
 		const debounced = debounce(() => {
 			handleChange(nextValue);
 			ref.current.value = nextValue;
 		}, timeThreshold, { edges });
-		ref.current.clearPreviousDebounce();
 		debounced();
 		ref.current.clearPreviousDebounce = debounced.cancel;
 	}, [

package/dist/hooks/useDoubleClick/useDoubleClick.cjs

@@ -3,10 +3,6 @@ const require_usePreservedCallback = require("../usePreservedCallback/usePreserv
 let react = require("react");
 //#region src/hooks/useDoubleClick/useDoubleClick.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
 * `useDoubleClick` is a React hook that differentiates between single and double click events.
 * It delays the single click callback execution for a specified time, and cancels it if a second click (i.e. a double click) occurs within that time.

package/dist/hooks/useDoubleClick/useDoubleClick.d.cts

@@ -7,10 +7,6 @@ type UseDoubleClickProps<E extends HTMLElement> = {
   doubleClick: (event: MouseEvent<E>) => void;
 };
 /**
- * @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
  * `useDoubleClick` is a React hook that differentiates between single and double click events.
  * It delays the single click callback execution for a specified time, and cancels it if a second click (i.e. a double click) occurs within that time.

package/dist/hooks/useDoubleClick/useDoubleClick.d.mts

@@ -7,10 +7,6 @@ type UseDoubleClickProps<E extends HTMLElement> = {
   doubleClick: (event: MouseEvent<E>) => void;
 };
 /**
- * @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
  * `useDoubleClick` is a React hook that differentiates between single and double click events.
  * It delays the single click callback execution for a specified time, and cancels it if a second click (i.e. a double click) occurs within that time.

package/dist/hooks/useDoubleClick/useDoubleClick.mjs

@@ -3,10 +3,6 @@ import { usePreservedCallback } from "../usePreservedCallback/usePreservedCallba
 import { useCallback, useEffect, useRef } from "react";
 //#region src/hooks/useDoubleClick/useDoubleClick.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
 * `useDoubleClick` is a React hook that differentiates between single and double click events.
 * It delays the single click callback execution for a specified time, and cancels it if a second click (i.e. a double click) occurs within that time.

package/dist/hooks/useGeolocation/useGeolocation.cjs

@@ -14,10 +14,6 @@ const GeolocationMountBehavior = {
 	WATCH: "watch"
 };
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (navigator.geolocation).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useGeolocation` is a React hook that retrieves and tracks the user's geographical location.
 * It uses the browser's `Geolocation API` to support both one-time position retrieval and continuous location tracking.

package/dist/hooks/useGeolocation/useGeolocation.d.cts

@@ -26,10 +26,6 @@ type GeolocationOptions = {
   mountBehavior?: GeolocationMountBehaviorType;
 } & PositionOptions;
 /**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (navigator.geolocation).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
  * @description
  * `useGeolocation` is a React hook that retrieves and tracks the user's geographical location.
  * It uses the browser's `Geolocation API` to support both one-time position retrieval and continuous location tracking.

package/dist/hooks/useGeolocation/useGeolocation.d.mts

@@ -26,10 +26,6 @@ type GeolocationOptions = {
   mountBehavior?: GeolocationMountBehaviorType;
 } & PositionOptions;
 /**
- * @deprecated This hook is deprecated as it depends on browser-specific APIs (navigator.geolocation).
- * react-simplikit is now focused on platform-independent, pure state/logic hooks.
- * This hook will be removed in a future major version.
- *
  * @description
  * `useGeolocation` is a React hook that retrieves and tracks the user's geographical location.
  * It uses the browser's `Geolocation API` to support both one-time position retrieval and continuous location tracking.

package/dist/hooks/useGeolocation/useGeolocation.mjs

@@ -14,10 +14,6 @@ const GeolocationMountBehavior = {
 	WATCH: "watch"
 };
 /**
-* @deprecated This hook is deprecated as it depends on browser-specific APIs (navigator.geolocation).
-* react-simplikit is now focused on platform-independent, pure state/logic hooks.
-* This hook will be removed in a future major version.
-*
 * @description
 * `useGeolocation` is a React hook that retrieves and tracks the user's geographical location.
 * It uses the browser's `Geolocation API` to support both one-time position retrieval and continuous location tracking.

package/dist/hooks/useImpressionRef/useImpressionRef.cjs

@@ -6,10 +6,6 @@ const require_useVisibilityEvent = require("../useVisibilityEvent/useVisibilityE
 let react = require("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 = require_usePreservedCallback.usePreservedCallback(onImpressionStart);
 	const impressionEndHandler = require_usePreservedCallback.usePreservedCallback(onImpressionEnd);
 	const isIntersectingRef = (0, react.useRef)(false);
+	const hasImpressionStartedRef = (0, react.useRef)(false);
 	const impressionEventHandler = require_useDebouncedCallback.useDebouncedCallback({
 		timeThreshold,
 		onChange: (impressed) => {
-			(impressed ? impressionStartHandler : impressionEndHandler)();
+			if (impressed) {
+				hasImpressionStartedRef.current = true;
+				impressionStartHandler();
+				return;
+			}
+			if (hasImpressionStartedRef.current) impressionEndHandler();
 		},
 		leading: true
 	});

package/dist/hooks/useImpressionRef/useImpressionRef.d.cts

@@ -8,10 +8,6 @@ type UseImpressionRefOptions = Partial<{
   timeThreshold: number;
 }>;
 /**
- * @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.

package/dist/hooks/useImpressionRef/useImpressionRef.d.mts

@@ -8,10 +8,6 @@ type UseImpressionRefOptions = Partial<{
   timeThreshold: number;
 }>;
 /**
- * @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.