@tanstack/solid-pacer 0.2.0

package/dist/esm/throttler/createThrottledSignal.js

@@ -0,0 +1,11 @@
+import { createSignal } from "solid-js";
+import { createThrottler } from "./createThrottler.js";
+function createThrottledSignal(value, initialOptions) {
+  const [throttledValue, setThrottledValue] = createSignal(value);
+  const throttler = createThrottler(setThrottledValue, initialOptions);
+  return [throttledValue, throttler.maybeExecute, throttler];
+}
+export {
+  createThrottledSignal
+};
+//# sourceMappingURL=createThrottledSignal.js.map

package/dist/esm/throttler/createThrottledSignal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createThrottledSignal.js","sources":["../../../src/throttler/createThrottledSignal.ts"],"sourcesContent":["import { createSignal } from 'solid-js'\nimport { createThrottler } from './createThrottler'\nimport type { SolidThrottler } from './createThrottler'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { ThrottlerOptions } from '@tanstack/pacer/throttler'\n\n/**\n * A Solid hook that creates a throttled state value that updates at most once within a specified time window.\n * This hook combines Solid's createSignal 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 accessor\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 createThrottler hook instead.\n *\n * @example\n * ```tsx\n * // Basic throttling - update state at most once per second\n * const [value, setValue, throttler] = createThrottledSignal(0, { wait: 1000 });\n *\n * // With custom leading/trailing behavior\n * const [value, setValue] = createThrottledSignal(0, {\n *   wait: 1000,\n *   leading: true,   // Update immediately on first change\n *   trailing: false  // Skip trailing edge updates\n * });\n *\n * // Access throttler state via signals\n * console.log('Executions:', throttler.executionCount());\n * console.log('Is pending:', throttler.isPending());\n * console.log('Last execution:', throttler.lastExecutionTime());\n * console.log('Next execution:', throttler.nextExecutionTime());\n * ```\n */\nexport function createThrottledSignal<TValue>(\n  value: TValue,\n  initialOptions: ThrottlerOptions<Setter<TValue>, [Accessor<TValue>]>,\n): [\n  Accessor<TValue>,\n  Setter<TValue>,\n  SolidThrottler<Setter<TValue>, [Accessor<TValue>]>,\n] {\n  const [throttledValue, setThrottledValue] = createSignal<TValue>(value)\n  const throttler = createThrottler(setThrottledValue, initialOptions)\n  return [throttledValue, throttler.maybeExecute as Setter<TValue>, throttler]\n}\n"],"names":[],"mappings":";;AAwCgB,SAAA,sBACd,OACA,gBAKA;AACA,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,aAAqB,KAAK;AAChE,QAAA,YAAY,gBAAgB,mBAAmB,cAAc;AACnE,SAAO,CAAC,gBAAgB,UAAU,cAAgC,SAAS;AAC7E;"}

package/dist/esm/throttler/createThrottledValue.d.ts

@@ -0,0 +1,36 @@
+import { SolidThrottler } from './createThrottler.js';
+import { Accessor, Setter } from 'solid-js';
+import { ThrottlerOptions } from '@tanstack/pacer/throttler';
+/**
+ * A high-level Solid hook that creates a throttled version of a value that updates at most once within a specified time window.
+ * This hook uses Solid's createSignal internally to manage the throttled state.
+ *
+ * Throttling ensures the value updates occur at a controlled rate regardless of how frequently the input value changes.
+ * This is useful for rate-limiting expensive re-renders or API calls that depend on rapidly changing values.
+ *
+ * The hook returns both the throttled value and the underlying throttler instance for additional control.
+ * The throttled value will update according to the leading/trailing edge behavior specified in the options.
+ *
+ * For more direct control over throttling behavior without Solid state management,
+ * consider using the lower-level createThrottler hook instead.
+ *
+ * @example
+ * ```tsx
+ * // Basic throttling - update at most once per second
+ * const [throttledValue] = createThrottledValue(rawValue, { wait: 1000 });
+ *
+ * // With custom leading/trailing behavior
+ * const [throttledValue, throttler] = createThrottledValue(rawValue, {
+ *   wait: 1000,
+ *   leading: true,   // Update immediately on first change
+ *   trailing: false  // Skip trailing edge updates
+ * });
+ *
+ * // Access throttler state via signals
+ * console.log('Executions:', throttler.executionCount());
+ * console.log('Is pending:', throttler.isPending());
+ * console.log('Last execution:', throttler.lastExecutionTime());
+ * console.log('Next execution:', throttler.nextExecutionTime());
+ * ```
+ */
+export declare function createThrottledValue<TValue>(value: Accessor<TValue>, initialOptions: ThrottlerOptions<Setter<TValue>, [Accessor<TValue>]>): [Accessor<TValue>, SolidThrottler<Setter<TValue>, [Accessor<TValue>]>];

