feat: angular adapter

docs/framework/angular/reference/functions/injectAsyncBatchedCallback.md

@@ -0,0 +1,82 @@
+---
+id: injectAsyncBatchedCallback
+title: injectAsyncBatchedCallback
+---
+
+# Function: injectAsyncBatchedCallback()
+
+```ts
+function injectAsyncBatchedCallback<TValue>(fn, options): (item) => Promise<void>;
+```
+
+Defined in: [async-batcher/injectAsyncBatchedCallback.ts:42](https://github.com/theVedanta/pacer/blob/main/packages/angular-pacer/src/async-batcher/injectAsyncBatchedCallback.ts#L42)
+
+An Angular function that creates an async batched version of a callback function.
+This function is essentially a wrapper around `injectAsyncBatcher` that provides
+a simplified API for basic async batching needs.
+
+The batched function will collect items and process them in batches asynchronously based on
+the configured conditions (maxSize, wait time, etc.).
+
+This function provides a simpler API compared to `injectAsyncBatcher`, making it ideal for basic
+async batching needs. However, it does not expose the underlying AsyncBatcher instance.
+
+For advanced usage requiring features like:
+- Manual flushing
+- Access to batch state
+- Error handling callbacks
+- Retry support
+
+Consider using the `injectAsyncBatcher` function instead.
+
+## Type Parameters
+
+### TValue
+
+`TValue`
+
+## Parameters
+
+### fn
+
+(`items`) => `Promise`\<`any`\>
+
+### options
+
+`AsyncBatcherOptions`\<`TValue`\>
+
+## Returns
+
+```ts
+(item): Promise<void>;
+```
+
+### Parameters
+
+#### item
+
+`TValue`
+
+### Returns
+
+`Promise`\<`void`\>
+
+## Example
+
+```ts
+// Batch async API calls
+const batchApiCall = injectAsyncBatchedCallback(
+  async (items: Array<Data>) => {
+    const response = await fetch('/api/batch', {
+      method: 'POST',
+      body: JSON.stringify(items)
+    });
+    return response.json();
+  },
+  { maxSize: 10, wait: 1000 }
+);
+
+// Items will be batched and sent together
+await batchApiCall(data1);
+await batchApiCall(data2);
+```

docs/framework/angular/reference/functions/injectAsyncBatcher.md

@@ -0,0 +1,85 @@
+---
+id: injectAsyncBatcher
+title: injectAsyncBatcher
+---
+
+# Function: injectAsyncBatcher()
+
+```ts
+function injectAsyncBatcher<TValue, TSelected>(
+   fn, 
+   options, 
+selector): AngularAsyncBatcher<TValue, TSelected>;
+```
+
+Defined in: [async-batcher/injectAsyncBatcher.ts:69](https://github.com/theVedanta/pacer/blob/main/packages/angular-pacer/src/async-batcher/injectAsyncBatcher.ts#L69)
+
+An Angular function that creates and manages an AsyncBatcher instance.
+
+This is a lower-level function that provides direct access to the AsyncBatcher's functionality.
+This allows you to integrate it with any state management solution you prefer.
+
+The AsyncBatcher collects items and processes them in batches asynchronously with support for
+promise-based processing, error handling, retry capabilities, and abort support.
+
+## 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.
+
+## Type Parameters
+
+### TValue
+
+`TValue`
+
+### TSelected
+
+`TSelected` = \{
+\}
+
+## Parameters
+
+### fn
+
+(`items`) => `Promise`\<`any`\>
+
+### options
+
+`AsyncBatcherOptions`\<`TValue`\> = `{}`
+
+### selector
+
+(`state`) => `TSelected`
+
+## Returns
+
+[`AngularAsyncBatcher`](../interfaces/AngularAsyncBatcher.md)\<`TValue`, `TSelected`\>
+
+## Example
+
+```ts
+// Default behavior - no reactive state subscriptions
+const batcher = injectAsyncBatcher(
+  async (items: Array<Data>) => {
+    const response = await fetch('/api/batch', {
+      method: 'POST',
+      body: JSON.stringify(items)
+    });
+    return response.json();
+  },
+  { maxSize: 10, wait: 2000 }
+);
+
+// Add items
+batcher.addItem(data1);
+batcher.addItem(data2);
+
+// Access the selected state
+const { items, isExecuting } = batcher.state();
+```

docs/framework/angular/reference/functions/injectAsyncDebouncedCallback.md

@@ -0,0 +1,79 @@
+---
+id: injectAsyncDebouncedCallback
+title: injectAsyncDebouncedCallback
+---
+
+# Function: injectAsyncDebouncedCallback()
+
+```ts
+function injectAsyncDebouncedCallback<TFn>(fn, options): (...args) => Promise<Awaited<ReturnType<TFn>> | undefined>;
+```
+
+Defined in: [async-debouncer/injectAsyncDebouncedCallback.ts:40](https://github.com/theVedanta/pacer/blob/main/packages/angular-pacer/src/async-debouncer/injectAsyncDebouncedCallback.ts#L40)
+
+An Angular function that creates an async debounced version of a callback function.
+This function is essentially a wrapper around `injectAsyncDebouncer` that provides
+a simplified API for basic async debouncing needs.
+
+The debounced function will only execute after the specified wait time has elapsed
+since its last invocation. If called again before the wait time expires, the timer
+resets and starts waiting again.
+
+This function provides a simpler API compared to `injectAsyncDebouncer`, making it ideal for basic
+async debouncing needs. However, it does not expose the underlying AsyncDebouncer instance.
+
+For advanced usage requiring features like:
+- Manual cancellation
+- Access to execution counts
+- Error handling callbacks
+- Retry support
+
+Consider using the `injectAsyncDebouncer` function instead.
+
+## Type Parameters
+
+### TFn
+
+`TFn` *extends* `AnyAsyncFunction`
+
+## Parameters
+
+### fn
+
+`TFn`
+
+### options
+
+`AsyncDebouncerOptions`\<`TFn`\>
+
+## Returns
+
+```ts
+(...args): Promise<Awaited<ReturnType<TFn>> | undefined>;
+```
+
+### Parameters
+
+#### args
+
+...`Parameters`\<`TFn`\>
+
+### Returns
+
+`Promise`\<`Awaited`\<`ReturnType`\<`TFn`\>\> \| `undefined`\>
+
+## Example
+
+```ts
+// Debounce an async search handler
+const handleSearch = injectAsyncDebouncedCallback(
+  async (query: string) => {
+    const response = await fetch(`/api/search?q=${query}`);
+    return response.json();
+  },
+  { wait: 500 }
+);
+
+// Use in an input
+const results = await handleSearch(searchQuery);
+```

docs/framework/angular/reference/functions/injectAsyncDebouncer.md

@@ -0,0 +1,107 @@
+---
+id: injectAsyncDebouncer
+title: injectAsyncDebouncer
+---
+
+# Function: injectAsyncDebouncer()
+
+```ts
+function injectAsyncDebouncer<TFn, TSelected>(
+   fn, 
+   options, 
+selector): AngularAsyncDebouncer<TFn, TSelected>;
+```
+
+Defined in: [async-debouncer/injectAsyncDebouncer.ts:92](https://github.com/theVedanta/pacer/blob/main/packages/angular-pacer/src/async-debouncer/injectAsyncDebouncer.ts#L92)
+
+An Angular function that creates and manages an AsyncDebouncer instance.
+
+This is a lower-level function that provides direct access to the AsyncDebouncer's functionality.
+This allows you to integrate it with any state management solution you prefer.
+
+This function provides async debouncing functionality with promise support, error handling,
+retry capabilities, and abort support.
+
+The debouncer will only execute the function after the specified wait time has elapsed
+since the last call. If the function is called again before the wait time expires, the
+timer resets and starts waiting again.
+
+## 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.
+
+Available state properties:
+- `canLeadingExecute`: Whether the debouncer can execute on the leading edge
+- `errorCount`: Number of function executions that have resulted in errors
+- `isExecuting`: Whether the debounced function is currently executing asynchronously
+- `isPending`: Whether the debouncer is waiting for the timeout to trigger execution
+- `lastArgs`: The arguments from the most recent call to maybeExecute
+- `lastResult`: The result from the most recent successful function execution
+- `settleCount`: Number of function executions that have completed (either successfully or with errors)
+- `status`: Current execution status ('disabled' | 'idle' | 'pending' | 'executing' | 'settled')
+- `successCount`: Number of function executions that have completed successfully
+
+## Type Parameters
+
+### TFn
+
+`TFn` *extends* `AnyAsyncFunction`
+
+### TSelected
+
+`TSelected` = \{
+\}
+
+## Parameters
+
+### fn
+
+`TFn`
+
+### options
+
+`AsyncDebouncerOptions`\<`TFn`\>
+
+### selector
+
+(`state`) => `TSelected`
+
+## Returns
+
+[`AngularAsyncDebouncer`](../interfaces/AngularAsyncDebouncer.md)\<`TFn`, `TSelected`\>
+
+## Example
+
+```ts
+// Default behavior - no reactive state subscriptions
+const debouncer = injectAsyncDebouncer(
+  async (query: string) => {
+    const response = await fetch(`/api/search?q=${query}`);
+    return response.json();
+  },
+  { wait: 500 }
+);
+
+// Opt-in to track isExecuting changes (optimized for loading states)
+const debouncer = injectAsyncDebouncer(
+  async (query: string) => fetchSearchResults(query),
+  { wait: 500 },
+  (state) => ({ isExecuting: state.isExecuting, isPending: state.isPending })
+);
+
+// In an event handler
+const handleChange = async (e: Event) => {
+  const target = e.target as HTMLInputElement;
+  const result = await debouncer.maybeExecute(target.value);
+  console.log('Search results:', result);
+};
+
+// Access the selected state
+const { isExecuting, errorCount } = debouncer.state();
+```