@tanstack/angular-pacer 0.24.0 → 0.25.0

package/README.md

@@ -103,10 +103,10 @@ A lightweight timing and scheduling library for debouncing, throttling, rate lim
 > [!NOTE]
 > You may know **TanStack Pacer** by our adapter names, too!
 >
-> - [**React Pacer**](https://tanstack.com/pacer/latest/docs/framework/react/react-pacer)
-> - [**Preact Pacer**](https://tanstack.com/pacer/latest/docs/framework/preact/preact-pacer)
-> - [**Solid Pacer**](https://tanstack.com/pacer/latest/docs/framework/solid/solid-pacer)
-> - [**Angular Pacer**](https://tanstack.com/pacer/latest/docs/framework/angular/angular-pacer)
+> - [**React Pacer**](https://tanstack.com/pacer/latest/docs/framework/react)
+> - [**Preact Pacer**](https://tanstack.com/pacer/latest/docs/framework/preact)
+> - [**Solid Pacer**](https://tanstack.com/pacer/latest/docs/framework/solid)
+> - [**Angular Pacer**](https://tanstack.com/pacer/latest/docs/framework/angular)
 > - Svelte Pacer - needs a contributor!
 > - Vue Pacer - needs a contributor!
 

package/dist/async-batcher/injectAsyncBatchedCallback.d.ts

@@ -38,7 +38,5 @@ import { AsyncBatcherOptions } from "@tanstack/pacer/async-batcher";
  * await batchApiCall(data2);
  * ```
  */
-declare function injectAsyncBatchedCallback<TValue>(fn: (items: Array<TValue>) => Promise<any>, options: AsyncBatcherOptions<TValue>): (item: TValue) => Promise<void>;
-//#endregion
-export { injectAsyncBatchedCallback };
-//# sourceMappingURL=injectAsyncBatchedCallback.d.ts.map
+export declare function injectAsyncBatchedCallback<TValue>(fn: (items: Array<TValue>) => Promise<any>, options: AsyncBatcherOptions<TValue>): (item: TValue) => Promise<void>;
+//#endregion

package/dist/async-batcher/injectAsyncBatchedCallback.js

@@ -45,5 +45,4 @@ function injectAsyncBatchedCallback(fn, options) {
 }
 
 //#endregion
-export { injectAsyncBatchedCallback };
-//# sourceMappingURL=injectAsyncBatchedCallback.js.map
+export { injectAsyncBatchedCallback };

package/dist/async-batcher/injectAsyncBatcher.d.ts

@@ -2,7 +2,7 @@ import { Signal } from "@angular/core";
 import { Store } from "@tanstack/angular-store";
 import { AsyncBatcher, AsyncBatcherOptions, AsyncBatcherState } from "@tanstack/pacer/async-batcher";
 //#region src/async-batcher/injectAsyncBatcher.d.ts
-interface AngularAsyncBatcherOptions<TValue, TSelected = {}> extends AsyncBatcherOptions<TValue> {
+export interface AngularAsyncBatcherOptions<TValue, TSelected = {}> extends AsyncBatcherOptions<TValue> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the batcher instance.
    * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), cancel(), add logging, etc.
@@ -10,7 +10,7 @@ interface AngularAsyncBatcherOptions<TValue, TSelected = {}> extends AsyncBatche
    */
   onUnmount?: (batcher: AngularAsyncBatcher<TValue, TSelected>) => void;
 }
-interface AngularAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
+export interface AngularAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<TValue>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async batcher state changes
    *
@@ -78,7 +78,5 @@ interface AngularAsyncBatcher<TValue, TSelected = {}> extends Omit<AsyncBatcher<
  * const { items, isExecuting } = batcher.state();
  * ```
  */
-declare function injectAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: AngularAsyncBatcherOptions<TValue, TSelected>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): AngularAsyncBatcher<TValue, TSelected>;
-//#endregion
-export { AngularAsyncBatcher, AngularAsyncBatcherOptions, injectAsyncBatcher };
-//# sourceMappingURL=injectAsyncBatcher.d.ts.map
+export declare function injectAsyncBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => Promise<any>, options?: AngularAsyncBatcherOptions<TValue, TSelected>, selector?: (state: AsyncBatcherState<TValue>) => TSelected): AngularAsyncBatcher<TValue, TSelected>;
+//#endregion

package/dist/async-batcher/injectAsyncBatcher.js

@@ -81,5 +81,4 @@ function injectAsyncBatcher(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { injectAsyncBatcher };
-//# sourceMappingURL=injectAsyncBatcher.js.map
+export { injectAsyncBatcher };

package/dist/async-debouncer/injectAsyncDebouncedCallback.d.ts

@@ -36,7 +36,5 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * const results = await handleSearch(searchQuery);
  * ```
  */
-declare function injectAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncDebouncerOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
-//#endregion
-export { injectAsyncDebouncedCallback };
-//# sourceMappingURL=injectAsyncDebouncedCallback.d.ts.map
+export declare function injectAsyncDebouncedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncDebouncerOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion

package/dist/async-debouncer/injectAsyncDebouncedCallback.js

@@ -45,5 +45,4 @@ function injectAsyncDebouncedCallback(fn, options) {
 }
 
 //#endregion
-export { injectAsyncDebouncedCallback };
-//# sourceMappingURL=injectAsyncDebouncedCallback.js.map
+export { injectAsyncDebouncedCallback };

package/dist/async-debouncer/injectAsyncDebouncer.d.ts

@@ -3,7 +3,7 @@ import { Store } from "@tanstack/angular-store";
 import { AsyncDebouncer, AsyncDebouncerOptions, AsyncDebouncerState } from "@tanstack/pacer/async-debouncer";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-debouncer/injectAsyncDebouncer.d.ts
-interface AngularAsyncDebouncerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncDebouncerOptions<TFn> {
+export interface AngularAsyncDebouncerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncDebouncerOptions<TFn> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the debouncer instance.
    * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), cancel(), add logging, etc.
@@ -11,7 +11,7 @@ interface AngularAsyncDebouncerOptions<TFn extends AnyAsyncFunction, TSelected =
    */
   onUnmount?: (debouncer: AngularAsyncDebouncer<TFn, TSelected>) => void;
 }
-interface AngularAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncDebouncer<TFn>, 'store'> {
+export interface AngularAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncDebouncer<TFn>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async debouncer state changes
    *
@@ -101,7 +101,5 @@ interface AngularAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}> ex
  * const { isExecuting, errorCount } = debouncer.state();
  * ```
  */
-declare function injectAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncDebouncerOptions<TFn, TSelected>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): AngularAsyncDebouncer<TFn, TSelected>;
-//#endregion
-export { AngularAsyncDebouncer, AngularAsyncDebouncerOptions, injectAsyncDebouncer };
-//# sourceMappingURL=injectAsyncDebouncer.d.ts.map
+export declare function injectAsyncDebouncer<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncDebouncerOptions<TFn, TSelected>, selector?: (state: AsyncDebouncerState<TFn>) => TSelected): AngularAsyncDebouncer<TFn, TSelected>;
+//#endregion

package/dist/async-debouncer/injectAsyncDebouncer.js

@@ -103,5 +103,4 @@ function injectAsyncDebouncer(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { injectAsyncDebouncer };
-//# sourceMappingURL=injectAsyncDebouncer.js.map
+export { injectAsyncDebouncer };

package/dist/async-queuer/injectAsyncQueuedSignal.d.ts

@@ -1,7 +1,7 @@
 import { AngularAsyncQueuer } from "./injectAsyncQueuer.js";
 import { AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
 //#region src/async-queuer/injectAsyncQueuedSignal.d.ts
-interface AsyncQueuedSignal<TValue, TSelected = {}> {
+export interface AsyncQueuedSignal<TValue, TSelected = {}> {
   (): Array<TValue>;
   addItem: AngularAsyncQueuer<TValue, TSelected>['addItem'];
   queuer: AngularAsyncQueuer<TValue, TSelected>;
@@ -43,7 +43,5 @@ interface AsyncQueuedSignal<TValue, TSelected = {}> {
  * queued.queuer.stop();
  * ```
  */
-declare function injectAsyncQueuedSignal<TValue, TSelected extends Pick<AsyncQueuerState<TValue>, 'items'> = Pick<AsyncQueuerState<TValue>, 'items'>>(fn: (value: TValue) => Promise<any>, options?: AsyncQueuerOptions<TValue>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AsyncQueuedSignal<TValue, TSelected>;
-//#endregion
-export { AsyncQueuedSignal, injectAsyncQueuedSignal };
-//# sourceMappingURL=injectAsyncQueuedSignal.d.ts.map
+export declare function injectAsyncQueuedSignal<TValue, TSelected extends Pick<AsyncQueuerState<TValue>, 'items'> = Pick<AsyncQueuerState<TValue>, 'items'>>(fn: (value: TValue) => Promise<any>, options?: AsyncQueuerOptions<TValue>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AsyncQueuedSignal<TValue, TSelected>;
+//#endregion

package/dist/async-queuer/injectAsyncQueuedSignal.js

@@ -49,5 +49,4 @@ function injectAsyncQueuedSignal(fn, options = {}, selector = (state) => ({ item
 }
 
 //#endregion
-export { injectAsyncQueuedSignal };
-//# sourceMappingURL=injectAsyncQueuedSignal.js.map
+export { injectAsyncQueuedSignal };

package/dist/async-queuer/injectAsyncQueuer.d.ts

@@ -2,7 +2,7 @@ import { Signal } from "@angular/core";
 import { Store } from "@tanstack/angular-store";
 import { AsyncQueuer, AsyncQueuerOptions, AsyncQueuerState } from "@tanstack/pacer/async-queuer";
 //#region src/async-queuer/injectAsyncQueuer.d.ts
-interface AngularAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerOptions<TValue> {
+export interface AngularAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerOptions<TValue> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the queuer instance.
    * When provided, replaces the default cleanup (stop + abort); use it to call flush(), stop(), add logging, etc.
@@ -10,7 +10,7 @@ interface AngularAsyncQueuerOptions<TValue, TSelected = {}> extends AsyncQueuerO
    */
   onUnmount?: (queuer: AngularAsyncQueuer<TValue, TSelected>) => void;
 }
-interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
+export interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TValue>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async queuer state changes
    *
@@ -78,7 +78,5 @@ interface AngularAsyncQueuer<TValue, TSelected = {}> extends Omit<AsyncQueuer<TV
  * const { items, isExecuting } = queuer.state();
  * ```
  */
-declare function injectAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: AngularAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AngularAsyncQueuer<TValue, TSelected>;
-//#endregion
-export { AngularAsyncQueuer, AngularAsyncQueuerOptions, injectAsyncQueuer };
-//# sourceMappingURL=injectAsyncQueuer.d.ts.map
+export declare function injectAsyncQueuer<TValue, TSelected = {}>(fn: (value: TValue) => Promise<any>, options?: AngularAsyncQueuerOptions<TValue, TSelected>, selector?: (state: AsyncQueuerState<TValue>) => TSelected): AngularAsyncQueuer<TValue, TSelected>;
+//#endregion

package/dist/async-queuer/injectAsyncQueuer.js

@@ -81,5 +81,4 @@ function injectAsyncQueuer(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { injectAsyncQueuer };
-//# sourceMappingURL=injectAsyncQueuer.js.map
+export { injectAsyncQueuer };

package/dist/async-rate-limiter/injectAsyncRateLimitedCallback.d.ts

@@ -39,7 +39,5 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * const result = await makeApiCall(apiData);
  * ```
  */
-declare function injectAsyncRateLimitedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncRateLimiterOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
-//#endregion
-export { injectAsyncRateLimitedCallback };
-//# sourceMappingURL=injectAsyncRateLimitedCallback.d.ts.map
+export declare function injectAsyncRateLimitedCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncRateLimiterOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion

package/dist/async-rate-limiter/injectAsyncRateLimitedCallback.js

@@ -48,5 +48,4 @@ function injectAsyncRateLimitedCallback(fn, options) {
 }
 
 //#endregion
-export { injectAsyncRateLimitedCallback };
-//# sourceMappingURL=injectAsyncRateLimitedCallback.js.map
+export { injectAsyncRateLimitedCallback };

package/dist/async-rate-limiter/injectAsyncRateLimiter.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/angular-store";
 import { AsyncRateLimiter, AsyncRateLimiterOptions, AsyncRateLimiterState } from "@tanstack/pacer/async-rate-limiter";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-rate-limiter/injectAsyncRateLimiter.d.ts
-interface AngularAsyncRateLimiterOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncRateLimiterOptions<TFn> {
+export interface AngularAsyncRateLimiterOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncRateLimiterOptions<TFn> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the rate limiter instance.
    * When provided, replaces the default cleanup (abort).
    */
   onUnmount?: (rateLimiter: AngularAsyncRateLimiter<TFn, TSelected>) => void;
 }
-interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
+export interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncRateLimiter<TFn>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async rate limiter state changes
    *
@@ -65,7 +65,5 @@ interface AngularAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>
  * };
  * ```
  */
-declare function injectAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
-//#endregion
-export { AngularAsyncRateLimiter, AngularAsyncRateLimiterOptions, injectAsyncRateLimiter };
-//# sourceMappingURL=injectAsyncRateLimiter.d.ts.map
+export declare function injectAsyncRateLimiter<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncRateLimiterOptions<TFn, TSelected>, selector?: (state: AsyncRateLimiterState<TFn>) => TSelected): AngularAsyncRateLimiter<TFn, TSelected>;
+//#endregion

package/dist/async-rate-limiter/injectAsyncRateLimiter.js

@@ -65,5 +65,4 @@ function injectAsyncRateLimiter(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { injectAsyncRateLimiter };
-//# sourceMappingURL=injectAsyncRateLimiter.js.map
+export { injectAsyncRateLimiter };

package/dist/async-throttler/injectAsyncThrottledCallback.d.ts

@@ -37,7 +37,5 @@ import { AnyAsyncFunction } from "@tanstack/pacer/types";
  * const result = await handleUpdate(updateData);
  * ```
  */
-declare function injectAsyncThrottledCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncThrottlerOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
-//#endregion
-export { injectAsyncThrottledCallback };
-//# sourceMappingURL=injectAsyncThrottledCallback.d.ts.map
+export declare function injectAsyncThrottledCallback<TFn extends AnyAsyncFunction>(fn: TFn, options: AsyncThrottlerOptions<TFn>): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+//#endregion

package/dist/async-throttler/injectAsyncThrottledCallback.js

@@ -46,5 +46,4 @@ function injectAsyncThrottledCallback(fn, options) {
 }
 
 //#endregion
-export { injectAsyncThrottledCallback };
-//# sourceMappingURL=injectAsyncThrottledCallback.js.map
+export { injectAsyncThrottledCallback };

package/dist/async-throttler/injectAsyncThrottler.d.ts

@@ -3,7 +3,7 @@ import { Store } from "@tanstack/angular-store";
 import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState } from "@tanstack/pacer/async-throttler";
 import { AnyAsyncFunction } from "@tanstack/pacer/types";
 //#region src/async-throttler/injectAsyncThrottler.d.ts
-interface AngularAsyncThrottlerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncThrottlerOptions<TFn> {
+export interface AngularAsyncThrottlerOptions<TFn extends AnyAsyncFunction, TSelected = {}> extends AsyncThrottlerOptions<TFn> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the throttler instance.
    * When provided, replaces the default cleanup (cancel + abort); use it to call flush(), cancel(), add logging, etc.
@@ -11,7 +11,7 @@ interface AngularAsyncThrottlerOptions<TFn extends AnyAsyncFunction, TSelected =
    */
   onUnmount?: (throttler: AngularAsyncThrottler<TFn, TSelected>) => void;
 }
-interface AngularAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
+export interface AngularAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
   /**
    * Reactive state signal that will be updated when the async throttler state changes
    *
@@ -80,7 +80,5 @@ interface AngularAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> ex
  * };
  * ```
  */
-declare function injectAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncThrottlerOptions<TFn, TSelected>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): AngularAsyncThrottler<TFn, TSelected>;
-//#endregion
-export { AngularAsyncThrottler, AngularAsyncThrottlerOptions, injectAsyncThrottler };
-//# sourceMappingURL=injectAsyncThrottler.d.ts.map
+export declare function injectAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AngularAsyncThrottlerOptions<TFn, TSelected>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): AngularAsyncThrottler<TFn, TSelected>;
+//#endregion

package/dist/async-throttler/injectAsyncThrottler.js

@@ -82,5 +82,4 @@ function injectAsyncThrottler(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { injectAsyncThrottler };
-//# sourceMappingURL=injectAsyncThrottler.js.map
+export { injectAsyncThrottler };

package/dist/batcher/injectBatchedCallback.d.ts

@@ -36,7 +36,5 @@ import { BatcherOptions } from "@tanstack/pacer/batcher";
  * batchApiCall('item2');
  * ```
  */
-declare function injectBatchedCallback<TValue>(fn: (items: Array<TValue>) => void, options: BatcherOptions<TValue>): (item: TValue) => void;
-//#endregion
-export { injectBatchedCallback };
-//# sourceMappingURL=injectBatchedCallback.d.ts.map
+export declare function injectBatchedCallback<TValue>(fn: (items: Array<TValue>) => void, options: BatcherOptions<TValue>): (item: TValue) => void;
+//#endregion

package/dist/batcher/injectBatchedCallback.js

@@ -43,5 +43,4 @@ function injectBatchedCallback(fn, options) {
 }
 
 //#endregion
-export { injectBatchedCallback };
-//# sourceMappingURL=injectBatchedCallback.js.map
+export { injectBatchedCallback };

package/dist/batcher/injectBatcher.d.ts

@@ -2,14 +2,14 @@ import { Signal } from "@angular/core";
 import { Store } from "@tanstack/angular-store";
 import { Batcher, BatcherOptions, BatcherState } from "@tanstack/pacer/batcher";
 //#region src/batcher/injectBatcher.d.ts
-interface AngularBatcherOptions<TValue, TSelected = {}> extends BatcherOptions<TValue> {
+export interface AngularBatcherOptions<TValue, TSelected = {}> extends BatcherOptions<TValue> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the batcher instance.
    * When provided, replaces the default cleanup (cancel); use it to call flush(), cancel(), add logging, etc.
    */
   onUnmount?: (batcher: AngularBatcher<TValue, TSelected>) => void;
 }
-interface AngularBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'store'> {
+export interface AngularBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, 'store'> {
   /**
    * Reactive state signal that will be updated when the batcher state changes
    *
@@ -70,7 +70,5 @@ interface AngularBatcher<TValue, TSelected = {}> extends Omit<Batcher<TValue>, '
  * const { items, isPending } = batcher.state();
  * ```
  */
-declare function injectBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => void, options?: AngularBatcherOptions<TValue, TSelected>, selector?: (state: BatcherState<TValue>) => TSelected): AngularBatcher<TValue, TSelected>;
-//#endregion
-export { AngularBatcher, AngularBatcherOptions, injectBatcher };
-//# sourceMappingURL=injectBatcher.d.ts.map
+export declare function injectBatcher<TValue, TSelected = {}>(fn: (items: Array<TValue>) => void, options?: AngularBatcherOptions<TValue, TSelected>, selector?: (state: BatcherState<TValue>) => TSelected): AngularBatcher<TValue, TSelected>;
+//#endregion

package/dist/batcher/injectBatcher.js

@@ -71,5 +71,4 @@ function injectBatcher(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { injectBatcher };
-//# sourceMappingURL=injectBatcher.js.map
+export { injectBatcher };

package/dist/debouncer/injectDebouncedCallback.d.ts

@@ -36,7 +36,5 @@ import { AnyFunction } from "@tanstack/pacer/types";
  * />
  * ```
  */
-declare function injectDebouncedCallback<TFn extends AnyFunction>(fn: TFn, options: DebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
-//#endregion
-export { injectDebouncedCallback };
-//# sourceMappingURL=injectDebouncedCallback.d.ts.map
+export declare function injectDebouncedCallback<TFn extends AnyFunction>(fn: TFn, options: DebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
+//#endregion

package/dist/debouncer/injectDebouncedCallback.js

@@ -42,5 +42,4 @@ function injectDebouncedCallback(fn, options) {
 }
 
 //#endregion
-export { injectDebouncedCallback };
-//# sourceMappingURL=injectDebouncedCallback.js.map
+export { injectDebouncedCallback };

package/dist/debouncer/injectDebouncedSignal.d.ts

@@ -2,7 +2,7 @@ import { AngularDebouncer } from "./injectDebouncer.js";
 import { DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
 //#region src/debouncer/injectDebouncedSignal.d.ts
 type Setter<T> = (value: T | ((prev: T) => T)) => void;
-interface DebouncedSignal<TValue, TSelected = {}> {
+export interface DebouncedSignal<TValue, TSelected = {}> {
   (): TValue;
   set: Setter<TValue>;
   debouncer: AngularDebouncer<Setter<TValue>, TSelected>;
@@ -53,7 +53,5 @@ interface DebouncedSignal<TValue, TSelected = {}> {
  * console.log(debouncedQuery.debouncer.state().isPending)
  * ```
  */
-declare function injectDebouncedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
-//#endregion
-export { DebouncedSignal, injectDebouncedSignal };
-//# sourceMappingURL=injectDebouncedSignal.d.ts.map
+export declare function injectDebouncedSignal<TValue, TSelected = {}>(value: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
+//#endregion

package/dist/debouncer/injectDebouncedSignal.js

@@ -64,5 +64,4 @@ function injectDebouncedSignal(value, initialOptions, selector) {
 }
 
 //#endregion
-export { injectDebouncedSignal };
-//# sourceMappingURL=injectDebouncedSignal.js.map
+export { injectDebouncedSignal };

package/dist/debouncer/injectDebouncedValue.d.ts

@@ -68,8 +68,6 @@ type Setter<T> = (value: T | ((prev: T) => T)) => void;
  * debounced.cancel() // Cancel any pending updates
  * ```
  */
-declare function injectDebouncedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
-declare function injectDebouncedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
-//#endregion
-export { injectDebouncedValue };
-//# sourceMappingURL=injectDebouncedValue.d.ts.map
+export declare function injectDebouncedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
+export declare function injectDebouncedValue<TValue, TSelected = {}>(value: Signal<TValue>, initialValue: TValue, initialOptions: DebouncerOptions<Setter<TValue>>, selector?: (state: DebouncerState<Setter<TValue>>) => TSelected): DebouncedSignal<TValue, TSelected>;
+//#endregion

package/dist/debouncer/injectDebouncedValue.js

@@ -13,5 +13,4 @@ function injectDebouncedValue(value, initialValueOrOptions, initialOptionsOrSele
 }
 
 //#endregion
-export { injectDebouncedValue };
-//# sourceMappingURL=injectDebouncedValue.js.map
+export { injectDebouncedValue };

package/dist/debouncer/injectDebouncer.d.ts

@@ -3,14 +3,14 @@ import { Store } from "@tanstack/angular-store";
 import { Debouncer, DebouncerOptions, DebouncerState } from "@tanstack/pacer/debouncer";
 import { AnyFunction } from "@tanstack/pacer/types";
 //#region src/debouncer/injectDebouncer.d.ts
-interface AngularDebouncerOptions<TFn extends AnyFunction, TSelected = {}> extends DebouncerOptions<TFn> {
+export interface AngularDebouncerOptions<TFn extends AnyFunction, TSelected = {}> extends DebouncerOptions<TFn> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the debouncer instance.
    * When provided, replaces the default cleanup (cancel); use it to call flush(), cancel(), add logging, etc.
    */
   onUnmount?: (debouncer: AngularDebouncer<TFn, TSelected>) => void;
 }
-interface AngularDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
+export interface AngularDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit<Debouncer<TFn>, 'store'> {
   /**
    * Reactive state signal that will be updated when the debouncer state changes
    *
@@ -91,7 +91,5 @@ interface AngularDebouncer<TFn extends AnyFunction, TSelected = {}> extends Omit
  * const { isPending } = debouncer.state();
  * ```
  */
-declare function injectDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: AngularDebouncerOptions<TFn, TSelected>, selector?: (state: DebouncerState<TFn>) => TSelected): AngularDebouncer<TFn, TSelected>;
-//#endregion
-export { AngularDebouncer, AngularDebouncerOptions, injectDebouncer };
-//# sourceMappingURL=injectDebouncer.d.ts.map
+export declare function injectDebouncer<TFn extends AnyFunction, TSelected = {}>(fn: TFn, options: AngularDebouncerOptions<TFn, TSelected>, selector?: (state: DebouncerState<TFn>) => TSelected): AngularDebouncer<TFn, TSelected>;
+//#endregion

package/dist/debouncer/injectDebouncer.js

@@ -91,5 +91,4 @@ function injectDebouncer(fn, options, selector = () => ({})) {
 }
 
 //#endregion
-export { injectDebouncer };
-//# sourceMappingURL=injectDebouncer.js.map
+export { injectDebouncer };

package/dist/provider/pacer-context.d.ts

@@ -1,7 +1,7 @@
 import { AnyAsyncFunction, AnyFunction, AsyncBatcherOptions, AsyncDebouncerOptions, AsyncQueuerOptions, AsyncRateLimiterOptions, AsyncThrottlerOptions, BatcherOptions, DebouncerOptions, QueuerOptions, RateLimiterOptions, ThrottlerOptions } from "@tanstack/pacer";
 import { InjectionToken } from "@angular/core";
 //#region src/provider/pacer-context.d.ts
-interface PacerProviderOptions {
+export interface PacerProviderOptions {
   asyncBatcher?: Partial<AsyncBatcherOptions<any>>;
   asyncDebouncer?: Partial<AsyncDebouncerOptions<AnyAsyncFunction>>;
   asyncQueuer?: Partial<AsyncQueuerOptions<any>>;
@@ -13,8 +13,6 @@ interface PacerProviderOptions {
   rateLimiter?: Partial<RateLimiterOptions<AnyFunction>>;
   throttler?: Partial<ThrottlerOptions<AnyFunction>>;
 }
-declare const PACER_OPTIONS: InjectionToken<PacerProviderOptions>;
-declare function injectPacerOptions(): PacerProviderOptions;
-//#endregion
-export { PACER_OPTIONS, PacerProviderOptions, injectPacerOptions };
-//# sourceMappingURL=pacer-context.d.ts.map
+export declare const PACER_OPTIONS: InjectionToken<PacerProviderOptions>;
+export declare function injectPacerOptions(): PacerProviderOptions;
+//#endregion

package/dist/provider/pacer-context.js

@@ -15,5 +15,4 @@ function injectPacerOptions() {
 }
 
 //#endregion
-export { PACER_OPTIONS, injectPacerOptions };
-//# sourceMappingURL=pacer-context.js.map
+export { PACER_OPTIONS, injectPacerOptions };

package/dist/provider/pacer-provider.d.ts

@@ -29,7 +29,5 @@ import { Provider } from "@angular/core";
  * export class AppModule {}
  * ```
  */
-declare function providePacerOptions(options: PacerProviderOptions): Provider;
-//#endregion
-export { providePacerOptions };
-//# sourceMappingURL=pacer-provider.d.ts.map
+export declare function providePacerOptions(options: PacerProviderOptions): Provider;
+//#endregion

package/dist/provider/pacer-provider.js

@@ -37,5 +37,4 @@ function providePacerOptions(options) {
 }
 
 //#endregion
-export { providePacerOptions };
-//# sourceMappingURL=pacer-provider.js.map
+export { providePacerOptions };

package/dist/queuer/injectQueuedSignal.d.ts

@@ -1,7 +1,7 @@
 import { AngularQueuer } from "./injectQueuer.js";
 import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
 //#region src/queuer/injectQueuedSignal.d.ts
-interface QueuedSignal<TValue, TSelected = {}> {
+export interface QueuedSignal<TValue, TSelected = {}> {
   (): Array<TValue>;
   addItem: AngularQueuer<TValue, TSelected>['addItem'];
   queuer: AngularQueuer<TValue, TSelected>;
@@ -37,7 +37,5 @@ interface QueuedSignal<TValue, TSelected = {}> {
  * queued.queuer.stop();
  * ```
  */
-declare function injectQueuedSignal<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): QueuedSignal<TValue, TSelected>;
-//#endregion
-export { QueuedSignal, injectQueuedSignal };
-//# sourceMappingURL=injectQueuedSignal.d.ts.map
+export declare function injectQueuedSignal<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(fn: (item: TValue) => void, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): QueuedSignal<TValue, TSelected>;
+//#endregion

package/dist/queuer/injectQueuedSignal.js

@@ -43,5 +43,4 @@ function injectQueuedSignal(fn, options = {}, selector = (state) => ({ items: st
 }
 
 //#endregion
-export { injectQueuedSignal };
-//# sourceMappingURL=injectQueuedSignal.js.map
+export { injectQueuedSignal };

package/dist/queuer/injectQueuedValue.d.ts

@@ -26,8 +26,6 @@ import { QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
  * queued.addItem('new value')
  * ```
  */
-declare function injectQueuedValue<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(value: Signal<TValue>, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): QueuedSignal<TValue, TSelected>;
-declare function injectQueuedValue<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(value: Signal<TValue>, initialValue: TValue, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): QueuedSignal<TValue, TSelected>;
-//#endregion
-export { injectQueuedValue };
-//# sourceMappingURL=injectQueuedValue.d.ts.map
+export declare function injectQueuedValue<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(value: Signal<TValue>, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): QueuedSignal<TValue, TSelected>;
+export declare function injectQueuedValue<TValue, TSelected extends Pick<QueuerState<TValue>, 'items'> = Pick<QueuerState<TValue>, 'items'>>(value: Signal<TValue>, initialValue: TValue, options?: QueuerOptions<TValue>, selector?: (state: QueuerState<TValue>) => TSelected): QueuedSignal<TValue, TSelected>;
+//#endregion

package/dist/queuer/injectQueuedValue.js

@@ -19,5 +19,4 @@ function injectQueuedValue(value, initialValueOrOptions, initialOptionsOrSelecto
 }
 
 //#endregion
-export { injectQueuedValue };
-//# sourceMappingURL=injectQueuedValue.js.map
+export { injectQueuedValue };

package/dist/queuer/injectQueuer.d.ts

@@ -2,14 +2,14 @@ import { Signal } from "@angular/core";
 import { Store } from "@tanstack/angular-store";
 import { Queuer, QueuerOptions, QueuerState } from "@tanstack/pacer/queuer";
 //#region src/queuer/injectQueuer.d.ts
-interface AngularQueuerOptions<TValue, TSelected = {}> extends QueuerOptions<TValue> {
+export interface AngularQueuerOptions<TValue, TSelected = {}> extends QueuerOptions<TValue> {
   /**
    * Optional callback invoked when the component is destroyed. Receives the queuer instance.
    * When provided, replaces the default cleanup (stop); use it to call flush(), stop(), add logging, etc.
    */
   onUnmount?: (queuer: AngularQueuer<TValue, TSelected>) => void;
 }
-interface AngularQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
+export interface AngularQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'store'> {
   /**
    * Reactive state signal that will be updated when the queuer state changes
    *
@@ -75,7 +75,5 @@ interface AngularQueuer<TValue, TSelected = {}> extends Omit<Queuer<TValue>, 'st
  * });
  * ```
  */
-declare function injectQueuer<TValue, TSelected = {}>(fn: (item: TValue) => void, options?: AngularQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): AngularQueuer<TValue, TSelected>;
-//#endregion
-export { AngularQueuer, AngularQueuerOptions, injectQueuer };
-//# sourceMappingURL=injectQueuer.d.ts.map
+export declare function injectQueuer<TValue, TSelected = {}>(fn: (item: TValue) => void, options?: AngularQueuerOptions<TValue, TSelected>, selector?: (state: QueuerState<TValue>) => TSelected): AngularQueuer<TValue, TSelected>;
+//#endregion

package/dist/queuer/injectQueuer.js

@@ -76,5 +76,4 @@ function injectQueuer(fn, options = {}, selector = () => ({})) {
 }
 
 //#endregion
-export { injectQueuer };
-//# sourceMappingURL=injectQueuer.js.map
+export { injectQueuer };