package/dist/esm/throttler/createThrottledValue.js

@@ -0,0 +1,19 @@
+import { createEffect, onCleanup } from "solid-js";
+import { createThrottledSignal } from "./createThrottledSignal.js";
+function createThrottledValue(value, initialOptions) {
+  const [throttledValue, setThrottledValue, throttler] = createThrottledSignal(
+    value(),
+    initialOptions
+  );
+  createEffect(() => {
+    setThrottledValue(value());
+    onCleanup(() => {
+      throttler.cancel();
+    });
+  });
+  return [throttledValue, throttler];
+}
+export {
+  createThrottledValue
+};
+//# sourceMappingURL=createThrottledValue.js.map

package/dist/esm/throttler/createThrottledValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createThrottledValue.js","sources":["../../../src/throttler/createThrottledValue.ts"],"sourcesContent":["import { createEffect, onCleanup } from 'solid-js'\nimport { createThrottledSignal } from './createThrottledSignal'\nimport type { SolidThrottler } from './createThrottler'\nimport type { Accessor, Setter } from 'solid-js'\nimport type { ThrottlerOptions } from '@tanstack/pacer/throttler'\n\n/**\n * A high-level Solid hook that creates a throttled version of a value that updates at most once within a specified time window.\n * This hook uses Solid's createSignal 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 both the throttled value and the underlying throttler instance for additional control.\n * The throttled value will update according to the leading/trailing edge behavior specified in the options.\n *\n * For more direct control over throttling behavior without Solid state management,\n * consider using the lower-level createThrottler hook instead.\n *\n * @example\n * ```tsx\n * // Basic throttling - update at most once per second\n * const [throttledValue] = createThrottledValue(rawValue, { wait: 1000 });\n *\n * // With custom leading/trailing behavior\n * const [throttledValue, throttler] = createThrottledValue(rawValue, {\n *   wait: 1000,\n *   leading: true,   // Update immediately on first change\n *   trailing: false  // Skip trailing edge updates\n * });\n *\n * // Access throttler state via signals\n * console.log('Executions:', throttler.executionCount());\n * console.log('Is pending:', throttler.isPending());\n * console.log('Last execution:', throttler.lastExecutionTime());\n * console.log('Next execution:', throttler.nextExecutionTime());\n * ```\n */\nexport function createThrottledValue<TValue>(\n  value: Accessor<TValue>,\n  initialOptions: ThrottlerOptions<Setter<TValue>, [Accessor<TValue>]>,\n): [Accessor<TValue>, SolidThrottler<Setter<TValue>, [Accessor<TValue>]>] {\n  const [throttledValue, setThrottledValue, throttler] = createThrottledSignal(\n    value(),\n    initialOptions,\n  )\n\n  createEffect(() => {\n    setThrottledValue(value() as any)\n    onCleanup(() => {\n      throttler.cancel()\n    })\n  })\n\n  return [throttledValue, throttler]\n}\n"],"names":[],"mappings":";;AAsCgB,SAAA,qBACd,OACA,gBACwE;AACxE,QAAM,CAAC,gBAAgB,mBAAmB,SAAS,IAAI;AAAA,IACrD,MAAM;AAAA,IACN;AAAA,EACF;AAEA,eAAa,MAAM;AACjB,sBAAkB,OAAc;AAChC,cAAU,MAAM;AACd,gBAAU,OAAO;AAAA,IAAA,CAClB;AAAA,EAAA,CACF;AAEM,SAAA,CAAC,gBAAgB,SAAS;AACnC;"}

