@ngdux/list 3.0.1 → 5.0.0

package/fesm2022/ngdux-list.mjs

@@ -1,19 +1,18 @@
-import { getDefaultRequestOptions, RequestState, DEFAULT_PAGE } from '@ngdux/data-model-common';
+import { RequestState, getDefaultRequestOptions, DEFAULT_PAGE } from '@ngdux/data-model-common';
 export { RequestState } from '@ngdux/data-model-common';
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Inject, Optional, NgModule } from '@angular/core';
+import { InjectionToken, Inject, Injectable, Optional, NgModule, inject } from '@angular/core';
 import * as i1 from '@ngrx/store';
-import { createAction, props, createReducer, on, createSelector, createFeatureSelector, select, Store } from '@ngrx/store';
+import { createAction, props, createReducer, on, createSelector, createFeatureSelector, select, Store, provideState } from '@ngrx/store';
 import * as i1$1 from '@ngdux/store-common';
 import { getLastPageNumber, createLoadingStateActionHandlers, createRequestStateActionHandlers } from '@ngdux/store-common';
 import { createEntityAdapter } from '@ngrx/entity';
 import * as i2 from '@ngrx/effects';
-import { createEffect, ofType, Actions } from '@ngrx/effects';
+import { createEffect, ofType, Actions, provideEffects } from '@ngrx/effects';
 import { __decorate, __param, __metadata } from 'tslib';
-import { of } from 'rxjs';
+import { of, map as map$1, withLatestFrom as withLatestFrom$1, filter as filter$1, switchMap as switchMap$1, catchError as catchError$1, exhaustMap as exhaustMap$1, tap as tap$1 } from 'rxjs';
 import { map, withLatestFrom, filter, switchMap, catchError, exhaustMap, tap } from 'rxjs/operators';
 
-/* eslint-disable @typescript-eslint/ban-types */
 const LIST_FEATURE_KEY = new InjectionToken('LIST_FEATURE_KEY');
 const LIST_FEATURE_KEYS = new InjectionToken('LIST_FEATURE_KEYS');
 const LIST_SERVICES = new InjectionToken('LIST_SERVICES');
@@ -291,16 +290,19 @@ class ListStateService {
     getFeatureSelectors(featureKey) {
         return this.selectors[featureKey];
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ListStateService, deps: [{ token: i1.ReducerManager }, { token: LIST_FEATURE_KEYS }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ListStateService }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: ListStateService, deps: [{ token: i1.ReducerManager }, { token: LIST_FEATURE_KEYS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: ListStateService }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ListStateService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: ListStateService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.ReducerManager }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [LIST_FEATURE_KEYS]
                 }] }] });
 
+/**
+ * @deprecated This class is deprecated and will be removed in a future release. Please use `createListEffects` instead.
+ */
 class AbstractListEffects {
     constructor(actions$, store, service, listActions, listSelectors, notificationService) {
         this.actions$ = actions$;
@@ -374,13 +376,16 @@ class NotificationServicePlaceholder {
         console.log(data.title, data.message);
         return of(true);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NotificationServicePlaceholder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NotificationServicePlaceholder }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: NotificationServicePlaceholder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: NotificationServicePlaceholder }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NotificationServicePlaceholder, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: NotificationServicePlaceholder, decorators: [{
             type: Injectable
         }] });
 
+/**
+ * @deprecated This NgModule is deprecated and will be removed in a future release. Use `provideListState` and `createListState` instead to set up your list state in a more modular way.
+ */
 class NgduxListStateModule {
     constructor(registerEffectsService, actions$, store, listStateService, featureKeys, services, notificationServices) {
         featureKeys.forEach((featureKey, index) => {
@@ -401,11 +406,11 @@ class NgduxListStateModule {
             ]
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NgduxListStateModule, deps: [{ token: i1$1.RegisterEffectsService }, { token: i2.Actions }, { token: i1.Store }, { token: ListStateService }, { token: LIST_FEATURE_KEYS }, { token: LIST_SERVICES }, { token: LIST_NOTIFICATION_SERVICES }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: NgduxListStateModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NgduxListStateModule, providers: [ListStateService] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: NgduxListStateModule, deps: [{ token: i1$1.RegisterEffectsService }, { token: i2.Actions }, { token: i1.Store }, { token: ListStateService }, { token: LIST_FEATURE_KEYS }, { token: LIST_SERVICES }, { token: LIST_NOTIFICATION_SERVICES }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.1.4", ngImport: i0, type: NgduxListStateModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: NgduxListStateModule, providers: [ListStateService] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: NgduxListStateModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: NgduxListStateModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [ListStateService]
@@ -421,6 +426,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImpor
                     args: [LIST_NOTIFICATION_SERVICES]
                 }] }] });
 
