@tanstack/angular-pacer 0.20.0

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

@@ -0,0 +1,44 @@
+import { AsyncThrottlerOptions } from "@tanstack/pacer/async-throttler";
+import { AnyAsyncFunction } from "@tanstack/pacer/types";
+
+//#region src/async-throttler/injectAsyncThrottledCallback.d.ts
+/**
+ * An Angular function that creates an async throttled version of a callback function.
+ * This function is essentially a wrapper around `injectAsyncThrottler` that provides
+ * a simplified API for basic async throttling needs.
+ *
+ * The throttled function will execute at most once within the specified wait time.
+ *
+ * This function provides a simpler API compared to `injectAsyncThrottler`, making it ideal for basic
+ * async throttling needs. However, it does not expose the underlying AsyncThrottler instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual cancellation
+ * - Access to execution counts
+ * - Error handling callbacks
+ * - Retry support
+ *
+ * Consider using the `injectAsyncThrottler` function instead.
+ *
+ * @example
+ * ```ts
+ * // Throttle an async update handler
+ * const handleUpdate = injectAsyncThrottledCallback(
+ *   async (data: Data) => {
+ *     const response = await fetch('/api/update', {
+ *       method: 'POST',
+ *       body: JSON.stringify(data)
+ *     });
+ *     return response.json();
+ *   },
+ *   { wait: 1000 }
+ * );
+ *
+ * // Use in an event handler
+ * 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

package/dist/async-throttler/injectAsyncThrottledCallback.js

@@ -0,0 +1,50 @@
+import { injectAsyncThrottler } from "./injectAsyncThrottler.js";
+
+//#region src/async-throttler/injectAsyncThrottledCallback.ts
+/**
+* An Angular function that creates an async throttled version of a callback function.
+* This function is essentially a wrapper around `injectAsyncThrottler` that provides
+* a simplified API for basic async throttling needs.
+*
+* The throttled function will execute at most once within the specified wait time.
+*
+* This function provides a simpler API compared to `injectAsyncThrottler`, making it ideal for basic
+* async throttling needs. However, it does not expose the underlying AsyncThrottler instance.
+*
+* For advanced usage requiring features like:
+* - Manual cancellation
+* - Access to execution counts
+* - Error handling callbacks
+* - Retry support
+*
+* Consider using the `injectAsyncThrottler` function instead.
+*
+* @example
+* ```ts
+* // Throttle an async update handler
+* const handleUpdate = injectAsyncThrottledCallback(
+*   async (data: Data) => {
+*     const response = await fetch('/api/update', {
+*       method: 'POST',
+*       body: JSON.stringify(data)
+*     });
+*     return response.json();
+*   },
+*   { wait: 1000 }
+* );
+*
+* // Use in an event handler
+* const result = await handleUpdate(updateData);
+* ```
+*/
+function injectAsyncThrottledCallback(fn, options) {
+	const throttler = injectAsyncThrottler(fn, options);
+	return async (...args) => {
+		const result = await throttler.maybeExecute(...args);
+		return result !== void 0 ? await result : void 0;
+	};
+}
+
+//#endregion
+export { injectAsyncThrottledCallback };
+//# sourceMappingURL=injectAsyncThrottledCallback.js.map