package/dist/esm/throttler/createThrottler.d.ts

@@ -0,0 +1,47 @@
+import { Throttler, ThrottlerOptions } from '@tanstack/pacer/throttler';
+import { Accessor } from 'solid-js';
+import { AnyFunction } from '@tanstack/pacer/types';
+/**
+ * An extension of the Throttler class that adds Solid signals to access the internal state of the throttler
+ */
+export interface SolidThrottler<TFn extends AnyFunction, TArgs extends Parameters<TFn>> extends Omit<Throttler<TFn, TArgs>, 'getExecutionCount' | 'getIsPending' | 'getLastExecutionTime' | 'getNextExecutionTime'> {
+    executionCount: Accessor<number>;
+    isPending: Accessor<boolean>;
+    lastExecutionTime: Accessor<number>;
+    nextExecutionTime: Accessor<number>;
+}
+/**
+ * A low-level Solid hook that creates a `Throttler` instance that limits how often the provided function can execute.
+ *
+ * This hook is designed to be flexible and state-management agnostic - it simply returns a throttler instance that
+ * you can integrate with any state management solution (createSignal, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that
+ * integrates directly with Solid's createSignal, see createThrottledSignal.
+ *
+ * Throttling ensures a function executes at most once within a specified time window,
+ * regardless of how many times it is called. This is useful for rate-limiting
+ * expensive operations or UI updates.
+ *
+ * @example
+ * ```tsx
+ * // Basic throttling with custom state
+ * const [value, setValue] = createSignal(0);
+ * const throttler = createThrottler(setValue, { wait: 1000 });
+ *
+ * // With any state manager
+ * const throttler = createThrottler(
+ *   (value) => stateManager.setState(value),
+ *   {
+ *     wait: 2000,
+ *     leading: true,   // Execute immediately on first call
+ *     trailing: false  // Skip trailing edge updates
+ *   }
+ * );
+ *
+ * // Access throttler state via signals
+ * console.log(throttler.executionCount()); // number of times executed
+ * console.log(throttler.isPending());      // whether throttled function is pending
+ * console.log(throttler.lastExecutionTime()); // timestamp of last execution
+ * console.log(throttler.nextExecutionTime()); // timestamp of next allowed execution
+ * ```
+ */
+export declare function createThrottler<TFn extends AnyFunction, TArgs extends Parameters<TFn>>(fn: TFn, initialOptions: ThrottlerOptions<TFn, TArgs>): SolidThrottler<TFn, TArgs>;

package/dist/esm/throttler/createThrottler.js

@@ -0,0 +1,42 @@
+import { Throttler } from "@tanstack/pacer/throttler";
+import { createSignal } from "solid-js";
+import { bindInstanceMethods } from "@tanstack/pacer/utils";
+function createThrottler(fn, initialOptions) {
+  const throttler = new Throttler(fn, initialOptions);
+  const [executionCount, setExecutionCount] = createSignal(
+    throttler.getExecutionCount()
+  );
+  const [isPending, setIsPending] = createSignal(throttler.getIsPending());
+  const [lastExecutionTime, setLastExecutionTime] = createSignal(
+    throttler.getLastExecutionTime()
+  );
+  const [nextExecutionTime, setNextExecutionTime] = createSignal(
+    throttler.getNextExecutionTime()
+  );
+  function setOptions(newOptions) {
+    throttler.setOptions({
+      ...newOptions,
+      onExecute: (throttler2) => {
+        setExecutionCount(throttler2.getExecutionCount());
+        setIsPending(throttler2.getIsPending());
+        setLastExecutionTime(throttler2.getLastExecutionTime());
+        setNextExecutionTime(throttler2.getNextExecutionTime());
+        const onExecute = newOptions.onExecute ?? initialOptions.onExecute;
+        onExecute == null ? void 0 : onExecute(throttler2);
+      }
+    });
+  }
+  setOptions(initialOptions);
+  return {
+    ...bindInstanceMethods(throttler),
+    executionCount,
+    isPending,
+    lastExecutionTime,
+    nextExecutionTime,
+    setOptions
+  };
+}
+export {
+  createThrottler
+};
+//# sourceMappingURL=createThrottler.js.map

