@tanstack/solid-pacer 0.22.0 → 0.23.0

package/dist/queuer/createQueuer.d.cts

@@ -1,147 +0,0 @@
-import { Store } from "@tanstack/solid-store";
-import { Accessor, JSX } from "solid-js";
-import { Queuer, QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
-//#region src/queuer/createQueuer.d.ts
-interface SolidQueuerOptions<TValue, TSelected = {}> extends QueuerOptions<TValue> {
-  /**
-   * Optional callback invoked when the owning component unmounts. Receives the queuer instance.
-   * When provided, replaces the default cleanup (stop); use it to call flush(), flushAsBatch(), stop(), add logging, etc.
-   */
-  onUnmount?: (queuer: SolidQueuer<TValue, TSelected>) => void;
-}
-interface SolidQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
-  /**
-   * A Solid component that allows you to subscribe to the queuer state.
-   *
-   * This is useful for tracking specific parts of the queuer state
-   * deep in your component tree without needing to pass a selector to the hook.
-   *
-   * @example
-   * <queuer.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>
-   *   {(state) => (
-   *     <div>Queue: {state().size} items, {state().isRunning ? 'Processing' : 'Idle'}</div>
-   *   )}
-   * </queuer.Subscribe>
-   */
-  Subscribe: <TSelected>(props: {
-    selector: (state: QueuerState<TValue>) => TSelected;
-    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element;
-  }) => JSX.Element;
-  /**
-   * Reactive state that will be updated when the queuer state changes
-   *
-   * Use this instead of `queuer.store.state`
-   */
-  readonly state: Accessor<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 `useSelector` hook internally.
-   * Although, you can make the state reactive by using the `useSelector` in your own usage.
-   */
-  readonly store: Store<Readonly<QueuerState<TValue>>>;
-}
-/**
- * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.
- *
- * Features:
- * - Synchronous processing of items using the provided `fn` function
- * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior
- * - Priority queueing via `getPriority` or item `priority` property
- * - Item expiration and removal of stale items
- * - Configurable wait time between processing items
- * - Pause/resume processing
- * - Callbacks for queue state changes, execution, rejection, and expiration
- * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity
- *
- * The queue processes items synchronously in order, with optional delays between each item. When started, it will process one item per tick, with an optional wait time between ticks. You can pause and resume processing with `stop()` and `start()`.
- *
- * By default, the queue uses FIFO behavior, but you can configure LIFO or double-ended queueing by specifying the position when adding or removing items.
- *
- * ## State Management and Selector
- *
- * The hook uses TanStack Store for reactive state management. You can subscribe to state changes
- * in two ways:
- *
- * **1. Using `queuer.Subscribe` component (Recommended for component tree subscriptions)**
- *
- * Use the `Subscribe` component to subscribe to state changes deep in your component tree without
- * needing to pass a selector to the hook. This is ideal when you want to subscribe to state
- * in child components.
- *
- * **2. Using the `selector` parameter (For hook-level subscriptions)**
- *
- * The `selector` parameter allows you to specify which state changes will trigger reactive updates
- * at the hook level, optimizing performance by preventing unnecessary updates when irrelevant
- * state changes occur.
- *
- * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function or using the `Subscribe` component. This prevents unnecessary
- * updates and gives you full control over when your component tracks state changes.
- *
- * Available state properties:
- * - `executionCount`: Number of items that have been processed
- * - `isRunning`: Whether the queuer is currently running (not stopped)
- * - `items`: Array of items currently queued for processing
- * - `rejectionCount`: Number of items that were rejected (expired or failed validation)
- *
- * ## Unmount behavior
- *
- * By default, the primitive stops the queuer when the owning component unmounts.
- * Use the `onUnmount` option to customize this. For example, to flush pending items instead:
- *
- * ```tsx
- * const queue = createQueuer(fn, {
- *   started: true,
- *   wait: 1000,
- *   onUnmount: (q) => q.flush()
- * });
- * ```
- *
- * Example usage:
- * ```tsx
- * // Default behavior - no reactive state subscriptions
- * const queue = createQueuer(
- *   (item) => {
- *     // process item synchronously
- *     console.log('Processing', item);
- *   },
- *   {
- *     started: true, // Start processing immediately
- *     wait: 1000,    // Process one item every second
- *     getPriority: (item) => item.priority // Process higher priority items first
- *   }
- * );
- *
- * // Opt-in to track items or isRunning changes (optimized for UI updates)
- * const queue = createQueuer(
- *   (item) => console.log('Processing', item),
- *   { started: true, wait: 1000 },
- *   (state) => ({ items: state.items, isRunning: state.isRunning })
- * );
- *
- * // Opt-in to track execution metrics changes (optimized for tracking progress)
- * const queue = createQueuer(
- *   (item) => console.log('Processing', item),
- *   { started: true, wait: 1000 },
- *   (state) => ({
- *     executionCount: state.executionCount,
- *     rejectionCount: state.rejectionCount
- *   })
- * );
- *
- * // Add items to process - they'll be handled automatically
- * queue.addItem('task1');
- * queue.addItem('task2');
- *
- * // Control the scheduler
- * queue.stop();  // Pause processing
- * queue.start(); // Resume processing
- *
- * // Access the selected state (will be empty object {} unless selector provided)
- * const { items, isRunning } = queue.state();
- * ```
- */
-declare function createQueuer<TValue, TSelected = {}>(fn: (item: TValue) => void, options?: SolidQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): SolidQueuer<TValue, TSelected>;
-//#endregion
-export { SolidQueuer, SolidQueuerOptions, createQueuer };
-//# sourceMappingURL=createQueuer.d.cts.map

