ngssm-store 21.0.0 → 21.1.0

package/README.md

@@ -1,85 +1,497 @@
-# State management
+# ngssm-store
 
-This is a simple custom adaptation and implementation of the **redux** pattern.
+A lightweight, production-ready state management library for Angular applications based on the Redux pattern. Provides centralized state management with full support for reducers, effects, and modern Angular signals.
 
-```mermaid
-  graph TB;
-    B["Store (State manager)"]
-    C[/Actions queue/]
-    A["State Observers: <br/> <ul> <li>Components</li> <li>Directives</li> <li>Guards</li></ul>"]  
-    
-    subgraph G[Action processors]
-        D[<b>Reducers</b> <br/> Updates state synchronously taking state immutability into account]
-        E[<b>Effects</b> <br/> No update of the state. <br/> Call to remote services <br/> Actions dispatch...]
-    end
+## Overview
 
-    C --- B
-    A -- Dispatch actions --> B
-    B -- Publish state --> A
-    B -- Apply action on state --> D
-    B -- Process action --> E
-    D -- Updated state --> B
-    E -- Dispatch actions --> B
+`ngssm-store` is a simple yet powerful custom implementation of the Redux pattern designed specifically for Angular. It leverages Angular's dependency injection, RxJS for reactive updates, and modern Angular signals for optimal reactivity.
 
-    style A text-align:left
-    style C fill:lightgray
+### Key Features
+
+- **Centralized State Management**: Single source of truth for application state
+- **Redux Pattern**: Actions → Reducers → State → Effects → Actions
+- **Dual Reactivity**: Both RxJS observables and Angular Signals support
+- **Immutable State**: Uses `immutability-helper` to ensure state immutability
+- **Effect System**: Side effects, async operations, and action chaining
+- **Feature States**: Modular state management with feature-based organization
+- **Action Queue**: Sequential action processing for predictable state updates
+- **Logging & Debugging**: Built-in logging system for monitoring state changes
+- **TypeScript Support**: Fully typed for better developer experience
+- **Dependency Injection**: Leverages Angular's DI system
+
+## Architecture
+
+### Redux Flow
+
+```
+Component/Effect
+    ↓ (dispatch)
+Action → Store → Action Queue
+                    ↓
+            Process Next Action
+                    ↓
+        Apply to Reducers
+                    ↓
+        Update State Immutably
+                    ↓
+        Publish New State
+                    ↓
+        Process Effects
+                    ↓
+            (Can dispatch actions)
+```
+
+## Installation
+
+```bash
+npm install ngssm-store
 ```
 
-## Store Overview
+### Peer Dependencies
+
+- `@angular/core` >= 20.0.0
+- `@angular/common` >= 20.0.0
+- `immutability-helper` >= 3.1.1
+
+## Setup
+
+### Global Provider
 
-### Action dispatching
+Initialize the store in your application bootstrapping:
 
-```mermaid
-  sequenceDiagram
-    actor O as Component/Effect
-    participant S as Store
-    participant Q as Actions Queue
-    participant E as Event loop
-    O->>S: dispatch action
-    S->>Q: add action
-    S->>E: add message to process next action
+```typescript
+import { provideNgssmStore } from 'ngssm-store';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideNgssmStore(),
+  ]
+});
 ```
 
-> An action dispatched by a component or an effect is not processed immediately. The store uses the `setTimeout` function to process "later" the action.
+## Core Concepts
 
-### Action processing
+### Actions
 
-```mermaid
-  sequenceDiagram
-    participant L as Event loop
-    participant S as Store
-    participant Q as Actions Queue
-    actor O as State Observer
-    participant R as Reducer
-    participant E as Effect
-    L->>S: doProcessNextAction
-    S->>Q: get next available action
-    alt There is an action to process
-      loop For all registered reducers for the current sction
-        S->>R: update state
-      end
+Actions are plain objects that describe what happened. They must have a `type` property:
 
-      S->>O: publish new state
+```typescript
+export interface Action {
+  type: string;
+}
 
-      loop For all registered effects for the current action
-        S->>E: process action
-      end
+// Example action class
+export class IncrementCounterAction implements Action {
+  readonly type = 'INCREMENT_COUNTER';
+  
+  constructor(public readonly amount: number = 1) {}
+}
 
