@angular-architects/ngrx-toolkit 0.0.2 → 0.0.3

package/README.md

@@ -1,76 +1,220 @@
-# 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 })),
-        ),
-      };
-    },
-  }),
-);
-```
-
+# 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);
+  }
+
+}
+```

package/esm2022/index.mjs

@@ -1,3 +1,6 @@
 export { withDevtools, patchState } from './lib/with-devtools';
 export * from './lib/with-redux';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQVUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RSxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgd2l0aERldnRvb2xzLCBwYXRjaFN0YXRlLCBBY3Rpb24gfSBmcm9tICcuL2xpYi93aXRoLWRldnRvb2xzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtcmVkdXgnO1xuIl19
+export * from './lib/with-call-state';
+export * from './lib/with-undo-redo';
+export * from './lib/with-data-service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQVUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgd2l0aERldnRvb2xzLCBwYXRjaFN0YXRlLCBBY3Rpb24gfSBmcm9tICcuL2xpYi93aXRoLWRldnRvb2xzJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvd2l0aC1yZWR1eCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtY2FsbC1zdGF0ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtdW5kby1yZWRvJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvd2l0aC1kYXRhLXNlcnZpY2UnO1xyXG4iXX0=

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/shared/empty.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvbGliL3NoYXJlZC9lbXB0eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9iYW4tdHlwZXNcclxuZXhwb3J0IHR5cGUgRW10cHkgPSB7fTsiXX0=

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