package/dist/queuer/createQueuer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createQueuer.js","names":[],"sources":["../../src/queuer/createQueuer.ts"],"sourcesContent":["import { Queuer } from '@tanstack/pacer/queuer'\nimport { shallow, useSelector } from '@tanstack/solid-store'\nimport { createEffect, onCleanup } from 'solid-js'\nimport { useDefaultPacerOptions } from '../provider/PacerProvider'\nimport type { Store } from '@tanstack/solid-store'\nimport type { Accessor, JSX } from 'solid-js'\nimport type { QueuerOptions, QueuerState } from '@tanstack/pacer/queuer'\n\nexport interface SolidQueuerOptions<\n  TValue,\n  TSelected = {},\n> extends QueuerOptions<TValue> {\n  /**\n   * Optional callback invoked when the owning component unmounts. Receives the queuer instance.\n   * When provided, replaces the default cleanup (stop); use it to call flush(), flushAsBatch(), stop(), add logging, etc.\n   */\n  onUnmount?: (queuer: SolidQueuer<TValue, TSelected>) => void\n}\n\nexport interface SolidQueuer<TValue, TSelected = {}> extends Omit<\n  Queuer<TValue>,\n  'store'\n> {\n  /**\n   * A Solid component that allows you to subscribe to the queuer state.\n   *\n   * This is useful for tracking specific parts of the queuer state\n   * deep in your component tree without needing to pass a selector to the hook.\n   *\n   * @example\n   * <queuer.Subscribe selector={(state) => ({ size: state.size, isRunning: state.isRunning })}>\n   *   {(state) => (\n   *     <div>Queue: {state().size} items, {state().isRunning ? 'Processing' : 'Idle'}</div>\n   *   )}\n   * </queuer.Subscribe>\n   */\n  Subscribe: <TSelected>(props: {\n    selector: (state: QueuerState<TValue>) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) => JSX.Element\n  /**\n   * Reactive state that will be updated when the queuer state changes\n   *\n   * Use this instead of `queuer.store.state`\n   */\n  readonly state: Accessor<Readonly<TSelected>>\n  /**\n   * @deprecated Use `queuer.state` instead of `queuer.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<QueuerState<TValue>>>\n}\n\n/**\n * Creates a Solid-compatible Queuer instance for managing a synchronous queue of items, exposing Solid signals for all stateful properties.\n *\n * Features:\n * - Synchronous processing of items using the provided `fn` function\n * - FIFO (First In First Out) or LIFO (Last In First Out) queue behavior\n * - Priority queueing via `getPriority` or item `priority` property\n * - Item expiration and removal of stale items\n * - Configurable wait time between processing items\n * - Pause/resume processing\n * - Callbacks for queue state changes, execution, rejection, and expiration\n * - All stateful properties (items, counts, etc.) are exposed as Solid signals for reactivity\n *\n * The queue processes items synchronously in order, with optional delays between each item. When started, it will process one item per tick, with an optional wait time between ticks. You can pause and resume processing with `stop()` and `start()`.\n *\n * By default, the queue uses FIFO behavior, but you can configure LIFO or double-ended queueing by specifying the position when adding or removing items.\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 `queuer.Subscribe` component (Recommended for component tree subscriptions)**\n *\n * Use the `Subscribe` component 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 reactive updates\n * at the hook level, optimizing performance by preventing unnecessary updates 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` component. This prevents unnecessary\n * updates and gives you full control over when your component tracks state changes.\n *\n * Available state properties:\n * - `executionCount`: Number of items that have been processed\n * - `isRunning`: Whether the queuer is currently running (not stopped)\n * - `items`: Array of items currently queued for processing\n * - `rejectionCount`: Number of items that were rejected (expired or failed validation)\n *\n * ## Unmount behavior\n *\n * By default, the primitive stops the queuer when the owning component unmounts.\n * Use the `onUnmount` option to customize this. For example, to flush pending items instead:\n *\n * ```tsx\n * const queue = createQueuer(fn, {\n *   started: true,\n *   wait: 1000,\n *   onUnmount: (q) => q.flush()\n * });\n * ```\n *\n * Example usage:\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const queue = createQueuer(\n *   (item) => {\n *     // process item synchronously\n *     console.log('Processing', item);\n *   },\n *   {\n *     started: true, // Start processing immediately\n *     wait: 1000,    // Process one item every second\n *     getPriority: (item) => item.priority // Process higher priority items first\n *   }\n * );\n *\n * // Opt-in to track items or isRunning changes (optimized for UI updates)\n * const queue = createQueuer(\n *   (item) => console.log('Processing', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({ items: state.items, isRunning: state.isRunning })\n * );\n *\n * // Opt-in to track execution metrics changes (optimized for tracking progress)\n * const queue = createQueuer(\n *   (item) => console.log('Processing', item),\n *   { started: true, wait: 1000 },\n *   (state) => ({\n *     executionCount: state.executionCount,\n *     rejectionCount: state.rejectionCount\n *   })\n * );\n *\n * // Add items to process - they'll be handled automatically\n * queue.addItem('task1');\n * queue.addItem('task2');\n *\n * // Control the scheduler\n * queue.stop();  // Pause processing\n * queue.start(); // Resume processing\n *\n * // Access the selected state (will be empty object {} unless selector provided)\n * const { items, isRunning } = queue.state();\n * ```\n */\nexport function createQueuer<TValue, TSelected = {}>(\n  fn: (item: TValue) => void,\n  options: SolidQueuerOptions<TValue, TSelected> = {},\n  selector: (state: QueuerState<TValue>) => TSelected = () => ({}) as TSelected,\n): SolidQueuer<TValue, TSelected> {\n  const mergedOptions = {\n    ...useDefaultPacerOptions().queuer,\n    ...options,\n  } as SolidQueuerOptions<TValue, TSelected>\n  const queuer = new Queuer(fn, mergedOptions) as unknown as SolidQueuer<\n    TValue,\n    TSelected\n  >\n\n  queuer.Subscribe = function Subscribe<TSelected>(props: {\n    selector: (state: QueuerState<TValue>) => TSelected\n    children: ((state: Accessor<TSelected>) => JSX.Element) | JSX.Element\n  }) {\n    const selected = useSelector(queuer.store, props.selector, {\n      compare: shallow,\n    })\n\n    return typeof props.children === 'function'\n      ? props.children(selected)\n      : props.children\n  }\n\n  const state = useSelector(queuer.store, selector, { compare: shallow })\n\n  createEffect(() => {\n    onCleanup(() => {\n      if (mergedOptions.onUnmount) {\n        mergedOptions.onUnmount(queuer)\n      } else {\n        queuer.stop()\n      }\n    })\n  })\n\n  return {\n    ...queuer,\n    state,\n  } as SolidQueuer<TValue, TSelected> // omit `store` in favor of `state`\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2JA,SAAgB,aACd,IACA,UAAiD,CAAC,GAClD,kBAA6D,CAAC,IAC9B;CAChC,MAAM,gBAAgB;EACpB,GAAG,uBAAuB,CAAC,CAAC;EAC5B,GAAG;CACL;CACA,MAAM,SAAS,IAAI,OAAO,IAAI,aAAa;CAK3C,OAAO,YAAY,SAAS,UAAqB,OAG9C;EACD,MAAM,WAAW,YAAY,OAAO,OAAO,MAAM,UAAU,EACzD,SAAS,QACX,CAAC;EAED,OAAO,OAAO,MAAM,aAAa,aAC7B,MAAM,SAAS,QAAQ,IACvB,MAAM;CACZ;CAEA,MAAM,QAAQ,YAAY,OAAO,OAAO,UAAU,EAAE,SAAS,QAAQ,CAAC;CAEtE,mBAAmB;EACjB,gBAAgB;GACd,IAAI,cAAc,WAChB,cAAc,UAAU,MAAM;QAE9B,OAAO,KAAK;EAEhB,CAAC;CACH,CAAC;CAED,OAAO;EACL,GAAG;EACH;CACF;AACF"}

package/dist/queuer/index.cjs

@@ -1,13 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_createQueuer = require('./createQueuer.cjs');
-const require_createQueuedSignal = require('./createQueuedSignal.cjs');
-
-exports.createQueuedSignal = require_createQueuedSignal.createQueuedSignal;
-exports.createQueuer = require_createQueuer.createQueuer;
-var _tanstack_pacer_queuer = require("@tanstack/pacer/queuer");
-Object.keys(_tanstack_pacer_queuer).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return _tanstack_pacer_queuer[k]; }
-  });
-});