package/dist/esm/throttler/createThrottler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createThrottler.js","sources":["../../../src/throttler/createThrottler.ts"],"sourcesContent":["import { Throttler } from '@tanstack/pacer/throttler'\nimport { createSignal } from 'solid-js'\nimport { bindInstanceMethods } from '@tanstack/pacer/utils'\nimport type { Accessor } from 'solid-js'\nimport type { AnyFunction } from '@tanstack/pacer/types'\nimport type { ThrottlerOptions } from '@tanstack/pacer/throttler'\n\n/**\n * An extension of the Throttler class that adds Solid signals to access the internal state of the throttler\n */\nexport interface SolidThrottler<\n  TFn extends AnyFunction,\n  TArgs extends Parameters<TFn>,\n> extends Omit<\n    Throttler<TFn, TArgs>,\n    | 'getExecutionCount'\n    | 'getIsPending'\n    | 'getLastExecutionTime'\n    | 'getNextExecutionTime'\n  > {\n  executionCount: Accessor<number>\n  isPending: Accessor<boolean>\n  lastExecutionTime: Accessor<number>\n  nextExecutionTime: Accessor<number>\n}\n\n/**\n * A low-level Solid 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 (createSignal, Redux, Zustand, Jotai, etc). For a simpler and higher-level hook that\n * integrates directly with Solid's createSignal, see createThrottledSignal.\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 * @example\n * ```tsx\n * // Basic throttling with custom state\n * const [value, setValue] = createSignal(0);\n * const throttler = createThrottler(setValue, { wait: 1000 });\n *\n * // With any state manager\n * const throttler = createThrottler(\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 throttler state via signals\n * console.log(throttler.executionCount()); // number of times executed\n * console.log(throttler.isPending());      // whether throttled function is pending\n * console.log(throttler.lastExecutionTime()); // timestamp of last execution\n * console.log(throttler.nextExecutionTime()); // timestamp of next allowed execution\n * ```\n */\nexport function createThrottler<\n  TFn extends AnyFunction,\n  TArgs extends Parameters<TFn>,\n>(\n  fn: TFn,\n  initialOptions: ThrottlerOptions<TFn, TArgs>,\n): SolidThrottler<TFn, TArgs> {\n  const throttler = new Throttler<TFn, TArgs>(fn, initialOptions)\n\n  const [executionCount, setExecutionCount] = createSignal(\n    throttler.getExecutionCount(),\n  )\n  const [isPending, setIsPending] = createSignal(throttler.getIsPending())\n  const [lastExecutionTime, setLastExecutionTime] = createSignal(\n    throttler.getLastExecutionTime(),\n  )\n  const [nextExecutionTime, setNextExecutionTime] = createSignal(\n    throttler.getNextExecutionTime(),\n  )\n\n  function setOptions(newOptions: Partial<ThrottlerOptions<TFn, TArgs>>) {\n    throttler.setOptions({\n      ...newOptions,\n      onExecute: (throttler) => {\n        setExecutionCount(throttler.getExecutionCount())\n        setIsPending(throttler.getIsPending())\n        setLastExecutionTime(throttler.getLastExecutionTime())\n        setNextExecutionTime(throttler.getNextExecutionTime())\n\n        const onExecute = newOptions.onExecute ?? initialOptions.onExecute\n        onExecute?.(throttler)\n      },\n    })\n  }\n\n  setOptions(initialOptions)\n\n  return {\n    ...bindInstanceMethods(throttler),\n    executionCount,\n    isPending,\n    lastExecutionTime,\n    nextExecutionTime,\n    setOptions,\n  }\n}\n"],"names":["throttler"],"mappings":";;;AA4DgB,SAAA,gBAId,IACA,gBAC4B;AAC5B,QAAM,YAAY,IAAI,UAAsB,IAAI,cAAc;AAExD,QAAA,CAAC,gBAAgB,iBAAiB,IAAI;AAAA,IAC1C,UAAU,kBAAkB;AAAA,EAC9B;AACA,QAAM,CAAC,WAAW,YAAY,IAAI,aAAa,UAAU,cAAc;AACjE,QAAA,CAAC,mBAAmB,oBAAoB,IAAI;AAAA,IAChD,UAAU,qBAAqB;AAAA,EACjC;AACM,QAAA,CAAC,mBAAmB,oBAAoB,IAAI;AAAA,IAChD,UAAU,qBAAqB;AAAA,EACjC;AAEA,WAAS,WAAW,YAAmD;AACrE,cAAU,WAAW;AAAA,MACnB,GAAG;AAAA,MACH,WAAW,CAACA,eAAc;AACNA,0BAAAA,WAAU,mBAAmB;AAClCA,qBAAAA,WAAU,cAAc;AAChBA,6BAAAA,WAAU,sBAAsB;AAChCA,6BAAAA,WAAU,sBAAsB;AAE/C,cAAA,YAAY,WAAW,aAAa,eAAe;AACzD,+CAAYA;AAAAA,MAAS;AAAA,IACvB,CACD;AAAA,EAAA;AAGH,aAAW,cAAc;AAElB,SAAA;AAAA,IACL,GAAG,oBAAoB,SAAS;AAAA,IAChC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;"}

