@angular-architects/ngrx-toolkit 20.0.3 → 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 { watchState, getState, signalStoreFeature, withMethods, withHooks, patchState as patchState$1, withState, withComputed, withProps } from '@ngrx/signals';
+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,9 +1782,287 @@ 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) => {
+        const resourceOrDictionary = resourceFactory({
+            ...store.stateSignals,
+            ...store.props,
+            ...store.methods,
+        });
+        if (isResourceRef(resourceOrDictionary)) {
+            return createUnnamedResource(resourceOrDictionary)(store);
+        }
+        else {
+            return createNamedResource(resourceOrDictionary)(store);
+        }
+    };
+}
+function createUnnamedResource(resource) {
+    function hasValue() {
+        return resource.hasValue();
+    }
+    return signalStoreFeature(withLinkedState(() => ({ value: resource.value })), withProps(() => ({
+        status: resource.status,
+        error: resource.error,
+        isLoading: resource.isLoading,
+    })), withMethods(() => ({
+        hasValue,
+        _reload: () => resource.reload(),
+    })));
+}
+function createNamedResource(dictionary) {
+    const keys = Object.keys(dictionary);
+    const state = keys.reduce((state, resourceName) => ({
+        ...state,
+        [`${resourceName}Value`]: dictionary[resourceName].value,
+    }), {});
+    const props = keys.reduce((props, resourceName) => ({
+        ...props,
+        [`${resourceName}Status`]: dictionary[resourceName].status,
+        [`${resourceName}Error`]: dictionary[resourceName].error,
+        [`${resourceName}IsLoading`]: dictionary[resourceName].isLoading,
+    }), {});
+    const methods = keys.reduce((methods, resourceName) => {
+        return {
+            ...methods,
+            [`${resourceName}HasValue`]: () => dictionary[resourceName].hasValue(),
+            [`_${resourceName}Reload`]: () => dictionary[resourceName].reload(),
+        };
+    }, {});
+    return signalStoreFeature(withLinkedState(() => state), withProps(() => props), withMethods(() => methods));
+}
+function isResourceRef(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'value' in value &&
+        isSignal(value.value) &&
+        'status' in value &&
+        'error' in value &&
+        'isLoading' in value &&
+        'hasValue' in value &&
+        'reload' in value);
+}
+//** Implementation of `mapToResource` */
+/**
+ * @experimental
+ * @description
+ *
+ * Maps a named resource to type `Resource<T>`.
+ *
+ * @usageNotes
+ *
+ * ```ts
+ * const store = signalStore(
+ *   withState({ userId: undefined as number | undefined }),
+ *   withResource(({ userId }) => ({
+ *     user: httpResource<User[]>(() => '/users', { defaultValue: [] }),
+ *   }))
+ * );
+ * const userResource = mapToResource(store, 'user');
+ * userResource satisfies Resource<User[]>;
+ * ```
+ *
+ * @param store The store instance to map the resource to.
+ * @param name The name of the resource to map.
+ * @returns `ResourceRef<T>`
+ */
+function mapToResource(store, name) {
+    const resourceName = String(name);
+    function hasValue() {
+        return store[`${resourceName}HasValue`]();
+    }
+    return {
+        value: store[`${resourceName}Value`],
+        status: store[`${resourceName}Status`],
+        error: store[`${resourceName}Error`],
+        isLoading: store[`${resourceName}IsLoading`],
+        hasValue,
+    };
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { capitalize, createEffects, createPageArray, createReducer, deriveCallStateKeys, emptyFeature, firstPage, getCallStateKeys, getCollectionArray, getDataServiceKeys, getUndoRedoKeys, gotoPage, 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, 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