ng-simple-state 21.1.4 → 21.1.5

package/README.md

@@ -1,4 +1,4 @@
-# NgSimpleState [![Build Status](https://app.travis-ci.com/nigrosimone/ng-simple-state.svg?branch=main)](https://app.travis-ci.com/nigrosimone/ng-simple-state) [![Coverage Status](https://coveralls.io/repos/github/nigrosimone/ng-simple-state/badge.svg?branch=main)](https://coveralls.io/github/nigrosimone/ng-simple-state?branch=main) [![NPM version](https://img.shields.io/npm/v/ng-simple-state.svg)](https://www.npmjs.com/package/ng-simple-state) [![Maintainability](https://api.codeclimate.com/v1/badges/1bfc363a95053ecc3429/maintainability)](https://codeclimate.com/github/nigrosimone/ng-simple-state/maintainability)
+# NgSimpleState [![NPM version](https://img.shields.io/npm/v/ng-simple-state.svg)](https://www.npmjs.com/package/ng-simple-state) [![Maintainability](https://qlty.sh/gh/nigrosimone/projects/ng-simple-state/maintainability.svg)](https://qlty.sh/gh/nigrosimone/projects/ng-simple-state)
 
 Simple state management in Angular with only Services and RxJS or Signal.
 
@@ -31,7 +31,6 @@ npm i ng-simple-state
 | *serializeState*       | A function used to serialize the state to a string.                                             | `JSON.stringify` |
 | *deserializeState*     | A function used to deserialize the state from a string.                                         | `JSON.parse`     |
 | *plugins*              | Array of plugins to extend store functionality.                                                 | `[]`             |
-| *enableImmer*          | Enable Immer-style immutable updates.                                                           | `false`          |
 | *immerProduce*         | Custom Immer produce function for immutable updates.                                            | undefined        |
 
 _Side note: each store can be override the global configuration implementing `storeConfig()` method (see "Override global config")._
@@ -1154,7 +1153,6 @@ Usage in component:
   selector: 'app-profile',
   template: `
     <p>Full Name: {{ store.fullName() }}</p>
-    <p>Is Adult: {{ store.isAdult() ? 'Yes' : 'No' }}</p>
     <input [value]="firstName()" (input)="updateFirstName($event)" placeholder="First name" />
     <input [value]="lastName()" (input)="updateLastName($event)" placeholder="Last name" />
   `
@@ -1283,89 +1281,83 @@ const myCustomPlugin: NgSimpleStatePlugin = {
 };
 ```
 
-### Batch Updates
+### Transactions
 
-Group multiple state updates into a single emission to improve performance:
+Execute operations with automatic rollback on error using `withTransaction`:
 
 ```ts