package/dist/queuer/index.d.cts

@@ -1,4 +0,0 @@
-import { SolidQueuer, SolidQueuerOptions, createQueuer } from "./createQueuer.cjs";
-import { createQueuedSignal } from "./createQueuedSignal.cjs";
-export * from "@tanstack/pacer/queuer";
-export { SolidQueuer, SolidQueuerOptions, createQueuedSignal, createQueuer };

package/dist/rate-limiter/createRateLimitedSignal.cjs

@@ -1,102 +0,0 @@
-const require_createRateLimiter = require('./createRateLimiter.cjs');
-let solid_js = require("solid-js");
-
-//#region src/rate-limiter/createRateLimitedSignal.ts
-/**
-* A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.
-* This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.
-*
-* Rate limiting is a simple "hard limit" approach - it allows all updates until the limit is reached, then blocks
-* subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out
-* or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.
-*
-* The rate limiter supports two types of windows:
-* - 'fixed': A strict window that resets after the window period. All updates within the window count
-*   towards the limit, and the window resets completely after the period.
-* - 'sliding': A rolling window that allows updates as old ones expire. This provides a more
-*   consistent rate of updates over time.
-*
-* For smoother update patterns, consider:
-* - createThrottledSignal: When you want consistent spacing between updates (e.g. UI changes)
-* - createDebouncedSignal: When you want to collapse rapid updates into a single update (e.g. search input)
-*
-* Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.
-*
-* The hook returns a tuple containing:
-* - The rate-limited state value accessor
-* - A rate-limited setter function that respects the configured limits
-* - The rateLimiter instance for additional control
-*
-* For more direct control over rate limiting without state management,
-* consider using the lower-level createRateLimiter hook instead.
-*
-* ## State Management and Selector
-*
-* The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.
-* The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,
-* optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
-*
-* **By default, there will be no reactive state subscriptions** and you must opt-in to state
-* tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
-* full control over when your component subscribes to state changes. Only when you provide a selector will
-* the reactive system track the selected state values.
-*
-* Available rate limiter state properties:
-* - `callsInWindow`: Number of calls made in the current window
-* - `remainingInWindow`: Number of calls remaining in the current window
-* - `windowStart`: Unix timestamp when the current window started
-* - `nextWindowStart`: Unix timestamp when the next window will start
-* - `msUntilNextWindow`: Milliseconds until the next window starts
-* - `isAtLimit`: Whether the call limit for the current window has been reached
-* - `status`: Current status ('disabled' | 'idle' | 'at-limit')
-*
-* @example
-* ```tsx
-* // Default behavior - no reactive state subscriptions
-* const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {
-*   limit: 5,
-*   window: 60000,
-*   windowType: 'sliding'
-* });
-*
-* // Opt-in to reactive updates when limit state changes (optimized for UI feedback)
-* const [value, setValue, rateLimiter] = createRateLimitedSignal(
-*   0,
-*   { limit: 5, window: 60000 },
-*   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })
-* );
-*
-* // With rejection callback and fixed window
-* const [value, setValue] = createRateLimitedSignal(0, {
-*   limit: 3,
-*   window: 5000,
-*   windowType: 'fixed',
-*   onReject: (rateLimiter) => {
-*     alert(`Rate limit reached. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
-*   }
-* });
-*
-* // Access rateLimiter state via signals
-* const handleSubmit = () => {
-*   const remaining = rateLimiter.state().remainingInWindow;
-*   if (remaining > 0) {
-*     setValue(newValue);
-*   } else {
-*     showRateLimitWarning();
-*   }
-* };
-* ```
-*/
-function createRateLimitedSignal(value, initialOptions, selector) {
-	const [rateLimitedValue, setRateLimitedValue] = (0, solid_js.createSignal)(value);
-	const rateLimiter = require_createRateLimiter.createRateLimiter(setRateLimitedValue, initialOptions, selector);
-	return [
-		rateLimitedValue,
-		rateLimiter.maybeExecute,
-		rateLimiter
-	];
-}
-
-//#endregion
-exports.createRateLimitedSignal = createRateLimitedSignal;
-//# sourceMappingURL=createRateLimitedSignal.cjs.map

