@angular-architects/ngrx-toolkit 0.0.2 → 0.0.4

package/README.md

@@ -74,3 +74,147 @@ export const FlightStore = signalStore(
 );
 ```
 
+## 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL25ncngtdG9vbGtpdC9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQVUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgd2l0aERldnRvb2xzLCBwYXRjaFN0YXRlLCBBY3Rpb24gfSBmcm9tICcuL2xpYi93aXRoLWRldnRvb2xzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtcmVkdXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvd2l0aC1jYWxsLXN0YXRlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtdW5kby1yZWRvJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dpdGgtZGF0YS1zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/shared/empty.mjs

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

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

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

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

package/esm2022/lib/with-undo-redo.mjs

@@ -0,0 +1,93 @@
+import { patchState, signalStoreFeature, withComputed, withHooks, withMethods } from "@ngrx/signals";
+import { effect, signal, untracked, isSignal } from "@angular/core";
+import { capitalize } from "./with-data-service";
+const defaultOptions = {
+    maxStackSize: 100
+};
+export function getUndoRedoKeys(collections) {
+    if (collections) {
+        return collections.flatMap(c => [`${c}EntityMap`, `${c}Ids`, `selected${capitalize(c)}Ids`, `${c}Filter`]);
+    }
+    return ['entityMap', 'ids', 'selectedIds', 'filter'];
+}
+export function withUndoRedo(options = {}) {
+    let previous = null;
+    let skipOnce = false;
+    const normalized = {
+        ...defaultOptions,
+        ...options
+    };
+    //
+    // Design Decision: This feature has its own
+    // internal state.
+    //
+    const undoStack = [];
+    const redoStack = [];
+    const canUndo = signal(false);
+    const canRedo = signal(false);
+    const updateInternal = () => {
+        canUndo.set(undoStack.length !== 0);
+        canRedo.set(redoStack.length !== 0);
+    };
+    const keys = getUndoRedoKeys(normalized?.collections);
+    return signalStoreFeature(withComputed(() => ({
+        canUndo: canUndo.asReadonly(),
+        canRedo: canRedo.asReadonly()
+    })), withMethods((store) => ({
+        undo() {
+            const item = undoStack.pop();
+            if (item && previous) {
+                redoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState(store, item);
+                previous = item;
+            }
+            updateInternal();
+        },
+        redo() {
+            const item = redoStack.pop();
+            if (item && previous) {
+                undoStack.push(previous);
+            }
+            if (item) {
+                skipOnce = true;
+                patchState(store, item);
+                previous = item;
+            }
+            updateInternal();
+        }
+    })), withHooks({
+        onInit(store) {
+            effect(() => {
+                const cand = keys.reduce((acc, key) => {
+                    const s = store[key];
+                    if (s && isSignal(s)) {
+                        return {
+                            ...acc,
+                            [key]: s()
+                        };
+                    }
+                    return acc;
+                }, {});
+                if (skipOnce) {
+                    skipOnce = false;
+                    return;
+                }
+                // Clear redoStack after recorded action
+                redoStack.splice(0);
+                if (previous) {
+                    undoStack.push(previous);
+                }
+                if (redoStack.length > normalized.maxStackSize) {
+                    undoStack.unshift();
+                }
+                previous = cand;
+                // Don't propogate current reactive context
+                untracked(() => updateInternal());
+            });
+        }
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-undo-redo.js","sourceRoot":"","sources":["../../../../../libs/ngrx-toolkit/src/lib/with-undo-redo.ts"],"names":[],"mappings":"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","sourcesContent":["import { SignalStoreFeature, patchState, signalStoreFeature, withComputed, withHooks, withMethods } from \"@ngrx/signals\";\nimport { EntityId, EntityMap, EntityState } from \"@ngrx/signals/entities\";\nimport { Signal, effect, signal, untracked, isSignal } from \"@angular/core\";\nimport { EntitySignals, NamedEntitySignals } from \"@ngrx/signals/entities/src/models\";\nimport { Entity, capitalize } from \"./with-data-service\";\nimport { Emtpy } from \"./shared/empty\";\n\nexport type StackItem = Record<string, unknown>;\n\nexport type NormalizedUndoRedoOptions = {\n    maxStackSize: number;\n    collections?: string[]\n}\n\nconst defaultOptions: NormalizedUndoRedoOptions = {\n    maxStackSize: 100\n};\n\nexport type NamedUndoRedoState<Collection extends string> = {\n    [K in Collection as `${K}EntityMap`]: EntityMap<Entity>;\n} & {\n        [K in Collection as `${K}Ids`]: EntityId[];\n    }\n\nexport type NamedUndoRedoSignals<Collection extends string> = {\n    [K in Collection as `${K}Entities`]: Signal<Entity[]>\n}\n\nexport function getUndoRedoKeys(collections?: string[]): string[] {\n    if (collections) {\n        return collections.flatMap(c => [`${c}EntityMap`, `${c}Ids`, `selected${capitalize(c)}Ids`, `${c}Filter`])\n    }\n    return ['entityMap', 'ids', 'selectedIds', 'filter'];\n}\n\nexport function withUndoRedo<Collection extends string>(options?: { maxStackSize?: number; collections: Collection[] }): SignalStoreFeature<\n    {\n        state: Emtpy,\n        // This alternative breaks type inference:\n        // state: NamedEntityState<Entity, Collection>\n        signals: NamedEntitySignals<Entity, Collection>,\n        methods: Emtpy\n    },\n    {\n        state: Emtpy,\n        signals: {\n            canUndo: Signal<boolean>,\n            canRedo: Signal<boolean>\n        },\n        methods: {\n            undo: () => void,\n            redo: () => void\n        }\n    }>;\n\nexport function withUndoRedo(options?: { maxStackSize?: number }): SignalStoreFeature<\n    {\n        state: EntityState<Entity>,\n        signals: EntitySignals<Entity>,\n        methods: Emtpy\n    },\n    {\n        state: Emtpy,\n        signals: {\n            canUndo: Signal<boolean>,\n            canRedo: Signal<boolean>\n        },\n        methods: {\n            undo: () => void,\n            redo: () => void\n        }\n    }>;\n\nexport function withUndoRedo<Collection extends string>(options: {\n    maxStackSize?: number;\n    collections?: Collection[]\n} = {}): \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nSignalStoreFeature<any, any> {\n    let previous: StackItem | null = null;\n    let skipOnce = false;\n\n    const normalized = {\n        ...defaultOptions,\n        ...options\n    };\n\n    //\n    // Design Decision: This feature has its own\n    // internal state.\n    //\n\n    const undoStack: StackItem[] = [];\n    const redoStack: StackItem[] = [];\n\n    const canUndo = signal(false);\n    const canRedo = signal(false);\n\n    const updateInternal = () => {\n        canUndo.set(undoStack.length !== 0);\n        canRedo.set(redoStack.length !== 0);\n    };\n\n    const keys = getUndoRedoKeys(normalized?.collections);\n\n    return signalStoreFeature(\n\n        withComputed(() => ({\n            canUndo: canUndo.asReadonly(),\n            canRedo: canRedo.asReadonly()\n        })),\n        withMethods((store) => ({\n            undo(): void {\n                const item = undoStack.pop();\n\n                if (item && previous) {\n                    redoStack.push(previous);\n                }\n\n                if (item) {\n                    skipOnce = true;\n                    patchState(store, item);\n                    previous = item;\n                }\n\n                updateInternal();\n            },\n            redo(): void {\n                const item = redoStack.pop();\n\n                if (item && previous) {\n                    undoStack.push(previous);\n                }\n\n                if (item) {\n                    skipOnce = true;\n                    patchState(store, item);\n                    previous = item;\n                }\n\n                updateInternal();\n            }\n        })),\n        withHooks({\n            onInit(store: Record<string, unknown>) {\n                effect(() => {\n\n                    const cand = keys.reduce((acc, key) => {\n                        const s = store[key];\n                        if (s && isSignal(s)) {\n                            return {\n                                ...acc,\n                                [key]: s()\n                            }\n                        }\n                        return acc;\n                    }, {});\n\n                    if (skipOnce) {\n                        skipOnce = false;\n                        return;\n                    }\n\n                    // Clear redoStack after recorded action\n                    redoStack.splice(0);\n\n                    if (previous) {\n                        undoStack.push(previous);\n                    }\n\n                    if (redoStack.length > normalized.maxStackSize) {\n                        undoStack.unshift();\n                    }\n\n                    previous = cand;\n\n                    // Don't propogate current reactive context\n                    untracked(() => updateInternal());\n                })\n            }\n        })\n\n    )\n}\n"]}