package/dist/async-throttler/injectAsyncThrottledCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncThrottledCallback.js","names":[],"sources":["../../src/async-throttler/injectAsyncThrottledCallback.ts"],"sourcesContent":["import { injectAsyncThrottler } from './injectAsyncThrottler'\nimport type { AsyncThrottlerOptions } from '@tanstack/pacer/async-throttler'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\n\n/**\n * An Angular function that creates an async throttled version of a callback function.\n * This function is essentially a wrapper around `injectAsyncThrottler` that provides\n * a simplified API for basic async throttling needs.\n *\n * The throttled function will execute at most once within the specified wait time.\n *\n * This function provides a simpler API compared to `injectAsyncThrottler`, making it ideal for basic\n * async throttling needs. However, it does not expose the underlying AsyncThrottler instance.\n *\n * For advanced usage requiring features like:\n * - Manual cancellation\n * - Access to execution counts\n * - Error handling callbacks\n * - Retry support\n *\n * Consider using the `injectAsyncThrottler` function instead.\n *\n * @example\n * ```ts\n * // Throttle an async update handler\n * const handleUpdate = injectAsyncThrottledCallback(\n *   async (data: Data) => {\n *     const response = await fetch('/api/update', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   { wait: 1000 }\n * );\n *\n * // Use in an event handler\n * const result = await handleUpdate(updateData);\n * ```\n */\nexport function injectAsyncThrottledCallback<TFn extends AnyAsyncFunction>(\n  fn: TFn,\n  options: AsyncThrottlerOptions<TFn>,\n): (...args: Parameters<TFn>) => Promise<Awaited<ReturnType<TFn>> | undefined> {\n  const throttler = injectAsyncThrottler(fn, options)\n  return async (...args: Parameters<TFn>) => {\n    const result = await throttler.maybeExecute(...args)\n    return result !== undefined ? await result : undefined\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,6BACd,IACA,SAC6E;CAC7E,MAAM,YAAY,qBAAqB,IAAI,QAAQ;AACnD,QAAO,OAAO,GAAG,SAA0B;EACzC,MAAM,SAAS,MAAM,UAAU,aAAa,GAAG,KAAK;AACpD,SAAO,WAAW,SAAY,MAAM,SAAS"}

package/dist/async-throttler/injectAsyncThrottler.cjs

@@ -0,0 +1,62 @@
+const require_pacer_context = require('../provider/pacer-context.cjs');
+let _tanstack_angular_store = require("@tanstack/angular-store");
+let _tanstack_pacer_async_throttler = require("@tanstack/pacer/async-throttler");
+
+//#region src/async-throttler/injectAsyncThrottler.ts
+/**
+* An Angular function that creates and manages an AsyncThrottler instance.
+*
+* This is a lower-level function that provides direct access to the AsyncThrottler's functionality.
+* This allows you to integrate it with any state management solution you prefer.
+*
+* This function provides async throttling functionality with promise support, error handling,
+* retry capabilities, and abort support.
+*
+* The throttler will execute the function at most once within the specified wait time.
+*
+* ## State Management and Selector
+*
+* The function uses TanStack Store for state management and wraps it with Angular signals.
+* The `selector` parameter allows you to specify which state changes will trigger signal updates,
+* 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. This prevents unnecessary updates and gives you
+* full control over when your component tracks state changes.
+*
+* @example
+* ```ts
+* // Default behavior - no reactive state subscriptions
+* const throttler = injectAsyncThrottler(
+*   async (data: Data) => {
+*     const response = await fetch('/api/update', {
+*       method: 'POST',
+*       body: JSON.stringify(data)
+*     });
+*     return response.json();
+*   },
+*   { wait: 1000 }
+* );
+*
+* // In an event handler
+* const handleUpdate = async (data: Data) => {
+*   const result = await throttler.maybeExecute(data);
+*   console.log('Update result:', result);
+* };
+* ```
+*/
+function injectAsyncThrottler(fn, options, selector = () => ({})) {
+	const throttler = new _tanstack_pacer_async_throttler.AsyncThrottler(fn, {
+		...require_pacer_context.injectPacerOptions().asyncThrottler,
+		...options
+	});
+	const state = (0, _tanstack_angular_store.injectStore)(throttler.store, selector);
+	return {
+		...throttler,
+		state
+	};
+}
+
+//#endregion
+exports.injectAsyncThrottler = injectAsyncThrottler;
+//# sourceMappingURL=injectAsyncThrottler.cjs.map

package/dist/async-throttler/injectAsyncThrottler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncThrottler.cjs","names":["AsyncThrottler","injectPacerOptions"],"sources":["../../src/async-throttler/injectAsyncThrottler.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { AsyncThrottler } from '@tanstack/pacer/async-throttler'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncThrottlerOptions,\n  AsyncThrottlerState,\n} from '@tanstack/pacer/async-throttler'\n\nexport interface AngularAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncThrottler<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async throttler state changes\n   *\n   * Use this instead of `throttler.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive in Angular signals.\n   */\n  readonly store: Store<Readonly<AsyncThrottlerState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncThrottler instance.\n *\n * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async throttling functionality with promise support, error handling,\n * retry capabilities, and abort support.\n *\n * The throttler will execute the function at most once within the specified wait time.\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for state management and wraps it with Angular signals.\n * The `selector` parameter allows you to specify which state changes will trigger signal updates,\n * optimizing performance by preventing unnecessary updates 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 updates and gives you\n * full control over when your component tracks state changes.\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const throttler = injectAsyncThrottler(\n *   async (data: Data) => {\n *     const response = await fetch('/api/update', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   { wait: 1000 }\n * );\n *\n * // In an event handler\n * const handleUpdate = async (data: Data) => {\n *   const result = await throttler.maybeExecute(data);\n *   console.log('Update result:', result);\n * };\n * ```\n */\nexport function injectAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncThrottlerOptions<TFn>,\n  selector: (state: AsyncThrottlerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncThrottler<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncThrottler,\n    ...options,\n  } as AsyncThrottlerOptions<TFn>\n\n  const throttler = new AsyncThrottler<TFn>(fn, mergedOptions)\n  const state = injectStore(throttler.store, selector)\n\n  return {\n    ...throttler,\n    state,\n  } as AngularAsyncThrottler<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,SAAgB,qBAId,IACA,SACA,kBACG,EAAE,GACkC;CAMvC,MAAM,YAAY,IAAIA,+CAAoB,IALpB;EACpB,GAAGC,0CAAoB,CAAC;EACxB,GAAG;EACJ,CAE2D;CAC5D,MAAM,iDAAoB,UAAU,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}

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