-import { Injectable, Signal } from '@angular/core';
-import { NgSimpleStateBaseSignalStore, NgSimpleStateStoreConfig, batchState } from 'ng-simple-state';
-
-export interface FormState {
-  name: string;
-  email: string;
-  phone: string;
-  isValid: boolean;
-}
-
-@Injectable({ providedIn: 'root' })
-export class FormStore extends NgSimpleStateBaseSignalStore<FormState> {
+import { withTransaction } from 'ng-simple-state';
+
+// Transaction with automatic rollback on error
+await withTransaction(store, async (tx) => {
+  store.setState({ step: 1 });
+  await apiCall(); // If this fails, state rolls back automatically
+  store.setState({ step: 2 });
+  tx.commit(); // Explicit commit (optional - auto-commits if not called)
+});
 
-  storeConfig(): NgSimpleStateStoreConfig<FormState> {
-    return { storeName: 'FormStore' };
+// Manual rollback example
+await withTransaction(store, async (tx) => {
+  store.setState({ processing: true });
+  const result = await riskyOperation();
+  
+  if (!result.success) {
+    tx.rollback(); // Manually rollback to initial state
+    return;
   }
+  
+  store.setState({ data: result.data });
+  tx.commit();
+});
+```
 
-  initialState(): FormState {
-    return { name: '', email: '', phone: '', isValid: false };
-  }
+### Debounced Updates
 
-  selectForm(): Signal<FormState> {
-    return this.selectState();
-  }
+Rate-limit state updates with `createDebouncedUpdater`. Only the last update within the time window is applied:
 
-  // Batch multiple updates - only one emission at the end
-  updateAllFields(name: string, email: string, phone: string): void {
-    batchState(() => {
-      this.setState({ name });
-      this.setState({ email });
-      this.setState({ phone });
-      this.setState({ isValid: this.validateForm(name, email, phone) });
-    }); // Single emission with all changes
-  }
+```ts
+import { createDebouncedUpdater } from 'ng-simple-state';
 
-  // Regular updates (each triggers an emission)
-  setName(name: string): void {
-    this.setState({ name });
-  }
+// Create a debounced updater with 300ms delay
+const { update, flush, cancel } = createDebouncedUpdater<MyState>(
+  (state) => store.setState(state),
+  300
+);
 
-  setEmail(email: string): void {
-    this.setState({ email });
-  }
+// Rapid calls - only the last one is applied after 300ms
+update({ searchQuery: 'a' });
+update({ searchQuery: 'ab' });
+update({ searchQuery: 'abc' }); // Only this is applied after 300ms
 
-  private validateForm(name: string, email: string, phone: string): boolean {
-    return name.length > 0 && email.includes('@') && phone.length >= 10;
-  }
-}
+// Force immediate update
+flush();
+
+// Cancel any pending update
+cancel();
 ```
 
-Usage in component:
+### Throttled Updates
+
+Limit update frequency with `createThrottledUpdater`. At most one update per time window:
 
 ```ts
-@Component({
-  selector: 'app-form',
-  template: `
-    <form (ngSubmit)="submitForm()">
-      <input [(ngModel)]="name" name="name" placeholder="Name" />
-      <input [(ngModel)]="email" name="email" placeholder="Email" />
-      <input [(ngModel)]="phone" name="phone" placeholder="Phone" />
-      <button type="submit">Save All (Batched)</button>
-    </form>
-    <p>Form Valid: {{ form().isValid ? 'Yes' : 'No' }}</p>
-  `
-})
-export class FormComponent {
-  store = inject(FormStore);
-  form = this.store.selectForm();
-  
-  name = '';
-  email = '';
-  phone = '';
+import { createThrottledUpdater } from 'ng-simple-state';
 
-  submitForm(): void {
-    // All updates batched into single emission
-    this.store.updateAllFields(this.name, this.email, this.phone);
-  }
-}
+// Create a throttled updater with 100ms delay
+const { update, cancel } = createThrottledUpdater<MyState>(
+  (state) => store.setState(state),
+  100
+);
+
+// First call executes immediately, subsequent calls are throttled
+update({ scrollPosition: 100 }); // Executes immediately
+update({ scrollPosition: 150 }); // Queued
+update({ scrollPosition: 200 }); // Replaces queued update
+
+// After 100ms, { scrollPosition: 200 } is applied
+
+// Cancel pending throttled update
+cancel();
 ```
 
 ### Immer-style Updates
@@ -1508,6 +1500,43 @@ Features available in Redux DevTools:
 
 ![Redux DevTools](https://github.com/nigrosimone/ng-simple-state/blob/main/projects/ng-simple-state-demo/src/assets/dev-tool.gif?raw=true)
 
+### Integration with ng-http-caching
+
+`ng-simple-state` can be used as a reactive storage backend for [ng-http-caching](https://www.npmjs.com/package/ng-http-caching). This integration allows you to manage the HTTP cache through `ng-simple-state` stores, providing full visibility and control over the cache state within your DevTools or application state.
+
+1. Install `ng-http-caching`:
+
+```bash
+npm i ng-http-caching
+```
+
+2. Configure `ng-http-caching` to use the `ng-simple-state` adapter in your `bootstrapApplication`:
+
+```ts
+import { provideNgHttpCaching } from 'ng-http-caching';
+import { withNgHttpCachingNgSimpleState } from 'ng-http-caching/ng-simple-state';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideNgHttpCaching({
+      store: withNgHttpCachingNgSimpleState(),
+    }),
+    // ... other providers
+  ]
+});
+```
+
+You can customize the store configuration (e.g., enable persistence or change the store name) by passing a configuration object to the adapter:
+
+```ts
+provideNgHttpCaching({
+  store: withNgHttpCachingNgSimpleState({
+    storeName: 'MyCacheStore',
+    // ... other NgSimpleStateStoreConfig options
+  }),
+})
+```
+
 ## Alternatives
 
 Aren't you satisfied? there are some valid alternatives:

package/fesm2022/ng-simple-state.mjs

@@ -21,11 +21,11 @@ class NgSimpleStateModule {
             ],
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateModule, decorators: [{
             type: NgModule
         }] });
 
@@ -50,9 +50,9 @@ class NgSimpleStateDevTool {
         this.historyIdCounter = 0;
         this.maxHistorySize = 100;
         /** Current history position for time-travel */
-        this.currentPositionSig = signal(-1, ...(ngDevMode ? [{ debugName: "currentPositionSig" }] : []));
+        this.currentPositionSig = signal(-1, ...(ngDevMode ? [{ debugName: "currentPositionSig" }] : /* istanbul ignore next */ []));
         /** Paused state - when true, state changes are not recorded */
-        this.isPausedSig = signal(false, ...(ngDevMode ? [{ debugName: "isPausedSig" }] : []));
+        this.isPausedSig = signal(false, ...(ngDevMode ? [{ debugName: "isPausedSig" }] : /* istanbul ignore next */ []));
         if (this.globalDevtools) {
             inject(NgZone).runOutsideAngular(() => {
                 this.localDevTool = this.globalDevtools.connect({
@@ -404,10 +404,10 @@ class NgSimpleStateDevTool {
         }
         return NgSimpleStateDevTool.computeDiff(last.prevState, last.state);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateDevTool, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateDevTool, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateDevTool, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateDevTool, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateDevTool, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateDevTool, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
@@ -822,7 +822,9 @@ class NgSimpleStateBaseCommonStore {
             return undefined;
         }
         // avoid function call if not necessary
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
         this.devTool && this.devToolSend(state, resolvedActionName);
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
         this.storage && this.statePersist(state);
         // Notify plugins after change
         this.notifyPluginsAfterChange(currState, state, resolvedActionName);
@@ -869,7 +871,9 @@ class NgSimpleStateBaseCommonStore {
             return undefined;
         }
         // avoid function call if not necessary
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
         this.devTool && this.devToolSend(newState, resolvedActionName);
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
         this.storage && this.statePersist(newState);
         // Notify plugins after change
         this.notifyPluginsAfterChange(currState, newState, resolvedActionName);
@@ -925,11 +929,11 @@ class NgSimpleStateBaseCommonStore {
             this.storage.setItem(this.storeName, state);
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseCommonStore, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.0.0", type: NgSimpleStateBaseCommonStore, isStandalone: true, ngImport: i0 }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseCommonStore }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseCommonStore, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.5", type: NgSimpleStateBaseCommonStore, isStandalone: true, ngImport: i0 }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseCommonStore }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseCommonStore, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseCommonStore, decorators: [{
             type: Injectable
         }, {
             type: Directive
@@ -982,18 +986,29 @@ class NgSimpleStateBaseRxjsStore extends NgSimpleStateBaseCommonStore {
         return this.state$.pipe(map(state => selectFn(state)), distinctUntilChanged(comparator ?? this.comparator), observeOn(asyncScheduler));
     }
     /**
-     * Create an effect that reacts to state changes
+     * Create an effect from an observable
      * @param name Unique effect name
-     * @param effectFn Effect function that receives current state
+     * @param source$ Observable source
+     * @param effectFn Effect function that receives the observable value
      */
-    createEffect(name, effectFn) {
+    createEffectFromObservable(name, source$, effectFn) {
         // Cleanup existing effect with same name
         this.destroyEffect(name);
-        const subscription = this.state$.pipe(takeUntil(this.destroy$)).subscribe(state => {
-            effectFn(state);
+        const subscription = source$
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(value => {
+            effectFn(value);
         });
         this.registeredEffects.set(name, subscription);
     }
+    /**
+     * Create an effect that reacts to state changes
+     * @param name Unique effect name
+     * @param effectFn Effect function that receives current state
+     */
+    createEffect(name, effectFn) {
+        this.createEffectFromObservable(name, this.state$, effectFn);
+    }
     /**
      * Create an effect that reacts to selected state changes
      * @param name Unique effect name
@@ -1001,11 +1016,7 @@ class NgSimpleStateBaseRxjsStore extends NgSimpleStateBaseCommonStore {
      * @param effectFn Effect function that receives selected value
      */
     createSelectorEffect(name, selector, effectFn) {
-        this.destroyEffect(name);
-        const subscription = this.selectState(selector).pipe(takeUntil(this.destroy$)).subscribe(value => {
-            effectFn(value);
-        });
-        this.registeredEffects.set(name, subscription);
+        this.createEffectFromObservable(name, this.selectState(selector), effectFn);
     }
     /**
      * Destroy a specific effect by name
@@ -1091,11 +1102,11 @@ class NgSimpleStateBaseRxjsStore extends NgSimpleStateBaseCommonStore {
         }
         return false;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseRxjsStore, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.0.0", type: NgSimpleStateBaseRxjsStore, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseRxjsStore }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseRxjsStore, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.5", type: NgSimpleStateBaseRxjsStore, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseRxjsStore }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseRxjsStore, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseRxjsStore, decorators: [{
             type: Injectable
         }, {
             type: Directive
@@ -1106,7 +1117,7 @@ class NgSimpleStateBaseSignalStore extends NgSimpleStateBaseCommonStore {
     constructor() {
         super(...arguments);
         this.stackPoint = 4;
-        this.stateSig = signal(this.firstState, ...(ngDevMode ? [{ debugName: "stateSig" }] : []));
+        this.stateSig = signal(this.firstState, ...(ngDevMode ? [{ debugName: "stateSig" }] : /* istanbul ignore next */ []));
         this.stateSigRo = this.stateSig.asReadonly();
         this.registeredEffects = new Map();
         this.injector = inject(Injector);
@@ -1151,7 +1162,7 @@ class NgSimpleStateBaseSignalStore extends NgSimpleStateBaseCommonStore {
      * @returns WritableSignal that is linked to the store state
      */
     linkedState(options) {
-        const sourceSignal = computed(() => options.source(this.stateSig()), ...(ngDevMode ? [{ debugName: "sourceSignal" }] : []));
+        const sourceSignal = computed(() => options.source(this.stateSig()), ...(ngDevMode ? [{ debugName: "sourceSignal" }] : /* istanbul ignore next */ []));
         return linkedSignal({
             source: sourceSignal,
             computation: (source, previous) => {
@@ -1163,26 +1174,36 @@ class NgSimpleStateBaseSignalStore extends NgSimpleStateBaseCommonStore {
         });
     }
     /**
-     * Create an effect that reacts to state changes
+     * Create an effect from a signal
      * @param name Unique effect name
-     * @param effectFn Effect function that receives current state
+     * @param sourceSignal Signal source
+     * @param effectFn Effect function that receives the signal value
      * @returns EffectRef for cleanup
      */
-    createEffect(name, effectFn) {
+    createEffectFromSignal(name, sourceSignal, effectFn) {
         // Cleanup existing effect with same name
         this.destroyEffect(name);
         let cleanup;
         const effectRef = runInInjectionContext(this.injector, () => effect(() => {
-            const state = this.stateSig();
+            const value = sourceSignal();
             // Run previous cleanup
             if (cleanup) {
                 cleanup();
             }
-            cleanup = effectFn(state);
+            cleanup = effectFn(value);
         }));
         this.registeredEffects.set(name, effectRef);
         return effectRef;
     }
+    /**
+     * Create an effect that reacts to state changes
+     * @param name Unique effect name
+     * @param effectFn Effect function that receives current state
+     * @returns EffectRef for cleanup
+     */
+    createEffect(name, effectFn) {
+        return this.createEffectFromSignal(name, this.stateSig, effectFn);
+    }
     /**
      * Create an effect that reacts to selected state changes
      * @param name Unique effect name
@@ -1191,18 +1212,8 @@ class NgSimpleStateBaseSignalStore extends NgSimpleStateBaseCommonStore {
      * @returns EffectRef for cleanup
      */
     createSelectorEffect(name, selector, effectFn) {
-        this.destroyEffect(name);
-        const selectedSignal = computed(() => selector(this.stateSig()), ...(ngDevMode ? [{ debugName: "selectedSignal" }] : []));
-        let cleanup;
-        const effectRef = runInInjectionContext(this.injector, () => effect(() => {
-            const value = selectedSignal();
-            if (cleanup) {
-                cleanup();
-            }
-            cleanup = effectFn(value);
-        }));
-        this.registeredEffects.set(name, effectRef);
-        return effectRef;
+        const selectedSignal = computed(() => selector(this.stateSig()), ...(ngDevMode ? [{ debugName: "selectedSignal" }] : /* istanbul ignore next */ []));
+        return this.createEffectFromSignal(name, selectedSignal, effectFn);
     }
     /**
      * Destroy a specific effect by name
@@ -1288,11 +1299,11 @@ class NgSimpleStateBaseSignalStore extends NgSimpleStateBaseCommonStore {
         }
         return false;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseSignalStore, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.0.0", type: NgSimpleStateBaseSignalStore, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseSignalStore }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseSignalStore, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.5", type: NgSimpleStateBaseSignalStore, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseSignalStore }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgSimpleStateBaseSignalStore, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: NgSimpleStateBaseSignalStore, decorators: [{
             type: Injectable
         }, {
             type: Directive
@@ -1340,121 +1351,6 @@ function provideNgSimpleStatePlugins(plugins) {
         }]);
 }
 
-/**
- * Batch updates manager for grouping multiple state changes
- * into a single emission
- */
-class NgSimpleStateBatchManager {
-    constructor() {
-        this.batching = false;
-        this.pendingUpdates = new Map();
-        this.isBatchingSig = signal(false, ...(ngDevMode ? [{ debugName: "isBatchingSig" }] : []));
-    }
-    /**
-     * Get singleton instance
-     */
-    static getInstance() {
-        if (!NgSimpleStateBatchManager.instance) {
-            NgSimpleStateBatchManager.instance = new NgSimpleStateBatchManager();
-        }
-        return NgSimpleStateBatchManager.instance;
-    }
-    /**
-     * Check if currently batching
-     */
-    get isBatching() {
-        return this.isBatchingSig.asReadonly();
-    }
-    /**
-     * Start a batch operation
-     */
-    startBatch() {
-        this.batching = true;
-        this.isBatchingSig.set(true);
-    }
-    /**
-     * End batch operation and flush all pending updates
-     */
-    endBatch() {
-        this.batching = false;
-        this.isBatchingSig.set(false);
-        this.flush();
-    }
-    /**
-     * Check if currently in batch mode
-     */
-    isInBatch() {
-        return this.batching;
-    }
-    /**
-     * Queue an update for batching
-     * @param storeId Unique store identifier
-     * @param updateFn Update function to execute
-     */
-    queueUpdate(storeId, updateFn) {
-        if (!this.pendingUpdates.has(storeId)) {
-            this.pendingUpdates.set(storeId, []);
-        }
-        this.pendingUpdates.get(storeId).push(updateFn);
-    }
-    /**
-     * Flush all pending updates
-     */
-    flush() {
-        const updates = new Map(this.pendingUpdates);
-        this.pendingUpdates.clear();
-        updates.forEach((fns, storeId) => {
-            // Execute only the last update for each store
-            // since intermediate states are not needed
-            const lastUpdate = fns[fns.length - 1];
-            if (lastUpdate) {
-                lastUpdate();
-            }
-        });
-    }
-    /**
-     * Clear pending updates without executing
-     */
-    clearPending() {
-        this.pendingUpdates.clear();
-    }
-}
-/**
- * Execute multiple state updates in a batch
- * Only the final state is emitted
- *
- * @example
- * ```ts
- * batchState(() => {
- *   store.setState({ count: 1 });
- *   store.setState({ count: 2 });
- *   store.setState({ count: 3 });
- * }); // Only emits once with count: 3
- * ```
- */
-function batchState(updateFn) {
-    const manager = NgSimpleStateBatchManager.getInstance();
-    manager.startBatch();
-    try {
-        return updateFn();
-    }
-    finally {
-        manager.endBatch();
-    }
-}
-/**
- * Execute multiple state updates in a batch asynchronously
- */
-async function batchStateAsync(updateFn) {
-    const manager = NgSimpleStateBatchManager.getInstance();
-    manager.startBatch();
-    try {
-        return await updateFn();
-    }
-    finally {
-        manager.endBatch();
-    }
-}
 /**
  * Transaction wrapper for atomic state updates
  * Rolls back on error
@@ -1504,6 +1400,8 @@ class StateTransaction {
  *
  * @example
  * ```ts
