@angular-architects/ngrx-toolkit 0.0.4 → 0.0.6

package/README.md

@@ -1,220 +1,369 @@
-# NgRx Toolkit
-
-<p align="center">
-<img src="https://raw.githubusercontent.com/angular-architects/ngrx-toolkit/main/logo.png" width="320" style="text-align: center">
-</p>
-
-NgRx Toolkit is an extension to the NgRx Signals Store. **It is still in beta** but already offers following features:
-
-- Devtools: Integration into Redux Devtools
-- Redux: Possibility to use the Redux Pattern (Reducer, Actions, Effects)
-
-To install it, run
-
-```shell
-npm i @angular-architects/ngrx-toolkit
-```
-
-## Devtools: `withDevtools()`
-
-This extension is very easy to use. Just add it to a `signalStore`. Example:
-
-```typescript
-export const FlightStore = signalStore(
-  { providedIn: 'root' },
-  withDevtools('flights'), // <-- add this
-  withState({ flights: [] as Flight[] }),
-  // ...
-);
-```
-
-## Redux: `withRedux()`
-
-`withRedux()` bring back the Redux pattern into the Signal Store.
-
-It can be combined with any other extension of the Signal Store.
-
-Example:
-
-```typescript
-export const FlightStore = signalStore(
-  { providedIn: 'root' },
-  withState({ flights: [] as Flight[] }),
-  withRedux({
-    actions: {
-      public: {
-        load: payload<{ from: string; to: string }>(),
-      },
-      private: {
-        loaded: payload<{ flights: Flight[] }>(),
-      },
-    },
-    reducer(actions, on) {
-      on(actions.loaded, ({ flights }, state) => {
-        patchState(state, 'flights loaded', { flights });
-      });
-    },
-    effects(actions, create) {
-      const httpClient = inject(HttpClient);
-      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),
-              },
-            ),
-          ),
-          tap((flights) => actions.loaded({ flights })),
-        ),
-      };
-    },
-  }),
-);
-```
-
-## DataService `withDataService()`
-
-`withDataService()` allows to connect a Data Service to the store:
-
-This gives you a store for a CRUD use case:
-
-```typescript
-export const SimpleFlightBookingStore = signalStore(
-  { providedIn: 'root' },
-  withCallState(),
-  withEntities<Flight>(),
-  withDataService({
-    dataServiceType: FlightService, 
-    filter: { from: 'Paris', to: 'New York' },
-  }),
-  withUndoRedo(),
-);
-```
-
-The features ``withCallState`` and ``withUndoRedo`` are optional, but when present, they enrich each other.
-
-The Data Service needs to implement the ``DataService`` interface:
-
-```typescript 
-@Injectable({
-  providedIn: 'root'
-})
-export class FlightService implements DataService<Flight, FlightFilter> {
-  loadById(id: EntityId): Promise<Flight> { ... }
-  load(filter: FlightFilter): Promise<Flight[]> { ... }
-
-  create(entity: Flight): Promise<Flight> { ... }
-  update(entity: Flight): Promise<Flight> { ... }
-  delete(entity: Flight): Promise<void> { ... }
-  [...]
-}
-```
-
-Once the store is defined, it gives its consumers numerous signals and methods they just need to delegate to:
-
-```typescript
-@Component(...)
-export class FlightSearchSimpleComponent {
-  private store = inject(SimpleFlightBookingStore);
-
-  from = this.store.filter.from;
-  to = this.store.filter.to;
-  flights = this.store.entities;
-  selected = this.store.selectedEntities;
-  selectedIds = this.store.selectedIds;
-
-  loading = this.store.loading;
-
-  canUndo = this.store.canUndo;
-  canRedo = this.store.canRedo;
-
-  async search() {
-    this.store.load();
-  }
-
-  undo(): void {
-    this.store.undo();
-  }
-
-  redo(): void {
-    this.store.redo();
-  }
-
-  updateCriteria(from: string, to: string): void {
-    this.store.updateFilter({ from, to });
-  }
-
-  updateBasket(id: number, selected: boolean): void {
-    this.store.updateSelected(id, selected);
-  }
-
-}
-```
-
-## 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:
-
-```typescript
-export const FlightBookingStore = signalStore(
-  { providedIn: 'root' },
-  withCallState({
-    collection: 'flight'
-  }),
-  withEntities({ 
-    entity: type<Flight>(), 
-    collection: 'flight'
-  }),
-  withDataService({
-    dataServiceType: FlightService, 
-    filter: { from: 'Graz', to: 'Hamburg' },
-    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:
-
-```typescript
-@Component(...)
-export class FlightSearchDynamicComponent {
-  private store = inject(FlightBookingStore);
-
-  from = this.store.flightFilter.from;
-  to = this.store.flightFilter.to;
-  flights = this.store.flightEntities;
-  selected = this.store.selectedFlightEntities;
-  selectedIds = this.store.selectedFlightIds;
-
-  loading = this.store.flightLoading;
-
-  canUndo = this.store.canUndo;
-  canRedo = this.store.canRedo;
-
-  async search() {
-    this.store.loadFlightEntities();
-  }
-
-  undo(): void {
-    this.store.undo();
-  }
-
-  redo(): void {
-    this.store.redo();
-  }
-
-  updateCriteria(from: string, to: string): void {
-    this.store.updateFlightFilter({ from, to });
-  }
-
-  updateBasket(id: number, selected: boolean): void {
-    this.store.updateSelectedFlightEntities(id, selected);
-  }
-
-}
-```
+# 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>
+
+NgRx Toolkit is an extension to the NgRx Signals Store. **It is still in beta** but already offers following features:
+
+- 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
+
+```shell
+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:
+
+```typescript
+export const FlightStore = signalStore(
+  { providedIn: 'root' },
+  withDevtools('flights'), // <-- add this
+  withState({ flights: [] as Flight[] }),
+  // ...
+);
+```
+
+## Redux: `withRedux()`
+
+`withRedux()` bring back the Redux pattern into the Signal Store.
+
+It can be combined with any other extension of the Signal Store.
+
+Example:
+
+```typescript
+export const FlightStore = signalStore(
+  { providedIn: 'root' },
+  withState({ flights: [] as Flight[] }),
+  withRedux({
+    actions: {
+      public: {
+        load: payload<{ from: string; to: string }>(),
+      },
+      private: {
+        loaded: payload<{ flights: Flight[] }>(),
+      },
+    },
+    reducer(actions, on) {
+      on(actions.loaded, ({ flights }, state) => {
+        patchState(state, 'flights loaded', { flights });
+      });
+    },
+    effects(actions, create) {
+      const httpClient = inject(HttpClient);
+      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),
+              },
+            ),
+          ),
+          tap((flights) => actions.loaded({ flights })),
+        ),
+      };
+    },
+  }),
+);
+```
+
+## DataService `withDataService()`
+
+`withDataService()` allows to connect a Data Service to the store:
+
+This gives you a store for a CRUD use case:
+
+```typescript
+export const SimpleFlightBookingStore = signalStore(
+  { providedIn: 'root' },
+  withCallState(),
+  withEntities<Flight>(),
+  withDataService({
+    dataServiceType: FlightService, 
+    filter: { from: 'Paris', to: 'New York' },
+  }),
+  withUndoRedo(),
+);
+```
+
+The features ``withCallState`` and ``withUndoRedo`` are optional, but when present, they enrich each other.
+
+The Data Service needs to implement the ``DataService`` interface:
+
+```typescript 
+@Injectable({
+  providedIn: 'root'
+})
+export class FlightService implements DataService<Flight, FlightFilter> {
+  loadById(id: EntityId): Promise<Flight> { ... }
+  load(filter: FlightFilter): Promise<Flight[]> { ... }
+
+  create(entity: Flight): Promise<Flight> { ... }
+  update(entity: Flight): Promise<Flight> { ... }
+  delete(entity: Flight): Promise<void> { ... }
+  [...]
+}
+```
+
+Once the store is defined, it gives its consumers numerous signals and methods they just need to delegate to:
+
+```typescript
+@Component(...)
+export class FlightSearchSimpleComponent {
+  private store = inject(SimpleFlightBookingStore);
+
+  from = this.store.filter.from;
+  to = this.store.filter.to;
+  flights = this.store.entities;
+  selected = this.store.selectedEntities;
+  selectedIds = this.store.selectedIds;
+
+  loading = this.store.loading;
+
+  canUndo = this.store.canUndo;
+  canRedo = this.store.canRedo;
+
+  async search() {
+    this.store.load();
+  }
+
+  undo(): void {
+    this.store.undo();
+  }
+
+  redo(): void {
+    this.store.redo();
+  }
+
+  updateCriteria(from: string, to: string): void {
+    this.store.updateFilter({ from, to });
+  }
+
+  updateBasket(id: number, selected: boolean): void {
+    this.store.updateSelected(id, selected);
+  }
+
+}
+```
+
+## 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:
+
+```typescript
+export const FlightBookingStore = signalStore(
+  { providedIn: 'root' },
+  withCallState({
+    collection: 'flight'
+  }),
+  withEntities({ 
+    entity: type<Flight>(), 
+    collection: 'flight'
+  }),
+  withDataService({
+    dataServiceType: FlightService, 
+    filter: { from: 'Graz', to: 'Hamburg' },
+    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:
+
+```typescript
+@Component(...)
+export class FlightSearchDynamicComponent {
+  private store = inject(FlightBookingStore);
+
+  from = this.store.flightFilter.from;
+  to = this.store.flightFilter.to;
+  flights = this.store.flightEntities;
+  selected = this.store.selectedFlightEntities;
+  selectedIds = this.store.selectedFlightIds;
+
+  loading = this.store.flightLoading;
+
+  canUndo = this.store.canUndo;
+  canRedo = this.store.canRedo;
+
+  async search() {
+    this.store.loadFlightEntities();
+  }
+
+  undo(): void {
+    this.store.undo();
+  }
+
+  redo(): void {
+    this.store.redo();
+  }
+
+  updateCriteria(from: string, to: string): void {
+    this.store.updateFlightFilter({ from, to });
+  }
+
+  updateBasket(id: number, selected: boolean): void {
+    this.store.updateSelectedFlightEntities(id, selected);
+  }
+
+}
+```
+
+## 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,6 @@ 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 * from './lib/redux-connector';
+export * from './lib/redux-connector/rxjs-interop';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQVUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RSxjQUFjLGtCQUFrQixDQUFDO0FBRWpDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDO0FBRXhDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IHdpdGhEZXZ0b29scywgcGF0Y2hTdGF0ZSwgQWN0aW9uIH0gZnJvbSAnLi9saWIvd2l0aC1kZXZ0b29scyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtcmVkdXgnO1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvd2l0aC1jYWxsLXN0YXRlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvd2l0aC11bmRvLXJlZG8nO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi93aXRoLWRhdGEtc2VydmljZSc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZWR1eC1jb25uZWN0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9yZWR1eC1jb25uZWN0b3Ivcnhqcy1pbnRlcm9wJztcclxuIl19

package/esm2022/lib/assertions/assertions.mjs

@@ -3,4 +3,4 @@ export function assertActionFnSpecs(obj) {
         throw new Error('%o is not an Action Specification');
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXJ0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10b29sa2l0L3NyYy9saWIvYXNzZXJ0aW9ucy9hc3NlcnRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxtQkFBbUIsQ0FDakMsR0FBWTtJQUVaLElBQUksQ0FBQyxHQUFHLElBQUksT0FBTyxHQUFHLEtBQUssUUFBUSxFQUFFO1FBQ25DLE1BQU0sSUFBSSxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQztLQUN0RDtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBY3Rpb25zRm5TcGVjcyB9IGZyb20gJy4uL3dpdGgtcmVkdXgnO1xuXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0QWN0aW9uRm5TcGVjcyhcbiAgb2JqOiB1bmtub3duXG4pOiBhc3NlcnRzIG9iaiBpcyBBY3Rpb25zRm5TcGVjcyB7XG4gIGlmICghb2JqIHx8IHR5cGVvZiBvYmogIT09ICdvYmplY3QnKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCclbyBpcyBub3QgYW4gQWN0aW9uIFNwZWNpZmljYXRpb24nKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXJ0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmdyeC10b29sa2l0L3NyYy9saWIvYXNzZXJ0aW9ucy9hc3NlcnRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxtQkFBbUIsQ0FDakMsR0FBWTtJQUVaLElBQUksQ0FBQyxHQUFHLElBQUksT0FBTyxHQUFHLEtBQUssUUFBUSxFQUFFO1FBQ25DLE1BQU0sSUFBSSxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQztLQUN0RDtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBY3Rpb25zRm5TcGVjcyB9IGZyb20gJy4uL3dpdGgtcmVkdXgnO1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydEFjdGlvbkZuU3BlY3MoXHJcbiAgb2JqOiB1bmtub3duXHJcbik6IGFzc2VydHMgb2JqIGlzIEFjdGlvbnNGblNwZWNzIHtcclxuICBpZiAoIW9iaiB8fCB0eXBlb2Ygb2JqICE9PSAnb2JqZWN0Jykge1xyXG4gICAgdGhyb3cgbmV3IEVycm9yKCclbyBpcyBub3QgYW4gQWN0aW9uIFNwZWNpZmljYXRpb24nKTtcclxuICB9XHJcbn1cclxuIl19

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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