@@ -0,0 +1,65 @@
+import { Signal } from "@angular/core";
+import { Store } from "@tanstack/store";
+import { AnyAsyncFunction } from "@tanstack/pacer/types";
+import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState } from "@tanstack/pacer/async-throttler";
+
+//#region src/async-throttler/injectAsyncThrottler.d.ts
+interface AngularAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the async throttler state changes
+   *
+   * Use this instead of `throttler.store.state`
+   */
+  readonly state: Signal<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.
+   * The state on the store object is not reactive in Angular signals.
+   */
+  readonly store: Store<Readonly<AsyncThrottlerState<TFn>>>;
+}
+/**
+ * An Angular function that creates and manages an AsyncThrottler instance.
+ *
+ * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * This function provides async throttling functionality with promise support, error handling,
+ * retry capabilities, and abort support.
+ *
+ * The throttler will execute the function at most once within the specified wait time.
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for state management and wraps it with Angular signals.
+ * The `selector` parameter allows you to specify which state changes will trigger signal updates,
+ * 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. This prevents unnecessary updates and gives you
+ * full control over when your component tracks state changes.
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const throttler = injectAsyncThrottler(
+ *   async (data: Data) => {
+ *     const response = await fetch('/api/update', {
+ *       method: 'POST',
+ *       body: JSON.stringify(data)
+ *     });
+ *     return response.json();
+ *   },
+ *   { wait: 1000 }
+ * );
+ *
+ * // In an event handler
+ * const handleUpdate = async (data: Data) => {
+ *   const result = await throttler.maybeExecute(data);
+ *   console.log('Update result:', result);
+ * };
+ * ```
+ */
+declare function injectAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AsyncThrottlerOptions<TFn>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): AngularAsyncThrottler<TFn, TSelected>;
+//#endregion
+export { AngularAsyncThrottler, injectAsyncThrottler };
+//# sourceMappingURL=injectAsyncThrottler.d.cts.map

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