+ * import { withTransaction } from 'ng-simple-state';
+ *
  * await withTransaction(store, async (tx) => {
  *   store.setState({ step: 1 });
  *   await apiCall(); // If this fails, state rolls back
@@ -1531,6 +1429,27 @@ async function withTransaction(store, fn) {
 /**
  * Debounce state updates
  * Only the last update within the time window is applied
+ *
+ * @example
+ * ```ts
+ * import { createDebouncedUpdater } from 'ng-simple-state';
+ *
+ * // Create a debounced updater with 300ms delay
+ * const { update, flush, cancel } = createDebouncedUpdater<MyState>(
+ *   (state) => store.setState(state),
+ *   300
+ * );
+ *
+ * // Rapid calls - only the last one is applied after 300ms
+ * update({ searchQuery: 'a' });
+ * update({ searchQuery: 'ab' });
+ * update({ searchQuery: 'abc' }); // Only this is applied after 300ms
+ *
+ * // Force immediate update
+ * flush();
+ *
+ * // Cancel any pending update
+ * cancel();
  */
 function createDebouncedUpdater(updateFn, delay = 100) {
     let timeoutId = null;
@@ -1564,6 +1483,27 @@ function createDebouncedUpdater(updateFn, delay = 100) {
 /**
  * Throttle state updates
  * At most one update per time window
+ *
+ * @example
+ * ```ts
+ * import { createThrottledUpdater } from 'ng-simple-state';
+ *
+ * // Create a throttled updater with 100ms delay
+ * const { update, cancel } = createThrottledUpdater<MyState>(
+ *   (state) => store.setState(state),
+ *   100
+ * );
+ *
+ * // First call executes immediately, subsequent calls are throttled
+ * update({ scrollPosition: 100 }); // Executes immediately
+ * update({ scrollPosition: 150 }); // Queued
+ * update({ scrollPosition: 200 }); // Replaces queued update
+ *
+ * // After 100ms, { scrollPosition: 200 } is applied
+ *
+ * // Cancel pending throttled update
+ * cancel();
+```
  */
 function createThrottledUpdater(updateFn, delay = 100) {
     let lastCall = 0;
@@ -1608,5 +1548,5 @@ function createThrottledUpdater(updateFn, delay = 100) {
  * Generated bundle index. Do not edit.
  */
 
-export { NG_SIMPLE_STATE_PLUGINS, NG_SIMPLE_STATE_UNDO_REDO, NG_SIMPLE_STORE_CONFIG, NgSimpleStateBaseCommonStore, NgSimpleStateBaseRxjsStore, NgSimpleStateBaseSignalStore, NgSimpleStateBatchManager, NgSimpleStateDevTool, NgSimpleStateLocalStorage, NgSimpleStateModule, NgSimpleStateSessionStorage, StateTransaction, batchState, batchStateAsync, createDebouncedUpdater, createThrottledUpdater, persistPlugin, provideNgSimpleState, provideNgSimpleStatePlugins, undoRedoPlugin, withTransaction };
+export { NG_SIMPLE_STATE_PLUGINS, NG_SIMPLE_STATE_UNDO_REDO, NG_SIMPLE_STORE_CONFIG, NgSimpleStateBaseCommonStore, NgSimpleStateBaseRxjsStore, NgSimpleStateBaseSignalStore, NgSimpleStateDevTool, NgSimpleStateLocalStorage, NgSimpleStateModule, NgSimpleStateSessionStorage, StateTransaction, createDebouncedUpdater, createThrottledUpdater, persistPlugin, provideNgSimpleState, provideNgSimpleStatePlugins, undoRedoPlugin, withTransaction };
 //# sourceMappingURL=ng-simple-state.mjs.map