package/dist/esm/throttler/index.d.ts

@@ -0,0 +1,4 @@
+export * from '@tanstack/pacer/throttler';
+export * from './createThrottledSignal.js';
+export * from './createThrottledValue.js';
+export * from './createThrottler.js';

package/dist/esm/throttler/index.js

@@ -0,0 +1,10 @@
+export * from "@tanstack/pacer/throttler";
+import { createThrottledSignal } from "./createThrottledSignal.js";
+import { createThrottledValue } from "./createThrottledValue.js";
+import { createThrottler } from "./createThrottler.js";
+export {
+  createThrottledSignal,
+  createThrottledValue,
+  createThrottler
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/throttler/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/esm/types/index.d.ts

@@ -0,0 +1 @@
+export * from '@tanstack/pacer/types';

package/dist/esm/types/index.js

@@ -0,0 +1,2 @@
+export * from "@tanstack/pacer/types";
+//# sourceMappingURL=index.js.map

package/dist/esm/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1 @@
+export * from '@tanstack/pacer/utils';

package/dist/esm/utils/index.js

@@ -0,0 +1,2 @@
+export * from "@tanstack/pacer/utils";
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/package.json

@@ -0,0 +1,163 @@
+{
+  "name": "@tanstack/solid-pacer",
+  "version": "0.2.0",
+  "description": "Utilities for debouncing and throttling functions in Solid.",
+  "author": "Tanner Linsley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TanStack/pacer.git",
+    "directory": "packages/solid-pacer"
+  },
+  "homepage": "https://tanstack.com/pacer",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "keywords": [
+    "solid",
+    "debounce",
+    "throttle",
+    "rate-limit",
+    "queue",
+    "async"
+  ],
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./async-debouncer": {
+      "import": {
+        "types": "./dist/esm/async-debouncer/index.d.ts",
+        "default": "./dist/esm/async-debouncer/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/async-debouncer/index.d.cts",
+        "default": "./dist/cjs/async-debouncer/index.cjs"
+      }
+    },
+    "./async-queuer": {
+      "import": {
+        "types": "./dist/esm/async-queuer/index.d.ts",
+        "default": "./dist/esm/async-queuer/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/async-queuer/index.d.cts",
+        "default": "./dist/cjs/async-queuer/index.cjs"
+      }
+    },
+    "./async-rate-limiter": {
+      "import": {
+        "types": "./dist/esm/async-rate-limiter/index.d.ts",
+        "default": "./dist/esm/async-rate-limiter/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/async-rate-limiter/index.d.cts",
+        "default": "./dist/cjs/async-rate-limiter/index.cjs"
+      }
+    },
+    "./async-throttler": {
+      "import": {
+        "types": "./dist/esm/async-throttler/index.d.ts",
+        "default": "./dist/esm/async-throttler/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/async-throttler/index.d.cts",
+        "default": "./dist/cjs/async-throttler/index.cjs"
+      }
+    },
+    "./debouncer": {
+      "import": {
+        "types": "./dist/esm/debouncer/index.d.ts",
+        "default": "./dist/esm/debouncer/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/debouncer/index.d.cts",
+        "default": "./dist/cjs/debouncer/index.cjs"
+      }
+    },
+    "./queuer": {
+      "import": {
+        "types": "./dist/esm/queuer/index.d.ts",
+        "default": "./dist/esm/queuer/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/queuer/index.d.cts",
+        "default": "./dist/cjs/queuer/index.cjs"
+      }
+    },
+    "./rate-limiter": {
+      "import": {
+        "types": "./dist/esm/rate-limiter/index.d.ts",
+        "default": "./dist/esm/rate-limiter/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/rate-limiter/index.d.cts",
+        "default": "./dist/cjs/rate-limiter/index.cjs"
+      }
+    },
+    "./throttler": {
+      "import": {
+        "types": "./dist/esm/throttler/index.d.ts",
+        "default": "./dist/esm/throttler/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/throttler/index.d.cts",
+        "default": "./dist/cjs/throttler/index.cjs"
+      }
+    },
+    "./types": {
+      "types": "./dist/esm/types/index.d.ts",
+      "default": "./dist/esm/types/index.js"
+    },
+    "./utils": {
+      "import": {
+        "types": "./dist/esm/utils/index.d.ts",
+        "default": "./dist/esm/utils/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/utils/index.d.cts",
+        "default": "./dist/cjs/utils/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@tanstack/pacer": "0.2.0"
+  },
+  "devDependencies": {
+    "solid-js": "^1.9.5",
+    "vite-plugin-solid": "^2.11.6"
+  },
+  "peerDependencies": {
+    "solid-js": ">=1.9.5"
+  },
+  "scripts": {
+    "clean": "premove ./build ./dist",
+    "test:eslint": "eslint ./src",
+    "test:lib": "vitest --passWithNoTests",
+    "test:lib:dev": "pnpm test:lib --watch",
+    "test:types": "tsc",
+    "test:build": "publint --strict",
+    "build": "vite build"
+  }
+}