package/dist/rate-limiter/createRateLimitedSignal.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRateLimitedSignal.cjs","names":["createSignal","createRateLimiter"],"sources":["../../src/rate-limiter/createRateLimitedSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createRateLimiter } from './createRateLimiter'\nimport type {\n  SolidRateLimiter,\n  SolidRateLimiterOptions,\n} from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { RateLimiterState } from '@tanstack/pacer/rate-limiter'\n\n/**\n * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.\n * This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledSignal: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedSignal: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - The rate-limited state value accessor\n * - A rate-limited setter function that respects the configured limits\n * - The rateLimiter instance for additional control\n *\n * For more direct control over rate limiting without state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.\n * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,\n * optimizing performance by preventing unnecessary subscriptions 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 reactive updates and gives you\n * full control over when your component subscribes to state changes. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available rate limiter state properties:\n * - `callsInWindow`: Number of calls made in the current window\n * - `remainingInWindow`: Number of calls remaining in the current window\n * - `windowStart`: Unix timestamp when the current window started\n * - `nextWindowStart`: Unix timestamp when the next window will start\n * - `msUntilNextWindow`: Milliseconds until the next window starts\n * - `isAtLimit`: Whether the call limit for the current window has been reached\n * - `status`: Current status ('disabled' | 'idle' | 'at-limit')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Opt-in to reactive updates when limit state changes (optimized for UI feedback)\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(\n *   0,\n *   { limit: 5, window: 60000 },\n *   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })\n * );\n *\n * // With rejection callback and fixed window\n * const [value, setValue] = createRateLimitedSignal(0, {\n *   limit: 3,\n *   window: 5000,\n *   windowType: 'fixed',\n *   onReject: (rateLimiter) => {\n *     alert(`Rate limit reached. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rateLimiter state via signals\n * const handleSubmit = () => {\n *   const remaining = rateLimiter.state().remainingInWindow;\n *   if (remaining > 0) {\n *     setValue(newValue);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n * ```\n */\nexport function createRateLimitedSignal<TValue, TSelected = {}>(\n  value: TValue,\n  initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidRateLimiter<Setter<TValue>, TSelected>,\n] {\n  const [rateLimitedValue, setRateLimitedValue] = createSignal<TValue>(value)\n\n  const rateLimiter = createRateLimiter(\n    setRateLimitedValue,\n    initialOptions,\n    selector,\n  )\n\n  return [\n    rateLimitedValue,\n    rateLimiter.maybeExecute as Setter<TValue>,\n    rateLimiter,\n  ]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8FA,SAAgB,wBACd,OACA,gBACA,UAKA;CACA,MAAM,CAAC,kBAAkB,2BAAuBA,uBAAqB,KAAK;CAE1E,MAAM,cAAcC,4CAClB,qBACA,gBACA,QACF;CAEA,OAAO;EACL;EACA,YAAY;EACZ;CACF;AACF"}

package/dist/rate-limiter/createRateLimitedSignal.d.cts

@@ -1,93 +0,0 @@
-import { SolidRateLimiter, SolidRateLimiterOptions } from "./createRateLimiter.cjs";
-import { Accessor, Setter } from "solid-js";
-import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
-//#region src/rate-limiter/createRateLimitedSignal.d.ts
-/**
- * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.
- * This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.
- *
- * Rate limiting is a simple "hard limit" approach - it allows all updates until the limit is reached, then blocks
- * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out
- * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.
- *
- * The rate limiter supports two types of windows:
- * - 'fixed': A strict window that resets after the window period. All updates within the window count
- *   towards the limit, and the window resets completely after the period.
- * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more
- *   consistent rate of updates over time.
- *
- * For smoother update patterns, consider:
- * - createThrottledSignal: When you want consistent spacing between updates (e.g. UI changes)
- * - createDebouncedSignal: When you want to collapse rapid updates into a single update (e.g. search input)
- *
- * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.
- *
- * The hook returns a tuple containing:
- * - The rate-limited state value accessor
- * - A rate-limited setter function that respects the configured limits
- * - The rateLimiter instance for additional control
- *
- * For more direct control over rate limiting without state management,
- * consider using the lower-level createRateLimiter hook instead.
- *
- * ## State Management and Selector
- *
- * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.
- * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,
- * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
- *
- * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
- * full control over when your component subscribes to state changes. Only when you provide a selector will
- * the reactive system track the selected state values.
- *
- * Available rate limiter state properties:
- * - `callsInWindow`: Number of calls made in the current window
- * - `remainingInWindow`: Number of calls remaining in the current window
- * - `windowStart`: Unix timestamp when the current window started
- * - `nextWindowStart`: Unix timestamp when the next window will start
- * - `msUntilNextWindow`: Milliseconds until the next window starts
- * - `isAtLimit`: Whether the call limit for the current window has been reached
- * - `status`: Current status ('disabled' | 'idle' | 'at-limit')
- *
- * @example
- * ```tsx
- * // Default behavior - no reactive state subscriptions
- * const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {
- *   limit: 5,
- *   window: 60000,
- *   windowType: 'sliding'
- * });
- *
- * // Opt-in to reactive updates when limit state changes (optimized for UI feedback)
- * const [value, setValue, rateLimiter] = createRateLimitedSignal(
- *   0,
- *   { limit: 5, window: 60000 },
- *   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })
- * );
- *
- * // With rejection callback and fixed window
- * const [value, setValue] = createRateLimitedSignal(0, {
- *   limit: 3,
- *   window: 5000,
- *   windowType: 'fixed',
- *   onReject: (rateLimiter) => {
- *     alert(`Rate limit reached. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
- *   }
- * });
- *
- * // Access rateLimiter state via signals
- * const handleSubmit = () => {
- *   const remaining = rateLimiter.state().remainingInWindow;
- *   if (remaining > 0) {
- *     setValue(newValue);
- *   } else {
- *     showRateLimitWarning();
- *   }
- * };
- * ```
- */
-declare function createRateLimitedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, Setter<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];
-//#endregion
-export { createRateLimitedSignal };
-//# sourceMappingURL=createRateLimitedSignal.d.cts.map