@@ -0,0 +1,58 @@
+import { computed } from '@angular/core';
+import { signalStoreFeature, withComputed, withState, } from '@ngrx/signals';
+export function getCallStateKeys(config) {
+    const prop = config?.collection;
+    return {
+        callStateKey: prop ? `${config.collection}CallState` : 'callState',
+        loadingKey: prop ? `${config.collection}Loading` : 'loading',
+        loadedKey: prop ? `${config.collection}Loaded` : 'loaded',
+        errorKey: prop ? `${config.collection}Error` : 'error',
+    };
+}
+export function withCallState(config) {
+    const { callStateKey, errorKey, loadedKey, loadingKey } = getCallStateKeys(config);
+    return signalStoreFeature(withState({ [callStateKey]: 'init' }), withComputed((state) => {
+        const callState = state[callStateKey];
+        return {
+            [loadingKey]: computed(() => callState() === 'loading'),
+            [loadedKey]: computed(() => callState() === 'loaded'),
+            [errorKey]: computed(() => {
+                const v = callState();
+                return typeof v === 'object' ? v.error : null;
+            })
+        };
+    }));
+}
+export function setLoading(prop) {
+    if (prop) {
+        return { [`${prop}CallState`]: 'loading' };
+    }
+    return { callState: 'loading' };
+}
+export function setLoaded(prop) {
+    if (prop) {
+        return { [`${prop}CallState`]: 'loaded' };
+    }
+    else {
+        return { callState: 'loaded' };
+    }
+}
+export function setError(error, prop) {
+    let errorMessage = '';
+    if (!error) {
+        errorMessage = '';
+    }
+    else if (typeof error === 'object' && 'message' in error) {
+        errorMessage = String(error.message);
+    }
+    else {
+        errorMessage = String(error);
+    }
+    if (prop) {
+        return { [`${prop}CallState`]: { error: errorMessage } };
+    }
+    else {
+        return { callState: { error: errorMessage } };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-call-state.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-call-state.ts"],"names":[],"mappings":"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","sourcesContent":["import { Signal, computed } from '@angular/core';\r\nimport {\r\n  SignalStoreFeature,\r\n  signalStoreFeature,\r\n  withComputed,\r\n  withState,\r\n} from '@ngrx/signals';\r\nimport { Emtpy } from './shared/empty';\r\n\r\nexport type CallState = 'init' | 'loading' | 'loaded' | { error: string };\r\n\r\nexport type NamedCallStateSlice<Collection extends string> = {\r\n  [K in Collection as `${K}CallState`]: CallState;\r\n};\r\n\r\nexport type CallStateSlice = {\r\n  callState: CallState\r\n}\r\n\r\nexport type NamedCallStateSignals<Prop extends string> = {\r\n  [K in Prop as `${K}Loading`]: Signal<boolean>;\r\n} & {\r\n    [K in Prop as `${K}Loaded`]: Signal<boolean>;\r\n  } & {\r\n    [K in Prop as `${K}Error`]: Signal<string | null>;\r\n  } \r\n\r\nexport type CallStateSignals = {\r\n  loading: Signal<boolean>;\r\n  loaded: Signal<boolean>;\r\n  error: Signal<string | null>\r\n} \r\n\r\nexport function getCallStateKeys(config?: { collection?: string }) {\r\n  const prop = config?.collection;\r\n  return {\r\n    callStateKey: prop ?  `${config.collection}CallState` : 'callState',\r\n    loadingKey: prop ? `${config.collection}Loading` : 'loading',\r\n    loadedKey: prop ? `${config.collection}Loaded` : 'loaded',\r\n    errorKey: prop ? `${config.collection}Error` : 'error',\r\n  };\r\n}\r\n\r\nexport function withCallState<Collection extends string>(config: {\r\n  collection: Collection;\r\n}): SignalStoreFeature<\r\n  { state: Emtpy, signals: Emtpy, methods: Emtpy },\r\n  {\r\n    state: NamedCallStateSlice<Collection>,\r\n    signals: NamedCallStateSignals<Collection>,\r\n    methods: Emtpy\r\n  }\r\n>;\r\nexport function withCallState(): SignalStoreFeature<\r\n  { state: Emtpy, signals: Emtpy, methods: Emtpy },\r\n  {\r\n    state: CallStateSlice,\r\n    signals: CallStateSignals,\r\n    methods: Emtpy\r\n  }\r\n>;\r\nexport function withCallState<Collection extends string>(config?: {\r\n  collection: Collection;\r\n}): SignalStoreFeature {\r\n  const { callStateKey, errorKey, loadedKey, loadingKey } =\r\n    getCallStateKeys(config);\r\n\r\n  return signalStoreFeature(\r\n    withState({ [callStateKey]: 'init' }),\r\n    withComputed((state: Record<string, Signal<unknown>>) => {\r\n\r\n      const callState = state[callStateKey] as Signal<CallState>;\r\n\r\n      return {\r\n        [loadingKey]: computed(() => callState() === 'loading'),\r\n        [loadedKey]: computed(() => callState() === 'loaded'),\r\n        [errorKey]: computed(() => {\r\n          const v = callState();\r\n          return typeof v === 'object' ? v.error : null;\r\n        })\r\n      }\r\n    })\r\n  );\r\n}\r\n\r\nexport function setLoading<Prop extends string>(\r\n  prop?: Prop\r\n): NamedCallStateSlice<Prop> | CallStateSlice {\r\n  if (prop) {\r\n    return { [`${prop}CallState`]: 'loading' } as NamedCallStateSlice<Prop>;\r\n  }\r\n\r\n  return { callState: 'loading' };\r\n}\r\n\r\nexport function setLoaded<Prop extends string>(\r\n  prop?: Prop\r\n): NamedCallStateSlice<Prop> | CallStateSlice {\r\n\r\n  if (prop) {\r\n    return { [`${prop}CallState`]: 'loaded' } as NamedCallStateSlice<Prop>;\r\n  }\r\n  else {\r\n    return { callState: 'loaded' };\r\n\r\n  }\r\n}\r\n\r\nexport function setError<Prop extends string>(\r\n  error: unknown,\r\n  prop?: Prop,\r\n  ): NamedCallStateSlice<Prop> | CallStateSlice {\r\n\r\n    let errorMessage = '';\r\n\r\n    if (!error) {\r\n      errorMessage = '';\r\n    }\r\n    else if (typeof error === 'object' && 'message' in error) {\r\n      errorMessage = String(error.message);\r\n    }\r\n    else {\r\n      errorMessage = String(error);\r\n    }\r\n    \r\n\r\n    if (prop) {\r\n      return { [`${prop}CallState`]: { error: errorMessage } } as NamedCallStateSlice<Prop>;\r\n    }\r\n    else {\r\n      return { callState: { error: errorMessage } };\r\n    }\r\n}\r\n"]}

package/esm2022/lib/with-data-service.mjs

@@ -0,0 +1,147 @@
+import { computed, inject } from "@angular/core";
+import { patchState, signalStoreFeature, withComputed, withMethods, withState } from "@ngrx/signals";
+import { getCallStateKeys, setError, setLoaded, setLoading } from "./with-call-state";
+import { setAllEntities, addEntity, updateEntity, removeEntity } from "@ngrx/signals/entities";
+export function capitalize(str) {
+    return str ? str[0].toUpperCase() + str.substring(1) : str;
+}
+export function getDataServiceKeys(options) {
+    const filterKey = options.collection ? `${options.collection}Filter` : 'filter';
+    const selectedIdsKey = options.collection ? `selected${capitalize(options.collection)}Ids` : 'selectedIds';
+    const selectedEntitiesKey = options.collection ? `selected${capitalize(options.collection)}Entities` : 'selectedEntities';
+    const updateFilterKey = options.collection ? `update${capitalize(options.collection)}Filter` : 'updateFilter';
+    const updateSelectedKey = options.collection ? `updateSelected${capitalize(options.collection)}Entities` : 'updateSelected';
+    const loadKey = options.collection ? `load${capitalize(options.collection)}Entities` : 'load';
+    const currentKey = options.collection ? `current${capitalize(options.collection)}` : 'current';
+    const loadByIdKey = options.collection ? `load${capitalize(options.collection)}ById` : 'loadById';
+    const setCurrentKey = options.collection ? `setCurrent${capitalize(options.collection)}` : 'setCurrent';
+    const createKey = options.collection ? `create${capitalize(options.collection)}` : 'create';
+    const updateKey = options.collection ? `update${capitalize(options.collection)}` : 'update';
+    const deleteKey = options.collection ? `delete${capitalize(options.collection)}` : 'delete';
+    // TODO: Take these from @ngrx/signals/entities, when they are exported
+    const entitiesKey = options.collection ? `${options.collection}Entities` : 'entities';
+    const entityMapKey = options.collection ? `${options.collection}EntityMap` : 'entityMap';
+    const idsKey = options.collection ? `${options.collection}Ids` : 'ids';
+    return {
+        filterKey,
+        selectedIdsKey,
+        selectedEntitiesKey,
+        updateFilterKey,
+        updateSelectedKey,
+        loadKey,
+        entitiesKey,
+        entityMapKey,
+        idsKey,
+        currentKey,
+        loadByIdKey,
+        setCurrentKey,
+        createKey,
+        updateKey,
+        deleteKey
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function withDataService(options) {
+    const { dataServiceType, filter, collection: prefix } = options;
+    const { entitiesKey, filterKey, loadKey, selectedEntitiesKey, selectedIdsKey, updateFilterKey, updateSelectedKey, currentKey, createKey, updateKey, deleteKey, loadByIdKey, setCurrentKey } = getDataServiceKeys(options);
+    const { callStateKey } = getCallStateKeys({ collection: prefix });
+    return signalStoreFeature(withState(() => ({
+        [filterKey]: filter,
+        [selectedIdsKey]: {},
+        [currentKey]: undefined
+    })), withComputed((store) => {
+        const entities = store[entitiesKey];
+        const selectedIds = store[selectedIdsKey];
+        return {
+            [selectedEntitiesKey]: computed(() => entities().filter(e => selectedIds()[e.id]))
+        };
+    }), withMethods((store) => {
+        const dataService = inject(dataServiceType);
+        return {
+            [updateFilterKey]: (filter) => {
+                patchState(store, { [filterKey]: filter });
+            },
+            [updateSelectedKey]: (id, selected) => {
+                patchState(store, (state) => ({
+                    [selectedIdsKey]: {
+                        ...state[selectedIdsKey],
+                        [id]: selected,
+                    }
+                }));
+            },
+            [loadKey]: async () => {
+                const filter = store[filterKey];
+                store[callStateKey] && patchState(store, setLoading(prefix));
+                try {
+                    const result = await dataService.load(filter());
+                    patchState(store, prefix ? setAllEntities(result, { collection: prefix }) : setAllEntities(result));
+                    store[callStateKey] && patchState(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [loadByIdKey]: async (id) => {
+                store[callStateKey] && patchState(store, setLoading(prefix));
+                try {
+                    const current = await dataService.loadById(id);
+                    store[callStateKey] && patchState(store, setLoaded(prefix));
+                    patchState(store, { [currentKey]: current });
+                }
+                catch (e) {
+                    store[callStateKey] && patchState(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [setCurrentKey]: (current) => {
+                patchState(store, { [currentKey]: current });
+            },
+            [createKey]: async (entity) => {
+                patchState(store, { [currentKey]: entity });
+                store[callStateKey] && patchState(store, setLoading(prefix));
+                try {
+                    const created = await dataService.create(entity);
+                    patchState(store, { [currentKey]: created });
+                    patchState(store, prefix ? addEntity(created, { collection: prefix }) : addEntity(created));
+                    store[callStateKey] && patchState(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [updateKey]: async (entity) => {
+                patchState(store, { [currentKey]: entity });
+                store[callStateKey] && patchState(store, setLoading(prefix));
+                try {
+                    const updated = await dataService.update(entity);
+                    patchState(store, { [currentKey]: updated });
+                    // Why do we need this cast to Partial<Entity>?
+                    const updateArg = { id: updated.id, changes: updated };
+                    patchState(store, prefix ? updateEntity(updateArg, { collection: prefix }) : updateEntity(updateArg));
+                    store[callStateKey] && patchState(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+            [deleteKey]: async (entity) => {
+                patchState(store, { [currentKey]: entity });
+                store[callStateKey] && patchState(store, setLoading(prefix));
+                try {
+                    await dataService.delete(entity);
+                    patchState(store, { [currentKey]: undefined });
+                    patchState(store, prefix ? removeEntity(entity.id, { collection: prefix }) : removeEntity(entity.id));
+                    store[callStateKey] && patchState(store, setLoaded(prefix));
+                }
+                catch (e) {
+                    store[callStateKey] && patchState(store, setError(e, prefix));
+                    throw e;
+                }
+            },
+        };
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-data-service.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-data-service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ProviderToken, Signal, computed, inject } from \"@angular/core\";\r\nimport { SignalStoreFeature, patchState, signalStoreFeature, withComputed, withMethods, withState } from \"@ngrx/signals\";\r\nimport { CallState, getCallStateKeys, setError, setLoaded, setLoading } from \"./with-call-state\";\r\nimport { setAllEntities, EntityId, addEntity, updateEntity, removeEntity } from \"@ngrx/signals/entities\";\r\nimport { EntityState, NamedEntitySignals } from \"@ngrx/signals/entities/src/models\";\r\nimport { StateSignal } from \"@ngrx/signals/src/state-signal\";\r\nimport { Emtpy } from \"./shared/empty\";\r\n\r\nexport type Filter = Record<string, unknown>;\r\nexport type Entity = { id: EntityId };\r\n\r\nexport interface DataService<E extends Entity, F extends Filter> {\r\n    load(filter: F): Promise<E[]>;\r\n    loadById(id: EntityId): Promise<E>;\r\n    create(entity: E): Promise<E>;\r\n    update(entity: E): Promise<E>;\r\n    delete(entity: E): Promise<void>;\r\n}\r\n\r\nexport function capitalize(str: string): string {\r\n    return str ? str[0].toUpperCase() + str.substring(1) : str;\r\n}\r\n\r\nexport function getDataServiceKeys(options: { collection?: string }) {\r\n    const filterKey = options.collection ? `${options.collection}Filter` : 'filter';\r\n    const selectedIdsKey = options.collection ? `selected${capitalize(options.collection)}Ids` : 'selectedIds';\r\n    const selectedEntitiesKey = options.collection ? `selected${capitalize(options.collection)}Entities` : 'selectedEntities';\r\n\r\n    const updateFilterKey = options.collection ? `update${capitalize(options.collection)}Filter` : 'updateFilter';\r\n    const updateSelectedKey = options.collection ? `updateSelected${capitalize(options.collection)}Entities` : 'updateSelected';\r\n    const loadKey = options.collection ? `load${capitalize(options.collection)}Entities` : 'load';\r\n\r\n    const currentKey = options.collection ? `current${capitalize(options.collection)}` : 'current';\r\n    const loadByIdKey = options.collection ? `load${capitalize(options.collection)}ById` : 'loadById';\r\n    const setCurrentKey = options.collection ? `setCurrent${capitalize(options.collection)}` : 'setCurrent';\r\n    const createKey = options.collection ? `create${capitalize(options.collection)}` : 'create';\r\n    const updateKey = options.collection ? `update${capitalize(options.collection)}` : 'update';\r\n    const deleteKey = options.collection ? `delete${capitalize(options.collection)}` : 'delete';\r\n\r\n    // TODO: Take these from @ngrx/signals/entities, when they are exported\r\n    const entitiesKey = options.collection ? `${options.collection}Entities` : 'entities';\r\n    const entityMapKey = options.collection ? `${options.collection}EntityMap` : 'entityMap';\r\n    const idsKey = options.collection ? `${options.collection}Ids` : 'ids';\r\n\r\n    return {\r\n        filterKey,\r\n        selectedIdsKey,\r\n        selectedEntitiesKey,\r\n        updateFilterKey,\r\n        updateSelectedKey,\r\n        loadKey,\r\n        entitiesKey,\r\n        entityMapKey,\r\n        idsKey,\r\n\r\n        currentKey,\r\n        loadByIdKey,\r\n        setCurrentKey,\r\n        createKey,\r\n        updateKey,\r\n        deleteKey\r\n    };\r\n}\r\n\r\nexport type NamedDataServiceState<E extends Entity, F extends Filter, Collection extends string> =\r\n    {\r\n        [K in Collection as `${K}Filter`]: F;\r\n    } & {\r\n        [K in Collection as `selected${Capitalize<K>}Ids`]: Record<EntityId, boolean>;\r\n    } & {\r\n        [K in Collection as `current${Capitalize<K>}`]: E;\r\n    }\r\n\r\nexport type DataServiceState<E extends Entity, F extends Filter> = {\r\n    filter: F;\r\n    selectedIds: Record<EntityId, boolean>;\r\n    current: E;\r\n}\r\n\r\nexport type NamedDataServiceSignals<E extends Entity, Collection extends string> =\r\n    {\r\n        [K in Collection as `selected${Capitalize<K>}Entities`]: Signal<E[]>;\r\n    }\r\n\r\nexport type DataServiceSignals<E extends Entity> =\r\n    {\r\n        selectedEntities: Signal<E[]>;\r\n    }\r\n\r\nexport type NamedDataServiceMethods<E extends Entity, F extends Filter, Collection extends string> =\r\n    {\r\n        [K in Collection as `update${Capitalize<K>}Filter`]: (filter: F) => void;\r\n    } &\r\n    {\r\n        [K in Collection as `updateSelected${Capitalize<K>}Entities`]: (id: EntityId, selected: boolean) => void;\r\n    } &\r\n    {\r\n        [K in Collection as `load${Capitalize<K>}Entities`]: () => Promise<void>;\r\n    } &\r\n\r\n    {\r\n        [K in Collection as `setCurrent${Capitalize<K>}`]: (entity: E) => void;\r\n    } &\r\n    {\r\n        [K in Collection as `load${Capitalize<K>}ById`]: (id: EntityId) => Promise<void>;\r\n    } &\r\n    {\r\n        [K in Collection as `create${Capitalize<K>}`]: (entity: E) => Promise<void>;\r\n    } &\r\n    {\r\n        [K in Collection as `update${Capitalize<K>}`]: (entity: E) => Promise<void>;\r\n    } &\r\n    {\r\n        [K in Collection as `delete${Capitalize<K>}`]: (entity: E) => Promise<void>;\r\n    };\r\n\r\n\r\nexport type DataServiceMethods<E extends Entity, F extends Filter> =\r\n    {\r\n        updateFilter: (filter: F) => void;\r\n        updateSelected: (id: EntityId, selected: boolean) => void;\r\n        load: () => Promise<void>;\r\n\r\n        setCurrent(entity: E): void;\r\n        loadById(id: EntityId): Promise<void>;\r\n        create(entity: E): Promise<void>;\r\n        update(entity: E): Promise<void>;\r\n        delete(entity: E): Promise<void>;\r\n    }\r\n\r\nexport type Empty = Record<string, never>\r\n\r\nexport function withDataService<E extends Entity, F extends Filter, Collection extends string>(options: { dataServiceType: ProviderToken<DataService<E, F>>, filter: F, collection: Collection }): SignalStoreFeature<\r\n    {\r\n        state: Emtpy,\r\n        // These alternatives break type inference: \r\n        // state: { callState: CallState } & NamedEntityState<E, Collection>,\r\n        // state: NamedEntityState<E, Collection>,\r\n\r\n        signals: NamedEntitySignals<E, Collection>,\r\n        methods: Emtpy,\r\n    },\r\n    {\r\n        state: NamedDataServiceState<E, F, Collection>\r\n        signals: NamedDataServiceSignals<E, Collection>\r\n        methods: NamedDataServiceMethods<E, F, Collection>\r\n    }\r\n>;\r\nexport function withDataService<E extends Entity, F extends Filter>(options: { dataServiceType: ProviderToken<DataService<E, F>>, filter: F }): SignalStoreFeature<\r\n    {\r\n        state: { callState: CallState } & EntityState<E>\r\n        signals: Emtpy,\r\n        methods: Emtpy,\r\n    },\r\n    {\r\n        state: DataServiceState<E, F>\r\n        signals: DataServiceSignals<E>\r\n        methods: DataServiceMethods<E, F>\r\n    }>;\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\r\nexport function withDataService<E extends Entity, F extends Filter, Collection extends string>(options: { dataServiceType: ProviderToken<DataService<E, F>>, filter: F, collection?: Collection }): SignalStoreFeature<any, any> {\r\n    const { dataServiceType, filter, collection: prefix } = options;\r\n    const {\r\n        entitiesKey,\r\n        filterKey,\r\n        loadKey,\r\n        selectedEntitiesKey,\r\n        selectedIdsKey,\r\n        updateFilterKey,\r\n        updateSelectedKey,\r\n\r\n        currentKey,\r\n        createKey,\r\n        updateKey,\r\n        deleteKey,\r\n        loadByIdKey,\r\n        setCurrentKey\r\n    } = getDataServiceKeys(options);\r\n\r\n    const { callStateKey } = getCallStateKeys({ collection: prefix });\r\n\r\n    return signalStoreFeature(\r\n        withState(() => ({\r\n            [filterKey]: filter,\r\n            [selectedIdsKey]: {} as Record<EntityId, boolean>,\r\n            [currentKey]: undefined as E | undefined\r\n        })),\r\n        withComputed((store: Record<string, unknown>) => {\r\n            const entities = store[entitiesKey] as Signal<E[]>;\r\n            const selectedIds = store[selectedIdsKey] as Signal<Record<EntityId, boolean>>;\r\n\r\n            return {\r\n                [selectedEntitiesKey]: computed(() => entities().filter(e => selectedIds()[e.id]))\r\n            }\r\n        }),\r\n        withMethods((store: Record<string, unknown> & StateSignal<object>) => {\r\n            const dataService = inject(dataServiceType)\r\n            return {\r\n                [updateFilterKey]: (filter: F): void => {\r\n                    patchState(store, { [filterKey]: filter });\r\n                },\r\n                [updateSelectedKey]: (id: EntityId, selected: boolean): void => {\r\n                    patchState(store, (state: Record<string, unknown>) => ({\r\n                        [selectedIdsKey]: {\r\n                            ...state[selectedIdsKey] as Record<EntityId, boolean>,\r\n                            [id]: selected,\r\n                        }\r\n                    }));\r\n                },\r\n                [loadKey]: async (): Promise<void> => {\r\n                    const filter = store[filterKey] as Signal<F>;\r\n                    store[callStateKey] && patchState(store, setLoading(prefix));\r\n\r\n                    try {\r\n                        const result = await dataService.load(filter());\r\n                        patchState(store, prefix ? setAllEntities(result, { collection: prefix }) : setAllEntities(result));\r\n                        store[callStateKey] && patchState(store, setLoaded(prefix));\r\n                    }\r\n                    catch (e) {\r\n                        store[callStateKey] && patchState(store, setError(e, prefix));\r\n                        throw e;\r\n                    }\r\n                },\r\n                [loadByIdKey]: async (id: EntityId): Promise<void> => {\r\n                    store[callStateKey] && patchState(store, setLoading(prefix));\r\n\r\n                    try {\r\n                        const current = await dataService.loadById(id);\r\n                        store[callStateKey] && patchState(store, setLoaded(prefix));\r\n                        patchState(store, { [currentKey]: current });\r\n                    }\r\n                    catch (e) {\r\n                        store[callStateKey] && patchState(store, setError(e, prefix));\r\n                        throw e;\r\n                    }\r\n                },\r\n                [setCurrentKey]: (current: E): void => {\r\n                    patchState(store, { [currentKey]: current });\r\n                },\r\n                [createKey]: async (entity: E): Promise<void> => {\r\n                    patchState(store, { [currentKey]: entity });\r\n                    store[callStateKey] && patchState(store, setLoading(prefix));\r\n\r\n                    try {\r\n                        const created = await dataService.create(entity);\r\n                        patchState(store, { [currentKey]: created });\r\n                        patchState(store, prefix ? addEntity(created, { collection: prefix }) : addEntity(created));\r\n                        store[callStateKey] && patchState(store, setLoaded(prefix));\r\n                    }\r\n                    catch (e) {\r\n                        store[callStateKey] && patchState(store, setError(e, prefix));\r\n                        throw e;\r\n                    }\r\n                },\r\n                [updateKey]: async (entity: E): Promise<void> => {\r\n                    patchState(store, { [currentKey]: entity });\r\n                    store[callStateKey] && patchState(store, setLoading(prefix));\r\n\r\n                    try {\r\n                        const updated = await dataService.update(entity);\r\n                        patchState(store, { [currentKey]: updated });\r\n                        // Why do we need this cast to Partial<Entity>?\r\n                        const updateArg = { id: updated.id, changes: updated as Partial<Entity> };\r\n                        patchState(store, prefix ? updateEntity(updateArg, { collection: prefix }) : updateEntity(updateArg));\r\n                        store[callStateKey] && patchState(store, setLoaded(prefix));\r\n                    }\r\n                    catch (e) {\r\n                        store[callStateKey] && patchState(store, setError(e, prefix));\r\n                        throw e;\r\n                    }\r\n                },\r\n                [deleteKey]: async (entity: E): Promise<void> => {\r\n                    patchState(store, { [currentKey]: entity });\r\n                    store[callStateKey] && patchState(store, setLoading(prefix));\r\n\r\n                    try {\r\n                        await dataService.delete(entity);\r\n                        patchState(store, { [currentKey]: undefined });\r\n                        patchState(store, prefix ? removeEntity(entity.id, { collection: prefix }) : removeEntity(entity.id));\r\n                        store[callStateKey] && patchState(store, setLoaded(prefix));\r\n                    }\r\n                    catch (e) {\r\n                        store[callStateKey] && patchState(store, setError(e, prefix));\r\n                        throw e;\r\n                    }\r\n                },\r\n            };\r\n        })\r\n    );\r\n}"]}

package/esm2022/lib/with-devtools.mjs

@@ -76,4 +76,4 @@ export const patchState = (state, action, ...rest) => {
     currentActionNames.add(action);
     return originalPatchState(state, ...rest);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-devtools.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-devtools.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  patchState as originalPatchState,\r\n  SignalStoreFeature,\r\n} from '@ngrx/signals';\r\nimport { SignalStoreFeatureResult } from '@ngrx/signals/src/signal-store-models';\r\nimport { effect, inject, PLATFORM_ID, signal, Signal } from '@angular/core';\r\nimport { isPlatformServer } from '@angular/common';\r\n\r\ndeclare global {\r\n  interface Window {\r\n    __REDUX_DEVTOOLS_EXTENSION__:\r\n      | {\r\n          connect: (options: { name: string }) => {\r\n            send: (action: Action, state: Record<string, unknown>) => void;\r\n          };\r\n        }\r\n      | undefined;\r\n  }\r\n}\r\n\r\ntype EmptyFeatureResult = { state: {}; signals: {}; methods: {} };\r\nexport type Action = { type: string };\r\n\r\nconst storeRegistry = signal<Record<string, Signal<unknown>>>({});\r\n\r\nlet currentActionNames = new Set<string>();\r\n\r\nlet synchronizationInitialized = false;\r\n\r\nfunction initSynchronization() {\r\n  effect(() => {\r\n    if (!connection) {\r\n      return;\r\n    }\r\n\r\n    const stores = storeRegistry();\r\n    const rootState: Record<string, unknown> = {};\r\n    for (const name in stores) {\r\n      const store = stores[name];\r\n      rootState[name] = store();\r\n    }\r\n\r\n    const names = Array.from(currentActionNames);\r\n    const type = names.length ? names.join(', ') : 'Store Update';\r\n    currentActionNames = new Set<string>();\r\n\r\n    connection.send({ type }, rootState);\r\n  });\r\n}\r\n\r\nfunction getValueFromSymbol(obj: unknown, symbol: symbol) {\r\n  if (typeof obj === 'object' && obj && symbol in obj) {\r\n    return (obj as { [key: symbol]: any })[symbol];\r\n  }\r\n}\r\n\r\nfunction getStoreSignal(store: unknown): Signal<unknown> {\r\n  const [signalStateKey] = Object.getOwnPropertySymbols(store);\r\n  if (!signalStateKey) {\r\n    throw new Error('Cannot find State Signal');\r\n  }\r\n\r\n  return getValueFromSymbol(store, signalStateKey);\r\n}\r\n\r\ntype ConnectResponse = {\r\n  send: (action: Action, state: Record<string, unknown>) => void;\r\n};\r\nlet connection: ConnectResponse | undefined;\r\n\r\n/**\r\n * required for testing. is not exported during build\r\n */\r\nexport function reset() {\r\n  connection = undefined;\r\n  synchronizationInitialized = false;\r\n  storeRegistry.set({});\r\n}\r\n\r\n/**\r\n * @param name store's name as it should appear in the DevTools\r\n */\r\nexport function withDevtools<Input extends SignalStoreFeatureResult>(\r\n  name: string\r\n): SignalStoreFeature<Input, EmptyFeatureResult> {\r\n  return (store) => {\r\n    const isServer = isPlatformServer(inject(PLATFORM_ID));\r\n    if (isServer) {\r\n      return store;\r\n    }\r\n\r\n    const extensions = window.__REDUX_DEVTOOLS_EXTENSION__;\r\n    if (!extensions) {\r\n      return store;\r\n    }\r\n\r\n    if (!connection) {\r\n      connection = extensions.connect({\r\n        name: 'NgRx Signal Store',\r\n      });\r\n    }\r\n\r\n    const storeSignal = getStoreSignal(store);\r\n    storeRegistry.update((value) => ({\r\n      ...value,\r\n      [name]: storeSignal,\r\n    }));\r\n\r\n    if (!synchronizationInitialized) {\r\n      initSynchronization();\r\n      synchronizationInitialized = true;\r\n    }\r\n\r\n    return store;\r\n  };\r\n}\r\n\r\ntype PatchFn = typeof originalPatchState extends (\r\n  arg1: infer First,\r\n  ...args: infer Rest\r\n) => infer Returner\r\n  ? (state: First, action: string, ...rest: Rest) => Returner\r\n  : never;\r\n\r\nexport const patchState: PatchFn = (state, action, ...rest) => {\r\n  currentActionNames.add(action);\r\n  return originalPatchState(state, ...rest);\r\n};\r\n"]}