package/src/async-debouncer/createAsyncDebouncer.ts

@@ -0,0 +1,89 @@
+import { AsyncDebouncer } from '@tanstack/pacer/async-debouncer'
+import { createSignal } from 'solid-js'
+import { bindInstanceMethods } from '@tanstack/pacer/utils'
+import type { AsyncDebouncerOptions } from '@tanstack/pacer/async-debouncer'
+import type { AnyAsyncFunction } from '@tanstack/pacer/types'
+import type { Accessor } from 'solid-js'
+
+export interface SolidAsyncDebouncer<
+  TFn extends AnyAsyncFunction,
+  TArgs extends Parameters<TFn>,
+> extends Omit<
+    AsyncDebouncer<TFn, TArgs>,
+    'getExecutionCount' | 'getIsPending'
+  > {
+  executionCount: Accessor<number>
+  isPending: Accessor<boolean>
+}
+
+/**
+ * A low-level Solid hook that creates an `AsyncDebouncer` instance to delay execution of an async function.
+ *
+ * This hook is designed to be flexible and state-management agnostic - it simply returns a debouncer instance that
+ * you can integrate with any state management solution (createSignal, etc).
+ *
+ * Async debouncing ensures that an async function only executes after a specified delay has passed since its last invocation.
+ * This is useful for handling fast-changing inputs like search fields, form validation, or any scenario where you want to
+ * wait for user input to settle before making expensive async calls.
+ *
+ * @example
+ * ```tsx
+ * // Basic API call debouncing
+ * const { maybeExecute } = createAsyncDebouncer(
+ *   async (query: string) => {
+ *     const results = await api.search(query);
+ *     return results;
+ *   },
+ *   { wait: 500 }
+ * );
+ *
+ * // With state management
+ * const [results, setResults] = createSignal([]);
+ * const { maybeExecute } = createAsyncDebouncer(
+ *   async (searchTerm) => {
+ *     const data = await searchAPI(searchTerm);
+ *     setResults(data);
+ *   },
+ *   {
+ *     wait: 300,
+ *   }
+ * );
+ * ```
+ */
+
+export function createAsyncDebouncer<
+  TFn extends AnyAsyncFunction,
+  TArgs extends Parameters<TFn>,
+>(
+  fn: TFn,
+  initialOptions: AsyncDebouncerOptions<TFn, TArgs>,
+): SolidAsyncDebouncer<TFn, TArgs> {
+  const asyncDebouncer = new AsyncDebouncer<TFn, TArgs>(fn, initialOptions)
+
+  const [executionCount, setExecutionCount] = createSignal(
+    asyncDebouncer.getExecutionCount(),
+  )
+  const [isPending, setIsPending] = createSignal(asyncDebouncer.getIsPending())
+
+  function setOptions(newOptions: Partial<AsyncDebouncerOptions<TFn, TArgs>>) {
+    asyncDebouncer.setOptions({
+      ...newOptions,
+      onExecute: (asyncDebouncer) => {
+        setExecutionCount(asyncDebouncer.getExecutionCount())
+        setIsPending(asyncDebouncer.getIsPending())
+
+        const onExecute = newOptions.onExecute ?? initialOptions.onExecute
+        onExecute?.(asyncDebouncer)
+      },
+    })
+  }
+
+  setOptions(initialOptions)
+
+  return {
+    ...bindInstanceMethods(asyncDebouncer),
+    executionCount,
+    isPending,
+    setOptions,
+  }
+}