@@ -0,0 +1,65 @@
+import { Signal } from "@angular/core";
+import { AsyncThrottler, AsyncThrottlerOptions, AsyncThrottlerState } from "@tanstack/pacer/async-throttler";
+import { AnyAsyncFunction } from "@tanstack/pacer/types";
+import { Store } from "@tanstack/store";
+
+//#region src/async-throttler/injectAsyncThrottler.d.ts
+interface AngularAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}> extends Omit<AsyncThrottler<TFn>, 'store'> {
+  /**
+   * Reactive state signal that will be updated when the async throttler state changes
+   *
+   * Use this instead of `throttler.store.state`
+   */
+  readonly state: Signal<Readonly<TSelected>>;
+  /**
+   * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.
+   * The state on the store object is not reactive in Angular signals.
+   */
+  readonly store: Store<Readonly<AsyncThrottlerState<TFn>>>;
+}
+/**
+ * An Angular function that creates and manages an AsyncThrottler instance.
+ *
+ * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.
+ * This allows you to integrate it with any state management solution you prefer.
+ *
+ * This function provides async throttling functionality with promise support, error handling,
+ * retry capabilities, and abort support.
+ *
+ * The throttler will execute the function at most once within the specified wait time.
+ *
+ * ## State Management and Selector
+ *
+ * The function uses TanStack Store for state management and wraps it with Angular signals.
+ * The `selector` parameter allows you to specify which state changes will trigger signal updates,
+ * 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. This prevents unnecessary updates and gives you
+ * full control over when your component tracks state changes.
+ *
+ * @example
+ * ```ts
+ * // Default behavior - no reactive state subscriptions
+ * const throttler = injectAsyncThrottler(
+ *   async (data: Data) => {
+ *     const response = await fetch('/api/update', {
+ *       method: 'POST',
+ *       body: JSON.stringify(data)
+ *     });
+ *     return response.json();
+ *   },
+ *   { wait: 1000 }
+ * );
+ *
+ * // In an event handler
+ * const handleUpdate = async (data: Data) => {
+ *   const result = await throttler.maybeExecute(data);
+ *   console.log('Update result:', result);
+ * };
+ * ```
+ */
+declare function injectAsyncThrottler<TFn extends AnyAsyncFunction, TSelected = {}>(fn: TFn, options: AsyncThrottlerOptions<TFn>, selector?: (state: AsyncThrottlerState<TFn>) => TSelected): AngularAsyncThrottler<TFn, TSelected>;
+//#endregion
+export { AngularAsyncThrottler, injectAsyncThrottler };
+//# sourceMappingURL=injectAsyncThrottler.d.ts.map

package/dist/async-throttler/injectAsyncThrottler.js

@@ -0,0 +1,62 @@
+import { injectPacerOptions } from "../provider/pacer-context.js";
+import { injectStore } from "@tanstack/angular-store";
+import { AsyncThrottler } from "@tanstack/pacer/async-throttler";
+
+//#region src/async-throttler/injectAsyncThrottler.ts
+/**
+* An Angular function that creates and manages an AsyncThrottler instance.
+*
+* This is a lower-level function that provides direct access to the AsyncThrottler's functionality.
+* This allows you to integrate it with any state management solution you prefer.
+*
+* This function provides async throttling functionality with promise support, error handling,
+* retry capabilities, and abort support.
+*
+* The throttler will execute the function at most once within the specified wait time.
+*
+* ## State Management and Selector
+*
+* The function uses TanStack Store for state management and wraps it with Angular signals.
+* The `selector` parameter allows you to specify which state changes will trigger signal updates,
+* 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. This prevents unnecessary updates and gives you
+* full control over when your component tracks state changes.
+*
+* @example
+* ```ts
+* // Default behavior - no reactive state subscriptions
+* const throttler = injectAsyncThrottler(
+*   async (data: Data) => {
+*     const response = await fetch('/api/update', {
+*       method: 'POST',
+*       body: JSON.stringify(data)
+*     });
+*     return response.json();
+*   },
+*   { wait: 1000 }
+* );
+*
+* // In an event handler
+* const handleUpdate = async (data: Data) => {
+*   const result = await throttler.maybeExecute(data);
+*   console.log('Update result:', result);
+* };
+* ```
+*/
+function injectAsyncThrottler(fn, options, selector = () => ({})) {
+	const throttler = new AsyncThrottler(fn, {
+		...injectPacerOptions().asyncThrottler,
+		...options
+	});
+	const state = injectStore(throttler.store, selector);
+	return {
+		...throttler,
+		state
+	};
+}
+
+//#endregion
+export { injectAsyncThrottler };
+//# sourceMappingURL=injectAsyncThrottler.js.map

