@angular-architects/ngrx-toolkit 0.0.4 → 0.0.7

package/README.md

@@ -1,5 +1,7 @@
 # NgRx Toolkit
 
+[![npm](https://img.shields.io/npm/v/%40angular-architects%2Fngrx-toolkit.svg)](https://www.npmjs.com/package/%40angular-architects%2Fngrx-toolkit)
+
 <p align="center">
 <img src="https://raw.githubusercontent.com/angular-architects/ngrx-toolkit/main/logo.png" width="320" style="text-align: center">
 </p>
@@ -8,6 +10,7 @@ NgRx Toolkit is an extension to the NgRx Signals Store. **It is still in beta**
 
 - Devtools: Integration into Redux Devtools
 - Redux: Possibility to use the Redux Pattern (Reducer, Actions, Effects)
+- Redux Connector: Map NgRx Store Actions to a present Signal Store
 
 To install it, run
 
@@ -15,6 +18,20 @@ To install it, run
 npm i @angular-architects/ngrx-toolkit
 ```
 
+
+- [NgRx Toolkit](#ngrx-toolkit)
+  - [Devtools: `withDevtools()`](#devtools-withdevtools)
+  - [Redux: `withRedux()`](#redux-withredux)
+  - [DataService `withDataService()`](#dataservice-withdataservice)
+  - [DataService with Dynamic Properties](#dataservice-with-dynamic-properties)
+  - [Redux Connector for the NgRx Signal Store `createReduxState()`](#redux-connector-for-the-ngrx-signal-store-createreduxstate)
+    - [Use a present Signal Store](#use-a-present-signal-store)
+    - [Use well-known NgRx Store Actions](#use-well-known-ngrx-store-actions)
+    - [Map Actions to Methods](#map-actions-to-methods)
+    - [Register an Angular Dependency Injection Provider](#register-an-angular-dependency-injection-provider)
+    - [Use the Store in your Component](#use-the-store-in-your-component)
+
+
 ## Devtools: `withDevtools()`
 
 This extension is very easy to use. Just add it to a `signalStore`. Example:
@@ -23,7 +40,7 @@ This extension is very easy to use. Just add it to a `signalStore`. Example:
 export const FlightStore = signalStore(
   { providedIn: 'root' },
   withDevtools('flights'), // <-- add this
-  withState({ flights: [] as Flight[] }),
+  withState({ flights: [] as Flight[] })
   // ...
 );
 ```
@@ -59,18 +76,15 @@ export const FlightStore = signalStore(
       return {
         load$: create(actions.load).pipe(
           switchMap(({ from, to }) =>
-            httpClient.get<Flight[]>(
-              'https://demo.angulararchitects.io/api/flight',
-              {
-                params: new HttpParams().set('from', from).set('to', to),
-              },
-            ),
+            httpClient.get<Flight[]>('https://demo.angulararchitects.io/api/flight', {
+              params: new HttpParams().set('from', from).set('to', to),
+            })
           ),
-          tap((flights) => actions.loaded({ flights })),
+          tap((flights) => actions.loaded({ flights }))
         ),
       };
     },
-  }),
+  })
 );
 ```
 
@@ -86,18 +100,18 @@ export const SimpleFlightBookingStore = signalStore(
   withCallState(),
   withEntities<Flight>(),
   withDataService({
-    dataServiceType: FlightService, 
+    dataServiceType: FlightService,
     filter: { from: 'Paris', to: 'New York' },
   }),
-  withUndoRedo(),
+  withUndoRedo()
 );
 ```
 
-The features ``withCallState`` and ``withUndoRedo`` are optional, but when present, they enrich each other.
+The features `withCallState` and `withUndoRedo` are optional, but when present, they enrich each other.
 
-The Data Service needs to implement the ``DataService`` interface:
+The Data Service needs to implement the `DataService` interface:
 
-```typescript 
+```typescript
 @Injectable({
   providedIn: 'root'
 })