+/**
+ * @deprecated This class is deprecated and will be removed in a future release.
+ */
 class AbstractListReducerManager {
     constructor(reducerManager, featureKey) {
         this.reducerManager = reducerManager;
@@ -447,16 +455,19 @@ class AbstractListReducerManager {
         const getState = createFeatureSelector(this.featureKey);
         return createListSelectors(this.entityAdapter, getState);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AbstractListReducerManager, deps: [{ token: i1.ReducerManager }, { token: LIST_FEATURE_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AbstractListReducerManager }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: AbstractListReducerManager, deps: [{ token: i1.ReducerManager }, { token: LIST_FEATURE_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: AbstractListReducerManager }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: AbstractListReducerManager, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.4", ngImport: i0, type: AbstractListReducerManager, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.ReducerManager }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [LIST_FEATURE_KEY]
                 }] }] });
 
+/**
+ * @deprecated This class is deprecated and will be removed in a future release. Please use `provideListFacade` or `createListFacade` instead.
+ */
 class AbstractListFacade {
     constructor(store, listActions, listSelectors) {
         this.store = store;
@@ -541,6 +552,178 @@ class AbstractListFacade {
     }
 }
 
+function createListEffects(listActions, listSelectors, listService, notificationService) {
+    return {
+        reload$: createEffect((actions$ = inject(Actions)) => reloadEffect(actions$, listActions), { functional: true }),
+        loadFirstPage$: createEffect((actions$ = inject(Actions)) => loadFirstPageEffect(actions$, listActions), {
+            functional: true
+        }),
+        loadPreviousPage$: createEffect((store = inject(Store), actions$ = inject(Actions)) => loadPreviousPageEffect(store, actions$, listActions, listSelectors), { functional: true }),
+        loadNextPage$: createEffect((store = inject(Store), actions$ = inject(Actions)) => loadNextPageEffect(store, actions$, listActions, listSelectors), { functional: true }),
+        loadPage$: createEffect((store = inject(Store), actions$ = inject(Actions), service = listService()) => loadPageEffect(store, actions$, listActions, listSelectors, service), { functional: true }),
+        patch$: createEffect((actions$ = inject(Actions), service = listService()) => patchEffect(actions$, listActions, service), { functional: true }),
+        delete$: createEffect((actions$ = inject(Actions), service = listService()) => deleteEffect(actions$, listActions, service), { functional: true }),
+        deleteSuccess$: createEffect((actions$ = inject(Actions), service = notificationService()) => deleteSuccessEffect(actions$, listActions, service), { functional: true, dispatch: false }),
+        errorsHandler$: createEffect((actions$ = inject(Actions), service = notificationService()) => errorsHandlerEffect(actions$, listActions, service), { functional: true, dispatch: false })
+    };
+}
+function reloadEffect(actions$, listActions) {
+    return actions$.pipe(ofType(listActions.changePageSize, listActions.changeSorting, listActions.changeFiltering, listActions.changePagingOptions, listActions.changeRequestParams, listActions.initialize, listActions.reset, listActions.changePageNumber, listActions.patchSuccess, listActions.deleteSuccess), map$1(() => listActions.loadPage()));
+}
+function loadFirstPageEffect(actions$, listActions) {
+    return actions$.pipe(ofType(listActions.loadFirstPage), map$1(() => listActions.changePageNumber({ pageNumber: 1 })));
+}
+function loadPreviousPageEffect(store, actions$, listActions, listSelectors) {
+    return actions$.pipe(ofType(listActions.loadPreviousPage), withLatestFrom$1(store.pipe(select(listSelectors.getCurrentPageNumber))), filter$1(([, currentPageNumber]) => currentPageNumber > 1), map$1(([, currentPageNumber]) => listActions.changePageNumber({ pageNumber: currentPageNumber - 1 })));
+}
+function loadNextPageEffect(store, actions$, listActions, listSelectors) {
+    return actions$.pipe(ofType(listActions.loadNextPage), withLatestFrom$1(store.pipe(select(listSelectors.isLastPage)), store.pipe(select(listSelectors.getCurrentPageNumber))), filter$1(([, isLastPage]) => !isLastPage), map$1(([, , currentPageNumber]) => listActions.changePageNumber({ pageNumber: currentPageNumber + 1 })));
+}
+function loadPageEffect(store, actions$, listActions, listSelectors, service) {
+    return actions$.pipe(ofType(listActions.loadPage), withLatestFrom$1(store.pipe(select(listSelectors.getPagingOptions)), store.pipe(select(listSelectors.getSortingOptions)), store.pipe(select(listSelectors.getFilteringOptions)), store.pipe(select(listSelectors.getRequestParameters))), switchMap$1(([, pagingOptions, sortingOptions, filteringOptions, requestParameters]) => {
+        return service
+            .loadResources({
+            pagingOptions,
+            sortingOptions,
+            filteringOptions,
+            requestParameters
+        })
+            .pipe(map$1(resources => listActions.loadPageSuccess({
+            resources,
+            pagingOptions
+        })), catchError$1((errors) => of(listActions.loadPageFailure({ errors }))));
+    }));
+}
+function patchEffect(actions$, listActions, service) {
+    return actions$.pipe(ofType(listActions.patch), exhaustMap$1(action => {
+        if (!service.patchResources) {
+            throw new Error('patchResources not implement in the ListService');
+        }
+        return service.patchResources(action.resourceIds, action.resource).pipe(map$1(resources => listActions.patchSuccess({ resources })), catchError$1((errors) => of(listActions.patchFailure({ errors }))));
+    }));
+}
+function deleteEffect(actions$, listActions, service) {
+    return actions$.pipe(ofType(listActions.delete), exhaustMap$1(({ resourceIds }) => {
+        if (!service.deleteResources) {
+            throw new Error('deleteResources not implement in the ListService');
+        }
+        return service.deleteResources(resourceIds).pipe(map$1(() => listActions.deleteSuccess({ resourceIds })), catchError$1((errors) => of(listActions.deleteFailure({ errors }))));
+    }));
+}
+function deleteSuccessEffect(actions$, listActions, notificationService) {
+    return actions$.pipe(ofType(listActions.deleteSuccess), tap$1(({ resourceIds }) => {
+        notificationService?.onListDelete(resourceIds);
+    }));
+}
+function errorsHandlerEffect(actions$, listActions, notificationService) {
+    return actions$.pipe(ofType(listActions.loadPageFailure, listActions.deleteFailure, listActions.patchFailure), tap$1(({ errors }) => {
+        notificationService?.onListErrors(errors);
+    }));
+}
+
+function provideListFacade(token, listActions, listSelectors) {
+    return {
+        provide: token,
+        useFactory: () => createListFacade(listActions, listSelectors, inject(Store))
+    };
+}
+function createListFacade(listActions, listSelectors, store) {
+    const resources$ = store.pipe(select(listSelectors.getAll));
+    const loadingState$ = store.pipe(select(listSelectors.getLoadingState));
+    const requestState$ = store.pipe(select(listSelectors.getRequestState));
+    const errors$ = store.pipe(select(listSelectors.getErrors));
+    const isReady$ = store.pipe(select(listSelectors.isReady));
+    const areSelectedReady$ = store.pipe(select(listSelectors.areSelectedReady));
+    const currentPageData$ = store.pipe(select(listSelectors.getCurrentPageData));
+    const currentPageNumber$ = store.pipe(select(listSelectors.getCurrentPageNumber));
+    const filteringOptions$ = store.pipe(select(listSelectors.getFilteringOptions));
+    const requestParameters$ = store.pipe(select(listSelectors.getRequestParameters));
+    const lastPageNumber$ = store.pipe(select(listSelectors.getLastPageNumber));
+    const pagingOptions$ = store.pipe(select(listSelectors.getPagingOptions));
+    const requestOptions$ = store.pipe(select(listSelectors.getRequestOptions));
+    const sortingOptions$ = store.pipe(select(listSelectors.getSortingOptions));
+    const selectedItems$ = store.pipe(select(listSelectors.getSelectedItems));
+    const totalCount$ = store.pipe(select(listSelectors.getTotalCount));
+    return {
+        resources$,
+        loadingState$,
+        requestState$,
+        errors$,
+        isReady$,
+        areSelectedReady$,
+        currentPageData$,
+        currentPageNumber$,
+        filteringOptions$,
+        requestParameters$,
+        lastPageNumber$,
+        pagingOptions$,
+        requestOptions$,
+        sortingOptions$,
+        selectedItems$,
+        totalCount$,
+        setPageSize(props) {
+            store.dispatch(listActions.setPageSize(props));
+        },
+        setFiltering(props) {
+            store.dispatch(listActions.setFiltering(props));
+        },
+        setSorting(props) {
+            store.dispatch(listActions.setSorting(props));
+        },
+        setRequestParameters(props) {
+            store.dispatch(listActions.setRequestParams(props));
+        },
+        changeFiltering(props) {
+            store.dispatch(listActions.changeFiltering(props));
+        },
+        changePagingOptions(props) {
+            store.dispatch(listActions.changePagingOptions(props));
+        },
+        changePageSize(props) {
+            store.dispatch(listActions.changePageSize(props));
+        },
+        changePageNumber(props) {
+            store.dispatch(listActions.changePageNumber(props));
+        },
+        changeSelectedResources(props) {
+            store.dispatch(listActions.changeSelectedResources(props));
+        },
+        changeSorting(props) {
+            store.dispatch(listActions.changeSorting(props));
+        },
+        changeRequestParams(props) {
+            store.dispatch(listActions.changeRequestParams(props));
+        },
+        loadPage() {
+            store.dispatch(listActions.loadPage());
+        },
+        loadFirstPage() {
+            store.dispatch(listActions.loadFirstPage());
+        },
+        loadNextPage() {
+            store.dispatch(listActions.loadNextPage());
+        },
+        loadPreviousPage() {
+            store.dispatch(listActions.loadPreviousPage());
+        },
+        patch(props) {
+            store.dispatch(listActions.patch(props));
+        },
+        delete(props) {
+            store.dispatch(listActions.delete(props));
+        },
+        initialize() {
+            store.dispatch(listActions.initialize());
+        },
+        reinitialize() {
+            store.dispatch(listActions.reset());
+        },
+        resetRequestState() {
+            store.dispatch(listActions.resetRequestState());
+        }
+    };
+}
+
 function createListState(featureName, idKey) {
     const actions = createListActions(featureName);
     const entityAdapter = createListEntityAdapter(idKey);
@@ -554,10 +737,22 @@ function createListState(featureName, idKey) {
         entityAdapter
     };
 }
+function provideListState(featureKey, facadeToken, service, notificationService = (NotificationServicePlaceholder)) {
+    const { actions, selectors, reducer } = createListState(featureKey);
+    return [
+        provideState(featureKey, reducer),
+        provideListFacade(facadeToken, actions, selectors),
+        provideEffects([
+            createListEffects(actions, selectors, () => inject(service), () => inject(notificationService))
+        ]),
+        service,
+        notificationService
+    ];
+}
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AbstractListEffects, AbstractListFacade, AbstractListReducerManager, LIST_FEATURE_KEY, LIST_FEATURE_KEYS, LIST_NOTIFICATION_SERVICES, LIST_SERVICES, ListStateService, NgduxListStateModule, createListActions, createListEntityAdapter, createListReducer, createListSelectors, createListState };
+export { AbstractListEffects, AbstractListFacade, AbstractListReducerManager, LIST_FEATURE_KEY, LIST_FEATURE_KEYS, LIST_NOTIFICATION_SERVICES, LIST_SERVICES, ListStateService, NgduxListStateModule, createListActions, createListEntityAdapter, createListReducer, createListSelectors, createListState, provideListState };
 //# sourceMappingURL=ngdux-list.mjs.map