package/dist/async-throttler/injectAsyncThrottler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectAsyncThrottler.js","names":[],"sources":["../../src/async-throttler/injectAsyncThrottler.ts"],"sourcesContent":["import { injectStore } from '@tanstack/angular-store'\nimport { AsyncThrottler } from '@tanstack/pacer/async-throttler'\nimport { injectPacerOptions } from '../provider/pacer-context'\nimport type { Signal } from '@angular/core'\nimport type { Store } from '@tanstack/store'\nimport type { AnyAsyncFunction } from '@tanstack/pacer/types'\nimport type {\n  AsyncThrottlerOptions,\n  AsyncThrottlerState,\n} from '@tanstack/pacer/async-throttler'\n\nexport interface AngularAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n> extends Omit<AsyncThrottler<TFn>, 'store'> {\n  /**\n   * Reactive state signal that will be updated when the async throttler state changes\n   *\n   * Use this instead of `throttler.store.state`\n   */\n  readonly state: Signal<Readonly<TSelected>>\n  /**\n   * @deprecated Use `throttler.state` instead of `throttler.store.state` if you want to read reactive state.\n   * The state on the store object is not reactive in Angular signals.\n   */\n  readonly store: Store<Readonly<AsyncThrottlerState<TFn>>>\n}\n\n/**\n * An Angular function that creates and manages an AsyncThrottler instance.\n *\n * This is a lower-level function that provides direct access to the AsyncThrottler's functionality.\n * This allows you to integrate it with any state management solution you prefer.\n *\n * This function provides async throttling functionality with promise support, error handling,\n * retry capabilities, and abort support.\n *\n * The throttler will execute the function at most once within the specified wait time.\n *\n * ## State Management and Selector\n *\n * The function uses TanStack Store for state management and wraps it with Angular signals.\n * The `selector` parameter allows you to specify which state changes will trigger signal updates,\n * optimizing performance by preventing unnecessary updates 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 updates and gives you\n * full control over when your component tracks state changes.\n *\n * @example\n * ```ts\n * // Default behavior - no reactive state subscriptions\n * const throttler = injectAsyncThrottler(\n *   async (data: Data) => {\n *     const response = await fetch('/api/update', {\n *       method: 'POST',\n *       body: JSON.stringify(data)\n *     });\n *     return response.json();\n *   },\n *   { wait: 1000 }\n * );\n *\n * // In an event handler\n * const handleUpdate = async (data: Data) => {\n *   const result = await throttler.maybeExecute(data);\n *   console.log('Update result:', result);\n * };\n * ```\n */\nexport function injectAsyncThrottler<\n  TFn extends AnyAsyncFunction,\n  TSelected = {},\n>(\n  fn: TFn,\n  options: AsyncThrottlerOptions<TFn>,\n  selector: (state: AsyncThrottlerState<TFn>) => TSelected = () =>\n    ({}) as TSelected,\n): AngularAsyncThrottler<TFn, TSelected> {\n  const mergedOptions = {\n    ...injectPacerOptions().asyncThrottler,\n    ...options,\n  } as AsyncThrottlerOptions<TFn>\n\n  const throttler = new AsyncThrottler<TFn>(fn, mergedOptions)\n  const state = injectStore(throttler.store, selector)\n\n  return {\n    ...throttler,\n    state,\n  } as AngularAsyncThrottler<TFn, TSelected>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,SAAgB,qBAId,IACA,SACA,kBACG,EAAE,GACkC;CAMvC,MAAM,YAAY,IAAI,eAAoB,IALpB;EACpB,GAAG,oBAAoB,CAAC;EACxB,GAAG;EACJ,CAE2D;CAC5D,MAAM,QAAQ,YAAY,UAAU,OAAO,SAAS;AAEpD,QAAO;EACL,GAAG;EACH;EACD"}

package/dist/batcher/index.cjs

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

package/dist/batcher/index.d.cts

@@ -0,0 +1,4 @@
+import { injectBatchedCallback } from "./injectBatchedCallback.cjs";
+import { AngularBatcher, injectBatcher } from "./injectBatcher.cjs";
+export * from "@tanstack/pacer/batcher";
+export { AngularBatcher, injectBatchedCallback, injectBatcher };

package/dist/batcher/index.d.ts

@@ -0,0 +1,4 @@
+import { injectBatchedCallback } from "./injectBatchedCallback.js";
+import { AngularBatcher, injectBatcher } from "./injectBatcher.js";
+export * from "@tanstack/pacer/batcher";
+export { AngularBatcher, injectBatchedCallback, injectBatcher };

package/dist/batcher/index.js

@@ -0,0 +1,6 @@
+import { injectBatcher } from "./injectBatcher.js";
+import { injectBatchedCallback } from "./injectBatchedCallback.js";
+
+export * from "@tanstack/pacer/batcher"
+
+export { injectBatchedCallback, injectBatcher };

package/dist/batcher/injectBatchedCallback.cjs

@@ -0,0 +1,47 @@
+const require_injectBatcher = require('./injectBatcher.cjs');
+
+//#region src/batcher/injectBatchedCallback.ts
+/**
+* An Angular function that creates a batched version of a callback function.
+* This function is essentially a wrapper around `injectBatcher` that provides
+* a simplified API for basic batching needs.
+*
+* The batched function will collect items and process them in batches based on
+* the configured conditions (maxSize, wait time, etc.).
+*
+* This function provides a simpler API compared to `injectBatcher`, making it ideal for basic
+* batching needs. However, it does not expose the underlying Batcher instance.
+*
+* For advanced usage requiring features like:
+* - Manual flushing
+* - Access to batch state
+* - State tracking
+*
+* Consider using the `injectBatcher` function instead.
+*
+* @example
+* ```ts
+* // Batch API calls
+* const batchApiCall = injectBatchedCallback(
+*   (items) => {
+*     return fetch('/api/batch', {
+*       method: 'POST',
+*       body: JSON.stringify(items)
+*     });
+*   },
+*   { maxSize: 10, wait: 1000 }
+* );
+*
+* // Items will be batched and sent together
+* batchApiCall('item1');
+* batchApiCall('item2');
+* ```
+*/
+function injectBatchedCallback(fn, options) {
+	const batcher = require_injectBatcher.injectBatcher(fn, options);
+	return (item) => batcher.addItem(item);
+}
+
+//#endregion
+exports.injectBatchedCallback = injectBatchedCallback;
+//# sourceMappingURL=injectBatchedCallback.cjs.map

package/dist/batcher/injectBatchedCallback.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectBatchedCallback.cjs","names":["injectBatcher"],"sources":["../../src/batcher/injectBatchedCallback.ts"],"sourcesContent":["import { injectBatcher } from './injectBatcher'\nimport type { BatcherOptions } from '@tanstack/pacer/batcher'\n\n/**\n * An Angular function that creates a batched version of a callback function.\n * This function is essentially a wrapper around `injectBatcher` that provides\n * a simplified API for basic batching needs.\n *\n * The batched function will collect items and process them in batches based on\n * the configured conditions (maxSize, wait time, etc.).\n *\n * This function provides a simpler API compared to `injectBatcher`, making it ideal for basic\n * batching needs. However, it does not expose the underlying Batcher instance.\n *\n * For advanced usage requiring features like:\n * - Manual flushing\n * - Access to batch state\n * - State tracking\n *\n * Consider using the `injectBatcher` function instead.\n *\n * @example\n * ```ts\n * // Batch API calls\n * const batchApiCall = injectBatchedCallback(\n *   (items) => {\n *     return fetch('/api/batch', {\n *       method: 'POST',\n *       body: JSON.stringify(items)\n *     });\n *   },\n *   { maxSize: 10, wait: 1000 }\n * );\n *\n * // Items will be batched and sent together\n * batchApiCall('item1');\n * batchApiCall('item2');\n * ```\n */\nexport function injectBatchedCallback<TValue>(\n  fn: (items: Array<TValue>) => void,\n  options: BatcherOptions<TValue>,\n): (item: TValue) => void {\n  const batcher = injectBatcher(fn, options)\n  return (item: TValue) => batcher.addItem(item)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,sBACd,IACA,SACwB;CACxB,MAAM,UAAUA,oCAAc,IAAI,QAAQ;AAC1C,SAAQ,SAAiB,QAAQ,QAAQ,KAAK"}

package/dist/batcher/injectBatchedCallback.d.cts

@@ -0,0 +1,43 @@
+import { BatcherOptions } from "@tanstack/pacer/batcher";
+
+//#region src/batcher/injectBatchedCallback.d.ts
+/**
+ * An Angular function that creates a batched version of a callback function.
+ * This function is essentially a wrapper around `injectBatcher` that provides
+ * a simplified API for basic batching needs.
+ *
+ * The batched function will collect items and process them in batches based on
+ * the configured conditions (maxSize, wait time, etc.).
+ *
+ * This function provides a simpler API compared to `injectBatcher`, making it ideal for basic
+ * batching needs. However, it does not expose the underlying Batcher instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual flushing
+ * - Access to batch state
+ * - State tracking
+ *
+ * Consider using the `injectBatcher` function instead.
+ *
+ * @example
+ * ```ts
+ * // Batch API calls
+ * const batchApiCall = injectBatchedCallback(
+ *   (items) => {
+ *     return fetch('/api/batch', {
+ *       method: 'POST',
+ *       body: JSON.stringify(items)
+ *     });
+ *   },
+ *   { maxSize: 10, wait: 1000 }
+ * );
+ *
+ * // Items will be batched and sent together
+ * batchApiCall('item1');
+ * batchApiCall('item2');
+ * ```
+ */
+declare function injectBatchedCallback<TValue>(fn: (items: Array<TValue>) => void, options: BatcherOptions<TValue>): (item: TValue) => void;
+//#endregion
+export { injectBatchedCallback };
+//# sourceMappingURL=injectBatchedCallback.d.cts.map

package/dist/batcher/injectBatchedCallback.d.ts

@@ -0,0 +1,43 @@
+import { BatcherOptions } from "@tanstack/pacer/batcher";
+
+//#region src/batcher/injectBatchedCallback.d.ts
+/**
+ * An Angular function that creates a batched version of a callback function.
+ * This function is essentially a wrapper around `injectBatcher` that provides
+ * a simplified API for basic batching needs.
+ *
+ * The batched function will collect items and process them in batches based on
+ * the configured conditions (maxSize, wait time, etc.).
+ *
+ * This function provides a simpler API compared to `injectBatcher`, making it ideal for basic
+ * batching needs. However, it does not expose the underlying Batcher instance.
+ *
+ * For advanced usage requiring features like:
+ * - Manual flushing
+ * - Access to batch state
+ * - State tracking
+ *
+ * Consider using the `injectBatcher` function instead.
+ *
+ * @example
+ * ```ts
+ * // Batch API calls
+ * const batchApiCall = injectBatchedCallback(
+ *   (items) => {
+ *     return fetch('/api/batch', {
+ *       method: 'POST',
+ *       body: JSON.stringify(items)
+ *     });
+ *   },
+ *   { maxSize: 10, wait: 1000 }
+ * );
+ *
+ * // Items will be batched and sent together
+ * batchApiCall('item1');
+ * 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

package/dist/batcher/injectBatchedCallback.js

@@ -0,0 +1,47 @@
+import { injectBatcher } from "./injectBatcher.js";
+
+//#region src/batcher/injectBatchedCallback.ts
+/**
+* An Angular function that creates a batched version of a callback function.
+* This function is essentially a wrapper around `injectBatcher` that provides
+* a simplified API for basic batching needs.
+*
+* The batched function will collect items and process them in batches based on
+* the configured conditions (maxSize, wait time, etc.).
+*
+* This function provides a simpler API compared to `injectBatcher`, making it ideal for basic
+* batching needs. However, it does not expose the underlying Batcher instance.
+*
+* For advanced usage requiring features like:
+* - Manual flushing
+* - Access to batch state
+* - State tracking
+*
+* Consider using the `injectBatcher` function instead.
+*
+* @example
+* ```ts
+* // Batch API calls
+* const batchApiCall = injectBatchedCallback(
+*   (items) => {
+*     return fetch('/api/batch', {
+*       method: 'POST',
+*       body: JSON.stringify(items)
+*     });
+*   },
+*   { maxSize: 10, wait: 1000 }
+* );
+*
+* // Items will be batched and sent together
+* batchApiCall('item1');
+* batchApiCall('item2');
+* ```
+*/
+function injectBatchedCallback(fn, options) {
+	const batcher = injectBatcher(fn, options);
+	return (item) => batcher.addItem(item);
+}
+
+//#endregion
+export { injectBatchedCallback };
+//# sourceMappingURL=injectBatchedCallback.js.map

package/dist/batcher/injectBatchedCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectBatchedCallback.js","names":[],"sources":["../../src/batcher/injectBatchedCallback.ts"],"sourcesContent":["import { injectBatcher } from './injectBatcher'\nimport type { BatcherOptions } from '@tanstack/pacer/batcher'\n\n/**\n * An Angular function that creates a batched version of a callback function.\n * This function is essentially a wrapper around `injectBatcher` that provides\n * a simplified API for basic batching needs.\n *\n * The batched function will collect items and process them in batches based on\n * the configured conditions (maxSize, wait time, etc.).\n *\n * This function provides a simpler API compared to `injectBatcher`, making it ideal for basic\n * batching needs. However, it does not expose the underlying Batcher instance.\n *\n * For advanced usage requiring features like:\n * - Manual flushing\n * - Access to batch state\n * - State tracking\n *\n * Consider using the `injectBatcher` function instead.\n *\n * @example\n * ```ts\n * // Batch API calls\n * const batchApiCall = injectBatchedCallback(\n *   (items) => {\n *     return fetch('/api/batch', {\n *       method: 'POST',\n *       body: JSON.stringify(items)\n *     });\n *   },\n *   { maxSize: 10, wait: 1000 }\n * );\n *\n * // Items will be batched and sent together\n * batchApiCall('item1');\n * batchApiCall('item2');\n * ```\n */\nexport function injectBatchedCallback<TValue>(\n  fn: (items: Array<TValue>) => void,\n  options: BatcherOptions<TValue>,\n): (item: TValue) => void {\n  const batcher = injectBatcher(fn, options)\n  return (item: TValue) => batcher.addItem(item)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,sBACd,IACA,SACwB;CACxB,MAAM,UAAU,cAAc,IAAI,QAAQ;AAC1C,SAAQ,SAAiB,QAAQ,QAAQ,KAAK"}