@daffodil/category 0.39.13 → 0.42.0

package/fesm2020/daffodil-category-state.mjs

@@ -0,0 +1,752 @@
+import * as i0 from '@angular/core';
+import { Injectable, Inject, NgModule } from '@angular/core';
+import * as i1 from '@ngrx/store';
+import { createFeatureSelector, createSelector, defaultMemoize, select, StoreModule } from '@ngrx/store';
+import { getDaffProductSelectors, DaffProductGridLoadSuccess, DaffProductStateModule } from '@daffodil/product/state';
+import { createEntityAdapter } from '@ngrx/entity';
+import { daffToggleRequestOnFilters, daffRemoveRequestsFromFilters, daffClearFilters, daffApplyRequestsToFilters, daffCategoryComputeAppliedFilters, DaffCategoryRequestKind, daffCategoryFiltersToRequests, DAFF_CATEGORY_ERROR_MATCHER } from '@daffodil/category';
+import * as i1$1 from '@ngrx/effects';
+import { createEffect, ofType, EffectsModule } from '@ngrx/effects';
+import { asyncScheduler, of } from 'rxjs';
+import { withLatestFrom, map, throttleTime, switchMap, catchError, mergeMap } from 'rxjs/operators';
+import { DaffCategoryDriver } from '@daffodil/category/driver';
+
+function daffCategoryEntitiesAdapter() {
+    return createEntityAdapter();
+}
+
+/**
+ * The possible types of category page actions.
+ */
+var DaffCategoryPageActionTypes;
+(function (DaffCategoryPageActionTypes) {
+    DaffCategoryPageActionTypes["CategoryPageLoadAction"] = "[@daffodil/category] Category Page Load Action";
+    DaffCategoryPageActionTypes["CategoryPageLoadByUrlAction"] = "[@daffodil/category] Category Page Load By URL Action";
+    DaffCategoryPageActionTypes["CategoryPageLoadSuccessAction"] = "[@daffodil/category] Category Page Load Success Action";
+    DaffCategoryPageActionTypes["CategoryPageLoadFailureAction"] = "[@daffodil/category] Category Page Load Failure Action";
+    DaffCategoryPageActionTypes["CategoryPageChangeSizeAction"] = "[@daffodil/category] Category Page Change Size Action";
+    DaffCategoryPageActionTypes["CategoryPageChangeCurrentPageAction"] = "[@daffodil/category] Category Page Change Current Page Action";
+    DaffCategoryPageActionTypes["CategoryPageChangeSortingOptionAction"] = "[@daffodil/category] Category Page Change Sorting Option Action";
+})(DaffCategoryPageActionTypes || (DaffCategoryPageActionTypes = {}));
+/**
+ * An action triggered to initialize a category page load request.
+ * This is intended to be used for loading full category pages.
+ * Queries the category by ID.
+ *
+ * @param request - DaffCategoryRequest object
+ */
+class DaffCategoryPageLoad {
+    constructor(request) {
+        this.request = request;
+        this.type = DaffCategoryPageActionTypes.CategoryPageLoadAction;
+    }
+}
+/**
+ * An action triggered to initialize a category page load request.
+ * This is intended to be used for loading full category pages.
+ * Queries the category by URL.
+ *
+ * @param request - DaffCategoryRequest object
+ */
+class DaffCategoryPageLoadByUrl {
+    constructor(request) {
+        this.request = request;
+        this.type = DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction;
+    }
+}
+/**
+ * An action triggered upon a successful category page request.
+ *
+ * @param response - DaffGetCategoryResponse object
+ */
+class DaffCategoryPageLoadSuccess {
+    constructor(response) {
+        this.response = response;
+        this.type = DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction;
+    }
+}
+/**
+ * An action triggered upon a failed category page request.
+ *
+ * @param errorMessage - an error message
+ */
+class DaffCategoryPageLoadFailure {
+    constructor(errorMessage) {
+        this.errorMessage = errorMessage;
+        this.type = DaffCategoryPageActionTypes.CategoryPageLoadFailureAction;
+    }
+}
+/**
+ * An action for changing the number of products shown on each page for the selected category.
+ *
+ * @param pageSize - The number of products per page.
+ */
+class DaffCategoryPageChangePageSize {
+    constructor(pageSize) {
+        this.pageSize = pageSize;
+        this.type = DaffCategoryPageActionTypes.CategoryPageChangeSizeAction;
+    }
+}
+/**
+ * An action for changing the current page of products for the selected category.
+ *
+ * @param currentPage - The current page of products for the selected category.
+ */
+class DaffCategoryPageChangeCurrentPage {
+    constructor(currentPage) {
+        this.currentPage = currentPage;
+        this.type = DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction;
+    }
+}
+/**
+ * An action for changing the sorting option for the selected category.
+ *
+ * @param sort - The sort option to be applied.
+ */
+class DaffCategoryPageChangeSortingOption {
+    constructor(sort) {
+        this.sort = sort;
+        this.type = DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction;
+    }
+}
+
+/**
+ * The possible types of category actions.
+ */
+var DaffCategoryActionTypes;
+(function (DaffCategoryActionTypes) {
+    DaffCategoryActionTypes["CategoryLoadAction"] = "[Daff-Category] Category Load Action";
+    DaffCategoryActionTypes["CategoryLoadSuccessAction"] = "[Daff-Category] Category Load Success Action";
+    DaffCategoryActionTypes["CategoryLoadFailureAction"] = "[Daff-Category] Category Load Failure Action";
+})(DaffCategoryActionTypes || (DaffCategoryActionTypes = {}));
+/**
+ * An action triggered to initialize a category load request.
+ *
+ * @param request - DaffCategoryRequest object
+ */
+class DaffCategoryLoad {
+    constructor(request) {
+        this.request = request;
+        this.type = DaffCategoryActionTypes.CategoryLoadAction;
+    }
+}
+/**
+ * An action triggered upon a successful category request.
+ *
+ * @param response - DaffGetCategoryResponse object
+ */
+class DaffCategoryLoadSuccess {
+    constructor(response) {
+        this.response = response;
+        this.type = DaffCategoryActionTypes.CategoryLoadSuccessAction;
+    }
+}
+/**
+ * An action triggered upon a failed category request.
+ *
+ * @param errorMessage - an error message
+ */
+class DaffCategoryLoadFailure {
+    constructor(errorMessage) {
+        this.errorMessage = errorMessage;
+        this.type = DaffCategoryActionTypes.CategoryLoadFailureAction;
+    }
+}
+
+/**
+ * A reducer function to store category entities from DaffCategoryLoadSuccess and DaffCategoryPageLoadSuccess actions.
+ */
+function daffCategoryEntitiesReducer(state = daffCategoryEntitiesAdapter().getInitialState(), action) {
+    switch (action.type) {
+        case DaffCategoryActionTypes.CategoryLoadSuccessAction:
+        case DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction:
+            return daffCategoryEntitiesAdapter().upsertOne({
+                id: action.response.category.id,
+                ...action.response.category,
+            }, state);
+        default:
+            return state;
+    }
+}
+
+/**
+ * The possible types of category page filter actions.
+ */
+var DaffCategoryPageFilterActionTypes;
+(function (DaffCategoryPageFilterActionTypes) {
+    DaffCategoryPageFilterActionTypes["CategoryPageChangeFiltersAction"] = "[@daffodil/category] Category Page Change Filters Action";
+    DaffCategoryPageFilterActionTypes["CategoryPageReplaceFiltersAction"] = "[@daffodil/category] Category Page Replace Filters Action";
+    DaffCategoryPageFilterActionTypes["CategoryPageApplyFiltersAction"] = "[@daffodil/category] Category Page Apply Filters Action";
+    DaffCategoryPageFilterActionTypes["CategoryPageRemoveFiltersAction"] = "[@daffodil/category] Category Page Remove Filters Action";
+    DaffCategoryPageFilterActionTypes["CategoryPageClearFiltersAction"] = "[@daffodil/category] Category Page Clear Filters Action";
+    DaffCategoryPageFilterActionTypes["CategoryPageToggleFilterAction"] = "[@daffodil/category] Category Page Toggle Filter Action";
+})(DaffCategoryPageFilterActionTypes || (DaffCategoryPageFilterActionTypes = {}));
+/**
+ * An action for changing the filters for the current category.
+ *
+ * @param filters - Filters to be changed on the current category.
+ * @deprecated use {@link DaffCategoryPageReplaceFilters} or {@link DaffCategoryPageApplyFilters}
+ */
+class DaffCategoryPageChangeFilters {
+    constructor(filters) {
+        this.filters = filters;
+        this.type = DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction;
+    }
+}
+/**
+ * An action for replacing the filters for the current category.
+ * All existing filters will be removed and the specified filters will be applied.
+ *
+ * @param filters - Filters to be set on the current category.
+ */
+class DaffCategoryPageReplaceFilters {
+    constructor(filters) {
+        this.filters = filters;
+        this.type = DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction;
+    }
+}
+/**
+ * An action for applying the specified filters for the current category.
+ *
+ * @param filters - Filters to be applied to the current category.
+ */
+class DaffCategoryPageApplyFilters {
+    constructor(filters) {
+        this.filters = filters;
+        this.type = DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction;
+    }
+}
+/**
+ * An action for removing the specified filters for the current category.
+ *
+ * @param filters - Filters to be removed from the current category.
+ */
+class DaffCategoryPageRemoveFilters {
+    constructor(filters) {
+        this.filters = filters;
+        this.type = DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction;
+    }
+}
+/**
+ * An action for removing all the filters for the current category.
+ */
+class DaffCategoryPageClearFilters {
+    constructor() {
+        this.type = DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction;
+    }
+}
+/**
+ * An action for toggling a filters for the current category.
+ *
+ * @param filter - Filter to be toggled on the current category.
+ */
+class DaffCategoryPageToggleFilter {
+    constructor(filter) {
+        this.filter = filter;
+        this.type = DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction;
+    }
+}
+
+const allowedMetadataKeys = [
+    'applied_sort_option',
+    'applied_sort_direction',
+    'current_page',
+    'page_size',
+];
+const buildMetadataFromRequest = (request) => allowedMetadataKeys.reduce((acc, key) => {
+    if (request[key]) {
+        acc[key] = request[key];
+    }
+    return acc;
+}, {});
+
+const initialState = {
+    categoryPageMetadata: {
+        id: null,
+        applied_sort_option: null,
+        applied_sort_direction: null,
+        current_page: null,
+        page_size: null,
+        total_pages: null,
+        filters: {},
+        sort_options: {
+            default: null,
+            options: [],
+        },
+        total_products: null,
+        product_ids: [],
+    },
+    daffState: "Stable" /* Stable */,
+    categoryLoading: false,
+    productsLoading: false,
+    errors: [],
+};
+/**
+ * Returns the state for category data except for category entities.
+ */
+function daffCategoryReducer(state = initialState, action) {
+    switch (action.type) {
+        case DaffCategoryPageActionTypes.CategoryPageLoadAction:
+        case DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction:
+            return {
+                ...state,
+                categoryLoading: true,
+                productsLoading: true,
+                daffState: "Resolving" /* Resolving */,
+                categoryPageMetadata: {
+                    ...initialState.categoryPageMetadata,
+                    ...buildMetadataFromRequest(action.request),
+                    id: null,
+                },
+            };
+        case DaffCategoryPageActionTypes.CategoryPageChangeSizeAction:
+            return {
+                ...state,
+                productsLoading: true,
+                daffState: "Mutating" /* Mutating */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    page_size: action.pageSize,
+                },
+            };
+        case DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction:
+            return {
+                ...state,
+                productsLoading: true,
+                daffState: "Mutating" /* Mutating */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    current_page: action.currentPage,
+                },
+            };
+        case DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction:
+            return {
+                ...state,
+                productsLoading: true,
+                daffState: "Mutating" /* Mutating */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    applied_sort_option: action.sort.option,
+                    applied_sort_direction: action.sort.direction,
+                },
+            };
+        case DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction:
+        case DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction:
+            return {
+                ...state,
+                productsLoading: true,
+                daffState: "Mutating" /* Mutating */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    filters: daffApplyRequestsToFilters(action.filters, daffClearFilters(state.categoryPageMetadata.filters)),
+                },
+            };
+        case DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction:
+            return {
+                ...state,
+                productsLoading: true,
+                daffState: "Mutating" /* Mutating */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    filters: daffApplyRequestsToFilters(action.filters, state.categoryPageMetadata.filters),
+                },
+            };
+        case DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction:
+            return {
+                ...state,
+                productsLoading: true,
+                daffState: "Mutating" /* Mutating */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    filters: daffClearFilters(state.categoryPageMetadata.filters),
+                },
+            };
+        case DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction:
+            return {
+                ...state,
+                productsLoading: true,
+                daffState: "Mutating" /* Mutating */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    filters: daffRemoveRequestsFromFilters(action.filters, state.categoryPageMetadata.filters),
+                },
+            };
+        case DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction:
+            return {
+                ...state,
+                productsLoading: true,
+                daffState: "Mutating" /* Mutating */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    filters: daffToggleRequestOnFilters(action.filter, state.categoryPageMetadata.filters),
+                },
+            };
+        case DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction:
+            return {
+                ...state,
+                categoryLoading: false,
+                productsLoading: false,
+                daffState: "Stable" /* Stable */,
+                categoryPageMetadata: {
+                    ...state.categoryPageMetadata,
+                    id: action.response.categoryPageMetadata.id,
+                    current_page: action.response.categoryPageMetadata.current_page,
+                    page_size: action.response.categoryPageMetadata.page_size,
+                    filters: action.response.categoryPageMetadata.filters,
+                    sort_options: action.response.categoryPageMetadata.sort_options,
+                    total_pages: action.response.categoryPageMetadata.total_pages,
+                    total_products: action.response.categoryPageMetadata.total_products,
+                    product_ids: action.response.categoryPageMetadata.product_ids,
+                    applied_sort_option: state.categoryPageMetadata.applied_sort_option || action.response.categoryPageMetadata.sort_options.default,
+                },
+            };
+        case DaffCategoryPageActionTypes.CategoryPageLoadFailureAction:
+            return {
+                ...state,
+                categoryLoading: false,
+                productsLoading: false,
+                errors: [action.errorMessage],
+                daffState: "Stable" /* Stable */,
+            };
+        default:
+            return state;
+    }
+}
+
+/**
+ * All daffodil defined category reducers.
+ */
+const daffCategoryReducers = {
+    category: daffCategoryReducer,
+    categoryEntities: daffCategoryEntitiesReducer,
+};
+
+/**
+ * The key for the slice of category related redux state in the global redux state object.
+ */
+const DAFF_CATEGORY_STORE_FEATURE_KEY = 'daffCategory';
+
+/**
+ * A function that returns a selector for the entire category feature state.
+ */
+const getDaffCategoryFeatureSelector = (() => {
+    let cache;
+    return () => cache = cache
+        ? cache
+        : { selectCategoryFeatureState: createFeatureSelector(DAFF_CATEGORY_STORE_FEATURE_KEY) };
+})();
+
+const createCategoryFeatureSelectors = () => {
+    const entitiesSelectors = daffCategoryEntitiesAdapter().getSelectors();
+    const categoryFeatureState = getDaffCategoryFeatureSelector().selectCategoryFeatureState;
+    const selectCategoryEntitiesState = createSelector(categoryFeatureState, (state) => state.categoryEntities);
+    const selectCategoryIds = createSelector(selectCategoryEntitiesState, entitiesSelectors.selectIds);
+    const selectCategoryEntities = createSelector(selectCategoryEntitiesState, entitiesSelectors.selectEntities);
+    const selectAllCategories = createSelector(selectCategoryEntitiesState, entitiesSelectors.selectAll);
+    const selectCategoryTotal = createSelector(selectCategoryEntitiesState, entitiesSelectors.selectTotal);
+    return {
+        selectCategoryEntitiesState,
+        selectCategoryIds,
+        selectCategoryEntities,
+        selectAllCategories,
+        selectCategoryTotal,
+    };
+};
+/**
+ * A function that returns all selectors related to category entities.
+ */
+const getDaffCategoryEntitiesSelectors = (() => {
+    let cache;
+    return () => cache = cache
+        ? cache
+        : createCategoryFeatureSelectors();
+})();
+
+const createCategoryPageSelectors = () => {
+    const selectCategoryFeatureState = getDaffCategoryFeatureSelector().selectCategoryFeatureState;
+    const selectCategoryState = createSelector(selectCategoryFeatureState, (state) => state.category);
+    const selectCategoryPageMetadata = createSelector(selectCategoryState, (state) => state.categoryPageMetadata);
+    const selectCategoryCurrentPage = createSelector(selectCategoryPageMetadata, (state) => state.current_page);
+    const selectCategoryTotalPages = createSelector(selectCategoryPageMetadata, (state) => state.total_pages);
+    const selectCategoryPageSize = createSelector(selectCategoryPageMetadata, (state) => state.page_size);
+    const selectCategoryFilters = createSelector(selectCategoryPageMetadata, (state) => state.filters);
+    const selectCategorySortOptions = createSelector(selectCategoryPageMetadata, (state) => state.sort_options.options);
+    const selectCategoryPageProductIds = createSelector(selectCategoryPageMetadata, (state) => state.product_ids);
+    const selectIsCategoryPageEmpty = createSelector(selectCategoryPageProductIds, (state) => !state.length);
+    const selectCategoryPageTotalProducts = createSelector(selectCategoryPageMetadata, (state) => state.total_products);
+    const selectCategoryPageAppliedFilters = createSelector(selectCategoryFilters, (filters) => daffCategoryComputeAppliedFilters(filters));
+    const selectCategoryPageAppliedSortOption = createSelector(selectCategoryPageMetadata, (state) => state.applied_sort_option);
+    const selectCategoryPageAppliedSortDirection = createSelector(selectCategoryPageMetadata, (state) => state.applied_sort_direction);
+    const selectCategoryPageState = createSelector(selectCategoryState, (state) => state.daffState);
+    const selectCurrentCategoryId = createSelector(selectCategoryPageMetadata, (state) => state.id);
+    const selectCategoryLoading = createSelector(selectCategoryState, (state) => state.categoryLoading);
+    const selectCategoryProductsLoading = createSelector(selectCategoryState, (state) => state.productsLoading);
+    const selectCategoryErrors = createSelector(selectCategoryState, (state) => state.errors);
+    const selectIsCategoryPageMutating = createSelector(selectCategoryPageState, (daffState) => daffState === "Mutating" /* Mutating */);
+    const selectIsCategoryPageResolving = createSelector(selectCategoryPageState, (daffState) => daffState === "Resolving" /* Resolving */);
+    return {
+        selectCategoryState,
+        selectCategoryPageMetadata,
+        selectCategoryCurrentPage,
+        selectCategoryTotalPages,
+        selectCategoryPageSize,
+        selectCategoryFilters,
+        selectCategorySortOptions,
+        selectCategoryPageProductIds,
+        selectIsCategoryPageEmpty,
+        selectCategoryPageTotalProducts,
+        selectCategoryPageAppliedFilters,
+        selectCategoryPageAppliedSortOption,
+        selectCategoryPageAppliedSortDirection,
+        selectCategoryPageState,
+        selectCurrentCategoryId,
+        selectCategoryLoading,
+        selectCategoryProductsLoading,
+        selectCategoryErrors,
+        selectIsCategoryPageMutating,
+        selectIsCategoryPageResolving,
+    };
+};
+/**
+ * A function that returns all selectors related to the category page metadata, category loading, and errors.
+ * Returns {@link DaffCategoryPageMemoizedSelectors}.
+ */
+const getDaffCategoryPageSelectors = (() => {
+    let cache;
+    return () => cache = cache
+        ? cache
+        : createCategoryPageSelectors();
+})();
+
+const createCategorySelectors = () => {
+    const { selectAllProducts, selectProductEntities } = getDaffProductSelectors();
+    const { selectCategoryEntities, } = getDaffCategoryEntitiesSelectors();
+    const { selectCurrentCategoryId, selectCategoryPageProductIds, } = getDaffCategoryPageSelectors();
+    /**
+     * Combinatoric Category Selectors
+     */
+    const selectCurrentCategory = createSelector(selectCategoryEntities, selectCurrentCategoryId, (entities, currentCategoryId) => entities[currentCategoryId]);
+    const selectCategoryPageProducts = createSelector(selectCategoryPageProductIds, selectProductEntities, (ids, products) => ids.map(id => products[id]).filter(p => p != null));
+    const selectCategory = defaultMemoize((categoryId) => createSelector(selectCategoryEntities, (entities) => entities[categoryId])).memoized;
+    const selectProductsByCategory = defaultMemoize((categoryId) => createSelector(selectCategory(categoryId), selectAllProducts, (category, products) => category?.product_ids
+        ? products.filter(product => category.product_ids.indexOf(product.id) >= 0)
+        : [])).memoized;
+    const selectTotalProductsByCategory = defaultMemoize((categoryId) => createSelector(selectProductsByCategory(categoryId), (products) => products.length)).memoized;
+    return {
+        ...getDaffCategoryFeatureSelector(),
+        ...getDaffCategoryEntitiesSelectors(),
+        ...getDaffCategoryPageSelectors(),
+        selectCurrentCategory,
+        selectCategoryPageProducts,
+        selectCategory,
+        selectProductsByCategory,
+        selectTotalProductsByCategory,
+    };
+};
+/**
+ * A function that returns all combinatoric category selectors.
+ */
+const getDaffCategorySelectors = (() => {
+    let cache;
+    return () => cache = cache
+        ? cache
+        : createCategorySelectors();
+})();
+
+/**
+ * A facade for interacting with the category state.
+ * This facade exposes many parts of the state for easy access and allows dispatching of actions.
+ *
+ * @inheritdoc
+ */
+class DaffCategoryFacade {
+    constructor(store) {
+        this.store = store;
+        this.categorySelectors = getDaffCategorySelectors();
+        this.category$ = this.store.pipe(select(this.categorySelectors.selectCurrentCategory));
+        this.products$ = this.store.pipe(select(this.categorySelectors.selectCategoryPageProducts));
+        this.totalProducts$ = this.store.pipe(select(this.categorySelectors.selectCategoryPageTotalProducts));
+        this.metadata$ = this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata));
+        this.pageLoadingState$ = this.store.pipe(select(this.categorySelectors.selectCategoryPageState));
+        this.isPageMutating$ = this.store.pipe(select(this.categorySelectors.selectIsCategoryPageMutating));
+        this.isPageResolving$ = this.store.pipe(select(this.categorySelectors.selectIsCategoryPageResolving));
+        this.currentPage$ = this.store.pipe(select(this.categorySelectors.selectCategoryCurrentPage));
+        this.totalPages$ = this.store.pipe(select(this.categorySelectors.selectCategoryTotalPages));
+        this.pageSize$ = this.store.pipe(select(this.categorySelectors.selectCategoryPageSize));
+        this.filters$ = this.store.pipe(select(this.categorySelectors.selectCategoryFilters));
+        this.sortOptions$ = this.store.pipe(select(this.categorySelectors.selectCategorySortOptions));
+        this.appliedFilters$ = this.store.pipe(select(this.categorySelectors.selectCategoryPageAppliedFilters));
+        this.appliedSortOption$ = this.store.pipe(select(this.categorySelectors.selectCategoryPageAppliedSortOption));
+        this.appliedSortDirection$ = this.store.pipe(select(this.categorySelectors.selectCategoryPageAppliedSortDirection));
+        this.categoryLoading$ = this.store.pipe(select(this.categorySelectors.selectCategoryLoading));
+        this.productsLoading$ = this.store.pipe(select(this.categorySelectors.selectCategoryProductsLoading));
+        this.errors$ = this.store.pipe(select(this.categorySelectors.selectCategoryErrors));
+        this.isCategoryEmpty$ = this.store.pipe(select(this.categorySelectors.selectIsCategoryPageEmpty));
+    }
+    getCategoryById(id) {
+        return this.store.pipe(select(this.categorySelectors.selectCategory(id)));
+    }
+    getProductsByCategory(categoryId) {
+        return this.store.pipe(select(this.categorySelectors.selectProductsByCategory(categoryId)));
+    }
+    getTotalProductsByCategory(categoryId) {
+        return this.store.pipe(select(this.categorySelectors.selectTotalProductsByCategory(categoryId)));
+    }
+    /**
+     * Dispatches the given action.
+     *
+     * @param action action to dispatch.
+     */
+    dispatch(action) {
+        this.store.dispatch(action);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffCategoryFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryFacade, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffCategoryFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryFacade, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryFacade, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
+
+class DaffCategoryPageFilterEffects {
+    constructor(actions$, driver, errorMatcher, facade) {
+        this.actions$ = actions$;
+        this.driver = driver;
+        this.errorMatcher = errorMatcher;
+        this.facade = facade;
+        /**
+         * Updates the filters applied to the category page. It will take the currently
+         * applied filters from state, form them into a request, and attempt to apply
+         * that request to a backend service.
+         *
+         * @param throttleWindow the amount of time to delay when apply/removing filters
+         * in a sequence.
+         */
+        this.updateFilters$ = createEffect(() => (throttleWindow = 300, scheduler = asyncScheduler) => this.actions$.pipe(ofType(DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction, DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction), withLatestFrom(this.facade.metadata$), map(([action, metadata]) => ({
+            kind: DaffCategoryRequestKind.ID,
+            id: metadata.id,
+            filter_requests: daffCategoryFiltersToRequests(metadata.filters),
+            applied_sort_option: metadata.applied_sort_option,
+            applied_sort_direction: metadata.applied_sort_direction,
+            current_page: metadata.current_page,
+            page_size: metadata.page_size,
+        })), throttleTime(throttleWindow, scheduler, { leading: true, trailing: true }), switchMap(payload => this.driver.get(payload).pipe(switchMap((resp) => [
+            new DaffProductGridLoadSuccess(resp.products),
+            new DaffCategoryPageLoadSuccess(resp),
+        ]), catchError((error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error))))))));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffCategoryPageFilterEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryPageFilterEffects, deps: [{ token: i1$1.Actions }, { token: DaffCategoryDriver }, { token: DAFF_CATEGORY_ERROR_MATCHER }, { token: DaffCategoryFacade }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffCategoryPageFilterEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryPageFilterEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryPageFilterEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.Actions }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DaffCategoryDriver]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DAFF_CATEGORY_ERROR_MATCHER]
+                }] }, { type: DaffCategoryFacade }]; } });
+
+class DaffCategoryPageEffects {
+    constructor(actions$, driver, errorMatcher, store) {
+        this.actions$ = actions$;
+        this.driver = driver;
+        this.errorMatcher = errorMatcher;
+        this.store = store;
+        this.categorySelectors = getDaffCategorySelectors();
+        this.loadCategoryPage$ = createEffect(() => this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageLoadAction), switchMap((action) => this.processCategoryGetRequest(action.request))));
+        this.loadCategoryPageByUrl$ = createEffect(() => this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction), switchMap((action) => this.driver.getByUrl(action.request).pipe(switchMap((resp) => [
+            new DaffProductGridLoadSuccess(resp.products),
+            new DaffCategoryPageLoadSuccess(resp),
+        ]), catchError((error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error))))))));
+        this.changeCategoryPageSize$ = createEffect(() => this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeSizeAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap(([action, metadata]) => this.processCategoryGetRequest({
+            ...metadata,
+            kind: DaffCategoryRequestKind.ID,
+            filter_requests: daffCategoryFiltersToRequests(metadata.filters),
+            page_size: action.pageSize,
+        }))));
+        this.changeCategoryCurrentPage$ = createEffect(() => this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap(([action, metadata]) => this.processCategoryGetRequest({
+            ...metadata,
+            kind: DaffCategoryRequestKind.ID,
+            filter_requests: daffCategoryFiltersToRequests(metadata.filters),
+            current_page: action.currentPage,
+        }))));
+        this.changeCategorySort$ = createEffect(() => this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap(([action, metadata]) => this.processCategoryGetRequest({
+            ...metadata,
+            kind: DaffCategoryRequestKind.ID,
+            filter_requests: daffCategoryFiltersToRequests(metadata.filters),
+            applied_sort_option: action.sort.option,
+            applied_sort_direction: action.sort.direction,
+        }))));
+    }
+    processCategoryGetRequest(payload) {
+        return this.driver.get(payload).pipe(switchMap((resp) => [
+            new DaffProductGridLoadSuccess(resp.products),
+            new DaffCategoryPageLoadSuccess(resp),
+        ]), catchError((error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error)))));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffCategoryPageEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryPageEffects, deps: [{ token: i1$1.Actions }, { token: DaffCategoryDriver }, { token: DAFF_CATEGORY_ERROR_MATCHER }, { token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffCategoryPageEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryPageEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryPageEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.Actions }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DaffCategoryDriver]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DAFF_CATEGORY_ERROR_MATCHER]
+                }] }, { type: i1.Store }]; } });
+
+class DaffCategoryEffects {
+    constructor(actions$, driver, errorMatcher) {
+        this.actions$ = actions$;
+        this.driver = driver;
+        this.errorMatcher = errorMatcher;
+        this.loadCategory$ = createEffect(() => this.actions$.pipe(ofType(DaffCategoryActionTypes.CategoryLoadAction), mergeMap((action) => this.driver.get(action.request).pipe(switchMap((resp) => of(new DaffProductGridLoadSuccess(resp.products), new DaffCategoryLoadSuccess(resp))), catchError((error) => of(new DaffCategoryLoadFailure(this.errorMatcher(error))))))));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffCategoryEffects.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryEffects, deps: [{ token: i1$1.Actions }, { token: DaffCategoryDriver }, { token: DAFF_CATEGORY_ERROR_MATCHER }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffCategoryEffects.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryEffects });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryEffects, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.Actions }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DaffCategoryDriver]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DAFF_CATEGORY_ERROR_MATCHER]
+                }] }]; } });
+
+/**
+ * A module that provides default reducers and effects for the category redux state.
+ */
+class DaffCategoryStateModule {
+}
+/** @nocollapse */ /** @nocollapse */ DaffCategoryStateModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryStateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ DaffCategoryStateModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryStateModule, imports: [i1.StoreFeatureModule, i1$1.EffectsFeatureModule, DaffProductStateModule] });
+/** @nocollapse */ /** @nocollapse */ DaffCategoryStateModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryStateModule, imports: [[
+            StoreModule.forFeature(DAFF_CATEGORY_STORE_FEATURE_KEY, daffCategoryReducers),
+            EffectsModule.forFeature([DaffCategoryEffects, DaffCategoryPageEffects, DaffCategoryPageFilterEffects]),
+            DaffProductStateModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryStateModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        StoreModule.forFeature(DAFF_CATEGORY_STORE_FEATURE_KEY, daffCategoryReducers),
+                        EffectsModule.forFeature([DaffCategoryEffects, DaffCategoryPageEffects, DaffCategoryPageFilterEffects]),
+                        DaffProductStateModule,
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DAFF_CATEGORY_STORE_FEATURE_KEY, DaffCategoryActionTypes, DaffCategoryFacade, DaffCategoryLoad, DaffCategoryLoadFailure, DaffCategoryLoadSuccess, DaffCategoryPageActionTypes, DaffCategoryPageApplyFilters, DaffCategoryPageChangeCurrentPage, DaffCategoryPageChangeFilters, DaffCategoryPageChangePageSize, DaffCategoryPageChangeSortingOption, DaffCategoryPageClearFilters, DaffCategoryPageFilterActionTypes, DaffCategoryPageLoad, DaffCategoryPageLoadByUrl, DaffCategoryPageLoadFailure, DaffCategoryPageLoadSuccess, DaffCategoryPageRemoveFilters, DaffCategoryPageReplaceFilters, DaffCategoryPageToggleFilter, DaffCategoryStateModule, daffCategoryEntitiesReducer, daffCategoryReducer, daffCategoryReducers, getDaffCategorySelectors };
+//# sourceMappingURL=daffodil-category-state.mjs.map