npm - @tanstack/preact-pacer - Versions diffs - 0.21.1 → 0.22.1 - Mend

@tanstack/preact-pacer 0.21.1 → 0.22.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (107) hide show

package/dist/rate-limiter/useRateLimiter.d.cts CHANGED Viewed

@@ -37,8 +37,8 @@ interface PreactRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omi
   readonly state: Readonly<TSelected>;
   /**
    * @deprecated Use `rateLimiter.state` instead of `rateLimiter.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
+   * Although, you can make the state reactive by using the `useSelector` in your own usage.
    */
   readonly store: Store<Readonly<RateLimiterState>>;
 }

package/dist/rate-limiter/useRateLimiter.d.ts CHANGED Viewed

@@ -37,8 +37,8 @@ interface PreactRateLimiter<TFn extends AnyFunction, TSelected = {}> extends Omi
   readonly state: Readonly<TSelected>;
   /**
    * @deprecated Use `rateLimiter.state` instead of `rateLimiter.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
+   * Although, you can make the state reactive by using the `useSelector` in your own usage.
    */
   readonly store: Store<Readonly<RateLimiterState>>;
 }

package/dist/rate-limiter/useRateLimiter.js CHANGED Viewed

@@ -1,6 +1,6 @@
 import { useDefaultPacerOptions } from "../provider/PacerProvider.js";
 import { useEffect, useMemo, useState } from "preact/hooks";
-import { shallow, useStore } from "@tanstack/preact-store";
+import { shallow, useSelector } from "@tanstack/preact-store";
 import { RateLimiter } from "@tanstack/pacer/rate-limiter";
 //#region src/rate-limiter/useRateLimiter.ts
