@angular-architects/ngrx-toolkit 20.1.0 → 20.3.0

package/fesm2022/angular-architects-ngrx-toolkit.mjs

@@ -1,9 +1,10 @@
 import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, signal, effect, inject, PLATFORM_ID, computed, isSignal, untracked, isDevMode as isDevMode$1 } from '@angular/core';
+import { Injectable, InjectionToken, signal, effect, inject, PLATFORM_ID, computed, isSignal, untracked, isDevMode as isDevMode$1, DestroyRef } from '@angular/core';
 import { watchState, getState, signalStoreFeature, withMethods, withHooks, patchState as patchState$1, withState, withComputed, withProps, withLinkedState } from '@ngrx/signals';
 import { isPlatformBrowser, isPlatformServer } from '@angular/common';
-import { Subject } from 'rxjs';
+import { Subject, switchMap, mergeMap, concatMap, exhaustMap, defer, tap, catchError, EMPTY, finalize } from 'rxjs';
 import { removeEntity, setAllEntities, updateEntity, addEntity } from '@ngrx/signals/entities';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 
 const DEVTOOLS_FEATURE = Symbol('DEVTOOLS_FEATURE');
 function createDevtoolsFeature(options) {
@@ -1781,6 +1782,185 @@ function withFeatureFactory(factoryFn) {
     };
 }
 