package/dist/rate-limiter/createRateLimitedSignal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRateLimitedSignal.js","names":[],"sources":["../../src/rate-limiter/createRateLimitedSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createRateLimiter } from './createRateLimiter'\nimport type {\n  SolidRateLimiter,\n  SolidRateLimiterOptions,\n} from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { RateLimiterState } from '@tanstack/pacer/rate-limiter'\n\n/**\n * A Solid hook that creates a rate-limited state value that enforces a hard limit on state updates within a time window.\n * This hook combines Solid's createSignal with rate limiting functionality to provide controlled state updates.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledSignal: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedSignal: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - The rate-limited state value accessor\n * - A rate-limited setter function that respects the configured limits\n * - The rateLimiter instance for additional control\n *\n * For more direct control over rate limiting without state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.\n * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,\n * optimizing performance by preventing unnecessary subscriptions 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 reactive updates and gives you\n * full control over when your component subscribes to state changes. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available rate limiter state properties:\n * - `callsInWindow`: Number of calls made in the current window\n * - `remainingInWindow`: Number of calls remaining in the current window\n * - `windowStart`: Unix timestamp when the current window started\n * - `nextWindowStart`: Unix timestamp when the next window will start\n * - `msUntilNextWindow`: Milliseconds until the next window starts\n * - `isAtLimit`: Whether the call limit for the current window has been reached\n * - `status`: Current status ('disabled' | 'idle' | 'at-limit')\n *\n * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(0, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Opt-in to reactive updates when limit state changes (optimized for UI feedback)\n * const [value, setValue, rateLimiter] = createRateLimitedSignal(\n *   0,\n *   { limit: 5, window: 60000 },\n *   (state) => ({ isAtLimit: state.isAtLimit, remainingInWindow: state.remainingInWindow })\n * );\n *\n * // With rejection callback and fixed window\n * const [value, setValue] = createRateLimitedSignal(0, {\n *   limit: 3,\n *   window: 5000,\n *   windowType: 'fixed',\n *   onReject: (rateLimiter) => {\n *     alert(`Rate limit reached. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access rateLimiter state via signals\n * const handleSubmit = () => {\n *   const remaining = rateLimiter.state().remainingInWindow;\n *   if (remaining > 0) {\n *     setValue(newValue);\n *   } else {\n *     showRateLimitWarning();\n *   }\n * };\n * ```\n */\nexport function createRateLimitedSignal<TValue, TSelected = {}>(\n  value: TValue,\n  initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidRateLimiter<Setter<TValue>, TSelected>,\n] {\n  const [rateLimitedValue, setRateLimitedValue] = createSignal<TValue>(value)\n\n  const rateLimiter = createRateLimiter(\n    setRateLimitedValue,\n    initialOptions,\n    selector,\n  )\n\n  return [\n    rateLimitedValue,\n    rateLimiter.maybeExecute as Setter<TValue>,\n    rateLimiter,\n  ]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8FA,SAAgB,wBACd,OACA,gBACA,UAKA;CACA,MAAM,CAAC,kBAAkB,uBAAuB,aAAqB,KAAK;CAE1E,MAAM,cAAc,kBAClB,qBACA,gBACA,QACF;CAEA,OAAO;EACL;EACA,YAAY;EACZ;CACF;AACF"}

package/dist/rate-limiter/createRateLimitedValue.cjs

@@ -1,102 +0,0 @@
-const require_createRateLimitedSignal = require('./createRateLimitedSignal.cjs');
-let solid_js = require("solid-js");
-
-//#region src/rate-limiter/createRateLimitedValue.ts
-/**
-* A high-level Solid hook that creates a rate-limited version of a value that updates at most a certain number of times within a time window.
-* This hook uses Solid's createSignal internally to manage the rate-limited state.
-*
-* Rate limiting is a simple "hard limit" approach - it allows all updates until the limit is reached, then blocks
-* subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out
-* or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.
-*
-* The rate limiter supports two types of windows:
-* - 'fixed': A strict window that resets after the window period. All updates within the window count
-*   towards the limit, and the window resets completely after the period.
-* - 'sliding': A rolling window that allows updates as old ones expire. This provides a more
-*   consistent rate of updates over time.
-*
-* For smoother update patterns, consider:
-* - createThrottledValue: When you want consistent spacing between updates (e.g. UI changes)
-* - createDebouncedValue: When you want to collapse rapid updates into a single update (e.g. search input)
-*
-* Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.
-*
-* The hook returns a tuple containing:
-* - An accessor function that provides the rate-limited value
-* - The rate limiter instance with control methods
-*
-* For more direct control over rate limiting behavior without Solid state management,
-* consider using the lower-level createRateLimiter hook instead.
-*
-* ## State Management and Selector
-*
-* The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.
-* The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,
-* optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
-*
-* **By default, there will be no reactive state subscriptions** and you must opt-in to state
-* tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
-* full control over when your component subscribes to state changes. Only when you provide a selector will
-* the reactive system track the selected state values.
-*
-* Available rate limiter state properties:
-* - `executionCount`: Number of function executions that have been completed
-* - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations
-* - `rejectionCount`: Number of function executions that have been rejected due to rate limiting
-*
-* @example
-* ```tsx
-* // Default behavior - no reactive state subscriptions
-* const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {
-*   limit: 5,
-*   window: 60000,
-*   windowType: 'sliding'
-* });
-*
-* // Opt-in to reactive updates when execution count changes (optimized for tracking successful updates)
-* const [rateLimitedValue, rateLimiter] = createRateLimitedValue(
-*   rawValue,
-*   { limit: 5, window: 60000, windowType: 'sliding' },
-*   (state) => ({ executionCount: state.executionCount })
-* );
-*
-* // Opt-in to reactive updates when rejection count changes (optimized for tracking rate limit violations)
-* const [rateLimitedValue, rateLimiter] = createRateLimitedValue(
-*   rawValue,
-*   { limit: 5, window: 60000, windowType: 'sliding' },
-*   (state) => ({ rejectionCount: state.rejectionCount })
-* );
-*
-* // Opt-in to reactive updates when execution times change (optimized for window calculations)
-* const [rateLimitedValue, rateLimiter] = createRateLimitedValue(
-*   rawValue,
-*   { limit: 5, window: 60000, windowType: 'sliding' },
-*   (state) => ({ executionTimes: state.executionTimes })
-* );
-*
-* // With rejection callback and fixed window
-* const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {
-*   limit: 3,
-*   window: 5000,
-*   windowType: 'fixed',
-*   onReject: (rateLimiter) => {
-*     console.log(`Update rejected. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
-*   }
-* });
-*
-* // Access the selected rate limiter state (will be empty object {} unless selector provided)
-* const { executionCount, rejectionCount } = rateLimiter.state;
-* ```
-*/
-function createRateLimitedValue(value, initialOptions, selector) {
-	const [rateLimitedValue, setRateLimitedValue, rateLimiter] = require_createRateLimitedSignal.createRateLimitedSignal(value(), initialOptions, selector);
-	(0, solid_js.createEffect)(() => {
-		setRateLimitedValue(value());
-	});
-	return [rateLimitedValue, rateLimiter];
-}
-
-//#endregion
-exports.createRateLimitedValue = createRateLimitedValue;
-//# sourceMappingURL=createRateLimitedValue.cjs.map

package/dist/rate-limiter/createRateLimitedValue.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRateLimitedValue.cjs","names":["createRateLimitedSignal"],"sources":["../../src/rate-limiter/createRateLimitedValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createRateLimitedSignal } from './createRateLimitedSignal'\nimport type {\n  SolidRateLimiter,\n  SolidRateLimiterOptions,\n} from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { RateLimiterState } from '@tanstack/pacer/rate-limiter'\n\n/**\n * A high-level Solid hook that creates a rate-limited version of a value that updates at most a certain number of times within a time window.\n * This hook uses Solid's createSignal internally to manage the rate-limited state.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledValue: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedValue: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the rate-limited value\n * - The rate limiter instance with control methods\n *\n * For more direct control over rate limiting behavior without Solid state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.\n * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,\n * optimizing performance by preventing unnecessary subscriptions 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 reactive updates and gives you\n * full control over when your component subscribes to state changes. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available rate limiter 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 * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Opt-in to reactive updates when execution count changes (optimized for tracking successful updates)\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(\n *   rawValue,\n *   { limit: 5, window: 60000, windowType: 'sliding' },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Opt-in to reactive updates when rejection count changes (optimized for tracking rate limit violations)\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(\n *   rawValue,\n *   { limit: 5, window: 60000, windowType: 'sliding' },\n *   (state) => ({ rejectionCount: state.rejectionCount })\n * );\n *\n * // Opt-in to reactive updates when execution times change (optimized for window calculations)\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(\n *   rawValue,\n *   { limit: 5, window: 60000, windowType: 'sliding' },\n *   (state) => ({ executionTimes: state.executionTimes })\n * );\n *\n * // With rejection callback and fixed window\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {\n *   limit: 3,\n *   window: 5000,\n *   windowType: 'fixed',\n *   onReject: (rateLimiter) => {\n *     console.log(`Update rejected. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access the selected rate limiter state (will be empty object {} unless selector provided)\n * const { executionCount, rejectionCount } = rateLimiter.state;\n * ```\n */\nexport function createRateLimitedValue<TValue, TSelected = {}>(\n  value: Accessor<TValue>,\n  initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>] {\n  const [rateLimitedValue, setRateLimitedValue, rateLimiter] =\n    createRateLimitedSignal(value(), initialOptions, selector)\n\n  createEffect(() => {\n    setRateLimitedValue(value() as any)\n  })\n\n  return [rateLimitedValue, rateLimiter]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGA,SAAgB,uBACd,OACA,gBACA,UACiE;CACjE,MAAM,CAAC,kBAAkB,qBAAqB,eAC5CA,wDAAwB,MAAM,GAAG,gBAAgB,QAAQ;CAE3D,iCAAmB;EACjB,oBAAoB,MAAM,CAAQ;CACpC,CAAC;CAED,OAAO,CAAC,kBAAkB,WAAW;AACvC"}

package/dist/rate-limiter/createRateLimitedValue.d.cts

@@ -1,95 +0,0 @@
-import { SolidRateLimiter, SolidRateLimiterOptions } from "./createRateLimiter.cjs";
-import { Accessor, Setter } from "solid-js";
-import { RateLimiterState } from "@tanstack/pacer/rate-limiter";
-//#region src/rate-limiter/createRateLimitedValue.d.ts
-/**
- * A high-level Solid hook that creates a rate-limited version of a value that updates at most a certain number of times within a time window.
- * This hook uses Solid's createSignal internally to manage the rate-limited state.
- *
- * Rate limiting is a simple "hard limit" approach - it allows all updates until the limit is reached, then blocks
- * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out
- * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.
- *
- * The rate limiter supports two types of windows:
- * - 'fixed': A strict window that resets after the window period. All updates within the window count
- *   towards the limit, and the window resets completely after the period.
- * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more
- *   consistent rate of updates over time.
- *
- * For smoother update patterns, consider:
- * - createThrottledValue: When you want consistent spacing between updates (e.g. UI changes)
- * - createDebouncedValue: When you want to collapse rapid updates into a single update (e.g. search input)
- *
- * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.
- *
- * The hook returns a tuple containing:
- * - An accessor function that provides the rate-limited value
- * - The rate limiter instance with control methods
- *
- * For more direct control over rate limiting behavior without Solid state management,
- * consider using the lower-level createRateLimiter hook instead.
- *
- * ## State Management and Selector
- *
- * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.
- * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,
- * optimizing performance by preventing unnecessary subscriptions when irrelevant state changes occur.
- *
- * **By default, there will be no reactive state subscriptions** and you must opt-in to state
- * tracking by providing a selector function. This prevents unnecessary reactive updates and gives you
- * full control over when your component subscribes to state changes. Only when you provide a selector will
- * the reactive system track the selected state values.
- *
- * Available rate limiter state properties:
- * - `executionCount`: Number of function executions that have been completed
- * - `executionTimes`: Array of timestamps when executions occurred for rate limiting calculations
- * - `rejectionCount`: Number of function executions that have been rejected due to rate limiting
- *
- * @example
- * ```tsx
- * // Default behavior - no reactive state subscriptions
- * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {
- *   limit: 5,
- *   window: 60000,
- *   windowType: 'sliding'
- * });
- *
- * // Opt-in to reactive updates when execution count changes (optimized for tracking successful updates)
- * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(
- *   rawValue,
- *   { limit: 5, window: 60000, windowType: 'sliding' },
- *   (state) => ({ executionCount: state.executionCount })
- * );
- *
- * // Opt-in to reactive updates when rejection count changes (optimized for tracking rate limit violations)
- * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(
- *   rawValue,
- *   { limit: 5, window: 60000, windowType: 'sliding' },
- *   (state) => ({ rejectionCount: state.rejectionCount })
- * );
- *
- * // Opt-in to reactive updates when execution times change (optimized for window calculations)
- * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(
- *   rawValue,
- *   { limit: 5, window: 60000, windowType: 'sliding' },
- *   (state) => ({ executionTimes: state.executionTimes })
- * );
- *
- * // With rejection callback and fixed window
- * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {
- *   limit: 3,
- *   window: 5000,
- *   windowType: 'fixed',
- *   onReject: (rateLimiter) => {
- *     console.log(`Update rejected. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);
- *   }
- * });
- *
- * // Access the selected rate limiter state (will be empty object {} unless selector provided)
- * const { executionCount, rejectionCount } = rateLimiter.state;
- * ```
- */
-declare function createRateLimitedValue<TValue, TSelected = {}>(value: Accessor<TValue>, initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>, selector?: (state: RateLimiterState) => TSelected): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>];
-//#endregion
-export { createRateLimitedValue };
-//# sourceMappingURL=createRateLimitedValue.d.cts.map