@@ -143,7 +143,7 @@ function useRateLimiter(fn, options, selector = () => ({})) {
 	const [rateLimiter] = useState(() => {
 		const rateLimiterInstance = new RateLimiter(fn, mergedOptions);
 		rateLimiterInstance.Subscribe = function Subscribe(props) {
-			const selected = useStore(rateLimiterInstance.store, props.selector, { equal: shallow });
+			const selected = useSelector(rateLimiterInstance.store, props.selector, { compare: shallow });
 			return typeof props.children === "function" ? props.children(selected) : props.children;
 		};
 		return rateLimiterInstance;
@@ -155,7 +155,7 @@ function useRateLimiter(fn, options, selector = () => ({})) {
 			if (mergedOptions.onUnmount) mergedOptions.onUnmount(rateLimiter);
 		};
 	}, []);
-	const state = useStore(rateLimiter.store, selector, { equal: shallow });
+	const state = useSelector(rateLimiter.store, selector, { compare: shallow });
 	return useMemo(() => ({
 		...rateLimiter,
 		state

package/dist/rate-limiter/useRateLimiter.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useRateLimiter.js","names":[],"sources":["../../src/rate-limiter/useRateLimiter.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from 'preact/hooks'\nimport { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { shallow, useStore } from '@tanstack/preact-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/preact-store'\nimport type {\n RateLimiterOptions,\n RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type { ComponentChildren } from 'preact'\n\nexport interface PreactRateLimiterOptions<\n TFn extends AnyFunction,\n TSelected = {},\n> extends RateLimiterOptions<TFn> {\n /*\n Optional callback invoked when the component unmounts. Receives the rate limiter instance.\n * When provided, replaces the default cleanup; use it to call reset(), add logging, etc.\n /\n onUnmount?: (rateLimiter: PreactRateLimiter<TFn, TSelected>) => void\n}\n\nexport interface PreactRateLimiter<\n TFn extends AnyFunction,\n TSelected = {},\n> extends Omit<RateLimiter<TFn>, 'store'> {\n /\n A Preact HOC (Higher Order Component) that allows you to subscribe to the rate limiter state.\n \n This is useful for opting into state re-renders for specific parts of the rate limiter state\n * deep in your component tree without needing to pass a selector to the hook.\n \n @example\n * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>\n * {({ rejectionCount }) => (\n * <div>Rejections: {rejectionCount}</div>\n * )}\n * </rateLimiter.Subscribe>\n /\n Subscribe: <TSelected>(props: {\n selector: (state: RateLimiterState) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) => ComponentChildren\n /\n Reactive state that will be updated and re-rendered when the rate limiter state changes\n \n Use this instead of `rateLimiter.store.state`\n /\n readonly state: Readonly<TSelected>\n /\n @deprecated Use `rateLimiter.state` instead of `rateLimiter.store.state` if you want to read reactive state.\n * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.\n * Although, you can make the state reactive by using the `useStore` in your own usage.\n /\n readonly store: Store<Readonly<RateLimiterState>>\n}\n\n/\n A low-level Preact hook that creates a `RateLimiter` instance to enforce rate limits on function execution.\n \n This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that\n * you can integrate with any state management solution (useState, Redux, Zustand, Jotai, etc).\n \n Rate limiting is a simple \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\n \n The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n * towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n * consistent rate of execution over time.\n \n For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n \n 1. Using `rateLimiter.Subscribe` HOC (Recommended for component tree subscriptions)\n \n Use the `Subscribe` HOC to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n \n 2. Using the `selector` parameter (For hook-level subscriptions)\n \n The `selector` parameter allows you to specify which state changes will trigger a re-render\n * at the hook level, optimizing performance by preventing unnecessary re-renders when irrelevant\n * state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` HOC. This prevents unnecessary\n * re-renders and gives you full control over when your component updates.\n \n Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations\n * - `rejectionCount`: Number of function executions that have been rejected due to rate limiting\n \n The hook returns an object containing:\n * - maybeExecute: The rate-limited function that respects the configured limits\n * - getExecutionCount: Returns the number of successful executions\n * - getRejectionCount: Returns the number of rejected executions due to rate limiting\n * - getRemainingInWindow: Returns how many more executions are allowed in the current window\n * - reset: Resets the execution counts and window timing\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const rateLimiter = useRateLimiter(apiCall, {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * });\n \n // Subscribe to state changes deep in component tree using Subscribe HOC\n * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>\n * {({ rejectionCount }) => (\n * <div>Rejections: {rejectionCount}</div>\n * )}\n * </rateLimiter.Subscribe>\n \n // Opt-in to re-render when execution count changes at hook level (optimized for tracking successful executions)\n * const rateLimiter = useRateLimiter(\n * apiCall,\n * {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when rejection count changes (optimized for tracking rate limit violations)\n * const rateLimiter = useRateLimiter(\n * apiCall,\n * {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * },\n * (state) => ({ rejectionCount: state.rejectionCount })\n * );\n \n // Opt-in to re-render when execution times change (optimized for window calculations)\n * const rateLimiter = useRateLimiter(\n * apiCall,\n * {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * },\n * (state) => ({ executionTimes: state.executionTimes })\n * );\n \n // Multiple state properties - re-render when any of these change\n * const rateLimiter = useRateLimiter(\n * apiCall,\n * {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * },\n * (state) => ({\n * executionCount: state.executionCount,\n * rejectionCount: state.rejectionCount\n * })\n * );\n \n // Monitor rate limit status\n * const handleClick = () => {\n * const remaining = rateLimiter.getRemainingInWindow();\n * if (remaining > 0) {\n * rateLimiter.maybeExecute(data);\n * } else {\n * showRateLimitWarning();\n * }\n * };\n \n // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, rejectionCount } = rateLimiter.state;\n * ```\n /\nexport function useRateLimiter<TFn extends AnyFunction, TSelected = {}>(\n fn: TFn,\n options: PreactRateLimiterOptions<TFn, TSelected>,\n selector: (state: RateLimiterState) => TSelected = () => ({}) as TSelected,\n): PreactRateLimiter<TFn, TSelected> {\n const mergedOptions = {\n ...useDefaultPacerOptions().rateLimiter,\n ...options,\n } as PreactRateLimiterOptions<TFn, TSelected>\n const [rateLimiter] = useState(() => {\n const rateLimiterInstance = new RateLimiter<TFn>(\n fn,\n mergedOptions,\n ) as unknown as PreactRateLimiter<TFn, TSelected>\n\n rateLimiterInstance.Subscribe = function Subscribe<TSelected>(props: {\n selector: (state: RateLimiterState) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) {\n const selected = useStore(rateLimiterInstance.store, props.selector, {\n equal: shallow,\n })\n\n return typeof props.children === 'function'\n ? props.children(selected)\n : props.children\n }\n\n return rateLimiterInstance\n })\n\n rateLimiter.fn = fn\n rateLimiter.setOptions(mergedOptions)\n\n / eslint-disable react-hooks/exhaustive-deps -- cleanup only; runs on unmount /\n useEffect(() => {\n return () => {\n if (mergedOptions.onUnmount) {\n mergedOptions.onUnmount(rateLimiter)\n }\n }\n }, [])\n / eslint-enable react-hooks/exhaustive-deps */\n\n const state = useStore(rateLimiter.store, selector, { equal: shallow })\n\n return useMemo(\n () =>\n ({\n ...rateLimiter,\n state,\n }) as PreactRateLimiter<TFn, TSelected>, // omit `store` in favor of `state`\n [rateLimiter, state],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6LA,SAAgB,eACd,IACA,SACA,kBAA0D,EAAE,GACzB;CACnC,MAAM,gBAAgB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ;CACD,MAAM,CAAC,eAAe,eAAe;EACnC,MAAM,sBAAsB,IAAI,YAC9B,IACA,cACD;AAED,sBAAoB,YAAY,SAAS,UAAqB,OAG3D;GACD,MAAM,WAAW,SAAS,oBAAoB,OAAO,MAAM,UAAU,EACnE,OAAO,SACR,CAAC;AAEF,UAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;AAGZ,SAAO;GACP;AAEF,aAAY,KAAK;AACjB,aAAY,WAAW,cAAc;AAGrC,iBAAgB;AACd,eAAa;AACX,OAAI,cAAc,UAChB,eAAc,UAAU,YAAY;;IAGvC,EAAE,CAAC;CAGN,MAAM,QAAQ,SAAS,YAAY,OAAO,UAAU,EAAE,OAAO,SAAS,CAAC;AAEvE,QAAO,eAEF;EACC,GAAG;EACH;EACD,GACH,CAAC,aAAa,MAAM,CACrB"}
1	+ {"version":3,"file":"useRateLimiter.js","names":[],"sources":["../../src/rate-limiter/useRateLimiter.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from 'preact/hooks'\nimport { RateLimiter } from '@tanstack/pacer/rate-limiter'\nimport { shallow, useSelector } from '@tanstack/preact-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/preact-store'\nimport type {\n RateLimiterOptions,\n RateLimiterState,\n} from '@tanstack/pacer/rate-limiter'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type { ComponentChildren } from 'preact'\n\nexport interface PreactRateLimiterOptions<\n TFn extends AnyFunction,\n TSelected = {},\n> extends RateLimiterOptions<TFn> {\n /*\n Optional callback invoked when the component unmounts. Receives the rate limiter instance.\n * When provided, replaces the default cleanup; use it to call reset(), add logging, etc.\n /\n onUnmount?: (rateLimiter: PreactRateLimiter<TFn, TSelected>) => void\n}\n\nexport interface PreactRateLimiter<\n TFn extends AnyFunction,\n TSelected = {},\n> extends Omit<RateLimiter<TFn>, 'store'> {\n /\n A Preact HOC (Higher Order Component) that allows you to subscribe to the rate limiter state.\n \n This is useful for opting into state re-renders for specific parts of the rate limiter state\n * deep in your component tree without needing to pass a selector to the hook.\n \n @example\n * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>\n * {({ rejectionCount }) => (\n * <div>Rejections: {rejectionCount}</div>\n * )}\n * </rateLimiter.Subscribe>\n /\n Subscribe: <TSelected>(props: {\n selector: (state: RateLimiterState) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) => ComponentChildren\n /\n Reactive state that will be updated and re-rendered when the rate limiter state changes\n \n Use this instead of `rateLimiter.store.state`\n /\n readonly state: Readonly<TSelected>\n /\n @deprecated Use `rateLimiter.state` instead of `rateLimiter.store.state` if you want to read reactive state.\n * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.\n * Although, you can make the state reactive by using the `useSelector` in your own usage.\n /\n readonly store: Store<Readonly<RateLimiterState>>\n}\n\n/\n A low-level Preact hook that creates a `RateLimiter` instance to enforce rate limits on function execution.\n \n This hook is designed to be flexible and state-management agnostic - it simply returns a rate limiter instance that\n * you can integrate with any state management solution (useState, Redux, Zustand, Jotai, etc).\n \n Rate limiting is a simple \"hard limit\" approach that allows executions until a maximum count is reached within\n * a time window, then blocks all subsequent calls until the window resets. Unlike throttling or debouncing,\n * it does not attempt to space out or collapse executions intelligently.\n \n The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All executions within the window count\n * towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows executions as old ones expire. This provides a more\n * consistent rate of execution over time.\n \n For smoother execution patterns:\n * - Use throttling when you want consistent spacing between executions (e.g. UI updates)\n * - Use debouncing when you want to collapse rapid-fire events (e.g. search input)\n * - Use rate limiting only when you need to enforce hard limits (e.g. API rate limits)\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n \n 1. Using `rateLimiter.Subscribe` HOC (Recommended for component tree subscriptions)\n \n Use the `Subscribe` HOC to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n \n 2. Using the `selector` parameter (For hook-level subscriptions)\n \n The `selector` parameter allows you to specify which state changes will trigger a re-render\n * at the hook level, optimizing performance by preventing unnecessary re-renders when irrelevant\n * state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` HOC. This prevents unnecessary\n * re-renders and gives you full control over when your component updates.\n \n Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations\n * - `rejectionCount`: Number of function executions that have been rejected due to rate limiting\n \n The hook returns an object containing:\n * - maybeExecute: The rate-limited function that respects the configured limits\n * - getExecutionCount: Returns the number of successful executions\n * - getRejectionCount: Returns the number of rejected executions due to rate limiting\n * - getRemainingInWindow: Returns how many more executions are allowed in the current window\n * - reset: Resets the execution counts and window timing\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const rateLimiter = useRateLimiter(apiCall, {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * });\n \n // Subscribe to state changes deep in component tree using Subscribe HOC\n * <rateLimiter.Subscribe selector={(state) => ({ rejectionCount: state.rejectionCount })}>\n * {({ rejectionCount }) => (\n * <div>Rejections: {rejectionCount}</div>\n * )}\n * </rateLimiter.Subscribe>\n \n // Opt-in to re-render when execution count changes at hook level (optimized for tracking successful executions)\n * const rateLimiter = useRateLimiter(\n * apiCall,\n * {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when rejection count changes (optimized for tracking rate limit violations)\n * const rateLimiter = useRateLimiter(\n * apiCall,\n * {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * },\n * (state) => ({ rejectionCount: state.rejectionCount })\n * );\n \n // Opt-in to re-render when execution times change (optimized for window calculations)\n * const rateLimiter = useRateLimiter(\n * apiCall,\n * {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * },\n * (state) => ({ executionTimes: state.executionTimes })\n * );\n \n // Multiple state properties - re-render when any of these change\n * const rateLimiter = useRateLimiter(\n * apiCall,\n * {\n * limit: 5,\n * window: 60000,\n * windowType: 'sliding',\n * },\n * (state) => ({\n * executionCount: state.executionCount,\n * rejectionCount: state.rejectionCount\n * })\n * );\n \n // Monitor rate limit status\n * const handleClick = () => {\n * const remaining = rateLimiter.getRemainingInWindow();\n * if (remaining > 0) {\n * rateLimiter.maybeExecute(data);\n * } else {\n * showRateLimitWarning();\n * }\n * };\n \n // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, rejectionCount } = rateLimiter.state;\n * ```\n /\nexport function useRateLimiter<TFn extends AnyFunction, TSelected = {}>(\n fn: TFn,\n options: PreactRateLimiterOptions<TFn, TSelected>,\n selector: (state: RateLimiterState) => TSelected = () => ({}) as TSelected,\n): PreactRateLimiter<TFn, TSelected> {\n const mergedOptions = {\n ...useDefaultPacerOptions().rateLimiter,\n ...options,\n } as PreactRateLimiterOptions<TFn, TSelected>\n const [rateLimiter] = useState(() => {\n const rateLimiterInstance = new RateLimiter<TFn>(\n fn,\n mergedOptions,\n ) as unknown as PreactRateLimiter<TFn, TSelected>\n\n rateLimiterInstance.Subscribe = function Subscribe<TSelected>(props: {\n selector: (state: RateLimiterState) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) {\n const selected = useSelector(rateLimiterInstance.store, props.selector, {\n compare: shallow,\n })\n\n return typeof props.children === 'function'\n ? props.children(selected)\n : props.children\n }\n\n return rateLimiterInstance\n })\n\n rateLimiter.fn = fn\n rateLimiter.setOptions(mergedOptions)\n\n / eslint-disable react-hooks/exhaustive-deps -- cleanup only; runs on unmount /\n useEffect(() => {\n return () => {\n if (mergedOptions.onUnmount) {\n mergedOptions.onUnmount(rateLimiter)\n }\n }\n }, [])\n / eslint-enable react-hooks/exhaustive-deps */\n\n const state = useSelector(rateLimiter.store, selector, { compare: shallow })\n\n return useMemo(\n () =>\n ({\n ...rateLimiter,\n state,\n }) as PreactRateLimiter<TFn, TSelected>, // omit `store` in favor of `state`\n [rateLimiter, state],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6LA,SAAgB,eACd,IACA,SACA,kBAA0D,EAAE,GACzB;CACnC,MAAM,gBAAgB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ;CACD,MAAM,CAAC,eAAe,eAAe;EACnC,MAAM,sBAAsB,IAAI,YAC9B,IACA,cACD;EAED,oBAAoB,YAAY,SAAS,UAAqB,OAG3D;GACD,MAAM,WAAW,YAAY,oBAAoB,OAAO,MAAM,UAAU,EACtE,SAAS,SACV,CAAC;GAEF,OAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;EAGZ,OAAO;GACP;CAEF,YAAY,KAAK;CACjB,YAAY,WAAW,cAAc;CAGrC,gBAAgB;EACd,aAAa;GACX,IAAI,cAAc,WAChB,cAAc,UAAU,YAAY;;IAGvC,EAAE,CAAC;CAGN,MAAM,QAAQ,YAAY,YAAY,OAAO,UAAU,EAAE,SAAS,SAAS,CAAC;CAE5E,OAAO,eAEF;EACC,GAAG;EACH;EACD,GACH,CAAC,aAAa,MAAM,CACrB"}

package/dist/throttler/useThrottledCallback.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useThrottledCallback.cjs","names":["useThrottler"],"sources":["../../src/throttler/useThrottledCallback.ts"],"sourcesContent":["import { useCallback } from 'preact/hooks'\nimport { useThrottler } from './useThrottler'\nimport type { PreactThrottlerOptions } from './useThrottler'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/*\n A Preact hook that creates a throttled version of a callback function.\n * This hook is essentially a wrapper around the basic `throttle` function\n * that is exported from `@tanstack/pacer`,\n * but optimized for Preact with reactive options and a stable function reference.\n \n The throttled function will execute at most once within the specified wait time period,\n * regardless of how many times it is called. If called multiple times during the wait period,\n * only the first invocation will execute, and subsequent calls will be ignored until\n * the wait period has elapsed.\n \n This hook provides a simpler API compared to `useThrottler`, making it ideal for basic\n * throttling needs. However, it does not expose the underlying Throttler instance.\n \n For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Custom useCallback dependencies\n \n Consider using the `useThrottler` hook instead.\n \n @example\n * ```tsx\n * // Throttle a window resize handler\n * const handleResize = useThrottledCallback(() => {\n * updateLayoutMeasurements();\n * }, {\n * wait: 100 // Execute at most once every 100ms\n * });\n \n // Use in an event listener\n * useEffect(() => {\n * window.addEventListener('resize', handleResize);\n * return () => window.removeEventListener('resize', handleResize);\n * }, [handleResize]);\n * ```\n */\nexport function useThrottledCallback<TFn extends AnyFunction>(\n fn: TFn,\n options: PreactThrottlerOptions<TFn, {}>,\n): (...args: Parameters<TFn>) => void {\n const throttledFn = useThrottler(fn, options).maybeExecute\n return useCallback(\n (...args: Parameters<TFn>) => throttledFn(...args),\n [throttledFn],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,qBACd,IACA,SACoC;CACpC,MAAM,cAAcA,kCAAa,IAAI,QAAQ,CAAC;~~AAC9C~~,~~uCACG~~,GAAG,SAA0B,YAAY,GAAG,KAAK,EAClD,CAAC,YAAY,CACd"}
1	+ {"version":3,"file":"useThrottledCallback.cjs","names":["useThrottler"],"sources":["../../src/throttler/useThrottledCallback.ts"],"sourcesContent":["import { useCallback } from 'preact/hooks'\nimport { useThrottler } from './useThrottler'\nimport type { PreactThrottlerOptions } from './useThrottler'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/*\n A Preact hook that creates a throttled version of a callback function.\n * This hook is essentially a wrapper around the basic `throttle` function\n * that is exported from `@tanstack/pacer`,\n * but optimized for Preact with reactive options and a stable function reference.\n \n The throttled function will execute at most once within the specified wait time period,\n * regardless of how many times it is called. If called multiple times during the wait period,\n * only the first invocation will execute, and subsequent calls will be ignored until\n * the wait period has elapsed.\n \n This hook provides a simpler API compared to `useThrottler`, making it ideal for basic\n * throttling needs. However, it does not expose the underlying Throttler instance.\n \n For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Custom useCallback dependencies\n \n Consider using the `useThrottler` hook instead.\n \n @example\n * ```tsx\n * // Throttle a window resize handler\n * const handleResize = useThrottledCallback(() => {\n * updateLayoutMeasurements();\n * }, {\n * wait: 100 // Execute at most once every 100ms\n * });\n \n // Use in an event listener\n * useEffect(() => {\n * window.addEventListener('resize', handleResize);\n * return () => window.removeEventListener('resize', handleResize);\n * }, [handleResize]);\n * ```\n */\nexport function useThrottledCallback<TFn extends AnyFunction>(\n fn: TFn,\n options: PreactThrottlerOptions<TFn, {}>,\n): (...args: Parameters<TFn>) => void {\n const throttledFn = useThrottler(fn, options).maybeExecute\n return useCallback(\n (...args: Parameters<TFn>) => throttledFn(...args),\n [throttledFn],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,qBACd,IACA,SACoC;CACpC,MAAM,cAAcA,kCAAa,IAAI,QAAQ,CAAC;CAC9C,sCACG,GAAG,SAA0B,YAAY,GAAG,KAAK,EAClD,CAAC,YAAY,CACd"}

package/dist/throttler/useThrottledCallback.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useThrottledCallback.js","names":[],"sources":["../../src/throttler/useThrottledCallback.ts"],"sourcesContent":["import { useCallback } from 'preact/hooks'\nimport { useThrottler } from './useThrottler'\nimport type { PreactThrottlerOptions } from './useThrottler'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/*\n A Preact hook that creates a throttled version of a callback function.\n * This hook is essentially a wrapper around the basic `throttle` function\n * that is exported from `@tanstack/pacer`,\n * but optimized for Preact with reactive options and a stable function reference.\n \n The throttled function will execute at most once within the specified wait time period,\n * regardless of how many times it is called. If called multiple times during the wait period,\n * only the first invocation will execute, and subsequent calls will be ignored until\n * the wait period has elapsed.\n \n This hook provides a simpler API compared to `useThrottler`, making it ideal for basic\n * throttling needs. However, it does not expose the underlying Throttler instance.\n \n For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Custom useCallback dependencies\n \n Consider using the `useThrottler` hook instead.\n \n @example\n * ```tsx\n * // Throttle a window resize handler\n * const handleResize = useThrottledCallback(() => {\n * updateLayoutMeasurements();\n * }, {\n * wait: 100 // Execute at most once every 100ms\n * });\n \n // Use in an event listener\n * useEffect(() => {\n * window.addEventListener('resize', handleResize);\n * return () => window.removeEventListener('resize', handleResize);\n * }, [handleResize]);\n * ```\n */\nexport function useThrottledCallback<TFn extends AnyFunction>(\n fn: TFn,\n options: PreactThrottlerOptions<TFn, {}>,\n): (...args: Parameters<TFn>) => void {\n const throttledFn = useThrottler(fn, options).maybeExecute\n return useCallback(\n (...args: Parameters<TFn>) => throttledFn(...args),\n [throttledFn],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,qBACd,IACA,SACoC;CACpC,MAAM,cAAc,aAAa,IAAI,QAAQ,CAAC;~~AAC9C~~,~~QAAO~~,aACJ,GAAG,SAA0B,YAAY,GAAG,KAAK,EAClD,CAAC,YAAY,CACd"}
1	+ {"version":3,"file":"useThrottledCallback.js","names":[],"sources":["../../src/throttler/useThrottledCallback.ts"],"sourcesContent":["import { useCallback } from 'preact/hooks'\nimport { useThrottler } from './useThrottler'\nimport type { PreactThrottlerOptions } from './useThrottler'\nimport type { AnyFunction } from '@tanstack/pacer/types'\n\n/*\n A Preact hook that creates a throttled version of a callback function.\n * This hook is essentially a wrapper around the basic `throttle` function\n * that is exported from `@tanstack/pacer`,\n * but optimized for Preact with reactive options and a stable function reference.\n \n The throttled function will execute at most once within the specified wait time period,\n * regardless of how many times it is called. If called multiple times during the wait period,\n * only the first invocation will execute, and subsequent calls will be ignored until\n * the wait period has elapsed.\n \n This hook provides a simpler API compared to `useThrottler`, making it ideal for basic\n * throttling needs. However, it does not expose the underlying Throttler instance.\n \n For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Custom useCallback dependencies\n \n Consider using the `useThrottler` hook instead.\n \n @example\n * ```tsx\n * // Throttle a window resize handler\n * const handleResize = useThrottledCallback(() => {\n * updateLayoutMeasurements();\n * }, {\n * wait: 100 // Execute at most once every 100ms\n * });\n \n // Use in an event listener\n * useEffect(() => {\n * window.addEventListener('resize', handleResize);\n * return () => window.removeEventListener('resize', handleResize);\n * }, [handleResize]);\n * ```\n */\nexport function useThrottledCallback<TFn extends AnyFunction>(\n fn: TFn,\n options: PreactThrottlerOptions<TFn, {}>,\n): (...args: Parameters<TFn>) => void {\n const throttledFn = useThrottler(fn, options).maybeExecute\n return useCallback(\n (...args: Parameters<TFn>) => throttledFn(...args),\n [throttledFn],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,qBACd,IACA,SACoC;CACpC,MAAM,cAAc,aAAa,IAAI,QAAQ,CAAC;CAC9C,OAAO,aACJ,GAAG,SAA0B,YAAY,GAAG,KAAK,EAClD,CAAC,YAAY,CACd"}

package/dist/throttler/useThrottledState.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useThrottledState.cjs","names":["useThrottler"],"sources":["../../src/throttler/useThrottledState.ts"],"sourcesContent":["import { useState } from 'preact/hooks'\nimport { useThrottler } from './useThrottler'\nimport type { Dispatch, StateUpdater } from 'preact/hooks'\nimport type { PreactThrottler, PreactThrottlerOptions } from './useThrottler'\nimport type { ThrottlerState } from '@tanstack/pacer/throttler'\n\n/*\n A Preact hook that creates a throttled state value that updates at most once within a specified time window.\n * This hook combines Preact's useState with throttling functionality to provide controlled state updates.\n \n Throttling ensures state updates occur at a controlled rate regardless of how frequently the setter is called.\n * This is useful for rate-limiting expensive re-renders or operations that depend on rapidly changing state.\n \n The hook returns a tuple containing:\n * - The throttled state value\n * - A throttled setter function that respects the configured wait time\n * - The throttler instance for additional control\n \n For more direct control over throttling without state management,\n * consider using the lower-level useThrottler hook instead.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n \n Available throttler state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue, throttler] = useThrottledState(0, { wait: 1000 });\n \n // Opt-in to re-render when execution count changes (optimized for tracking executions)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With custom leading/trailing behavior\n * const [value, setValue] = useThrottledState(0, {\n * wait: 1000,\n * leading: true, // Update immediately on first change\n * trailing: false // Skip trailing edge updates\n * });\n \n // Access throttler methods if needed\n * const handleReset = () => {\n * setValue(0);\n * throttler.cancel(); // Cancel any pending updates\n * };\n \n // Access the selected throttler state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n */\n\nexport function useThrottledState<\n TValue,\n TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n>(\n value: TValue,\n options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>,\n selector?: (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n): [\n TValue,\n Dispatch<StateUpdater<TValue>>,\n PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>,\n] {\n const [throttledValue, setThrottledValue] = useState<TValue>(value)\n const throttler = useThrottler(\n setThrottledValue,\n options,\n selector as (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n )\n return [\n throttledValue,\n throttler.maybeExecute as Dispatch<StateUpdater<TValue>>,\n throttler,\n ]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,kBAId,OACA,SACA,UAOA;CACA,MAAM,CAAC,gBAAgB,gDAAsC,MAAM;CACnE,MAAM,YAAYA,kCAChB,mBACA,SACA,SAGD;~~AACD~~,~~QAAO~~;EACL;EACA,UAAU;EACV;EACD"}
1	+ {"version":3,"file":"useThrottledState.cjs","names":["useThrottler"],"sources":["../../src/throttler/useThrottledState.ts"],"sourcesContent":["import { useState } from 'preact/hooks'\nimport { useThrottler } from './useThrottler'\nimport type { Dispatch, StateUpdater } from 'preact/hooks'\nimport type { PreactThrottler, PreactThrottlerOptions } from './useThrottler'\nimport type { ThrottlerState } from '@tanstack/pacer/throttler'\n\n/*\n A Preact hook that creates a throttled state value that updates at most once within a specified time window.\n * This hook combines Preact's useState with throttling functionality to provide controlled state updates.\n \n Throttling ensures state updates occur at a controlled rate regardless of how frequently the setter is called.\n * This is useful for rate-limiting expensive re-renders or operations that depend on rapidly changing state.\n \n The hook returns a tuple containing:\n * - The throttled state value\n * - A throttled setter function that respects the configured wait time\n * - The throttler instance for additional control\n \n For more direct control over throttling without state management,\n * consider using the lower-level useThrottler hook instead.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n \n Available throttler state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue, throttler] = useThrottledState(0, { wait: 1000 });\n \n // Opt-in to re-render when execution count changes (optimized for tracking executions)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With custom leading/trailing behavior\n * const [value, setValue] = useThrottledState(0, {\n * wait: 1000,\n * leading: true, // Update immediately on first change\n * trailing: false // Skip trailing edge updates\n * });\n \n // Access throttler methods if needed\n * const handleReset = () => {\n * setValue(0);\n * throttler.cancel(); // Cancel any pending updates\n * };\n \n // Access the selected throttler state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n */\n\nexport function useThrottledState<\n TValue,\n TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n>(\n value: TValue,\n options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>,\n selector?: (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n): [\n TValue,\n Dispatch<StateUpdater<TValue>>,\n PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>,\n] {\n const [throttledValue, setThrottledValue] = useState<TValue>(value)\n const throttler = useThrottler(\n setThrottledValue,\n options,\n selector as (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n )\n return [\n throttledValue,\n throttler.maybeExecute as Dispatch<StateUpdater<TValue>>,\n throttler,\n ]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,kBAId,OACA,SACA,UAOA;CACA,MAAM,CAAC,gBAAgB,gDAAsC,MAAM;CACnE,MAAM,YAAYA,kCAChB,mBACA,SACA,SAGD;CACD,OAAO;EACL;EACA,UAAU;EACV;EACD"}

package/dist/throttler/useThrottledState.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useThrottledState.js","names":[],"sources":["../../src/throttler/useThrottledState.ts"],"sourcesContent":["import { useState } from 'preact/hooks'\nimport { useThrottler } from './useThrottler'\nimport type { Dispatch, StateUpdater } from 'preact/hooks'\nimport type { PreactThrottler, PreactThrottlerOptions } from './useThrottler'\nimport type { ThrottlerState } from '@tanstack/pacer/throttler'\n\n/*\n A Preact hook that creates a throttled state value that updates at most once within a specified time window.\n * This hook combines Preact's useState with throttling functionality to provide controlled state updates.\n \n Throttling ensures state updates occur at a controlled rate regardless of how frequently the setter is called.\n * This is useful for rate-limiting expensive re-renders or operations that depend on rapidly changing state.\n \n The hook returns a tuple containing:\n * - The throttled state value\n * - A throttled setter function that respects the configured wait time\n * - The throttler instance for additional control\n \n For more direct control over throttling without state management,\n * consider using the lower-level useThrottler hook instead.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n \n Available throttler state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue, throttler] = useThrottledState(0, { wait: 1000 });\n \n // Opt-in to re-render when execution count changes (optimized for tracking executions)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With custom leading/trailing behavior\n * const [value, setValue] = useThrottledState(0, {\n * wait: 1000,\n * leading: true, // Update immediately on first change\n * trailing: false // Skip trailing edge updates\n * });\n \n // Access throttler methods if needed\n * const handleReset = () => {\n * setValue(0);\n * throttler.cancel(); // Cancel any pending updates\n * };\n \n // Access the selected throttler state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n */\n\nexport function useThrottledState<\n TValue,\n TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n>(\n value: TValue,\n options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>,\n selector?: (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n): [\n TValue,\n Dispatch<StateUpdater<TValue>>,\n PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>,\n] {\n const [throttledValue, setThrottledValue] = useState<TValue>(value)\n const throttler = useThrottler(\n setThrottledValue,\n options,\n selector as (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n )\n return [\n throttledValue,\n throttler.maybeExecute as Dispatch<StateUpdater<TValue>>,\n throttler,\n ]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,kBAId,OACA,SACA,UAOA;CACA,MAAM,CAAC,gBAAgB,qBAAqB,SAAiB,MAAM;CACnE,MAAM,YAAY,aAChB,mBACA,SACA,SAGD;~~AACD~~,~~QAAO~~;EACL;EACA,UAAU;EACV;EACD"}
1	+ {"version":3,"file":"useThrottledState.js","names":[],"sources":["../../src/throttler/useThrottledState.ts"],"sourcesContent":["import { useState } from 'preact/hooks'\nimport { useThrottler } from './useThrottler'\nimport type { Dispatch, StateUpdater } from 'preact/hooks'\nimport type { PreactThrottler, PreactThrottlerOptions } from './useThrottler'\nimport type { ThrottlerState } from '@tanstack/pacer/throttler'\n\n/*\n A Preact hook that creates a throttled state value that updates at most once within a specified time window.\n * This hook combines Preact's useState with throttling functionality to provide controlled state updates.\n \n Throttling ensures state updates occur at a controlled rate regardless of how frequently the setter is called.\n * This is useful for rate-limiting expensive re-renders or operations that depend on rapidly changing state.\n \n The hook returns a tuple containing:\n * - The throttled state value\n * - A throttled setter function that respects the configured wait time\n * - The throttler instance for additional control\n \n For more direct control over throttling without state management,\n * consider using the lower-level useThrottler hook instead.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n \n Available throttler state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue, throttler] = useThrottledState(0, { wait: 1000 });\n \n // Opt-in to re-render when execution count changes (optimized for tracking executions)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [value, setValue, throttler] = useThrottledState(\n * 0,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With custom leading/trailing behavior\n * const [value, setValue] = useThrottledState(0, {\n * wait: 1000,\n * leading: true, // Update immediately on first change\n * trailing: false // Skip trailing edge updates\n * });\n \n // Access throttler methods if needed\n * const handleReset = () => {\n * setValue(0);\n * throttler.cancel(); // Cancel any pending updates\n * };\n \n // Access the selected throttler state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n */\n\nexport function useThrottledState<\n TValue,\n TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n>(\n value: TValue,\n options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>,\n selector?: (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n): [\n TValue,\n Dispatch<StateUpdater<TValue>>,\n PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>,\n] {\n const [throttledValue, setThrottledValue] = useState<TValue>(value)\n const throttler = useThrottler(\n setThrottledValue,\n options,\n selector as (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n )\n return [\n throttledValue,\n throttler.maybeExecute as Dispatch<StateUpdater<TValue>>,\n throttler,\n ]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,kBAId,OACA,SACA,UAOA;CACA,MAAM,CAAC,gBAAgB,qBAAqB,SAAiB,MAAM;CACnE,MAAM,YAAY,aAChB,mBACA,SACA,SAGD;CACD,OAAO;EACL;EACA,UAAU;EACV;EACD"}

package/dist/throttler/useThrottledValue.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useThrottledValue.cjs","names":["useThrottledState"],"sources":["../../src/throttler/useThrottledValue.ts"],"sourcesContent":["import { useEffect } from 'preact/hooks'\nimport { useThrottledState } from './useThrottledState'\nimport type { Dispatch, StateUpdater } from 'preact/hooks'\nimport type { PreactThrottler, PreactThrottlerOptions } from './useThrottler'\nimport type { ThrottlerState } from '@tanstack/pacer/throttler'\n\n/*\n A high-level Preact hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Preact's useState internally to manage the throttled state.\n \n Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.\n * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.\n \n The hook returns a tuple containing:\n * - The throttled value that updates according to the leading/trailing edge behavior specified in the options\n * - The throttler instance with control methods\n \n For more direct control over throttling behavior without Preact state management,\n * consider using the lower-level useThrottler hook instead.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n \n Available throttler state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [throttledValue, throttler] = useThrottledValue(rawValue, { wait: 1000 });\n \n // Opt-in to re-render when execution count changes (optimized for tracking executions)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With custom leading/trailing behavior\n * const [throttledValue, throttler] = useThrottledValue(rawValue, {\n * wait: 1000,\n * leading: true, // Update immediately on first change\n * trailing: false // Skip trailing edge updates\n * });\n \n // Access the selected throttler state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n */\nexport function useThrottledValue<\n TValue,\n TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n>(\n value: TValue,\n options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>,\n selector?: (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n): [TValue, PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>] {\n const [throttledValue, setThrottledValue, throttler] = useThrottledState(\n value,\n options,\n selector,\n )\n\n useEffect(() => {\n ;(setThrottledValue as (value: TValue) => void)(value)\n }, [value, setThrottledValue])\n\n return [throttledValue, throttler]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,kBAId,OACA,SACA,UAGsE;CACtE,MAAM,CAAC,gBAAgB,mBAAmB,aAAaA,4CACrD,OACA,SACA,SACD;~~AAED~~,~~mCAAgB~~;~~AACb~~,~~EAAC~~,kBAA8C,MAAM;IACrD,CAAC,OAAO,kBAAkB,CAAC;~~AAE9B~~,~~QAAO~~,CAAC,gBAAgB,UAAU"}
1	+ {"version":3,"file":"useThrottledValue.cjs","names":["useThrottledState"],"sources":["../../src/throttler/useThrottledValue.ts"],"sourcesContent":["import { useEffect } from 'preact/hooks'\nimport { useThrottledState } from './useThrottledState'\nimport type { Dispatch, StateUpdater } from 'preact/hooks'\nimport type { PreactThrottler, PreactThrottlerOptions } from './useThrottler'\nimport type { ThrottlerState } from '@tanstack/pacer/throttler'\n\n/*\n A high-level Preact hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Preact's useState internally to manage the throttled state.\n \n Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.\n * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.\n \n The hook returns a tuple containing:\n * - The throttled value that updates according to the leading/trailing edge behavior specified in the options\n * - The throttler instance with control methods\n \n For more direct control over throttling behavior without Preact state management,\n * consider using the lower-level useThrottler hook instead.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n \n Available throttler state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [throttledValue, throttler] = useThrottledValue(rawValue, { wait: 1000 });\n \n // Opt-in to re-render when execution count changes (optimized for tracking executions)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With custom leading/trailing behavior\n * const [throttledValue, throttler] = useThrottledValue(rawValue, {\n * wait: 1000,\n * leading: true, // Update immediately on first change\n * trailing: false // Skip trailing edge updates\n * });\n \n // Access the selected throttler state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n */\nexport function useThrottledValue<\n TValue,\n TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n>(\n value: TValue,\n options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>,\n selector?: (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n): [TValue, PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>] {\n const [throttledValue, setThrottledValue, throttler] = useThrottledState(\n value,\n options,\n selector,\n )\n\n useEffect(() => {\n ;(setThrottledValue as (value: TValue) => void)(value)\n }, [value, setThrottledValue])\n\n return [throttledValue, throttler]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,kBAId,OACA,SACA,UAGsE;CACtE,MAAM,CAAC,gBAAgB,mBAAmB,aAAaA,4CACrD,OACA,SACA,SACD;CAED,kCAAgB;EACb,AAAC,kBAA8C,MAAM;IACrD,CAAC,OAAO,kBAAkB,CAAC;CAE9B,OAAO,CAAC,gBAAgB,UAAU"}

package/dist/throttler/useThrottledValue.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useThrottledValue.js","names":[],"sources":["../../src/throttler/useThrottledValue.ts"],"sourcesContent":["import { useEffect } from 'preact/hooks'\nimport { useThrottledState } from './useThrottledState'\nimport type { Dispatch, StateUpdater } from 'preact/hooks'\nimport type { PreactThrottler, PreactThrottlerOptions } from './useThrottler'\nimport type { ThrottlerState } from '@tanstack/pacer/throttler'\n\n/*\n A high-level Preact hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Preact's useState internally to manage the throttled state.\n \n Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.\n * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.\n \n The hook returns a tuple containing:\n * - The throttled value that updates according to the leading/trailing edge behavior specified in the options\n * - The throttler instance with control methods\n \n For more direct control over throttling behavior without Preact state management,\n * consider using the lower-level useThrottler hook instead.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n \n Available throttler state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [throttledValue, throttler] = useThrottledValue(rawValue, { wait: 1000 });\n \n // Opt-in to re-render when execution count changes (optimized for tracking executions)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With custom leading/trailing behavior\n * const [throttledValue, throttler] = useThrottledValue(rawValue, {\n * wait: 1000,\n * leading: true, // Update immediately on first change\n * trailing: false // Skip trailing edge updates\n * });\n \n // Access the selected throttler state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n */\nexport function useThrottledValue<\n TValue,\n TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n>(\n value: TValue,\n options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>,\n selector?: (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n): [TValue, PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>] {\n const [throttledValue, setThrottledValue, throttler] = useThrottledState(\n value,\n options,\n selector,\n )\n\n useEffect(() => {\n ;(setThrottledValue as (value: TValue) => void)(value)\n }, [value, setThrottledValue])\n\n return [throttledValue, throttler]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,kBAId,OACA,SACA,UAGsE;CACtE,MAAM,CAAC,gBAAgB,mBAAmB,aAAa,kBACrD,OACA,SACA,SACD;~~AAED~~,~~iBAAgB~~;~~AACb~~,~~EAAC~~,kBAA8C,MAAM;IACrD,CAAC,OAAO,kBAAkB,CAAC;~~AAE9B~~,~~QAAO~~,CAAC,gBAAgB,UAAU"}
1	+ {"version":3,"file":"useThrottledValue.js","names":[],"sources":["../../src/throttler/useThrottledValue.ts"],"sourcesContent":["import { useEffect } from 'preact/hooks'\nimport { useThrottledState } from './useThrottledState'\nimport type { Dispatch, StateUpdater } from 'preact/hooks'\nimport type { PreactThrottler, PreactThrottlerOptions } from './useThrottler'\nimport type { ThrottlerState } from '@tanstack/pacer/throttler'\n\n/*\n A high-level Preact hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Preact's useState internally to manage the throttled state.\n \n Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.\n * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.\n \n The hook returns a tuple containing:\n * - The throttled value that updates according to the leading/trailing edge behavior specified in the options\n * - The throttler instance with control methods\n \n For more direct control over throttling behavior without Preact state management,\n * consider using the lower-level useThrottler hook instead.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management via the underlying throttler instance.\n * The `selector` parameter allows you to specify which throttler state changes will trigger a re-render,\n * optimizing performance by preventing unnecessary re-renders when irrelevant state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function. This prevents unnecessary re-renders and gives you\n * full control over when your component updates. Only when you provide a selector will the\n * component re-render when the selected state values change.\n \n Available throttler state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [throttledValue, throttler] = useThrottledValue(rawValue, { wait: 1000 });\n \n // Opt-in to re-render when execution count changes (optimized for tracking executions)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [throttledValue, throttler] = useThrottledValue(\n * rawValue,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With custom leading/trailing behavior\n * const [throttledValue, throttler] = useThrottledValue(rawValue, {\n * wait: 1000,\n * leading: true, // Update immediately on first change\n * trailing: false // Skip trailing edge updates\n * });\n \n // Access the selected throttler state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n */\nexport function useThrottledValue<\n TValue,\n TSelected = ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n>(\n value: TValue,\n options: PreactThrottlerOptions<Dispatch<StateUpdater<TValue>>, TSelected>,\n selector?: (\n state: ThrottlerState<Dispatch<StateUpdater<TValue>>>,\n ) => TSelected,\n): [TValue, PreactThrottler<Dispatch<StateUpdater<TValue>>, TSelected>] {\n const [throttledValue, setThrottledValue, throttler] = useThrottledState(\n value,\n options,\n selector,\n )\n\n useEffect(() => {\n ;(setThrottledValue as (value: TValue) => void)(value)\n }, [value, setThrottledValue])\n\n return [throttledValue, throttler]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkFA,SAAgB,kBAId,OACA,SACA,UAGsE;CACtE,MAAM,CAAC,gBAAgB,mBAAmB,aAAa,kBACrD,OACA,SACA,SACD;CAED,gBAAgB;EACb,AAAC,kBAA8C,MAAM;IACrD,CAAC,OAAO,kBAAkB,CAAC;CAE9B,OAAO,CAAC,gBAAgB,UAAU"}

package/dist/throttler/useThrottler.cjs CHANGED Viewed

@@ -121,14 +121,14 @@ function useThrottler(fn, options, selector = () => ({})) {
 	const [throttler] = (0, preact_hooks.useState)(() => {
 		const throttlerInstance = new _tanstack_pacer_throttler.Throttler(fn, mergedOptions);
 		throttlerInstance.Subscribe = function Subscribe(props) {
-			const selected = (0, _tanstack_preact_store.useStore)(throttlerInstance.store, props.selector, { equal: _tanstack_preact_store.shallow });
+			const selected = (0, _tanstack_preact_store.useSelector)(throttlerInstance.store, props.selector, { compare: _tanstack_preact_store.shallow });
 			return typeof props.children === "function" ? props.children(selected) : props.children;
 		};
 		return throttlerInstance;
 	});
 	throttler.fn = fn;
 	throttler.setOptions(mergedOptions);
-	const state = (0, _tanstack_preact_store.useStore)(throttler.store, selector, { equal: _tanstack_preact_store.shallow });
+	const state = (0, _tanstack_preact_store.useSelector)(throttler.store, selector, { compare: _tanstack_preact_store.shallow });
 	(0, preact_hooks.useEffect)(() => {
 		return () => {
 			if (mergedOptions.onUnmount) mergedOptions.onUnmount(throttler);

package/dist/throttler/useThrottler.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useThrottler.cjs","names":["useDefaultPacerOptions","Throttler","shallow"],"sources":["../../src/throttler/useThrottler.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from 'preact/hooks'\nimport { Throttler } from '@tanstack/pacer/throttler'\nimport { shallow, ~~useStore~~ } from '@tanstack/preact-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/preact-store'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n ThrottlerOptions,\n ThrottlerState,\n} from '@tanstack/pacer/throttler'\nimport type { ComponentChildren } from 'preact'\n\nexport interface PreactThrottlerOptions<\n TFn extends AnyFunction,\n TSelected = {},\n> extends ThrottlerOptions<TFn> {\n /*\n Optional callback invoked when the component unmounts. Receives the throttler instance.\n * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.\n /\n onUnmount?: (throttler: PreactThrottler<TFn, TSelected>) => void\n}\n\nexport interface PreactThrottler<\n TFn extends AnyFunction,\n TSelected = {},\n> extends Omit<Throttler<TFn>, 'store'> {\n /\n A Preact HOC (Higher Order Component) that allows you to subscribe to the throttler state.\n \n This is useful for opting into state re-renders for specific parts of the throttler state\n * deep in your component tree without needing to pass a selector to the hook.\n \n @example\n * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n * {({ isPending }) => (\n * <div>{isPending ? 'Loading...' : 'Ready'}</div>\n * )}\n * </throttler.Subscribe>\n /\n Subscribe: <TSelected>(props: {\n selector: (state: ThrottlerState<TFn>) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) => ComponentChildren\n /\n Reactive state that will be updated and re-rendered when the throttler state changes\n \n Use this instead of `throttler.store.state`\n /\n readonly state: Readonly<TSelected>\n /\n @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.\n * The state on the store object is not reactive, as it has not been wrapped in a `~~useStore~~` hook internally.\n * Although, you can make the state reactive by using the `~~useStore~~` in your own usage.\n /\n readonly store: Store<Readonly<ThrottlerState<TFn>>>\n}\n\n/\n A low-level Preact hook that creates a `Throttler` instance that limits how often the provided function can execute.\n \n This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that\n * you can integrate with any state management solution (useState, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that\n * integrates directly with Preact's useState, see useThrottledState.\n \n Throttling ensures a function executes at most once within a specified time window,\n * regardless of how many times it is called. This is useful for rate-limiting\n * expensive operations or UI updates.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n \n 1. Using `throttler.Subscribe` HOC (Recommended for component tree subscriptions)\n \n Use the `Subscribe` HOC to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n \n 2. Using the `selector` parameter (For hook-level subscriptions)\n \n The `selector` parameter allows you to specify which state changes will trigger a re-render\n * at the hook level, optimizing performance by preventing unnecessary re-renders when irrelevant\n * state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` HOC. This prevents unnecessary\n * re-renders and gives you full control over when your component updates.\n \n Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n ## Unmount behavior\n \n By default, the hook cancels any pending execution when the component unmounts.\n * Use the `onUnmount` option to customize this. For example, to flush pending work instead:\n \n ```tsx\n * const throttler = useThrottler(fn, {\n * wait: 1000,\n * onUnmount: (t) => t.flush()\n * });\n * ```\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(setValue, { wait: 1000 });\n \n // Subscribe to state changes deep in component tree using Subscribe HOC\n * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n * {({ isPending }) => (\n * <div>{isPending ? 'Processing...' : 'Ready'}</div>\n * )}\n * </throttler.Subscribe>\n \n // Opt-in to re-render when execution count changes at hook level (optimized for tracking executions)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With any state manager\n * const throttler = useThrottler(\n * (value) => stateManager.setState(value),\n * {\n * wait: 2000,\n * leading: true, // Execute immediately on first call\n * trailing: false // Skip trailing edge updates\n * }\n * );\n \n // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n /\nexport function useThrottler<TFn extends AnyFunction, TSelected = {}>(\n fn: TFn,\n options: PreactThrottlerOptions<TFn, TSelected>,\n selector: (state: ThrottlerState<TFn>) => TSelected = () => ({}) as TSelected,\n): PreactThrottler<TFn, TSelected> {\n const mergedOptions = {\n ...useDefaultPacerOptions().throttler,\n ...options,\n } as PreactThrottlerOptions<TFn, TSelected>\n const [throttler] = useState(() => {\n const throttlerInstance = new Throttler<TFn>(\n fn,\n mergedOptions,\n ) as unknown as PreactThrottler<TFn, TSelected>\n\n throttlerInstance.Subscribe = function Subscribe<TSelected>(props: {\n selector: (state: ThrottlerState<TFn>) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) {\n const selected = ~~useStore~~(throttlerInstance.store, props.selector, {\n ~~equal~~: shallow,\n })\n\n return typeof props.children === 'function'\n ? props.children(selected)\n : props.children\n }\n\n return throttlerInstance\n })\n\n throttler.fn = fn\n throttler.setOptions(mergedOptions)\n\n const state = ~~useStore~~(throttler.store, selector, { ~~equal~~: shallow })\n\n / eslint-disable react-hooks/exhaustive-deps -- cleanup only; runs on unmount /\n useEffect(() => {\n return () => {\n if (mergedOptions.onUnmount) {\n mergedOptions.onUnmount(throttler)\n } else {\n throttler.cancel()\n }\n }\n }, [])\n / eslint-enable react-hooks/exhaustive-deps */\n\n return useMemo(\n () =>\n ({\n ...throttler,\n state,\n }) as PreactThrottler<TFn, TSelected>, // omit `store` in favor of `state`\n [throttler, state],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuKA,SAAgB,aACd,IACA,SACA,kBAA6D,EAAE,GAC9B;CACjC,MAAM,gBAAgB;EACpB,GAAGA,8CAAwB,CAAC;EAC5B,GAAG;EACJ;CACD,MAAM,CAAC,8CAA4B;EACjC,MAAM,oBAAoB,IAAIC,oCAC5B,IACA,cACD;~~AAED~~,~~oBAAkB~~,YAAY,SAAS,UAAqB,OAGzD;GACD,MAAM,~~gDAAoB~~,kBAAkB,OAAO,MAAM,UAAU,~~EACjE~~,~~OAAOC~~,~~gCACR~~,CAAC;~~AAEF~~,~~UAAO~~,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;~~AAGZ~~,~~SAAO~~;GACP;~~AAEF~~,~~WAAU~~,KAAK;~~AACf~~,~~WAAU~~,WAAW,cAAc;CAEnC,MAAM,~~6CAAiB~~,UAAU,OAAO,UAAU,EAAE,~~OAAOA~~,gCAAS,CAAC;~~AAGrE~~,~~mCAAgB~~;~~AACd~~,~~eAAa~~;~~AACX~~,~~OAAI~~,cAAc,~~UAChB~~,~~eAAc~~,UAAU,UAAU;~~OAElC~~,~~WAAU~~,QAAQ;;IAGrB,EAAE,CAAC;~~AAGN~~,~~yCAEK~~;EACC,GAAG;EACH;EACD,GACH,CAAC,WAAW,MAAM,CACnB"}
1	+ {"version":3,"file":"useThrottler.cjs","names":["useDefaultPacerOptions","Throttler","shallow"],"sources":["../../src/throttler/useThrottler.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from 'preact/hooks'\nimport { Throttler } from '@tanstack/pacer/throttler'\nimport { shallow, useSelector } from '@tanstack/preact-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/preact-store'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n ThrottlerOptions,\n ThrottlerState,\n} from '@tanstack/pacer/throttler'\nimport type { ComponentChildren } from 'preact'\n\nexport interface PreactThrottlerOptions<\n TFn extends AnyFunction,\n TSelected = {},\n> extends ThrottlerOptions<TFn> {\n /*\n Optional callback invoked when the component unmounts. Receives the throttler instance.\n * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.\n /\n onUnmount?: (throttler: PreactThrottler<TFn, TSelected>) => void\n}\n\nexport interface PreactThrottler<\n TFn extends AnyFunction,\n TSelected = {},\n> extends Omit<Throttler<TFn>, 'store'> {\n /\n A Preact HOC (Higher Order Component) that allows you to subscribe to the throttler state.\n \n This is useful for opting into state re-renders for specific parts of the throttler state\n * deep in your component tree without needing to pass a selector to the hook.\n \n @example\n * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n * {({ isPending }) => (\n * <div>{isPending ? 'Loading...' : 'Ready'}</div>\n * )}\n * </throttler.Subscribe>\n /\n Subscribe: <TSelected>(props: {\n selector: (state: ThrottlerState<TFn>) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) => ComponentChildren\n /\n Reactive state that will be updated and re-rendered when the throttler state changes\n \n Use this instead of `throttler.store.state`\n /\n readonly state: Readonly<TSelected>\n /\n @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.\n * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.\n * Although, you can make the state reactive by using the `useSelector` in your own usage.\n /\n readonly store: Store<Readonly<ThrottlerState<TFn>>>\n}\n\n/\n A low-level Preact hook that creates a `Throttler` instance that limits how often the provided function can execute.\n \n This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that\n * you can integrate with any state management solution (useState, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that\n * integrates directly with Preact's useState, see useThrottledState.\n \n Throttling ensures a function executes at most once within a specified time window,\n * regardless of how many times it is called. This is useful for rate-limiting\n * expensive operations or UI updates.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n \n 1. Using `throttler.Subscribe` HOC (Recommended for component tree subscriptions)\n \n Use the `Subscribe` HOC to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n \n 2. Using the `selector` parameter (For hook-level subscriptions)\n \n The `selector` parameter allows you to specify which state changes will trigger a re-render\n * at the hook level, optimizing performance by preventing unnecessary re-renders when irrelevant\n * state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` HOC. This prevents unnecessary\n * re-renders and gives you full control over when your component updates.\n \n Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n ## Unmount behavior\n \n By default, the hook cancels any pending execution when the component unmounts.\n * Use the `onUnmount` option to customize this. For example, to flush pending work instead:\n \n ```tsx\n * const throttler = useThrottler(fn, {\n * wait: 1000,\n * onUnmount: (t) => t.flush()\n * });\n * ```\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(setValue, { wait: 1000 });\n \n // Subscribe to state changes deep in component tree using Subscribe HOC\n * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n * {({ isPending }) => (\n * <div>{isPending ? 'Processing...' : 'Ready'}</div>\n * )}\n * </throttler.Subscribe>\n \n // Opt-in to re-render when execution count changes at hook level (optimized for tracking executions)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With any state manager\n * const throttler = useThrottler(\n * (value) => stateManager.setState(value),\n * {\n * wait: 2000,\n * leading: true, // Execute immediately on first call\n * trailing: false // Skip trailing edge updates\n * }\n * );\n \n // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n /\nexport function useThrottler<TFn extends AnyFunction, TSelected = {}>(\n fn: TFn,\n options: PreactThrottlerOptions<TFn, TSelected>,\n selector: (state: ThrottlerState<TFn>) => TSelected = () => ({}) as TSelected,\n): PreactThrottler<TFn, TSelected> {\n const mergedOptions = {\n ...useDefaultPacerOptions().throttler,\n ...options,\n } as PreactThrottlerOptions<TFn, TSelected>\n const [throttler] = useState(() => {\n const throttlerInstance = new Throttler<TFn>(\n fn,\n mergedOptions,\n ) as unknown as PreactThrottler<TFn, TSelected>\n\n throttlerInstance.Subscribe = function Subscribe<TSelected>(props: {\n selector: (state: ThrottlerState<TFn>) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) {\n const selected = useSelector(throttlerInstance.store, props.selector, {\n compare: shallow,\n })\n\n return typeof props.children === 'function'\n ? props.children(selected)\n : props.children\n }\n\n return throttlerInstance\n })\n\n throttler.fn = fn\n throttler.setOptions(mergedOptions)\n\n const state = useSelector(throttler.store, selector, { compare: shallow })\n\n / eslint-disable react-hooks/exhaustive-deps -- cleanup only; runs on unmount /\n useEffect(() => {\n return () => {\n if (mergedOptions.onUnmount) {\n mergedOptions.onUnmount(throttler)\n } else {\n throttler.cancel()\n }\n }\n }, [])\n / eslint-enable react-hooks/exhaustive-deps */\n\n return useMemo(\n () =>\n ({\n ...throttler,\n state,\n }) as PreactThrottler<TFn, TSelected>, // omit `store` in favor of `state`\n [throttler, state],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuKA,SAAgB,aACd,IACA,SACA,kBAA6D,EAAE,GAC9B;CACjC,MAAM,gBAAgB;EACpB,GAAGA,8CAAwB,CAAC;EAC5B,GAAG;EACJ;CACD,MAAM,CAAC,8CAA4B;EACjC,MAAM,oBAAoB,IAAIC,oCAC5B,IACA,cACD;EAED,kBAAkB,YAAY,SAAS,UAAqB,OAGzD;GACD,MAAM,mDAAuB,kBAAkB,OAAO,MAAM,UAAU,EACpE,SAASC,gCACV,CAAC;GAEF,OAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;EAGZ,OAAO;GACP;CAEF,UAAU,KAAK;CACf,UAAU,WAAW,cAAc;CAEnC,MAAM,gDAAoB,UAAU,OAAO,UAAU,EAAE,SAASA,gCAAS,CAAC;CAG1E,kCAAgB;EACd,aAAa;GACX,IAAI,cAAc,WAChB,cAAc,UAAU,UAAU;QAElC,UAAU,QAAQ;;IAGrB,EAAE,CAAC;CAGN,wCAEK;EACC,GAAG;EACH;EACD,GACH,CAAC,WAAW,MAAM,CACnB"}

package/dist/throttler/useThrottler.d.cts CHANGED Viewed

@@ -37,8 +37,8 @@ interface PreactThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit<
   readonly state: Readonly<TSelected>;
   /**
    * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
+   * Although, you can make the state reactive by using the `useSelector` in your own usage.
    */
   readonly store: Store<Readonly<ThrottlerState<TFn>>>;
 }

package/dist/throttler/useThrottler.d.ts CHANGED Viewed

@@ -37,8 +37,8 @@ interface PreactThrottler<TFn extends AnyFunction, TSelected = {}> extends Omit<
   readonly state: Readonly<TSelected>;
   /**
    * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
+   * Although, you can make the state reactive by using the `useSelector` in your own usage.
    */
   readonly store: Store<Readonly<ThrottlerState<TFn>>>;
 }

package/dist/throttler/useThrottler.js CHANGED Viewed

@@ -1,6 +1,6 @@
 import { useDefaultPacerOptions } from "../provider/PacerProvider.js";
 import { useEffect, useMemo, useState } from "preact/hooks";
-import { shallow, useStore } from "@tanstack/preact-store";
+import { shallow, useSelector } from "@tanstack/preact-store";
 import { Throttler } from "@tanstack/pacer/throttler";
 //#region src/throttler/useThrottler.ts
@@ -121,14 +121,14 @@ function useThrottler(fn, options, selector = () => ({})) {
 	const [throttler] = useState(() => {
 		const throttlerInstance = new Throttler(fn, mergedOptions);
 		throttlerInstance.Subscribe = function Subscribe(props) {
-			const selected = useStore(throttlerInstance.store, props.selector, { equal: shallow });
+			const selected = useSelector(throttlerInstance.store, props.selector, { compare: shallow });
 			return typeof props.children === "function" ? props.children(selected) : props.children;
 		};
 		return throttlerInstance;
 	});
 	throttler.fn = fn;
 	throttler.setOptions(mergedOptions);
-	const state = useStore(throttler.store, selector, { equal: shallow });
+	const state = useSelector(throttler.store, selector, { compare: shallow });
 	useEffect(() => {
 		return () => {
 			if (mergedOptions.onUnmount) mergedOptions.onUnmount(throttler);

package/dist/throttler/useThrottler.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useThrottler.js","names":[],"sources":["../../src/throttler/useThrottler.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from 'preact/hooks'\nimport { Throttler } from '@tanstack/pacer/throttler'\nimport { shallow, ~~useStore~~ } from '@tanstack/preact-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/preact-store'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n ThrottlerOptions,\n ThrottlerState,\n} from '@tanstack/pacer/throttler'\nimport type { ComponentChildren } from 'preact'\n\nexport interface PreactThrottlerOptions<\n TFn extends AnyFunction,\n TSelected = {},\n> extends ThrottlerOptions<TFn> {\n /*\n Optional callback invoked when the component unmounts. Receives the throttler instance.\n * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.\n /\n onUnmount?: (throttler: PreactThrottler<TFn, TSelected>) => void\n}\n\nexport interface PreactThrottler<\n TFn extends AnyFunction,\n TSelected = {},\n> extends Omit<Throttler<TFn>, 'store'> {\n /\n A Preact HOC (Higher Order Component) that allows you to subscribe to the throttler state.\n \n This is useful for opting into state re-renders for specific parts of the throttler state\n * deep in your component tree without needing to pass a selector to the hook.\n \n @example\n * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n * {({ isPending }) => (\n * <div>{isPending ? 'Loading...' : 'Ready'}</div>\n * )}\n * </throttler.Subscribe>\n /\n Subscribe: <TSelected>(props: {\n selector: (state: ThrottlerState<TFn>) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) => ComponentChildren\n /\n Reactive state that will be updated and re-rendered when the throttler state changes\n \n Use this instead of `throttler.store.state`\n /\n readonly state: Readonly<TSelected>\n /\n @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.\n * The state on the store object is not reactive, as it has not been wrapped in a `~~useStore~~` hook internally.\n * Although, you can make the state reactive by using the `~~useStore~~` in your own usage.\n /\n readonly store: Store<Readonly<ThrottlerState<TFn>>>\n}\n\n/\n A low-level Preact hook that creates a `Throttler` instance that limits how often the provided function can execute.\n \n This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that\n * you can integrate with any state management solution (useState, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that\n * integrates directly with Preact's useState, see useThrottledState.\n \n Throttling ensures a function executes at most once within a specified time window,\n * regardless of how many times it is called. This is useful for rate-limiting\n * expensive operations or UI updates.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n \n 1. Using `throttler.Subscribe` HOC (Recommended for component tree subscriptions)\n \n Use the `Subscribe` HOC to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n \n 2. Using the `selector` parameter (For hook-level subscriptions)\n \n The `selector` parameter allows you to specify which state changes will trigger a re-render\n * at the hook level, optimizing performance by preventing unnecessary re-renders when irrelevant\n * state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` HOC. This prevents unnecessary\n * re-renders and gives you full control over when your component updates.\n \n Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n ## Unmount behavior\n \n By default, the hook cancels any pending execution when the component unmounts.\n * Use the `onUnmount` option to customize this. For example, to flush pending work instead:\n \n ```tsx\n * const throttler = useThrottler(fn, {\n * wait: 1000,\n * onUnmount: (t) => t.flush()\n * });\n * ```\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(setValue, { wait: 1000 });\n \n // Subscribe to state changes deep in component tree using Subscribe HOC\n * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n * {({ isPending }) => (\n * <div>{isPending ? 'Processing...' : 'Ready'}</div>\n * )}\n * </throttler.Subscribe>\n \n // Opt-in to re-render when execution count changes at hook level (optimized for tracking executions)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With any state manager\n * const throttler = useThrottler(\n * (value) => stateManager.setState(value),\n * {\n * wait: 2000,\n * leading: true, // Execute immediately on first call\n * trailing: false // Skip trailing edge updates\n * }\n * );\n \n // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n /\nexport function useThrottler<TFn extends AnyFunction, TSelected = {}>(\n fn: TFn,\n options: PreactThrottlerOptions<TFn, TSelected>,\n selector: (state: ThrottlerState<TFn>) => TSelected = () => ({}) as TSelected,\n): PreactThrottler<TFn, TSelected> {\n const mergedOptions = {\n ...useDefaultPacerOptions().throttler,\n ...options,\n } as PreactThrottlerOptions<TFn, TSelected>\n const [throttler] = useState(() => {\n const throttlerInstance = new Throttler<TFn>(\n fn,\n mergedOptions,\n ) as unknown as PreactThrottler<TFn, TSelected>\n\n throttlerInstance.Subscribe = function Subscribe<TSelected>(props: {\n selector: (state: ThrottlerState<TFn>) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) {\n const selected = ~~useStore~~(throttlerInstance.store, props.selector, {\n ~~equal~~: shallow,\n })\n\n return typeof props.children === 'function'\n ? props.children(selected)\n : props.children\n }\n\n return throttlerInstance\n })\n\n throttler.fn = fn\n throttler.setOptions(mergedOptions)\n\n const state = ~~useStore~~(throttler.store, selector, { ~~equal~~: shallow })\n\n / eslint-disable react-hooks/exhaustive-deps -- cleanup only; runs on unmount /\n useEffect(() => {\n return () => {\n if (mergedOptions.onUnmount) {\n mergedOptions.onUnmount(throttler)\n } else {\n throttler.cancel()\n }\n }\n }, [])\n / eslint-enable react-hooks/exhaustive-deps */\n\n return useMemo(\n () =>\n ({\n ...throttler,\n state,\n }) as PreactThrottler<TFn, TSelected>, // omit `store` in favor of `state`\n [throttler, state],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuKA,SAAgB,aACd,IACA,SACA,kBAA6D,EAAE,GAC9B;CACjC,MAAM,gBAAgB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ;CACD,MAAM,CAAC,aAAa,eAAe;EACjC,MAAM,oBAAoB,IAAI,UAC5B,IACA,cACD;~~AAED~~,~~oBAAkB~~,YAAY,SAAS,UAAqB,OAGzD;GACD,MAAM,WAAW,~~SAAS~~,kBAAkB,OAAO,MAAM,UAAU,~~EACjE~~,~~OAAO~~,~~SACR~~,CAAC;~~AAEF~~,~~UAAO~~,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;~~AAGZ~~,~~SAAO~~;GACP;~~AAEF~~,~~WAAU~~,KAAK;~~AACf~~,~~WAAU~~,WAAW,cAAc;CAEnC,MAAM,QAAQ,~~SAAS~~,UAAU,OAAO,UAAU,EAAE,~~OAAO~~,SAAS,CAAC;~~AAGrE~~,~~iBAAgB~~;~~AACd~~,~~eAAa~~;~~AACX~~,~~OAAI~~,cAAc,~~UAChB~~,~~eAAc~~,UAAU,UAAU;~~OAElC~~,~~WAAU~~,QAAQ;;IAGrB,EAAE,CAAC;~~AAGN~~,~~QAAO~~,eAEF;EACC,GAAG;EACH;EACD,GACH,CAAC,WAAW,MAAM,CACnB"}
1	+ {"version":3,"file":"useThrottler.js","names":[],"sources":["../../src/throttler/useThrottler.ts"],"sourcesContent":["import { useEffect, useMemo, useState } from 'preact/hooks'\nimport { Throttler } from '@tanstack/pacer/throttler'\nimport { shallow, useSelector } from '@tanstack/preact-store'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/preact-store'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type {\n ThrottlerOptions,\n ThrottlerState,\n} from '@tanstack/pacer/throttler'\nimport type { ComponentChildren } from 'preact'\n\nexport interface PreactThrottlerOptions<\n TFn extends AnyFunction,\n TSelected = {},\n> extends ThrottlerOptions<TFn> {\n /*\n Optional callback invoked when the component unmounts. Receives the throttler instance.\n * When provided, replaces the default cleanup (cancel); use it to call flush(), reset(), cancel(), add logging, etc.\n /\n onUnmount?: (throttler: PreactThrottler<TFn, TSelected>) => void\n}\n\nexport interface PreactThrottler<\n TFn extends AnyFunction,\n TSelected = {},\n> extends Omit<Throttler<TFn>, 'store'> {\n /\n A Preact HOC (Higher Order Component) that allows you to subscribe to the throttler state.\n \n This is useful for opting into state re-renders for specific parts of the throttler state\n * deep in your component tree without needing to pass a selector to the hook.\n \n @example\n * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n * {({ isPending }) => (\n * <div>{isPending ? 'Loading...' : 'Ready'}</div>\n * )}\n * </throttler.Subscribe>\n /\n Subscribe: <TSelected>(props: {\n selector: (state: ThrottlerState<TFn>) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) => ComponentChildren\n /\n Reactive state that will be updated and re-rendered when the throttler state changes\n \n Use this instead of `throttler.store.state`\n /\n readonly state: Readonly<TSelected>\n /\n @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.\n * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.\n * Although, you can make the state reactive by using the `useSelector` in your own usage.\n /\n readonly store: Store<Readonly<ThrottlerState<TFn>>>\n}\n\n/\n A low-level Preact hook that creates a `Throttler` instance that limits how often the provided function can execute.\n \n This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that\n * you can integrate with any state management solution (useState, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that\n * integrates directly with Preact's useState, see useThrottledState.\n \n Throttling ensures a function executes at most once within a specified time window,\n * regardless of how many times it is called. This is useful for rate-limiting\n * expensive operations or UI updates.\n \n ## State Management and Selector\n \n The hook uses TanStack Store for reactive state management. You can subscribe to state changes\n * in two ways:\n \n 1. Using `throttler.Subscribe` HOC (Recommended for component tree subscriptions)\n \n Use the `Subscribe` HOC to subscribe to state changes deep in your component tree without\n * needing to pass a selector to the hook. This is ideal when you want to subscribe to state\n * in child components.\n \n 2. Using the `selector` parameter (For hook-level subscriptions)\n \n The `selector` parameter allows you to specify which state changes will trigger a re-render\n * at the hook level, optimizing performance by preventing unnecessary re-renders when irrelevant\n * state changes occur.\n \n By default, there will be no reactive state subscriptions and you must opt-in to state\n * tracking by providing a selector function or using the `Subscribe` HOC. This prevents unnecessary\n * re-renders and gives you full control over when your component updates.\n \n Available state properties:\n * - `executionCount`: Number of function executions that have been completed\n * - `lastArgs`: The arguments from the most recent call to maybeExecute\n * - `lastExecutionTime`: Timestamp of the last function execution in milliseconds\n * - `nextExecutionTime`: Timestamp when the next execution can occur in milliseconds\n * - `isPending`: Whether the throttler is waiting for the timeout to trigger execution\n * - `status`: Current execution status ('disabled' \| 'idle' \| 'pending')\n \n ## Unmount behavior\n \n By default, the hook cancels any pending execution when the component unmounts.\n * Use the `onUnmount` option to customize this. For example, to flush pending work instead:\n \n ```tsx\n * const throttler = useThrottler(fn, {\n * wait: 1000,\n * onUnmount: (t) => t.flush()\n * });\n * ```\n \n @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(setValue, { wait: 1000 });\n \n // Subscribe to state changes deep in component tree using Subscribe HOC\n * <throttler.Subscribe selector={(state) => ({ isPending: state.isPending })}>\n * {({ isPending }) => (\n * <div>{isPending ? 'Processing...' : 'Ready'}</div>\n * )}\n * </throttler.Subscribe>\n \n // Opt-in to re-render when execution count changes at hook level (optimized for tracking executions)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({ executionCount: state.executionCount })\n * );\n \n // Opt-in to re-render when throttling state changes (optimized for loading indicators)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({\n * isPending: state.isPending,\n * status: state.status\n * })\n * );\n \n // Opt-in to re-render when timing information changes (optimized for timing displays)\n * const [value, setValue] = useState(0);\n * const throttler = useThrottler(\n * setValue,\n * { wait: 1000 },\n * (state) => ({\n * lastExecutionTime: state.lastExecutionTime,\n * nextExecutionTime: state.nextExecutionTime\n * })\n * );\n \n // With any state manager\n * const throttler = useThrottler(\n * (value) => stateManager.setState(value),\n * {\n * wait: 2000,\n * leading: true, // Execute immediately on first call\n * trailing: false // Skip trailing edge updates\n * }\n * );\n \n // Access the selected state (will be empty object {} unless selector provided)\n * const { executionCount, isPending } = throttler.state;\n * ```\n /\nexport function useThrottler<TFn extends AnyFunction, TSelected = {}>(\n fn: TFn,\n options: PreactThrottlerOptions<TFn, TSelected>,\n selector: (state: ThrottlerState<TFn>) => TSelected = () => ({}) as TSelected,\n): PreactThrottler<TFn, TSelected> {\n const mergedOptions = {\n ...useDefaultPacerOptions().throttler,\n ...options,\n } as PreactThrottlerOptions<TFn, TSelected>\n const [throttler] = useState(() => {\n const throttlerInstance = new Throttler<TFn>(\n fn,\n mergedOptions,\n ) as unknown as PreactThrottler<TFn, TSelected>\n\n throttlerInstance.Subscribe = function Subscribe<TSelected>(props: {\n selector: (state: ThrottlerState<TFn>) => TSelected\n children: ((state: TSelected) => ComponentChildren) \| ComponentChildren\n }) {\n const selected = useSelector(throttlerInstance.store, props.selector, {\n compare: shallow,\n })\n\n return typeof props.children === 'function'\n ? props.children(selected)\n : props.children\n }\n\n return throttlerInstance\n })\n\n throttler.fn = fn\n throttler.setOptions(mergedOptions)\n\n const state = useSelector(throttler.store, selector, { compare: shallow })\n\n / eslint-disable react-hooks/exhaustive-deps -- cleanup only; runs on unmount /\n useEffect(() => {\n return () => {\n if (mergedOptions.onUnmount) {\n mergedOptions.onUnmount(throttler)\n } else {\n throttler.cancel()\n }\n }\n }, [])\n / eslint-enable react-hooks/exhaustive-deps */\n\n return useMemo(\n () =>\n ({\n ...throttler,\n state,\n }) as PreactThrottler<TFn, TSelected>, // omit `store` in favor of `state`\n [throttler, state],\n )\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuKA,SAAgB,aACd,IACA,SACA,kBAA6D,EAAE,GAC9B;CACjC,MAAM,gBAAgB;EACpB,GAAG,wBAAwB,CAAC;EAC5B,GAAG;EACJ;CACD,MAAM,CAAC,aAAa,eAAe;EACjC,MAAM,oBAAoB,IAAI,UAC5B,IACA,cACD;EAED,kBAAkB,YAAY,SAAS,UAAqB,OAGzD;GACD,MAAM,WAAW,YAAY,kBAAkB,OAAO,MAAM,UAAU,EACpE,SAAS,SACV,CAAC;GAEF,OAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,SAAS,GACxB,MAAM;;EAGZ,OAAO;GACP;CAEF,UAAU,KAAK;CACf,UAAU,WAAW,cAAc;CAEnC,MAAM,QAAQ,YAAY,UAAU,OAAO,UAAU,EAAE,SAAS,SAAS,CAAC;CAG1E,gBAAgB;EACd,aAAa;GACX,IAAI,cAAc,WAChB,cAAc,UAAU,UAAU;QAElC,UAAU,QAAQ;;IAGrB,EAAE,CAAC;CAGN,OAAO,eAEF;EACC,GAAG;EACH;EACD,GACH,CAAC,WAAW,MAAM,CACnB"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/preact-pacer",
-  "version": "0.21.1",
+  "version": "0.22.1",
   "description": "Utilities for debouncing and throttling functions in Preact.",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -98,13 +98,13 @@
     "src"
   ],
   "dependencies": {
-    "@tanstack/preact-store": "^0.11.3",
-    "@tanstack/pacer": "0.20.1"
+    "@tanstack/preact-store": "^0.13.1",
+    "@tanstack/pacer": "0.21.1"
   },
   "devDependencies": {
     "@preact/preset-vite": "^2.10.5",
-    "eslint-plugin-react-hooks": "^7.0.1",
-    "preact": "^10.29.0"
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "preact": "^10.29.1"
   },
   "peerDependencies": {
     "preact": ">=10.0.0"

package/src/async-batcher/useAsyncBatcher.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from 'preact/hooks'
 import { AsyncBatcher } from '@tanstack/pacer/async-batcher'
-import { shallow, useStore } from '@tanstack/preact-store'
+import { shallow, useSelector } from '@tanstack/preact-store'
 import { useDefaultPacerOptions } from '../provider/PacerProvider'
 import type { Store } from '@tanstack/preact-store'
 import type {
@@ -49,8 +49,8 @@ export interface PreactAsyncBatcher<TValue, TSelected = {}> extends Omit<
   readonly state: Readonly<TSelected>
   /**
    * @deprecated Use `batcher.state` instead of `batcher.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
+   * Although, you can make the state reactive by using the `useSelector` in your own usage.
    */
   readonly store: Store<Readonly<AsyncBatcherState<TValue>>>
 }
@@ -252,8 +252,8 @@ export function useAsyncBatcher<TValue, TSelected = {}>(
       selector: (state: AsyncBatcherState<TValue>) => TSelected
       children: ((state: TSelected) => ComponentChildren) | ComponentChildren
     }) {
-      const selected = useStore(batcherInstance.store, props.selector, {
-        equal: shallow,
+      const selected = useSelector(batcherInstance.store, props.selector, {
+        compare: shallow,
       })
       return typeof props.children === 'function'
@@ -280,7 +280,7 @@ export function useAsyncBatcher<TValue, TSelected = {}>(
   }, [])
   /* eslint-enable react-hooks/exhaustive-deps */
-  const state = useStore(asyncBatcher.store, selector, { equal: shallow })
+  const state = useSelector(asyncBatcher.store, selector, { compare: shallow })
   return useMemo(
     () =>

package/src/async-debouncer/useAsyncDebouncer.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from 'preact/hooks'
 import { AsyncDebouncer } from '@tanstack/pacer/async-debouncer'
-import { shallow, useStore } from '@tanstack/preact-store'
+import { shallow, useSelector } from '@tanstack/preact-store'
 import { useDefaultPacerOptions } from '../provider/PacerProvider'
 import type { Store } from '@tanstack/preact-store'
 import type { AnyAsyncFunction } from '@tanstack/pacer/types'
@@ -50,8 +50,8 @@ export interface PreactAsyncDebouncer<
   readonly state: Readonly<TSelected>
   /**
    * @deprecated Use `debouncer.state` instead of `debouncer.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
+   * Although, you can make the state reactive by using the `useSelector` in your own usage.
    */
   readonly store: Store<Readonly<AsyncDebouncerState<TFn>>>
 }
@@ -231,8 +231,8 @@ export function useAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(
       selector: (state: AsyncDebouncerState<TFn>) => TSelected
       children: ((state: TSelected) => ComponentChildren) | ComponentChildren
     }) {
-      const selected = useStore(debouncerInstance.store, props.selector, {
-        equal: shallow,
+      const selected = useSelector(debouncerInstance.store, props.selector, {
+        compare: shallow,
       })
       return typeof props.children === 'function'
@@ -246,7 +246,9 @@ export function useAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(
   asyncDebouncer.fn = fn
   asyncDebouncer.setOptions(mergedOptions)
-  const state = useStore(asyncDebouncer.store, selector, { equal: shallow })
+  const state = useSelector(asyncDebouncer.store, selector, {
+    compare: shallow,
+  })
   /* eslint-disable react-hooks/exhaustive-deps -- cleanup only; runs on unmount */
   useEffect(() => {

package/src/async-queuer/useAsyncQueuer.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from 'preact/hooks'
 import { AsyncQueuer } from '@tanstack/pacer/async-queuer'
-import { shallow, useStore } from '@tanstack/preact-store'
+import { shallow, useSelector } from '@tanstack/preact-store'
 import { useDefaultPacerOptions } from '../provider/PacerProvider'
 import type { Store } from '@tanstack/preact-store'
 import type {
@@ -49,8 +49,8 @@ export interface PreactAsyncQueuer<TValue, TSelected = {}> extends Omit<
   readonly state: Readonly<TSelected>
   /**
    * @deprecated Use `queuer.state` instead of `queuer.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
+   * Although, you can make the state reactive by using the `useSelector` in your own usage.
    */
   readonly store: Store<Readonly<AsyncQueuerState<TValue>>>
 }
@@ -252,8 +252,8 @@ export function useAsyncQueuer<TValue, TSelected = {}>(
       selector: (state: AsyncQueuerState<TValue>) => TSelected
       children: ((state: TSelected) => ComponentChildren) | ComponentChildren
     }) {
-      const selected = useStore(queuerInstance.store, props.selector, {
-        equal: shallow,
+      const selected = useSelector(queuerInstance.store, props.selector, {
+        compare: shallow,
       })
       return typeof props.children === 'function'
@@ -280,7 +280,7 @@ export function useAsyncQueuer<TValue, TSelected = {}>(
   }, [])
   /* eslint-enable react-hooks/exhaustive-deps */
-  const state = useStore(asyncQueuer.store, selector, { equal: shallow })
+  const state = useSelector(asyncQueuer.store, selector, { compare: shallow })
   return useMemo(
     () =>

package/src/async-rate-limiter/useAsyncRateLimiter.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from 'preact/hooks'
 import { AsyncRateLimiter } from '@tanstack/pacer/async-rate-limiter'
-import { shallow, useStore } from '@tanstack/preact-store'
+import { shallow, useSelector } from '@tanstack/preact-store'
 import { useDefaultPacerOptions } from '../provider/PacerProvider'
 import type { Store } from '@tanstack/preact-store'
 import type { AnyAsyncFunction } from '@tanstack/pacer/types'
@@ -50,8 +50,8 @@ export interface PreactAsyncRateLimiter<
   readonly state: Readonly<TSelected>
   /**
    * @deprecated Use `rateLimiter.state` instead of `rateLimiter.store.state` if you want to read reactive state.
-   * The state on the store object is not reactive, as it has not been wrapped in a `useStore` hook internally.
-   * Although, you can make the state reactive by using the `useStore` in your own usage.
+   * The state on the store object is not reactive, as it has not been wrapped in a `useSelector` hook internally.
+   * Although, you can make the state reactive by using the `useSelector` in your own usage.
    */
   readonly store: Store<Readonly<AsyncRateLimiterState<TFn>>>
 }
@@ -252,8 +252,8 @@ export function useAsyncRateLimiter<
       selector: (state: AsyncRateLimiterState<TFn>) => TSelected
       children: ((state: TSelected) => ComponentChildren) | ComponentChildren
     }) {
-      const selected = useStore(rateLimiterInstance.store, props.selector, {
-        equal: shallow,
+      const selected = useSelector(rateLimiterInstance.store, props.selector, {
+        compare: shallow,
       })
       return typeof props.children === 'function'
@@ -279,7 +279,9 @@ export function useAsyncRateLimiter<
   }, [])
   /* eslint-enable react-hooks/exhaustive-deps */
-  const state = useStore(asyncRateLimiter.store, selector, { equal: shallow })
+  const state = useSelector(asyncRateLimiter.store, selector, {
+    compare: shallow,
+  })
   return useMemo(
     () =>