+const switchOp = {
+    rxJsOperator: switchMap,
+    exhaustSemantics: false,
+};
+const mergeOp = {
+    rxJsOperator: mergeMap,
+    exhaustSemantics: false,
+};
+const concatOp = {
+    rxJsOperator: concatMap,
+    exhaustSemantics: false,
+};
+const exhaustOp = {
+    rxJsOperator: exhaustMap,
+    exhaustSemantics: true,
+};
+
+/**
+ * Creates a mutation that leverages RxJS.
+ *
+ * For each mutation the following options can be defined:
+ * - `operation`: A function that defines the mutation logic. It returns an Observable.
+ * - `onSuccess`: A callback that is called when the mutation is successful.
+ * - `onError`: A callback that is called when the mutation fails.
+ * - `operator`: An optional wrapper of an RxJS flattening operator. By default `concat` sematics are used.
+ * - `injector`: An optional Angular injector to use for dependency injection.
+ *
+ * The `operation` is the only mandatory option.
+ *
+ * ```typescript
+ * export type Params = {
+ *   value: number;
+ * };
+ *
+ * export const CounterStore = signalStore(
+ *   { providedIn: 'root' },
+ *   withState({ counter: 0 }),
+ *   withMutations((store) => ({
+ *     increment: rxMutation({
+ *       operation: (params: Params) => {
+ *         return calcSum(store.counter(), params.value);
+ *       },
+ *       operator: concatOp,
+ *       onSuccess: (result) => {
+ *         console.log('result', result);
+ *         patchState(store, { counter: result });
+ *       },
+ *       onError: (error) => {
+ *         console.error('Error occurred:', error);
+ *       },
+ *     }),
+ *   })),
+ * );
+ *
+ * function calcSum(a: number, b: number): Observable<number> {
+ *   return of(a + b);
+ * }
+ * ```
+ *
+ * @param options
+ * @returns
+ */
+function rxMutation(options) {
+    const inputSubject = new Subject();
+    const flatteningOp = options.operator ?? concatOp;
+    const destroyRef = options.injector?.get(DestroyRef) ?? inject(DestroyRef);
+    const callCount = signal(0, ...(ngDevMode ? [{ debugName: "callCount" }] : []));
+    const errorSignal = signal(undefined, ...(ngDevMode ? [{ debugName: "errorSignal" }] : []));
+    const idle = signal(true, ...(ngDevMode ? [{ debugName: "idle" }] : []));
+    const isPending = computed(() => callCount() > 0, ...(ngDevMode ? [{ debugName: "isPending" }] : []));
+    const status = computed(() => {
+        if (idle()) {
+            return 'idle';
+        }
+        if (callCount() > 0) {
+            return 'pending';
+        }
+        if (errorSignal()) {
+            return 'error';
+        }
+        return 'success';
+    }, ...(ngDevMode ? [{ debugName: "status" }] : []));
+    const initialInnerStatus = 'idle';
+    let innerStatus = initialInnerStatus;
+    let lastResult;
+    inputSubject
+        .pipe(flatteningOp.rxJsOperator((input) => defer(() => {
+        callCount.update((c) => c + 1);
+        idle.set(false);
+        return options.operation(input.param).pipe(tap((result) => {
+            options.onSuccess?.(result, input.param);
+            innerStatus = 'success';
+            errorSignal.set(undefined);
+            lastResult = result;
+        }), catchError((error) => {
+            options.onError?.(error, input.param);
+            errorSignal.set(error);
+            innerStatus = 'error';
+            return EMPTY;
+        }), finalize(() => {
+            callCount.update((c) => c - 1);
+            if (innerStatus === 'success') {
+                input.resolve({
+                    status: 'success',
+                    value: lastResult,
+                });
+            }
+            else if (innerStatus === 'error') {
+                input.resolve({
+                    status: 'error',
+                    error: errorSignal(),
+                });
+            }
+            else {
+                input.resolve({
+                    status: 'aborted',
+                });
+            }
+            innerStatus = initialInnerStatus;
+        }));
+    })), takeUntilDestroyed(destroyRef))
+        .subscribe();
+    const mutationFn = (param) => {
+        return new Promise((resolve) => {
+            if (callCount() > 0 && flatteningOp.exhaustSemantics) {
+                resolve({
+                    status: 'aborted',
+                });
+            }
+            else {
+                inputSubject.next({
+                    param,
+                    resolve,
+                });
+            }
+        });
+    };
+    const mutation = mutationFn;
+    mutation.status = status;
+    mutation.isPending = isPending;
+    mutation.error = errorSignal;
+    return mutation;
+}
+
+function withMutations(mutationsFactory) {
+    return (store) => {
+        // TODO: Is this the correct usage?
+        const source = store;
+        const mutations = mutationsFactory({
+            ...source,
+            ...store.props,
+            ...store.methods,
+            ...store.stateSignals,
+        });
+        const feature = createMutationsFeature(mutations);
+        return feature(store);
+    };
+}
+function createMutationsFeature(mutations) {
+    const keys = Object.keys(mutations);
+    const feature = signalStoreFeature(withMethods(() => keys.reduce((acc, key) => ({
+        ...acc,
+        [key]: async (params) => {
+            const mutation = mutations[key];
+            if (!mutation) {
+                throw new Error(`Mutation ${key} not found`);
+            }
+            const result = await mutation(params);
+            return result;
+        },
+    }), {})), withComputed(() => keys.reduce((acc, key) => ({
+        ...acc,
+        [`${key}IsPending`]: mutations[key].isPending,
+        [`${key}Status`]: mutations[key].status,
+        [`${key}Error`]: mutations[key].error,
+    }), {})));
+    return feature;
+}
+
 //** Types for `withResource` */
 function withResource(resourceFactory) {
     return (store) => {
@@ -1884,5 +2064,5 @@ function mapToResource(store, name) {
  * Generated bundle index. Do not edit.
  */
 
-export { capitalize, createEffects, createPageArray, createReducer, deriveCallStateKeys, emptyFeature, firstPage, getCallStateKeys, getCollectionArray, getDataServiceKeys, getUndoRedoKeys, gotoPage, mapToResource, nextPage, noPayload, patchState, payload, previousPage, provideDevtoolsConfig, renameDevtoolsName, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, updateState, withCallState, withConditional, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withFeatureFactory, withGlitchTracking, withImmutableState, withIndexedDB, withIndexedDB as withIndexeddb, withLocalStorage, withMapper, withPagination, withRedux, withReset, withResource, withSessionStorage, withStorageSync, withUndoRedo };
+export { capitalize, concatOp, createEffects, createPageArray, createReducer, deriveCallStateKeys, emptyFeature, exhaustOp, firstPage, getCallStateKeys, getCollectionArray, getDataServiceKeys, getUndoRedoKeys, gotoPage, mapToResource, mergeOp, nextPage, noPayload, patchState, payload, previousPage, provideDevtoolsConfig, renameDevtoolsName, rxMutation, setError, setLoaded, setLoading, setMaxPageNavigationArrayItems, setPageSize, setResetState, switchOp, updateState, withCallState, withConditional, withDataService, withDevToolsStub, withDevtools, withDisabledNameIndices, withFeatureFactory, withGlitchTracking, withImmutableState, withIndexedDB, withIndexedDB as withIndexeddb, withLocalStorage, withMapper, withMutations, withPagination, withRedux, withReset, withResource, withSessionStorage, withStorageSync, withUndoRedo };
 //# sourceMappingURL=angular-architects-ngrx-toolkit.mjs.map