package/dist/rate-limiter/createRateLimitedValue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createRateLimitedValue.js","names":[],"sources":["../../src/rate-limiter/createRateLimitedValue.ts"],"sourcesContent":["import { createEffect } from 'solid-js'\nimport { createRateLimitedSignal } from './createRateLimitedSignal'\nimport type {\n  SolidRateLimiter,\n  SolidRateLimiterOptions,\n} from './createRateLimiter'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { RateLimiterState } from '@tanstack/pacer/rate-limiter'\n\n/**\n * A high-level Solid hook that creates a rate-limited version of a value that updates at most a certain number of times within a time window.\n * This hook uses Solid's createSignal internally to manage the rate-limited state.\n *\n * Rate limiting is a simple \"hard limit\" approach - it allows all updates until the limit is reached, then blocks\n * subsequent updates until the window resets. Unlike throttling or debouncing, it does not attempt to space out\n * or intelligently collapse updates. This can lead to bursts of rapid updates followed by periods of no updates.\n *\n * The rate limiter supports two types of windows:\n * - 'fixed': A strict window that resets after the window period. All updates within the window count\n *   towards the limit, and the window resets completely after the period.\n * - 'sliding': A rolling window that allows updates as old ones expire. This provides a more\n *   consistent rate of updates over time.\n *\n * For smoother update patterns, consider:\n * - createThrottledValue: When you want consistent spacing between updates (e.g. UI changes)\n * - createDebouncedValue: When you want to collapse rapid updates into a single update (e.g. search input)\n *\n * Rate limiting should primarily be used when you need to enforce strict limits, like API rate limits.\n *\n * The hook returns a tuple containing:\n * - An accessor function that provides the rate-limited value\n * - The rate limiter instance with control methods\n *\n * For more direct control over rate limiting behavior without Solid state management,\n * consider using the lower-level createRateLimiter hook instead.\n *\n * ## State Management and Selector\n *\n * The hook uses TanStack Store for reactive state management via the underlying rate limiter instance.\n * The `selector` parameter allows you to specify which rate limiter state changes will trigger reactive updates,\n * optimizing performance by preventing unnecessary subscriptions 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 reactive updates and gives you\n * full control over when your component subscribes to state changes. Only when you provide a selector will\n * the reactive system track the selected state values.\n *\n * Available rate limiter 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 * @example\n * ```tsx\n * // Default behavior - no reactive state subscriptions\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {\n *   limit: 5,\n *   window: 60000,\n *   windowType: 'sliding'\n * });\n *\n * // Opt-in to reactive updates when execution count changes (optimized for tracking successful updates)\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(\n *   rawValue,\n *   { limit: 5, window: 60000, windowType: 'sliding' },\n *   (state) => ({ executionCount: state.executionCount })\n * );\n *\n * // Opt-in to reactive updates when rejection count changes (optimized for tracking rate limit violations)\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(\n *   rawValue,\n *   { limit: 5, window: 60000, windowType: 'sliding' },\n *   (state) => ({ rejectionCount: state.rejectionCount })\n * );\n *\n * // Opt-in to reactive updates when execution times change (optimized for window calculations)\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(\n *   rawValue,\n *   { limit: 5, window: 60000, windowType: 'sliding' },\n *   (state) => ({ executionTimes: state.executionTimes })\n * );\n *\n * // With rejection callback and fixed window\n * const [rateLimitedValue, rateLimiter] = createRateLimitedValue(rawValue, {\n *   limit: 3,\n *   window: 5000,\n *   windowType: 'fixed',\n *   onReject: (rateLimiter) => {\n *     console.log(`Update rejected. Try again in ${rateLimiter.getMsUntilNextWindow()}ms`);\n *   }\n * });\n *\n * // Access the selected rate limiter state (will be empty object {} unless selector provided)\n * const { executionCount, rejectionCount } = rateLimiter.state;\n * ```\n */\nexport function createRateLimitedValue<TValue, TSelected = {}>(\n  value: Accessor<TValue>,\n  initialOptions: SolidRateLimiterOptions<Setter<TValue>, TSelected>,\n  selector?: (state: RateLimiterState) => TSelected,\n): [Accessor<TValue>, SolidRateLimiter<Setter<TValue>, TSelected>] {\n  const [rateLimitedValue, setRateLimitedValue, rateLimiter] =\n    createRateLimitedSignal(value(), initialOptions, selector)\n\n  createEffect(() => {\n    setRateLimitedValue(value() as any)\n  })\n\n  return [rateLimitedValue, rateLimiter]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGA,SAAgB,uBACd,OACA,gBACA,UACiE;CACjE,MAAM,CAAC,kBAAkB,qBAAqB,eAC5C,wBAAwB,MAAM,GAAG,gBAAgB,QAAQ;CAE3D,mBAAmB;EACjB,oBAAoB,MAAM,CAAQ;CACpC,CAAC;CAED,OAAO,CAAC,kBAAkB,WAAW;AACvC"}