-      S->>L: add message to process next action
-    end
+export class LoadUsersAction implements Action {
+  readonly type = 'LOAD_USERS';
+}
 ```
 
-## Dependencies
+### Reducers
+
+Reducers are pure functions that take the current state and an action, then return a new state. They must be immutable:
+
+```typescript
+import { Reducer, State, Action } from 'ngssm-store';
+import update from 'immutability-helper';
+
+@Injectable()
+export class CounterReducer implements Reducer {
+  processedActions = ['INCREMENT_COUNTER', 'DECREMENT_COUNTER'];
+
+  updateState(state: State, action: Action): State {
+    switch (action.type) {
+      case 'INCREMENT_COUNTER':
+        return update(state, {
+          counter: {
+            value: { $apply: (v: number) => v + (action as IncrementCounterAction).amount }
+          }
+        });
+      case 'DECREMENT_COUNTER':
+        return update(state, {
+          counter: { value: { $set: state.counter.value - 1 } }
+        });
+      default:
+        return state;
+    }
+  }
+}
+```
+
+### Effects
+
+Effects handle side effects like API calls, logging, and dispatching new actions. They don't modify state:
+
+```typescript
+import { Effect, ActionDispatcher, State, Action } from 'ngssm-store';
+
+@Injectable()
+export class UserEffect implements Effect {
+  processedActions = ['LOAD_USERS'];
+  
+  private readonly userService = inject(UserService);
+
+  constructor(private injector: EnvironmentInjector) {}
+
+  processAction(dispatcher: ActionDispatcher, state: State, action: Action): void {
+    if (action.type === 'LOAD_USERS') {
+      this.userService.getUsers().subscribe((users) => {
+        dispatcher.dispatchAction(new SetUsersAction(users));
+      });
+    }
+  }
+}
+```
+
+### State
+
+The state is a plain object containing all application data. Structure it hierarchically:
+
+```typescript
+export interface State {
+  counter?: {
+    value: number;
+  };
+  users?: {
+    list: User[];
+    loading: boolean;
+    error?: Error;
+  };
+  settings?: {
+    theme: string;
+    language: string;
+  };
+}
+```
+
+## Usage
+
+### Dispatching Actions
+
+```typescript
+import { Store } from 'ngssm-store';
+
+@Component({
+  selector: 'app-counter',
+  template: `
+    <p>Count: {{ count() }}</p>
+    <button (click)="increment()">Increment</button>
+    <button (click)="decrement()">Decrement</button>
+  `
+})
+export class CounterComponent {
+  private store = inject(Store);
+  
+  count = createSignal((state) => state.counter?.value ?? 0);
+
+  increment() {
+    this.store.dispatchAction(new IncrementCounterAction(1));
+  }
+
+  decrement() {
+    this.store.dispatchAction(new DecrementCounterAction());
+  }
+}
+```
+
+### Accessing State with Signals
+
+Use the signal-based API for reactive components:
+
+```typescript
+import { createSignal } from 'ngssm-store';
+
+@Component({
+  selector: 'app-dashboard',
+  template: `
+    <div>
+      <p>Total Users: {{ userCount() }}</p>
+      <div *ngIf="loading()">Loading...</div>
+      <ul>
+        <li *ngFor="let user of users()">{{ user.name }}</li>
+      </ul>
+    </div>`
+})
+export class DashboardComponent {
+  private store = inject(Store);
+  
+  users = createSignal((state) => state.users?.list ?? []);
+  loading = createSignal((state) => state.users?.loading ?? false);
+  userCount = createSignal((state) => (state.users?.list ?? []).length);
+}
+```
+
+### Accessing State with RxJS
+
+For components that need RxJS integration:
+
+```typescript
+@Component({
+  selector: 'app-user-list',
+  template: `
+    <ul>
+      <li *ngFor="let user of users$ | async">{{ user.name }}</li>
+    </ul>`
+})
+export class UserListComponent {
+  private store = inject(Store);
+  
+  users$ = this.store.state$.pipe(
+    map((state) => state.users?.list ?? [])
+  );
+}
+```
+
+### Direct State Access
+
+Access the current state directly:
+
+```typescript
+@Component(...)
+export class MyComponent {
+  private store = inject(Store);
+
+  getCurrentState() {
+    const currentState = this.store.state(); // Signal access
+    // or
+    const viaObservable = this.store.state$; // Observable access
+  }
+}
+```
+
+### Tracking Processed Actions
+
+Monitor which action was last processed:
+
+```typescript
+@Component(...)
+export class MyComponent {
+  private store = inject(Store);
+  
+  lastAction = createSignal((state) => this.store.processedAction().type);
+  
+  // Or with RxJS
+  lastAction$ = this.store.processedAction$.pipe(map(a => a.type));
+}
+```
+
+## Registering Reducers and Effects
 
-- [angular](https://github.com/angular/angular): the library uses the dependency injection system provided by **angular**,
-- [rxjs](https://rxjs.dev/): the publish/subscribe pattern is implemented with **rxjs**,
-- [immutability-helper](https://github.com/kolodny/immutability-helper): used by the reducers to update safely the state
+### Single Reducer/Effect
 
-> The state must be immutable. But, to simplify the implementation, it is the responsibility of the user to be sure that the state instance is never updated.
+```typescript
+import { provideReducer, provideEffect } from 'ngssm-store';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideNgssmStore(),
+    provideReducer(CounterReducer),
+    provideEffect(UserEffect)
+  ]
+});
+```
+
+### Multiple Reducers/Effects
+
+```typescript
+import { provideReducers, provideEffects } from 'ngssm-store';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideNgssmStore(),
+    provideReducers(
+      CounterReducer,
+      UserReducer,
+      SettingsReducer
+    ),
+    provideEffects(
+      UserEffect,
+      NotificationEffect
+    )
+  ]
+});
+```
+
+### Effect Functions
+
+Effect functions are the modern replacement for the `Effect` interface. They are executed in an injection context, allowing you to use Angular's `inject` function for dependency injection:
+
+```typescript
+import { provideEffectFunc } from 'ngssm-store';
+import { inject } from '@angular/core';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideNgssmStore(),
+    provideEffectFunc('LOAD_USERS', (state, action) => {
+      const userService = inject(UserService);
+      const dispatcher = inject(ACTION_DISPATCHER);
+      
+      userService.getUsers().subscribe((users) => {
+        dispatcher.dispatchAction(new SetUsersAction(users));
+      });
+    })
+  ]
+});
+```
+
+Effect functions should be preferred over the legacy `Effect` interface implementation as they are more concise and leverage Angular's dependency injection system.
+
+## Feature States
+
+Organize state by feature for better modularity:
+
+```typescript
+import { NgSsmFeatureState } from 'ngssm-store';
+
+@NgSsmFeatureState({
+  featureStateKey: 'products',
+  initialState: {
+    list: [],
+    loading: false,
+    selectedId: null
+  }
+})
+export class ProductFeatureState {}
+
+// Access in components
+products = createSignal((state) => state.products?.list ?? []);
+```
+
+## State Initializers
+
+Initialize state with data from external sources:
+
+```typescript
+import { StateInitializer } from 'ngssm-store';
+
+@Injectable()
+export class AppInitializer implements StateInitializer {
+  private configService = inject(ConfigService);
+
+  initializeState(state: State): State {
+    const config = this.configService.getConfig();
+    return update(state, {
+      settings: { $set: config }
+    });
+  }
+}
+
+// Provide it
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideNgssmStore(),
+    { provide: NGSSM_STATE_INITIALIZER, useClass: AppInitializer }
+  ]
+});
+```
+
+## Action Processing
+
+### Sequential Processing
+
+Actions are processed sequentially using an action queue:
+
+1. Action dispatched
+2. Added to queue
+3. Store schedules processing (via setTimeout by default)
+4. Reducers update state
+5. State published to all subscribers
+6. Effects process action (can dispatch new actions)
+7. Next action processed
+
+### Macro Tasks vs Micro Tasks
+
+By default, the store uses `setTimeout` (macro-tasks) for action processing. You can switch to micro-tasks (Promises) if needed:
+
+```typescript
+@Injectable()
+export class Store {
+  // Set to false for micro-tasks (Promise.resolve())
+  public useMacroTasks = true;
+}
+```
+
+## Best Practices
+
+1. **Keep Actions Simple**: Actions should be serializable plain objects
+2. **Pure Reducers**: Never mutate state directly; always use `immutability-helper`
+3. **Avoid Side Effects in Reducers**: Use Effects for side effects
+4. **Type Your State**: Define clear State interfaces
+5. **Use Signals for Performance**: Prefer `createSignal` over RxJS when possible in new code
+6. **Single Responsibility**: One reducer per feature/domain
+7. **Logging**: Use the Logger service for debugging
+8. **Action Names**: Use clear, descriptive action type names (FEATURE_ACTION_NAME pattern)
+9. **Immutability**: Never modify state objects in reducers
+10. **Error Handling**: Handle errors in effects and dispatch error actions
+
+## API Reference
+
+### Store Class
+
+- `state(): Signal<State>` - Get current state as a Signal
+- `state$: Observable<State>` - Get state as an Observable
+- `processedAction(): Signal<Action>` - Get last processed action as a Signal
+- `processedAction$: Observable<Action>` - Get last processed action as Observable
+- `dispatchAction(action: Action): void` - Dispatch an action
+- `dispatchActionType(actionType: string): void` - Dispatch by action type string
+
+### Helper Functions
+
+- `createSignal<T>(selector: (state: State) => T): Signal<T>` - Create a derived signal from state
+- `provideNgssmStore()` - Initialize the store
+- `provideReducer(reducer)` - Register a single reducer
+- `provideReducers(...reducers)` - Register multiple reducers
+- `provideEffect(effect)` - Register a single effect
+- `provideEffects(...effects)` - Register multiple effects
+- `provideEffectFunc(actionType, func)` - Register an effect function
+
+### Interfaces
+
+- `Action` - Action interface with `type` property
+- `Reducer` - Reducer interface with `processedActions` and `updateState()`
+- `Effect` - Effect interface with `processedActions` and `processAction()`
+- `State` - Base state type (empty object by default)
+- `StateInitializer` - Interface for initializing state
+- `ActionDispatcher` - Interface for dispatching actions
+
+## Debugging
+
+### Logging
+
+Enable logging to monitor state changes and action processing:
+
+```typescript
+import { Logger } from 'ngssm-store';
+
+constructor(private logger: Logger) {
+  this.logger.information('Component initialized');
+}
+```
+
+### DevTools Integration
+
+The store can be integrated with Redux DevTools for advanced debugging (requires additional setup).
+
+## Performance Considerations
+
+- **Signals**: Prefer signals over observables for better performance in modern Angular
+- **Selectors**: Use `createSignal` with specific selectors to minimize re-renders
+- **Memoization**: Consider memoizing expensive selector functions
+- **Action Batching**: Dispatch related actions together to reduce re-renders
+
+## Dependencies
 
-- [schematics](https://www.npmjs.com/package/@angular-devkit/schematics): schematics are provided to create feature state, components, reducers, effects, actions...
-- [mermaid.js](https://mermaid-js.github.io/mermaid/#/) for the documentation.
+- **Angular Core**: Dependency injection, signals, lifecycle management
+- **RxJS**: Reactive state and action streams
+- **immutability-helper**: Safe state immutability patterns
+- **TypeScript**: Full type safety
 
-## Schematics
+## License
 
-See [ngssm-schematics](/projects/ngssm-schematics/README.md) for schematics used to create feature state, action, reducer, effect...
+MIT

package/fesm2022/ngssm-store-caching-testing.mjs

@@ -10,9 +10,7 @@ import { TestBed } from '@angular/core/testing';
  * Provides methods to apply a SetCachedItemAction, set the status, or set the value of a cached item.
  */
 class NgssmCachedItemSetter {
-    constructor() {
-        this.store = inject(Store);
-    }
+    store = inject(Store);
     /**
      * Applies a SetCachedItemAction to the StoreMock, updating the cache state.
      * @param action The SetCachedItemAction to apply.
@@ -95,10 +93,10 @@ class NgssmCachedItemSetter {
         }
         return this;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgssmCachedItemSetter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgssmCachedItemSetter }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: NgssmCachedItemSetter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: NgssmCachedItemSetter });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: NgssmCachedItemSetter, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: NgssmCachedItemSetter, decorators: [{
             type: Injectable
         }] });
 const ngssmCachedItemSetter = () => TestBed.inject(NgssmCachedItemSetter);

package/fesm2022/ngssm-store-caching-testing.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ngssm-store-caching-testing.mjs","sources":["../../../projects/ngssm-store/caching/testing/src/ngssm-cached-item-setter.ts","../../../projects/ngssm-store/caching/testing/src/provide-ngssm-caching-testing.ts","../../../projects/ngssm-store/caching/testing/ngssm-store-caching-testing.ts"],"sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { TestBed } from '@angular/core/testing';\n\nimport { Store } from 'ngssm-store';\nimport { CachedItemStatus, selectNgssmCachedItem, SetCachedItemAction, updateNgssmCachingState } from 'ngssm-store/caching';\nimport { StoreMock } from 'ngssm-store/testing';\n\n/**\n * Utility service for setting and updating cached items in the StoreMock during tests.\n * Provides methods to apply a SetCachedItemAction, set the status, or set the value of a cached item.\n */\n@Injectable()\nexport class NgssmCachedItemSetter {\n  public readonly store = inject(Store) as unknown as StoreMock;\n\n  /**\n   * Applies a SetCachedItemAction to the StoreMock, updating the cache state.\n   * @param action The SetCachedItemAction to apply.\n   * @returns The NgssmCachedItemSetter instance for chaining.\n   */\n  public apply<T = unknown>(action: SetCachedItemAction<T>): NgssmCachedItemSetter {\n    this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n      caches: {\n        [action.cachedItemKey]: {\n          $set: {\n            status: action.status,\n            item: action.cachedItem,\n            error: action.error\n          }\n        }\n      }\n    });\n\n    return this;\n  }\n\n  /**\n   * Sets the status of a cached item in the StoreMock.\n   * If the key does not exist in cache, it is created with an undefined value.\n   *\n   * @param cachedItemKey The key of the cached item.\n   * @param status The new status to set.\n   * @returns The NgssmCachedItemSetter instance for chaining.\n   */\n  public setCachedItemStatus(cachedItemKey: string, status: CachedItemStatus): NgssmCachedItemSetter {\n    if (selectNgssmCachedItem(this.store.stateValue, cachedItemKey)) {\n      this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n        caches: {\n          [cachedItemKey]: {\n            status: { $set: status }\n          }\n        }\n      });\n    } else {\n      this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n        caches: {\n          [cachedItemKey]: {\n            $set: {\n              status\n            }\n          }\n        }\n      });\n    }\n\n    return this;\n  }\n\n  /**\n   * Sets the value of a cached item in the StoreMock.\n   * If the key does not exist in cache, it is created with the status CachedItemStatus.notSet.\n   *\n   * @param cachedItemKey The key of the cached item.\n   * @param value The value to set.\n   * @returns The NgssmCachedItemSetter instance for chaining.\n   */\n  public setCachedItemValue<T>(cachedItemKey: string, value?: T): NgssmCachedItemSetter {\n    if (selectNgssmCachedItem(this.store.stateValue, cachedItemKey)) {\n      this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n        caches: {\n          [cachedItemKey]: {\n            item: { $set: value }\n          }\n        }\n      });\n    } else {\n      this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n        caches: {\n          [cachedItemKey]: {\n            $set: {\n              status: CachedItemStatus.notSet,\n              item: value\n            }\n          }\n        }\n      });\n    }\n\n    return this;\n  }\n}\n\nexport const ngssmCachedItemSetter = () => TestBed.inject(NgssmCachedItemSetter);\n","import { EnvironmentProviders, inject, makeEnvironmentProviders, provideAppInitializer } from '@angular/core';\n\nimport { Logger, Store } from 'ngssm-store';\nimport { StoreMock } from 'ngssm-store/testing';\nimport { NgssmCachingStateSpecification } from 'ngssm-store/caching';\n\nimport { NgssmCachedItemSetter } from './ngssm-cached-item-setter';\n\n/**\n * App initializer that sets up the NgssmCaching state in the StoreMock for testing purposes.\n * Throws an error if StoreMock is not registered.\n */\nexport const ngssmCachingStateInitializer = () => {\n  const logger = inject(Logger);\n  logger.information('[ngssm-caching-testing] Initialization of state');\n  const store = inject(Store);\n  if (!(store instanceof StoreMock)) {\n    throw new Error('StoreMock is not registered.');\n  }\n\n  store.stateValue = {\n    ...store.stateValue,\n    [NgssmCachingStateSpecification.featureStateKey]: NgssmCachingStateSpecification.initialState\n  };\n};\n\n/**\n * Provides environment providers for NgssmCaching testing, including the state initializer.\n */\nexport const provideNgssmCachingTesting = (): EnvironmentProviders => {\n  return makeEnvironmentProviders([provideAppInitializer(ngssmCachingStateInitializer), NgssmCachedItemSetter]);\n};\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public_api';\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"ngssm-store-caching-testing.mjs","sources":["../../../projects/ngssm-store/caching/testing/src/ngssm-cached-item-setter.ts","../../../projects/ngssm-store/caching/testing/src/provide-ngssm-caching-testing.ts","../../../projects/ngssm-store/caching/testing/ngssm-store-caching-testing.ts"],"sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { TestBed } from '@angular/core/testing';\n\nimport { Store } from 'ngssm-store';\nimport { CachedItemStatus, selectNgssmCachedItem, SetCachedItemAction, updateNgssmCachingState } from 'ngssm-store/caching';\nimport { StoreMock } from 'ngssm-store/testing';\n\n/**\n * Utility service for setting and updating cached items in the StoreMock during tests.\n * Provides methods to apply a SetCachedItemAction, set the status, or set the value of a cached item.\n */\n@Injectable()\nexport class NgssmCachedItemSetter {\n  public readonly store = inject(Store) as unknown as StoreMock;\n\n  /**\n   * Applies a SetCachedItemAction to the StoreMock, updating the cache state.\n   * @param action The SetCachedItemAction to apply.\n   * @returns The NgssmCachedItemSetter instance for chaining.\n   */\n  public apply<T = unknown>(action: SetCachedItemAction<T>): NgssmCachedItemSetter {\n    this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n      caches: {\n        [action.cachedItemKey]: {\n          $set: {\n            status: action.status,\n            item: action.cachedItem,\n            error: action.error\n          }\n        }\n      }\n    });\n\n    return this;\n  }\n\n  /**\n   * Sets the status of a cached item in the StoreMock.\n   * If the key does not exist in cache, it is created with an undefined value.\n   *\n   * @param cachedItemKey The key of the cached item.\n   * @param status The new status to set.\n   * @returns The NgssmCachedItemSetter instance for chaining.\n   */\n  public setCachedItemStatus(cachedItemKey: string, status: CachedItemStatus): NgssmCachedItemSetter {\n    if (selectNgssmCachedItem(this.store.stateValue, cachedItemKey)) {\n      this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n        caches: {\n          [cachedItemKey]: {\n            status: { $set: status }\n          }\n        }\n      });\n    } else {\n      this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n        caches: {\n          [cachedItemKey]: {\n            $set: {\n              status\n            }\n          }\n        }\n      });\n    }\n\n    return this;\n  }\n\n  /**\n   * Sets the value of a cached item in the StoreMock.\n   * If the key does not exist in cache, it is created with the status CachedItemStatus.notSet.\n   *\n   * @param cachedItemKey The key of the cached item.\n   * @param value The value to set.\n   * @returns The NgssmCachedItemSetter instance for chaining.\n   */\n  public setCachedItemValue<T>(cachedItemKey: string, value?: T): NgssmCachedItemSetter {\n    if (selectNgssmCachedItem(this.store.stateValue, cachedItemKey)) {\n      this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n        caches: {\n          [cachedItemKey]: {\n            item: { $set: value }\n          }\n        }\n      });\n    } else {\n      this.store.stateValue = updateNgssmCachingState(this.store.stateValue, {\n        caches: {\n          [cachedItemKey]: {\n            $set: {\n              status: CachedItemStatus.notSet,\n              item: value\n            }\n          }\n        }\n      });\n    }\n\n    return this;\n  }\n}\n\nexport const ngssmCachedItemSetter = () => TestBed.inject(NgssmCachedItemSetter);\n","import { EnvironmentProviders, inject, makeEnvironmentProviders, provideAppInitializer } from '@angular/core';\n\nimport { Logger, Store } from 'ngssm-store';\nimport { StoreMock } from 'ngssm-store/testing';\nimport { NgssmCachingStateSpecification } from 'ngssm-store/caching';\n\nimport { NgssmCachedItemSetter } from './ngssm-cached-item-setter';\n\n/**\n * App initializer that sets up the NgssmCaching state in the StoreMock for testing purposes.\n * Throws an error if StoreMock is not registered.\n */\nexport const ngssmCachingStateInitializer = () => {\n  const logger = inject(Logger);\n  logger.information('[ngssm-caching-testing] Initialization of state');\n  const store = inject(Store);\n  if (!(store instanceof StoreMock)) {\n    throw new Error('StoreMock is not registered.');\n  }\n\n  store.stateValue = {\n    ...store.stateValue,\n    [NgssmCachingStateSpecification.featureStateKey]: NgssmCachingStateSpecification.initialState\n  };\n};\n\n/**\n * Provides environment providers for NgssmCaching testing, including the state initializer.\n */\nexport const provideNgssmCachingTesting = (): EnvironmentProviders => {\n  return makeEnvironmentProviders([provideAppInitializer(ngssmCachingStateInitializer), NgssmCachedItemSetter]);\n};\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public_api';\n"],"names":[],"mappings":"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"}

package/fesm2022/ngssm-store-caching.mjs

@@ -33,19 +33,24 @@ var CachedItemStatus;
  * This action is dispatched to update the cache with a new or modified item, along with its status and any error information.
  */
 class SetCachedItemAction {
+    cachedItemKey;
+    cachedItem;
+    status;
+    error;
+    type = NgssmCachingActionType.setCachedItem;
     constructor(cachedItemKey, cachedItem, status = CachedItemStatus.set, error) {
         this.cachedItemKey = cachedItemKey;
         this.cachedItem = cachedItem;
         this.status = status;
         this.error = error;
-        this.type = NgssmCachingActionType.setCachedItem;
     }
 }
 
 class UnsetCachedItemAction {
+    cachedItemKey;
+    type = NgssmCachingActionType.unsetCachedItem;
     constructor(cachedItemKey) {
         this.cachedItemKey = cachedItemKey;
-        this.type = NgssmCachingActionType.unsetCachedItem;
     }
 }
 
@@ -54,10 +59,10 @@ const updateNgssmCachingState = (state, command) => update(state, {
     [NgssmCachingStateSpecification.featureStateKey]: command
 });
 let NgssmCachingStateSpecification = class NgssmCachingStateSpecification {
-    static { this.featureStateKey = 'ngssm-caching-state'; }
-    static { this.initialState = {
+    static featureStateKey = 'ngssm-caching-state';
+    static initialState = {
         caches: {}
-    }; }
+    };
 };
 NgssmCachingStateSpecification = __decorate([
     NgSsmFeatureState({
@@ -69,9 +74,7 @@ NgssmCachingStateSpecification = __decorate([
 const selectNgssmCachedItem = (state, key) => selectNgssmCachingState(state).caches[key];
 
 class CachedItemReducer {
-    constructor() {
-        this.processedActions = [NgssmCachingActionType.setCachedItem, NgssmCachingActionType.unsetCachedItem];
-    }
+    processedActions = [NgssmCachingActionType.setCachedItem, NgssmCachingActionType.unsetCachedItem];
     updateState(state, action) {
         switch (action.type) {
             case NgssmCachingActionType.setCachedItem: {
@@ -100,10 +103,10 @@ class CachedItemReducer {
         }
         return state;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: CachedItemReducer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: CachedItemReducer }); }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: CachedItemReducer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: CachedItemReducer });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: CachedItemReducer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: CachedItemReducer, decorators: [{
             type: Injectable
         }] });