@@ -155,30 +169,30 @@ export class FlightSearchSimpleComponent {
 
 ## DataService with Dynamic Properties
 
-To avoid naming conflicts, the properties set up by ``withDataService`` and the connected features can be configured in a typesafe way:
+To avoid naming conflicts, the properties set up by `withDataService` and the connected features can be configured in a typesafe way:
 
 ```typescript
 export const FlightBookingStore = signalStore(
   { providedIn: 'root' },
   withCallState({
-    collection: 'flight'
+    collection: 'flight',
   }),
-  withEntities({ 
-    entity: type<Flight>(), 
-    collection: 'flight'
+  withEntities({
+    entity: type<Flight>(),
+    collection: 'flight',
   }),
   withDataService({
-    dataServiceType: FlightService, 
+    dataServiceType: FlightService,
     filter: { from: 'Graz', to: 'Hamburg' },
-    collection: 'flight'
+    collection: 'flight',
   }),
   withUndoRedo({
     collections: ['flight'],
-  }),
+  })
 );
 ```
 
-This setup makes them use ``flight`` as part of the used property names. As these implementations respect the Type Script type system, the compiler will make sure these properties are used in a typesafe way:
+This setup makes them use `flight` as part of the used property names. As these implementations respect the Type Script type system, the compiler will make sure these properties are used in a typesafe way:
 
 ```typescript
 @Component(...)
@@ -217,4 +231,174 @@ export class FlightSearchDynamicComponent {
   }
 
 }
-```
+```
+
+## Storage Sync `withStorageSync()`
+
+`withStorageSync` adds automatic or manual synchronization with Web Storage (`localstorage`/`sessionstorage`).
+
+> [!WARNING]  
+> As Web Storage only works in browser environments it will fallback to a stub implementation on server environments.
+
+Example:
+
+```ts
+const SyncStore = signalStore(
+  withStorageSync<User>({
+    key: 'synced', // key used when writing to/reading from storage
+    autoSync: false, // read from storage on init and write on state changes - `true` by default
+    select: (state: User) => Partial<User>, // projection to keep specific slices in sync
+    parse: (stateString: string) => State, // custom parsing from storage - `JSON.parse` by default
+    stringify: (state: User) => string, // custom stringification - `JSON.stringify` by default
+    storage: () => sessionstorage, // factory to select storage to sync with
+  })
+);
+```
+
+```ts
+@Component(...)
+public class SyncedStoreComponent {
+  private syncStore = inject(SyncStore);
+
+  updateFromStorage(): void {
+    this.syncStore.readFromStorage(); // reads the stored item from storage and patches the state
+  }
+
+  updateStorage(): void {
+    this.syncStore.writeToStorage(); // writes the current state to storage
+  }
+
+  clearStorage(): void {
+    this.syncStore.clearStorage(); // clears the stored item in storage
+
+## Redux Connector for the NgRx Signal Store `createReduxState()`
+
+The Redux Connector turns any `signalStore()` into a Gobal State Management Slice following the Redux pattern.
+
+It supports:
+
+✅ Well-known NgRx Store Actions \
+✅ Global Action `dispatch()` \
+✅ Angular Lazy Loading \
+✅ Auto-generated `provideNamedStore()` & `injectNamedStore()` Functions \
+✅ Global Action to Store Method Mappers \
+
+
+### Use a present Signal Store
+
+```typescript
+export const FlightStore = signalStore(
+  // State
+  withEntities({ entity: type<Flight>(), collection: 'flight' }),
+  withEntities({ entity: type<number>(), collection: 'hide' }),
+  // Selectors
+  withComputed(({ flightEntities, hideEntities }) => ({
+    filteredFlights: computed(() => flightEntities()
+      .filter(flight => !hideEntities().includes(flight.id))),
+    flightCount: computed(() => flightEntities().length),
+  })),
+  // Updater
+  withMethods(store => ({
+    setFlights: (state: { flights: Flight[] }) => patchState(store,
+      setAllEntities(state.flights, { collection: 'flight' })),
+    updateFlight: (state: { flight: Flight }) => patchState(store,
+      updateEntity({ id: state.flight.id, changes: state.flight }, { collection: 'flight' })),
+    clearFlights: () => patchState(store,
+      removeAllEntities({ collection: 'flight' })),
+  })),
+  // Effects
+  withMethods((store, flightService = inject(FlightService)) => ({
+    loadFlights: reduxMethod<FlightFilter, { flights: Flight[] }>(pipe(
+      switchMap(filter => from(
+        flightService.load({ from: filter.from, to: filter.to })
+      )),
+      map(flights => ({ flights })),
+    ), store.setFlights),
+  })),
+);
+```
+
+### Use well-known NgRx Store Actions
+
+```typescript
+export const ticketActions = createActionGroup({
+  source: 'tickets',
+  events: {
+    'flights load': props<FlightFilter>(),
+    'flights loaded': props<{ flights: Flight[] }>(),
+    'flights loaded by passenger': props<{ flights: Flight[] }>(),
+    'flight update': props<{ flight: Flight }>(),
+    'flights clear': emptyProps()
+  }
+});
+```
+
+### Map Actions to Methods
+
+```typescript
+export const { provideFlightStore, injectFlightStore } =
+  createReduxState('flight', FlightStore, store => withActionMappers(
+    mapAction(
+      // Filtered Action
+      ticketActions.flightsLoad,
+      // Side-Effect
+      store.loadFlights,
+      // Result Action
+      ticketActions.flightsLoaded),
+    mapAction(
+      // Filtered Actions
+      ticketActions.flightsLoaded, ticketActions.flightsLoadedByPassenger,
+      // State Updater Method (like Reducers)
+      store.setFlights
+    ),
+    mapAction(ticketActions.flightUpdate, store.updateFlight),
+    mapAction(ticketActions.flightsClear, store.clearFlights),
+  )
+);
+```
+
+### Register an Angular Dependency Injection Provider
+
+```typescript
+export const appRoutes: Route[] = [
+  {
+    path: 'flight-search-redux-connector',
+    providers: [provideFlightStore()],
+    component: FlightSearchReducConnectorComponent
+  },
+];
+```
+
+### Use the Store in your Component
+
+```typescript
+@Component({
+  standalone: true,
+  imports: [
+    JsonPipe,
+    RouterLink,
+    FormsModule,
+    FlightCardComponent
+  ],
+  selector: 'demo-flight-search-redux-connector',
+  templateUrl: './flight-search.component.html',
+})
+export class FlightSearchReducConnectorComponent {
+  private store = injectFlightStore();
+
+  protected flights = this.store.flightEntities;
+
+  protected search() {
+    this.store.dispatch(
+      ticketActions.flightsLoad({
+        from: this.localState.filter.from(),
+        to: this.localState.filter.to()
+      })
+    );
+  }
+
+  protected reset(): void {
+    this.store.dispatch(ticketActions.flightsClear());
+  }
+}
+```

package/esm2022/index.mjs

@@ -3,4 +3,7 @@ export * from './lib/with-redux';
 export * from './lib/with-call-state';
 export * from './lib/with-undo-redo';
 export * from './lib/with-data-service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQVUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgd2l0aERldnRvb2xzLCBwYXRjaFN0YXRlLCBBY3Rpb24gfSBmcm9tICcuL2xpYi93aXRoLWRldnRvb2xzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtcmVkdXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvd2l0aC1jYWxsLXN0YXRlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtdW5kby1yZWRvJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtZGF0YS1zZXJ2aWNlJztcbiJdfQ==
+export { withStorageSync } from './lib/with-storage-sync';
+export * from './lib/redux-connector';
+export * from './lib/redux-connector/rxjs-interop';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQVUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RSxjQUFjLGtCQUFrQixDQUFDO0FBRWpDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFBO0FBQ3ZDLE9BQU8sRUFBRSxlQUFlLEVBQWMsTUFBTSx5QkFBeUIsQ0FBQztBQUN0RSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsb0NBQW9DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyB3aXRoRGV2dG9vbHMsIHBhdGNoU3RhdGUsIEFjdGlvbiB9IGZyb20gJy4vbGliL3dpdGgtZGV2dG9vbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvd2l0aC1yZWR1eCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtY2FsbC1zdGF0ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi93aXRoLXVuZG8tcmVkbyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi93aXRoLWRhdGEtc2VydmljZSdcbmV4cG9ydCB7IHdpdGhTdG9yYWdlU3luYywgU3luY0NvbmZpZyB9IGZyb20gJy4vbGliL3dpdGgtc3RvcmFnZS1zeW5jJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JlZHV4LWNvbm5lY3Rvcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZWR1eC1jb25uZWN0b3Ivcnhqcy1pbnRlcm9wJzsiXX0=

package/esm2022/lib/redux-connector/create-redux.mjs

@@ -0,0 +1,41 @@
+import { ENVIRONMENT_INITIALIZER, inject, makeEnvironmentProviders } from "@angular/core";
+import { SignalReduxStore, injectReduxDispatch } from "./signal-redux-store";
+import { capitalize, isActionCreator } from "./util";
+export function mapAction(...args) {
+    let resultMethod = args.pop();
+    let storeMethod = args.pop();
+    if (isActionCreator(storeMethod)) {
+        args.push(storeMethod);
+        storeMethod = resultMethod || storeMethod;
+        resultMethod = undefined;
+    }
+    const types = args.map((creator) => creator.type);
+    return {
+        types,
+        storeMethod,
+        resultMethod
+    };
+}
+export function withActionMappers(...mappers) {
+    return mappers;
+}
+export function createReduxState(storeName, signalStore, withActionMappers) {
+    const isRootProvider = signalStore?.ɵprov?.providedIn === 'root';
+    return {
+        [`provide${capitalize(storeName)}Store`]: (connectReduxDevtools = false) => makeEnvironmentProviders([
+            isRootProvider ? [] : signalStore,
+            {
+                provide: ENVIRONMENT_INITIALIZER,
+                multi: true,
+                useFactory: (signalReduxStore = inject(SignalReduxStore), store = inject(signalStore)) => () => {
+                    if (connectReduxDevtools) {
+                        // addStoreToReduxDevtools(store, storeName, false);
+                    }
+                    signalReduxStore.connectFeatureStore(withActionMappers(store));
+                }
+            }
+        ]),
+        [`inject${capitalize(storeName)}Store`]: () => Object.assign(inject(signalStore), { dispatch: injectReduxDispatch() })
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/redux-connector/index.mjs

@@ -0,0 +1,2 @@
+export { createReduxState, mapAction, withActionMappers } from './create-redux';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvbGliL3JlZHV4LWNvbm5lY3Rvci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsU0FBUyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcbmV4cG9ydCB7IGNyZWF0ZVJlZHV4U3RhdGUsIG1hcEFjdGlvbiwgd2l0aEFjdGlvbk1hcHBlcnMgfSBmcm9tICcuL2NyZWF0ZS1yZWR1eCc7XG4iXX0=

package/esm2022/lib/redux-connector/model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/redux-connector/rxjs-interop/index.mjs

@@ -0,0 +1,2 @@
+export { reduxMethod } from './redux-method';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvbGliL3JlZHV4LWNvbm5lY3Rvci9yeGpzLWludGVyb3AvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiXG5leHBvcnQgeyByZWR1eE1ldGhvZCB9IGZyb20gJy4vcmVkdXgtbWV0aG9kJztcbiJdfQ==

package/esm2022/lib/redux-connector/rxjs-interop/redux-method.mjs

@@ -0,0 +1,22 @@
+import { Injector, inject } from "@angular/core";
+import { rxMethod } from "@ngrx/signals/rxjs-interop";
+import { map, pipe } from "rxjs";
+export function reduxMethod(generator, resultMethodOrConfig, config) {
+    const injector = inject(Injector);
+    if (typeof resultMethodOrConfig === 'function') {
+        let unsubscribable;
+        const inputResultFn = ((input, resultMethod = resultMethodOrConfig) => {
+            const rxMethodWithResult = rxMethod(pipe(generator, map(resultMethod)), {
+                ...(config || {}),
+                injector: config?.injector || injector
+            });
+            const rxWithInput = rxMethodWithResult(input);
+            unsubscribable = { unsubscribe: rxWithInput.unsubscribe.bind(rxWithInput) };
+            return rxWithInput;
+        });
+        inputResultFn.unsubscribe = () => unsubscribable?.unsubscribe();
+        return inputResultFn;
+    }
+    return rxMethod(generator, resultMethodOrConfig);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/redux-connector/signal-redux-store.mjs

@@ -0,0 +1,43 @@
+import { Injectable, inject } from "@angular/core";
+import { rxMethod } from "@ngrx/signals/rxjs-interop";
+import { pipe, tap } from "rxjs";
+import { isUnsubscribable } from "./util";
+import * as i0 from "@angular/core";
+export class SignalReduxStore {
+    constructor() {
+        this.mapperDict = {};
+        this.dispatch = rxMethod(pipe(tap((action) => {
+            const callbacks = this.mapperDict[action.type];
+            if (callbacks?.storeMethod) {
+                if (isUnsubscribable(callbacks.storeMethod) &&
+                    callbacks.resultMethod) {
+                    return callbacks.storeMethod(action, (a) => {
+                        const resultAction = callbacks.resultMethod?.(a);
+                        this.dispatch(resultAction);
+                    });
+                }
+                return callbacks?.storeMethod(action);
+            }
+            return;
+        })));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    connectFeatureStore(mappers) {
+        mappers.forEach(mapper => mapper.types.forEach(action => this.mapperDict[action] = {
+            storeMethod: mapper.storeMethod,
+            resultMethod: mapper.resultMethod
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: SignalReduxStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: SignalReduxStore, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: SignalReduxStore, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+export function injectReduxDispatch() {
+    return inject(SignalReduxStore).dispatch;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/redux-connector/util.mjs

@@ -0,0 +1,13 @@
+export function isUnsubscribable(fn) {
+    return !!fn?.unsubscribe;
+}
+export function capitalize(str) {
+    return str ? str[0].toUpperCase() + str.substring(1) : str;
+}
+export function isActionCreator(action) {
+    return (typeof action === 'function' &&
+        action &&
+        action.type &&
+        typeof action.type === 'string');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10b29sa2l0L3NyYy9saWIvcmVkdXgtY29ubmVjdG9yL3V0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsTUFBTSxVQUFVLGdCQUFnQixDQUM5QixFQUE0QjtJQUU1QixPQUFPLENBQUMsQ0FBRSxFQUFnQyxFQUFFLFdBQVcsQ0FBQztBQUMxRCxDQUFDO0FBRUQsTUFBTSxVQUFVLFVBQVUsQ0FBQyxHQUFXO0lBQ3BDLE9BQU8sR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsV0FBVyxFQUFFLEdBQUcsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDO0FBQzdELENBQUM7QUFFRCxNQUFNLFVBQVUsZUFBZSxDQUFDLE1BQVc7SUFDekMsT0FBTyxDQUNMLE9BQU8sTUFBTSxLQUFLLFVBQVU7UUFDNUIsTUFBTTtRQUNOLE1BQU0sQ0FBQyxJQUFJO1FBQ1gsT0FBTyxNQUFNLENBQUMsSUFBSSxLQUFLLFFBQVEsQ0FDaEMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBY3Rpb24gfSBmcm9tICdAbmdyeC9zdG9yZSc7XG5pbXBvcnQgeyBVbnN1YnNjcmliYWJsZSB9IGZyb20gJ3J4anMnO1xuXG5cbmV4cG9ydCBmdW5jdGlvbiBpc1Vuc3Vic2NyaWJhYmxlPEYgZXh0ZW5kcyAoLi4uYXJnczogdW5rbm93bltdKSA9PiB1bmtub3duPihcbiAgZm46IEYgfCAoRiAmIFVuc3Vic2NyaWJhYmxlKVxuKTogZm4gaXMgRiAmIFVuc3Vic2NyaWJhYmxlIHtcbiAgcmV0dXJuICEhKGZuIGFzIGFueSBhcyBGICYgVW5zdWJzY3JpYmFibGUpPy51bnN1YnNjcmliZTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGNhcGl0YWxpemUoc3RyOiBzdHJpbmcpOiBzdHJpbmcge1xuICByZXR1cm4gc3RyID8gc3RyWzBdLnRvVXBwZXJDYXNlKCkgKyBzdHIuc3Vic3RyaW5nKDEpIDogc3RyO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gaXNBY3Rpb25DcmVhdG9yKGFjdGlvbjogYW55KTogYWN0aW9uIGlzIEFjdGlvbiB7XG4gIHJldHVybiAoXG4gICAgdHlwZW9mIGFjdGlvbiA9PT0gJ2Z1bmN0aW9uJyAmJlxuICAgIGFjdGlvbiAmJlxuICAgIGFjdGlvbi50eXBlICYmXG4gICAgdHlwZW9mIGFjdGlvbi50eXBlID09PSAnc3RyaW5nJ1xuICApO1xufVxuIl19

package/esm2022/lib/with-call-state.mjs

@@ -55,4 +55,4 @@ export function setError(error, prop) {
         return { callState: { error: errorMessage } };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/with-redux.mjs

@@ -11,7 +11,7 @@ function createActionFns(actionFnSpecs, reducerRegistry, effectsRegistry, state)
             const fullPayload = { ...payload, type };
             const reducer = reducerRegistry[type];
             if (reducer) {
-                reducer(fullPayload, state);
+                reducer(state, fullPayload);
             }
             const effectSubject = effectsRegistry[type];
             if (effectSubject) {
@@ -92,4 +92,4 @@ export function withRedux(redux) {
         };
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-redux.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-redux.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject, Subscription } from 'rxjs';\nimport { SignalStoreFeature } from '@ngrx/signals';\nimport {\n  EmptyFeatureResult,\n  SignalStoreFeatureResult,\n} from '@ngrx/signals/src/signal-store-models';\nimport { StateSignal } from '@ngrx/signals/src/state-signal';\nimport { assertActionFnSpecs } from './assertions/assertions';\nimport { effect } from '@angular/core';\n\n/** Actions **/\n\ntype Payload = Record<string, unknown>;\n\ntype ActionFn<\n  Type extends string = string,\n  ActionPayload extends Payload = Payload\n> = ((payload: ActionPayload) => ActionPayload & { type: Type }) & {\n  type: Type;\n};\n\ntype ActionFns = Record<string, ActionFn>;\n\nexport type ActionsFnSpecs = Record<string, Payload>;\n\ntype ActionFnCreator<Spec extends ActionsFnSpecs> = {\n  [ActionName in keyof Spec]: ((\n    payload: Spec[ActionName]\n  ) => Spec[ActionName] & { type: ActionName }) & { type: ActionName & string };\n};\n\ntype ActionFnPayload<Action> = Action extends (payload: infer Payload) => void\n  ? Payload\n  : never;\n\ntype ActionFnsCreator<Spec extends ActionsFnSpecs> = Spec extends {\n  private: Record<string, Payload>;\n  public: Record<string, Payload>;\n}\n  ? ActionFnCreator<Spec['private']> & ActionFnCreator<Spec['public']>\n  : ActionFnCreator<Spec>;\n\ntype PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {\n  public: Record<string, Payload>;\n}\n  ? ActionFnCreator<Spec['public']>\n  : ActionFnCreator<Spec>;\n\nexport function payload<Type extends Payload>(): Type {\n  return {} as Type;\n}\n\nexport const noPayload = {};\n\n/** Reducer **/\n\ntype ReducerFunction<ReducerAction, State> = (\n  action: ActionFnPayload<ReducerAction>,\n  state: State\n) => void;\n\ntype ReducerFactory<StateActionFns extends ActionFns, State> = (\n  actions: StateActionFns,\n  on: <ReducerAction extends { type: string }>(\n    action: ReducerAction,\n    reducerFn: ReducerFunction<ActionFnPayload<ReducerAction>, State>\n  ) => void\n) => void;\n\n/** Effect **/\n\ntype EffectsFactory<StateActionFns extends ActionFns> = (\n  actions: StateActionFns,\n  create: <EffectAction extends { type: string }>(\n    action: EffectAction\n  ) => Observable<ActionFnPayload<EffectAction>>\n) => Record<string, Observable<unknown>>;\n\nfunction createActionFns<Spec extends ActionsFnSpecs>(\n  actionFnSpecs: Spec,\n  reducerRegistry: Record<\n    string,\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\n  >,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,\n  state: unknown\n) {\n  const actionFns: Record<string, ActionFn> = {};\n\n  for (const type in actionFnSpecs) {\n    const actionFn = (payload: Payload) => {\n      const fullPayload = { ...payload, type };\n      const reducer = reducerRegistry[type];\n      if (reducer) {\n        (reducer as (payload: unknown, state: unknown) => void)(\n          fullPayload as unknown,\n          state\n        );\n      }\n      const effectSubject = effectsRegistry[type];\n      if (effectSubject) {\n        (effectSubject as unknown as Subject<unknown>).next(fullPayload);\n      }\n      return fullPayload;\n    };\n    actionFn.type = type.toString();\n    actionFns[type] = actionFn;\n  }\n\n  return actionFns;\n}\n\nfunction createPublicAndAllActionsFns<Spec extends ActionsFnSpecs>(\n  actionFnSpecs: Spec,\n  reducerRegistry: Record<\n    string,\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\n  >,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,\n  state: unknown\n): { all: ActionFns; publics: ActionFns } {\n  if ('public' in actionFnSpecs || 'private' in actionFnSpecs) {\n    const privates = actionFnSpecs['private'] || {};\n    const publics = actionFnSpecs['public'] || {};\n\n    assertActionFnSpecs(privates);\n    assertActionFnSpecs(publics);\n\n    const privateActionFns = createActionFns(\n      privates,\n      reducerRegistry,\n      effectsRegistry,\n      state\n    );\n    const publicActionFns = createActionFns(\n      publics,\n      reducerRegistry,\n      effectsRegistry,\n      state\n    );\n\n    return {\n      all: { ...privateActionFns, ...publicActionFns },\n      publics: publicActionFns,\n    };\n  }\n\n  const actionFns = createActionFns(\n    actionFnSpecs,\n    reducerRegistry,\n    effectsRegistry,\n    state\n  );\n\n  return { all: actionFns, publics: actionFns };\n}\n\nfunction fillReducerRegistry(\n  reducer: ReducerFactory<ActionFns, unknown>,\n  actionFns: ActionFns,\n  reducerRegistry: Record<\n    string,\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\n  >\n) {\n  function on(\n    action: { type: string },\n    reducerFn: (payload: ActionFnPayload<unknown>, state: unknown) => void\n  ) {\n    reducerRegistry[action.type] = reducerFn;\n  }\n\n  reducer(actionFns, on);\n\n  return reducerRegistry;\n}\n\nfunction fillEffects(\n  effects: EffectsFactory<ActionFns>,\n  actionFns: ActionFns,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>> = {}\n): Observable<unknown>[] {\n  function create(action: { type: string }) {\n    const subject = new Subject<ActionFnPayload<unknown>>();\n    effectsRegistry[action.type] = subject;\n    return subject.asObservable();\n  }\n\n  const effectObservables = effects(actionFns, create);\n  return Object.values(effectObservables);\n}\n\nfunction startSubscriptions(observables: Observable<unknown>[]) {\n  return observables.map((observable) => observable.subscribe());\n}\n\nfunction processRedux<Spec extends ActionsFnSpecs, ReturnType>(\n  actionFnSpecs: Spec,\n  reducer: ReducerFactory<ActionFns, unknown>,\n  effects: EffectsFactory<ActionFns>,\n  store: unknown\n) {\n  const reducerRegistry: Record<\n    string,\n    (payload: ActionFnPayload<unknown>, state: unknown) => void\n  > = {};\n  const effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>> = {};\n  const actionsMap = createPublicAndAllActionsFns(\n    actionFnSpecs,\n    reducerRegistry,\n    effectsRegistry,\n    store\n  );\n  const actionFns = actionsMap.all;\n  const publicActionsFns = actionsMap.publics;\n\n  fillReducerRegistry(reducer, actionFns, reducerRegistry);\n  const effectObservables = fillEffects(effects, actionFns, effectsRegistry);\n  const subscriptions = startSubscriptions(effectObservables);\n\n  return {\n    methods: publicActionsFns as ReturnType,\n    subscriptions: subscriptions,\n  };\n}\n\n/**\n * @param redux redux\n *\n * properties do not start with `with` since they are not extension functions on their own.\n *\n * no dependency to NgRx\n *\n * actions are passed to reducer and effects, but it is also possible to use other actions.\n * effects provide forAction and do not return anything. that is important because effects should stay inaccessible\n */\nexport function withRedux<\n  Spec extends ActionsFnSpecs,\n  Input extends SignalStoreFeatureResult,\n  StateActionFns extends ActionFnsCreator<Spec> = ActionFnsCreator<Spec>,\n  PublicStoreActionFns extends PublicActionFns<Spec> = PublicActionFns<Spec>\n>(redux: {\n  actions: Spec;\n  reducer: ReducerFactory<StateActionFns, StateSignal<Input['state']>>;\n  effects: EffectsFactory<StateActionFns>;\n}): SignalStoreFeature<\n  Input,\n  EmptyFeatureResult & { methods: PublicStoreActionFns }\n> {\n  return (store) => {\n    const { methods, subscriptions } = processRedux<Spec, PublicStoreActionFns>(\n      redux.actions,\n      redux.reducer as ReducerFactory<ActionFns, unknown>,\n      redux.effects as EffectsFactory<ActionFns>,\n      store\n    );\n    return {\n      ...store,\n      methods,\n    };\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-redux.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-redux.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject } from 'rxjs';\nimport { SignalStoreFeature } from '@ngrx/signals';\nimport {\n  EmptyFeatureResult,\n  SignalStoreFeatureResult,\n} from '@ngrx/signals/src/signal-store-models';\nimport { StateSignal } from '@ngrx/signals/src/state-signal';\nimport { assertActionFnSpecs } from './assertions/assertions';\n\n/** Actions **/\n\ntype Payload = Record<string, unknown>;\n\ntype ActionFn<\n  Type extends string = string,\n  ActionPayload extends Payload = Payload\n> = ((payload: ActionPayload) => ActionPayload & { type: Type }) & {\n  type: Type;\n};\n\ntype ActionFns = Record<string, ActionFn>;\n\nexport type ActionsFnSpecs = Record<string, Payload>;\n\ntype ActionFnCreator<Spec extends ActionsFnSpecs> = {\n  [ActionName in keyof Spec]: ((\n    payload: Spec[ActionName]\n  ) => Spec[ActionName] & { type: ActionName }) & { type: ActionName & string };\n};\n\ntype ActionFnPayload<Action> = Action extends (payload: infer Payload) => void\n  ? Payload\n  : never;\n\ntype ActionFnsCreator<Spec extends ActionsFnSpecs> = Spec extends {\n  private: Record<string, Payload>;\n  public: Record<string, Payload>;\n}\n  ? ActionFnCreator<Spec['private']> & ActionFnCreator<Spec['public']>\n  : ActionFnCreator<Spec>;\n\ntype PublicActionFns<Spec extends ActionsFnSpecs> = Spec extends {\n  public: Record<string, Payload>;\n}\n  ? ActionFnCreator<Spec['public']>\n  : ActionFnCreator<Spec>;\n\nexport function payload<Type extends Payload>(): Type {\n  return {} as Type;\n}\n\nexport const noPayload = {};\n\n/** Reducer **/\n\ntype ReducerFunction<ReducerAction, State> = (\n  state: State,\n  action: ActionFnPayload<ReducerAction>\n) => void;\n\ntype ReducerFactory<StateActionFns extends ActionFns, State> = (\n  actions: StateActionFns,\n  on: <ReducerAction extends { type: string }>(\n    action: ReducerAction,\n    reducerFn: ReducerFunction<ReducerAction, State>\n  ) => void\n) => void;\n\n/** Effect **/\n\ntype EffectsFactory<StateActionFns extends ActionFns> = (\n  actions: StateActionFns,\n  create: <EffectAction extends { type: string }>(\n    action: EffectAction\n  ) => Observable<ActionFnPayload<EffectAction>>\n) => Record<string, Observable<unknown>>;\n\nfunction createActionFns<Spec extends ActionsFnSpecs>(\n  actionFnSpecs: Spec,\n  reducerRegistry: Record<\n    string,\n    (state: unknown, payload: ActionFnPayload<unknown>) => void\n  >,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,\n  state: unknown\n) {\n  const actionFns: Record<string, ActionFn> = {};\n\n  for (const type in actionFnSpecs) {\n    const actionFn = (payload: Payload) => {\n      const fullPayload = { ...payload, type };\n      const reducer = reducerRegistry[type];\n      if (reducer) {\n        (reducer as (state: unknown, payload: unknown) => void)(\n          state,\n          fullPayload as unknown\n        );\n      }\n      const effectSubject = effectsRegistry[type];\n      if (effectSubject) {\n        (effectSubject as unknown as Subject<unknown>).next(fullPayload);\n      }\n      return fullPayload;\n    };\n    actionFn.type = type.toString();\n    actionFns[type] = actionFn;\n  }\n\n  return actionFns;\n}\n\nfunction createPublicAndAllActionsFns<Spec extends ActionsFnSpecs>(\n  actionFnSpecs: Spec,\n  reducerRegistry: Record<\n    string,\n    (state: unknown, payload: ActionFnPayload<unknown>) => void\n  >,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>>,\n  state: unknown\n): { all: ActionFns; publics: ActionFns } {\n  if ('public' in actionFnSpecs || 'private' in actionFnSpecs) {\n    const privates = actionFnSpecs['private'] || {};\n    const publics = actionFnSpecs['public'] || {};\n\n    assertActionFnSpecs(privates);\n    assertActionFnSpecs(publics);\n\n    const privateActionFns = createActionFns(\n      privates,\n      reducerRegistry,\n      effectsRegistry,\n      state\n    );\n    const publicActionFns = createActionFns(\n      publics,\n      reducerRegistry,\n      effectsRegistry,\n      state\n    );\n\n    return {\n      all: { ...privateActionFns, ...publicActionFns },\n      publics: publicActionFns,\n    };\n  }\n\n  const actionFns = createActionFns(\n    actionFnSpecs,\n    reducerRegistry,\n    effectsRegistry,\n    state\n  );\n\n  return { all: actionFns, publics: actionFns };\n}\n\nfunction fillReducerRegistry(\n  reducer: ReducerFactory<ActionFns, unknown>,\n  actionFns: ActionFns,\n  reducerRegistry: Record<\n    string,\n    (state: unknown, payload: ActionFnPayload<unknown>) => void\n  >\n) {\n  function on(\n    action: { type: string },\n    reducerFn: (state: unknown, payload: ActionFnPayload<unknown>) => void\n  ) {\n    reducerRegistry[action.type] = reducerFn;\n  }\n\n  reducer(actionFns, on);\n\n  return reducerRegistry;\n}\n\nfunction fillEffects(\n  effects: EffectsFactory<ActionFns>,\n  actionFns: ActionFns,\n  effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>> = {}\n): Observable<unknown>[] {\n  function create(action: { type: string }) {\n    const subject = new Subject<ActionFnPayload<unknown>>();\n    effectsRegistry[action.type] = subject;\n    return subject.asObservable();\n  }\n\n  const effectObservables = effects(actionFns, create);\n  return Object.values(effectObservables);\n}\n\nfunction startSubscriptions(observables: Observable<unknown>[]) {\n  return observables.map((observable) => observable.subscribe());\n}\n\nfunction processRedux<Spec extends ActionsFnSpecs, ReturnType>(\n  actionFnSpecs: Spec,\n  reducer: ReducerFactory<ActionFns, unknown>,\n  effects: EffectsFactory<ActionFns>,\n  store: unknown\n) {\n  const reducerRegistry: Record<\n    string,\n    (state: unknown, payload: ActionFnPayload<unknown>) => void\n  > = {};\n  const effectsRegistry: Record<string, Subject<ActionFnPayload<unknown>>> = {};\n  const actionsMap = createPublicAndAllActionsFns(\n    actionFnSpecs,\n    reducerRegistry,\n    effectsRegistry,\n    store\n  );\n  const actionFns = actionsMap.all;\n  const publicActionsFns = actionsMap.publics;\n\n  fillReducerRegistry(reducer, actionFns, reducerRegistry);\n  const effectObservables = fillEffects(effects, actionFns, effectsRegistry);\n  const subscriptions = startSubscriptions(effectObservables);\n\n  return {\n    methods: publicActionsFns as ReturnType,\n    subscriptions: subscriptions,\n  };\n}\n\n/**\n * @param redux redux\n *\n * properties do not start with `with` since they are not extension functions on their own.\n *\n * no dependency to NgRx\n *\n * actions are passed to reducer and effects, but it is also possible to use other actions.\n * effects provide forAction and do not return anything. that is important because effects should stay inaccessible\n */\nexport function withRedux<\n  Spec extends ActionsFnSpecs,\n  Input extends SignalStoreFeatureResult,\n  StateActionFns extends ActionFnsCreator<Spec> = ActionFnsCreator<Spec>,\n  PublicStoreActionFns extends PublicActionFns<Spec> = PublicActionFns<Spec>\n>(redux: {\n  actions: Spec;\n  reducer: ReducerFactory<StateActionFns, StateSignal<Input['state']>>;\n  effects: EffectsFactory<StateActionFns>;\n}): SignalStoreFeature<\n  Input,\n  EmptyFeatureResult & { methods: PublicStoreActionFns }\n> {\n  return (store) => {\n    const { methods, subscriptions } = processRedux<Spec, PublicStoreActionFns>(\n      redux.actions,\n      redux.reducer as ReducerFactory<ActionFns, unknown>,\n      redux.effects as EffectsFactory<ActionFns>,\n      store\n    );\n    return {\n      ...store,\n      methods,\n    };\n  };\n}\n"]}