package/src/async-debouncer/index.ts

@@ -0,0 +1,4 @@
+// re-export everything from the core pacer package, BUT ONLY from the async-debouncer module
+export * from '@tanstack/pacer/async-debouncer'
+
+export * from './createAsyncDebouncer'

package/src/async-queuer/createAsyncQueuer.ts

@@ -0,0 +1,175 @@
+import { AsyncQueuer } from '@tanstack/pacer/async-queuer'
+import { createSignal } from 'solid-js'
+import { bindInstanceMethods } from '@tanstack/pacer/utils'
+import type { Accessor } from 'solid-js'
+import type { AsyncQueuerOptions } from '@tanstack/pacer/async-queuer'
+
+export interface SolidAsyncQueuer<TValue>
+  extends Omit<
+    AsyncQueuer<TValue>,
+    | 'getActiveItems'
+    | 'getAllItems'
+    | 'getExecutionCount'
+    | 'getIsEmpty'
+    | 'getIsFull'
+    | 'getIsIdle'
+    | 'getIsRunning'
+    | 'getPeek'
+    | 'getPendingItems'
+    | 'getSize'
+  > {
+  /**
+   * Signal version of `getActiveItems`
+   */
+  activeItems: Accessor<Array<() => Promise<TValue>>>
+  /**
+   * Signal version of `getAllItems`
+   */
+  allItems: Accessor<Array<() => Promise<TValue>>>
+  /**
+   * Signal version of `getExecutionCount`
+   */
+  executionCount: Accessor<number>
+  /**
+   * Signal version of `getIsEmpty`
+   */
+  isEmpty: Accessor<boolean>
+  /**
+   * Signal version of `getIsFull`
+   */
+  isFull: Accessor<boolean>
+  /**
+   * Signal version of `getIsIdle`
+   */
+  isIdle: Accessor<boolean>
+  /**
+   * Signal version of `getIsRunning`
+   */
+  isRunning: Accessor<boolean>
+  /**
+   * Signal version of `getPeek`
+   */
+  peek: Accessor<TValue | undefined>
+  /**
+   * Signal version of `getPendingItems`
+   */
+  pendingItems: Accessor<Array<() => Promise<TValue>>>
+  /**
+   * Signal version of `getSize`
+   */
+  size: Accessor<number>
+}
+
+/**
+ * A lower-level React hook that creates an `AsyncQueuer` instance for managing an async queue of items.
+ *
+ * This hook provides a flexible, state-management agnostic way to handle queued async operations.
+ * It returns a queuer instance with methods to add items, control queue execution, and monitor queue state.
+ *
+ * The queue can be configured with:
+ * - Maximum concurrent operations
+ * - Maximum queue size
+ * - Processing function for queue items
+ * - Various lifecycle callbacks
+ *
+ * The hook returns an object containing methods to:
+ * - Add/remove items from the queue
+ * - Start/stop queue processing
+ * - Get queue status and items
+ * - Register event handlers
+ * - Control execution throttling
+ *
+ * @example
+ * ```tsx
+ * // Basic async queuer for API requests
+ * const asyncQueuer = createAsyncQueuer({
+ *   initialItems: [],
+ *   concurrency: 2,
+ *   maxSize: 100,
+ *   started: false,
+ * });
+ *
+ * // Add items to queue
+ * asyncQueuer.addItem(newItem);
+ *
+ * // Start processing
+ * asyncQueuer.start();
+ *
+ * // Handle results
+ * asyncQueuer.onSuccess((result) => {
+ *   console.log('Item processed:', result);
+ * });
+ *
+ * asyncQueuer.onError((error) => {
+ *   console.error('Processing failed:', error);
+ * });
+ * ```
+ */
+export function createAsyncQueuer<TValue>(
+  initialOptions: AsyncQueuerOptions<TValue> = {},
+): SolidAsyncQueuer<TValue> {
+  const asyncQueuer = new AsyncQueuer<TValue>(initialOptions)
+
+  const [executionCount, setExecutionCount] = createSignal(
+    asyncQueuer.getExecutionCount(),
+  )
+  const [rejectionCount, setRejectionCount] = createSignal(
+    asyncQueuer.getRejectionCount(),
+  )
+  const [isEmpty, setIsEmpty] = createSignal(asyncQueuer.getIsEmpty())
+  const [isFull, setIsFull] = createSignal(asyncQueuer.getIsFull())
+  const [isIdle, setIsIdle] = createSignal(asyncQueuer.getIsIdle())
+  const [isRunning, setIsRunning] = createSignal(asyncQueuer.getIsRunning())
+  const [allItems, setAllItems] = createSignal<Array<() => Promise<TValue>>>(
+    asyncQueuer.getAllItems(),
+  )
+  const [activeItems, setActiveItems] = createSignal<
+    Array<() => Promise<TValue>>
+  >(asyncQueuer.getActiveItems())
+  const [pendingItems, setPendingItems] = createSignal<
+    Array<() => Promise<TValue>>
+  >(asyncQueuer.getPendingItems())
+  const [peek, setPeek] = createSignal<(() => Promise<TValue>) | undefined>(
+    asyncQueuer.getPeek(),
+  )
+  const [size, setSize] = createSignal(asyncQueuer.getSize())
+
+  asyncQueuer.setOptions({
+    onItemsChange: (queuer) => {
+      setExecutionCount(queuer.getExecutionCount())
+      setIsEmpty(queuer.getIsEmpty())
+      setIsFull(queuer.getIsFull())
+      setIsIdle(queuer.getIsIdle())
+      setAllItems(queuer.getAllItems())
+      setActiveItems(queuer.getActiveItems())
+      setPendingItems(queuer.getPendingItems())
+      setPeek(() => queuer.getPeek())
+      setSize(queuer.getSize())
+      initialOptions.onItemsChange?.(queuer)
+    },
+    onIsRunningChange: (queuer) => {
+      setIsRunning(queuer.getIsRunning())
+      setIsIdle(queuer.getIsIdle())
+      initialOptions.onIsRunningChange?.(queuer)
+    },
+    onReject: (item, queuer) => {
+      setRejectionCount(queuer.getRejectionCount())
+      initialOptions.onReject?.(item, queuer)
+    },
+  })
+
+  return {
+    ...bindInstanceMethods(asyncQueuer),
+    activeItems,
+    executionCount,
+    isEmpty,
+    isFull,
+    isIdle,
+    isRunning,
+    allItems,
+    peek,
+    pendingItems,
+    rejectionCount,
+    size,
+  }
+}