@daffodil/category 0.38.9 → 0.39.0

package/fesm2015/daffodil-category-state.js

@@ -1,4 +1,4 @@
-import { Injectable, ɵɵdefineInjectable, ɵɵinject, Inject, NgModule } from '@angular/core';
+import { ɵɵdefineInjectable, ɵɵinject, Injectable, Inject, NgModule } from '@angular/core';
 import { createFeatureSelector, createSelector, defaultMemoize, select, Store, StoreModule } from '@ngrx/store';
 import { getDaffProductSelectors, DaffProductGridLoadSuccess, DaffProductStateModule } from '@daffodil/product/state';
 import { createEntityAdapter } from '@ngrx/entity';
@@ -9,34 +9,23 @@ import { asyncScheduler, of, Observable } from 'rxjs';
 import { withLatestFrom, map, throttleTime, switchMap, catchError, mergeMap } from 'rxjs/operators';
 import { DaffCategoryDriver } from '@daffodil/category/driver';
 
-/**
- * @fileoverview added by tsickle
- * Generated from: reducers/category-entities/category-entities-adapter.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template T
- * @return {?}
- */
 function daffCategoryEntitiesAdapter() {
     return createEntityAdapter();
 }
 
 /**
- * @fileoverview added by tsickle
- * Generated from: actions/category-page.actions.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * The possible types of category page actions.
  */
-/** @enum {string} */
-const DaffCategoryPageActionTypes = {
-    CategoryPageLoadAction: "[@daffodil/category] Category Page Load Action",
-    CategoryPageLoadByUrlAction: "[@daffodil/category] Category Page Load By URL Action",
-    CategoryPageLoadSuccessAction: "[@daffodil/category] Category Page Load Success Action",
-    CategoryPageLoadFailureAction: "[@daffodil/category] Category Page Load Failure Action",
-    CategoryPageChangeSizeAction: "[@daffodil/category] Category Page Change Size Action",
-    CategoryPageChangeCurrentPageAction: "[@daffodil/category] Category Page Change Current Page Action",
-    CategoryPageChangeSortingOptionAction: "[@daffodil/category] Category Page Change Sorting Option Action",
-};
+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.
@@ -45,20 +34,11 @@ const DaffCategoryPageActionTypes = {
  * @param request - DaffCategoryRequest object
  */
 class DaffCategoryPageLoad {
-    /**
-     * @param {?} request
-     */
     constructor(request) {
         this.request = request;
         this.type = DaffCategoryPageActionTypes.CategoryPageLoadAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageLoad.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageLoad.prototype.request;
-}
 /**
  * An action triggered to initialize a category page load request.
  * This is intended to be used for loading full category pages.
@@ -67,206 +47,112 @@ if (false) {
  * @param request - DaffCategoryRequest object
  */
 class DaffCategoryPageLoadByUrl {
-    /**
-     * @param {?} request
-     */
     constructor(request) {
         this.request = request;
         this.type = DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageLoadByUrl.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageLoadByUrl.prototype.request;
-}
 /**
  * An action triggered upon a successful category page request.
  *
  * @param response - DaffGetCategoryResponse object
- * @template V, W
  */
 class DaffCategoryPageLoadSuccess {
-    /**
-     * @param {?} response
-     */
     constructor(response) {
         this.response = response;
         this.type = DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageLoadSuccess.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageLoadSuccess.prototype.response;
-}
 /**
  * An action triggered upon a failed category page request.
  *
  * @param errorMessage - an error message
  */
 class DaffCategoryPageLoadFailure {
-    /**
-     * @param {?} errorMessage
-     */
     constructor(errorMessage) {
         this.errorMessage = errorMessage;
         this.type = DaffCategoryPageActionTypes.CategoryPageLoadFailureAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageLoadFailure.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageLoadFailure.prototype.errorMessage;
-}
 /**
  * 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 {
-    /**
-     * @param {?} pageSize
-     */
     constructor(pageSize) {
         this.pageSize = pageSize;
         this.type = DaffCategoryPageActionTypes.CategoryPageChangeSizeAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageChangePageSize.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageChangePageSize.prototype.pageSize;
-}
 /**
  * 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 {
-    /**
-     * @param {?} currentPage
-     */
     constructor(currentPage) {
         this.currentPage = currentPage;
         this.type = DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageChangeCurrentPage.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageChangeCurrentPage.prototype.currentPage;
-}
 /**
  * An action for changing the sorting option for the selected category.
  *
  * @param sort - The sort option to be applied.
  */
 class DaffCategoryPageChangeSortingOption {
-    /**
-     * @param {?} sort
-     */
     constructor(sort) {
         this.sort = sort;
         this.type = DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageChangeSortingOption.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageChangeSortingOption.prototype.sort;
-}
 
 /**
- * @fileoverview added by tsickle
- * Generated from: actions/category.actions.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * The possible types of category actions.
  */
-/** @enum {string} */
-const DaffCategoryActionTypes = {
-    CategoryLoadAction: "[Daff-Category] Category Load Action",
-    CategoryLoadSuccessAction: "[Daff-Category] Category Load Success Action",
-    CategoryLoadFailureAction: "[Daff-Category] Category Load Failure Action",
-};
+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 {
-    /**
-     * @param {?} request
-     */
     constructor(request) {
         this.request = request;
         this.type = DaffCategoryActionTypes.CategoryLoadAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryLoad.prototype.type;
-    /** @type {?} */
-    DaffCategoryLoad.prototype.request;
-}
 /**
  * An action triggered upon a successful category request.
  *
  * @param response - DaffGetCategoryResponse object
- * @template V, W
  */
 class DaffCategoryLoadSuccess {
-    /**
-     * @param {?} response
-     */
     constructor(response) {
         this.response = response;
         this.type = DaffCategoryActionTypes.CategoryLoadSuccessAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryLoadSuccess.prototype.type;
-    /** @type {?} */
-    DaffCategoryLoadSuccess.prototype.response;
-}
 /**
  * An action triggered upon a failed category request.
  *
  * @param errorMessage - an error message
  */
 class DaffCategoryLoadFailure {
-    /**
-     * @param {?} errorMessage
-     */
     constructor(errorMessage) {
         this.errorMessage = errorMessage;
         this.type = DaffCategoryActionTypes.CategoryLoadFailureAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryLoadFailure.prototype.type;
-    /** @type {?} */
-    DaffCategoryLoadFailure.prototype.errorMessage;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: reducers/category-entities/category-entities.reducer.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * A reducer function to store category entities from DaffCategoryLoadSuccess and DaffCategoryPageLoadSuccess actions.
- * @template V, W
- * @param {?=} state
- * @param {?=} action
- * @return {?}
  */
 function daffCategoryEntitiesReducer(state = daffCategoryEntitiesAdapter().getInitialState(), action) {
     switch (action.type) {
@@ -279,40 +165,29 @@ function daffCategoryEntitiesReducer(state = daffCategoryEntitiesAdapter().getIn
 }
 
 /**
- * @fileoverview added by tsickle
- * Generated from: actions/category-page-filter.actions.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * The possible types of category page filter actions.
  */
-/** @enum {string} */
-const DaffCategoryPageFilterActionTypes = {
-    CategoryPageChangeFiltersAction: "[@daffodil/category] Category Page Change Filters Action",
-    CategoryPageReplaceFiltersAction: "[@daffodil/category] Category Page Replace Filters Action",
-    CategoryPageApplyFiltersAction: "[@daffodil/category] Category Page Apply Filters Action",
-    CategoryPageRemoveFiltersAction: "[@daffodil/category] Category Page Remove Filters Action",
-    CategoryPageClearFiltersAction: "[@daffodil/category] Category Page Clear Filters Action",
-    CategoryPageToggleFilterAction: "[@daffodil/category] Category Page Toggle Filter Action",
-};
+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}
+ * @deprecated use {@link DaffCategoryPageReplaceFilters} or {@link DaffCategoryPageApplyFilters}
  */
 class DaffCategoryPageChangeFilters {
-    /**
-     * @param {?} filters
-     */
     constructor(filters) {
         this.filters = filters;
         this.type = DaffCategoryPageFilterActionTypes.CategoryPageChangeFiltersAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageChangeFilters.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageChangeFilters.prototype.filters;
-}
 /**
  * An action for replacing the filters for the current category.
  * All existing filters will be removed and the specified filters will be applied.
@@ -320,60 +195,33 @@ if (false) {
  * @param filters - Filters to be set on the current category.
  */
 class DaffCategoryPageReplaceFilters {
-    /**
-     * @param {?} filters
-     */
     constructor(filters) {
         this.filters = filters;
         this.type = DaffCategoryPageFilterActionTypes.CategoryPageReplaceFiltersAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageReplaceFilters.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageReplaceFilters.prototype.filters;
-}
 /**
  * An action for applying the specified filters for the current category.
  *
  * @param filters - Filters to be applied to the current category.
  */
 class DaffCategoryPageApplyFilters {
-    /**
-     * @param {?} filters
-     */
     constructor(filters) {
         this.filters = filters;
         this.type = DaffCategoryPageFilterActionTypes.CategoryPageApplyFiltersAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageApplyFilters.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageApplyFilters.prototype.filters;
-}
 /**
  * An action for removing the specified filters for the current category.
  *
  * @param filters - Filters to be removed from the current category.
  */
 class DaffCategoryPageRemoveFilters {
-    /**
-     * @param {?} filters
-     */
     constructor(filters) {
         this.filters = filters;
         this.type = DaffCategoryPageFilterActionTypes.CategoryPageRemoveFiltersAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageRemoveFilters.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageRemoveFilters.prototype.filters;
-}
 /**
  * An action for removing all the filters for the current category.
  */
@@ -382,67 +230,31 @@ class DaffCategoryPageClearFilters {
         this.type = DaffCategoryPageFilterActionTypes.CategoryPageClearFiltersAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageClearFilters.prototype.type;
-}
 /**
  * An action for toggling a filters for the current category.
  *
  * @param filter - Filter to be toggled on the current category.
  */
 class DaffCategoryPageToggleFilter {
-    /**
-     * @param {?} filter
-     */
     constructor(filter) {
         this.filter = filter;
         this.type = DaffCategoryPageFilterActionTypes.CategoryPageToggleFilterAction;
     }
 }
-if (false) {
-    /** @type {?} */
-    DaffCategoryPageToggleFilter.prototype.type;
-    /** @type {?} */
-    DaffCategoryPageToggleFilter.prototype.filter;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: reducers/category/pure/build-metadata-from-request.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
 const allowedMetadataKeys = [
     'applied_sort_option',
     'applied_sort_direction',
     'current_page',
     'page_size',
 ];
-/** @type {?} */
-const buildMetadataFromRequest = (/**
- * @param {?} request
- * @return {?}
- */
-(request) => allowedMetadataKeys.reduce((/**
- * @template K
- * @param {?} acc
- * @param {?} key
- * @return {?}
- */
-(acc, key) => {
+const buildMetadataFromRequest = (request) => allowedMetadataKeys.reduce((acc, key) => {
     if (request[key]) {
         acc[key] = request[key];
     }
     return acc;
-}), (/** @type {?} */ ({}))));
+}, {});
 
-/**
- * @fileoverview added by tsickle
- * Generated from: reducers/category/category.reducer.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
 const initialState = {
     categoryPageMetadata: {
         id: null,
@@ -466,10 +278,6 @@ const initialState = {
 };
 /**
  * Returns the state for category data except for category entities.
- * @template U, W
- * @param {?=} state
- * @param {?=} action
- * @return {?}
  */
 function daffCategoryReducer(state = initialState, action) {
     switch (action.type) {
@@ -502,133 +310,37 @@ function daffCategoryReducer(state = initialState, action) {
     }
 }
 
-/**
- * @fileoverview added by tsickle
- * Generated from: reducers/category-reducers.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * All daffodil defined category reducers.
- * @type {?}
  */
 const daffCategoryReducers = {
     category: daffCategoryReducer,
     categoryEntities: daffCategoryEntitiesReducer,
 };
 
-/**
- * @fileoverview added by tsickle
- * Generated from: reducers/category-store-feature-key.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * The key for the slice of category related redux state in the global redux state object.
- * @type {?}
  */
 const DAFF_CATEGORY_STORE_FEATURE_KEY = 'daffCategory';
 
-/**
- * @fileoverview added by tsickle
- * Generated from: reducers/public_api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: selectors/category-feature.selector.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * An interface for the entire category feature state.
- * @record
- * @template V
- */
-function DaffCategoryFeatureMemoizedSelectors() { }
-if (false) {
-    /** @type {?} */
-    DaffCategoryFeatureMemoizedSelectors.prototype.selectCategoryFeatureState;
-}
-const ɵ0 = /**
- * @return {?}
- */
-() => {
-    /** @type {?} */
+const ɵ0 = () => {
     let cache;
-    return (/**
-     * @template V
-     * @return {?}
-     */
-    () => cache = cache
+    return () => cache = cache
         ? cache
-        : { selectCategoryFeatureState: createFeatureSelector(DAFF_CATEGORY_STORE_FEATURE_KEY) });
+        : { selectCategoryFeatureState: createFeatureSelector(DAFF_CATEGORY_STORE_FEATURE_KEY) };
 };
 /**
  * A function that returns a selector for the entire category feature state.
- * @type {?}
  */
-const getDaffCategoryFeatureSelector = ((ɵ0))();
+const getDaffCategoryFeatureSelector = (ɵ0)();
 
-/**
- * @fileoverview added by tsickle
- * Generated from: selectors/category-entities/category-entities.selector.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * An interface to describe all selectors related to category ngrx entities state.
- * @record
- * @template V
- */
-function DaffCategoryEntitiesMemoizedSelectors() { }
-if (false) {
-    /**
-     * Selects ngrx category entities state.
-     * @type {?}
-     */
-    DaffCategoryEntitiesMemoizedSelectors.prototype.selectCategoryEntitiesState;
-    /**
-     * Selects the ids of all categories in state.
-     * @type {?}
-     */
-    DaffCategoryEntitiesMemoizedSelectors.prototype.selectCategoryIds;
-    /**
-     * Selects all categories in state as a dictionary.
-     * @type {?}
-     */
-    DaffCategoryEntitiesMemoizedSelectors.prototype.selectCategoryEntities;
-    /**
-     * Selects all categories in state as an array.
-     * @type {?}
-     */
-    DaffCategoryEntitiesMemoizedSelectors.prototype.selectAllCategories;
-    /**
-     * Selects the total number of categories in state.
-     * @type {?}
-     */
-    DaffCategoryEntitiesMemoizedSelectors.prototype.selectCategoryTotal;
-}
-/** @type {?} */
-const createCategoryFeatureSelectors = (/**
- * @template V
- * @return {?}
- */
-() => {
-    /** @type {?} */
+const createCategoryFeatureSelectors = () => {
     const entitiesSelectors = daffCategoryEntitiesAdapter().getSelectors();
-    /** @type {?} */
     const categoryFeatureState = getDaffCategoryFeatureSelector().selectCategoryFeatureState;
-    /** @type {?} */
-    const selectCategoryEntitiesState = createSelector(categoryFeatureState, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.categoryEntities));
-    /** @type {?} */
+    const selectCategoryEntitiesState = createSelector(categoryFeatureState, (state) => state.categoryEntities);
     const selectCategoryIds = createSelector(selectCategoryEntitiesState, entitiesSelectors.selectIds);
-    /** @type {?} */
     const selectCategoryEntities = createSelector(selectCategoryEntitiesState, entitiesSelectors.selectEntities);
-    /** @type {?} */
     const selectAllCategories = createSelector(selectCategoryEntitiesState, entitiesSelectors.selectAll);
-    /** @type {?} */
     const selectCategoryTotal = createSelector(selectCategoryEntitiesState, entitiesSelectors.selectTotal);
     return {
         selectCategoryEntitiesState,
@@ -637,270 +349,41 @@ const createCategoryFeatureSelectors = (/**
         selectAllCategories,
         selectCategoryTotal,
     };
-});
+};
 const ɵ0$1 = createCategoryFeatureSelectors;
-const ɵ1 = /**
- * @return {?}
- */
-() => {
-    /** @type {?} */
+const ɵ1 = () => {
     let cache;
-    return (/**
-     * @template V
-     * @return {?}
-     */
-    () => cache = cache
+    return () => cache = cache
         ? cache
-        : createCategoryFeatureSelectors());
+        : createCategoryFeatureSelectors();
 };
 /**
  * A function that returns all selectors related to category entities.
- * @type {?}
  */
-const getDaffCategoryEntitiesSelectors = ((ɵ1))();
+const getDaffCategoryEntitiesSelectors = (ɵ1)();
 
-/**
- * @fileoverview added by tsickle
- * Generated from: selectors/category-page/category-page.selector.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * An interface to describe all selectors related to the category page metadata, category loading, and errors.
- * @record
- * @template V
- */
-function DaffCategoryPageMemoizedSelectors() { }
-if (false) {
-    /**
-     * Selects all state related to the category page metadata, category loading, and errors.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryState;
-    /**
-     * Selects the metadata for the current category page.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageMetadata;
-    /**
-     * Selects the current page of products of the current category.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryCurrentPage;
-    /**
-     * Selects the total number of pages of products that exist in the current category.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryTotalPages;
-    /**
-     * Selects the number of products on each category page.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageSize;
-    /**
-     * Selects the filters that may be applied to the current category.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryFilters;
-    /**
-     * Selects the sort options that may be applied to the current category.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategorySortOptions;
-    /**
-     * Selects the ids of all products in the current category page.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageProductIds;
-    /**
-     * Selects whether the category page has no products.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectIsCategoryPageEmpty;
-    /**
-     * Selects the total number of products for the current category.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageTotalProducts;
-    /**
-     * Returns a dict of filters and only their applied options.
-     * Filters with no applied options will be omitted.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageAppliedFilters;
-    /**
-     * Selects the applied sorting option if one is applied.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageAppliedSortOption;
-    /**
-     * Selects the applied sorting direction if a sorting option is applied.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageAppliedSortDirection;
-    /**
-     * Selects the loading state of the current category; e.g. mutating, resolving, stable.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryPageState;
-    /**
-     * Selects the id of the current category.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCurrentCategoryId;
-    /**
-     * @deprecated Use selectIsCategoryPageResolving instead
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryLoading;
-    /**
-     * @deprecated Use selectIsCategoryPageResolving and selectIsCategoryPageMutating instead
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryProductsLoading;
-    /**
-     * Selects all errors associated with loading a category.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectCategoryErrors;
-    /**
-     * Selects whether the current category page is mutating; e.g. when a filter is applied to it.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectIsCategoryPageMutating;
-    /**
-     * Selects whether the current category is resolving; e.g. when the category first loads.
-     * @type {?}
-     */
-    DaffCategoryPageMemoizedSelectors.prototype.selectIsCategoryPageResolving;
-}
-/** @type {?} */
-const createCategoryPageSelectors = (/**
- * @template V
- * @return {?}
- */
-() => {
-    /** @type {?} */
+const createCategoryPageSelectors = () => {
     const selectCategoryFeatureState = getDaffCategoryFeatureSelector().selectCategoryFeatureState;
-    /** @type {?} */
-    const selectCategoryState = createSelector(selectCategoryFeatureState, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.category));
-    /** @type {?} */
-    const selectCategoryPageMetadata = createSelector(selectCategoryState, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.categoryPageMetadata));
-    /** @type {?} */
-    const selectCategoryCurrentPage = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.current_page));
-    /** @type {?} */
-    const selectCategoryTotalPages = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.total_pages));
-    /** @type {?} */
-    const selectCategoryPageSize = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.page_size));
-    /** @type {?} */
-    const selectCategoryFilters = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.filters));
-    /** @type {?} */
-    const selectCategorySortOptions = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.sort_options.options));
-    /** @type {?} */
-    const selectCategoryPageProductIds = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.product_ids));
-    /** @type {?} */
-    const selectIsCategoryPageEmpty = createSelector(selectCategoryPageProductIds, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => !state.length));
-    /** @type {?} */
-    const selectCategoryPageTotalProducts = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.total_products));
-    /** @type {?} */
-    const selectCategoryPageAppliedFilters = createSelector(selectCategoryFilters, (/**
-     * @param {?} filters
-     * @return {?}
-     */
-    (filters) => daffCategoryComputeAppliedFilters(filters)));
-    /** @type {?} */
-    const selectCategoryPageAppliedSortOption = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.applied_sort_option));
-    /** @type {?} */
-    const selectCategoryPageAppliedSortDirection = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.applied_sort_direction));
-    /** @type {?} */
-    const selectCategoryPageState = createSelector(selectCategoryState, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.daffState));
-    /** @type {?} */
-    const selectCurrentCategoryId = createSelector(selectCategoryPageMetadata, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.id));
-    /** @type {?} */
-    const selectCategoryLoading = createSelector(selectCategoryState, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.categoryLoading));
-    /** @type {?} */
-    const selectCategoryProductsLoading = createSelector(selectCategoryState, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.productsLoading));
-    /** @type {?} */
-    const selectCategoryErrors = createSelector(selectCategoryState, (/**
-     * @param {?} state
-     * @return {?}
-     */
-    (state) => state.errors));
-    /** @type {?} */
-    const selectIsCategoryPageMutating = createSelector(selectCategoryPageState, (/**
-     * @param {?} daffState
-     * @return {?}
-     */
-    (daffState) => daffState === "Mutating" /* Mutating */));
-    /** @type {?} */
-    const selectIsCategoryPageResolving = createSelector(selectCategoryPageState, (/**
-     * @param {?} daffState
-     * @return {?}
-     */
-    (daffState) => daffState === "Resolving" /* Resolving */));
+    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,
@@ -923,186 +406,58 @@ const createCategoryPageSelectors = (/**
         selectIsCategoryPageMutating,
         selectIsCategoryPageResolving,
     };
-});
+};
 const ɵ0$2 = createCategoryPageSelectors;
-const ɵ1$1 = /**
- * @return {?}
- */
-() => {
-    /** @type {?} */
+const ɵ1$1 = () => {
     let cache;
-    return (/**
-     * @template V
-     * @return {?}
-     */
-    () => cache = cache
+    return () => cache = cache
         ? cache
-        : createCategoryPageSelectors());
+        : createCategoryPageSelectors();
 };
 /**
  * A function that returns all selectors related to the category page metadata, category loading, and errors.
- * Returns {\@link DaffCategoryPageMemoizedSelectors}.
- * @type {?}
+ * Returns {@link DaffCategoryPageMemoizedSelectors}.
  */
-const getDaffCategoryPageSelectors = ((ɵ1$1))();
+const getDaffCategoryPageSelectors = (ɵ1$1)();
 
-/**
- * @fileoverview added by tsickle
- * Generated from: selectors/category.selector.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * An interface for selectors that combine category metadata and category entities selectors.
- * @record
- * @template V, W
- */
-function DaffCategoryMemoizedSelectors() { }
-if (false) {
-    /**
-     * Selects the current category
-     * @type {?}
-     */
-    DaffCategoryMemoizedSelectors.prototype.selectCurrentCategory;
-    /**
-     * Selects the products of the current category.
-     * @type {?}
-     */
-    DaffCategoryMemoizedSelectors.prototype.selectCategoryPageProducts;
-    /**
-     * Selects a category by id.
-     *
-     * \@param categoryId a category id.
-     * @type {?}
-     */
-    DaffCategoryMemoizedSelectors.prototype.selectCategory;
-    /**
-     * Selects products by category id.
-     *
-     * \@param categoryId a category id.
-     * @type {?}
-     */
-    DaffCategoryMemoizedSelectors.prototype.selectProductsByCategory;
-    /**
-     * Selects the total number of products in a category.
-     *
-     * \@param categoryId a category id.
-     * @type {?}
-     */
-    DaffCategoryMemoizedSelectors.prototype.selectTotalProductsByCategory;
-}
-/** @type {?} */
-const createCategorySelectors = (/**
- * @template V, W
- * @return {?}
- */
-() => {
+const createCategorySelectors = () => {
     const { selectAllProducts, selectProductEntities } = getDaffProductSelectors();
     const { selectCategoryEntities, } = getDaffCategoryEntitiesSelectors();
     const { selectCurrentCategoryId, selectCategoryPageProductIds, } = getDaffCategoryPageSelectors();
     /**
      * Combinatoric Category Selectors
-     * @type {?}
-     */
-    const selectCurrentCategory = createSelector(selectCategoryEntities, selectCurrentCategoryId, (/**
-     * @param {?} entities
-     * @param {?} currentCategoryId
-     * @return {?}
-     */
-    (entities, currentCategoryId) => entities[currentCategoryId]));
-    /** @type {?} */
-    const selectCategoryPageProducts = createSelector(selectCategoryPageProductIds, selectProductEntities, (/**
-     * @param {?} ids
-     * @param {?} products
-     * @return {?}
-     */
-    (ids, products) => ids.map((/**
-     * @param {?} id
-     * @return {?}
-     */
-    id => products[id])).filter((/**
-     * @param {?} p
-     * @return {?}
-     */
-    p => p != null))));
-    /** @type {?} */
-    const selectCategory = defaultMemoize((/**
-     * @param {?} categoryId
-     * @return {?}
-     */
-    (categoryId) => createSelector(selectCategoryEntities, (/**
-     * @param {?} entities
-     * @return {?}
-     */
-    (entities) => entities[categoryId])))).memoized;
-    /** @type {?} */
-    const selectProductsByCategory = defaultMemoize((/**
-     * @param {?} categoryId
-     * @return {?}
      */
-    (categoryId) => createSelector(selectCategory(categoryId), selectAllProducts, (/**
-     * @param {?} category
-     * @param {?} products
-     * @return {?}
-     */
-    (category, products) => (category === null || category === void 0 ? void 0 : category.product_ids) ? products.filter((/**
-     * @param {?} product
-     * @return {?}
-     */
-    product => category.product_ids.indexOf(product.id) >= 0))
-        : [])))).memoized;
-    /** @type {?} */
-    const selectTotalProductsByCategory = defaultMemoize((/**
-     * @param {?} categoryId
-     * @return {?}
-     */
-    (categoryId) => createSelector(selectProductsByCategory(categoryId), (/**
-     * @param {?} products
-     * @return {?}
-     */
-    (products) => products.length)))).memoized;
+    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 === null || category === void 0 ? void 0 : 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 Object.assign(Object.assign(Object.assign(Object.assign({}, getDaffCategoryFeatureSelector()), getDaffCategoryEntitiesSelectors()), getDaffCategoryPageSelectors()), { selectCurrentCategory,
         selectCategoryPageProducts,
         selectCategory,
         selectProductsByCategory,
         selectTotalProductsByCategory });
-});
+};
 const ɵ0$3 = createCategorySelectors;
-const ɵ1$2 = /**
- * @return {?}
- */
-() => {
-    /** @type {?} */
+const ɵ1$2 = () => {
     let cache;
-    return (/**
-     * @template V, W
-     * @return {?}
-     */
-    () => cache = cache
+    return () => cache = cache
         ? cache
-        : createCategorySelectors());
+        : createCategorySelectors();
 };
 /**
  * A function that returns all combinatoric category selectors.
- * @type {?}
  */
-const getDaffCategorySelectors = ((ɵ1$2))();
+const getDaffCategorySelectors = (ɵ1$2)();
 
-/**
- * @fileoverview added by tsickle
- * Generated from: facades/category.facade.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * 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
- * @template V, W
+ * @inheritdoc
  */
 class DaffCategoryFacade {
-    /**
-     * @param {?} store
-     */
     constructor(store) {
         this.store = store;
         this.categorySelectors = getDaffCategorySelectors();
@@ -1126,37 +481,25 @@ class DaffCategoryFacade {
         this.errors$ = this.store.pipe(select(this.categorySelectors.selectCategoryErrors));
         this.isCategoryEmpty$ = this.store.pipe(select(this.categorySelectors.selectIsCategoryPageEmpty));
     }
-    /**
-     * @param {?} id
-     * @return {?}
-     */
     getCategoryById(id) {
         return this.store.pipe(select(this.categorySelectors.selectCategory(id)));
     }
-    /**
-     * @param {?} categoryId
-     * @return {?}
-     */
     getProductsByCategory(categoryId) {
         return this.store.pipe(select(this.categorySelectors.selectProductsByCategory(categoryId)));
     }
-    /**
-     * @param {?} categoryId
-     * @return {?}
-     */
     getTotalProductsByCategory(categoryId) {
         return this.store.pipe(select(this.categorySelectors.selectTotalProductsByCategory(categoryId)));
     }
     /**
      * Dispatches the given action.
      *
-     * @param {?} action action to dispatch.
-     * @return {?}
+     * @param action action to dispatch.
      */
     dispatch(action) {
         this.store.dispatch(action);
     }
 }
+/** @nocollapse */ DaffCategoryFacade.ɵprov = ɵɵdefineInjectable({ factory: function DaffCategoryFacade_Factory() { return new DaffCategoryFacade(ɵɵinject(Store)); }, token: DaffCategoryFacade, providedIn: "root" });
 DaffCategoryFacade.decorators = [
     { type: Injectable, args: [{
                 providedIn: 'root',
@@ -1166,73 +509,8 @@ DaffCategoryFacade.decorators = [
 DaffCategoryFacade.ctorParameters = () => [
     { type: Store }
 ];
-/** @nocollapse */ DaffCategoryFacade.ɵprov = ɵɵdefineInjectable({ factory: function DaffCategoryFacade_Factory() { return new DaffCategoryFacade(ɵɵinject(Store)); }, token: DaffCategoryFacade, providedIn: "root" });
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryFacade.prototype.categorySelectors;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.category$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.metadata$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.pageLoadingState$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.isPageMutating$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.isPageResolving$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.currentPage$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.totalPages$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.totalProducts$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.pageSize$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.filters$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.sortOptions$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.appliedFilters$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.appliedSortOption$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.appliedSortDirection$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.products$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.categoryLoading$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.productsLoading$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.errors$;
-    /** @type {?} */
-    DaffCategoryFacade.prototype.isCategoryEmpty$;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryFacade.prototype.store;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: effects/category-page-filter.effects.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template V, W
- */
 class DaffCategoryPageFilterEffects {
-    /**
-     * @param {?} actions$
-     * @param {?} driver
-     * @param {?} errorMatcher
-     * @param {?} facade
-     */
     constructor(actions$, driver, errorMatcher, facade) {
         this.actions$ = actions$;
         this.driver = driver;
@@ -1246,16 +524,7 @@ class DaffCategoryPageFilterEffects {
          * @param throttleWindow the amount of time to delay when apply/removing filters
          * in a sequence.
          */
-        this.updateFilters$ = (/**
-         * @param {?=} throttleWindow
-         * @param {?=} scheduler
-         * @return {?}
-         */
-        (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((/**
-         * @param {?} __0
-         * @return {?}
-         */
-        ([action, metadata]) => ({
+        this.updateFilters$ = (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),
@@ -1263,22 +532,10 @@ class DaffCategoryPageFilterEffects {
             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((/**
-         * @param {?} payload
-         * @return {?}
-         */
-        payload => this.driver.get(payload).pipe(switchMap((/**
-         * @param {?} resp
-         * @return {?}
-         */
-        (resp) => [
+        })), throttleTime(throttleWindow, scheduler, { leading: true, trailing: true }), switchMap(payload => this.driver.get(payload).pipe(switchMap((resp) => [
             new DaffProductGridLoadSuccess(resp.products),
             new DaffCategoryPageLoadSuccess(resp),
-        ])), catchError((/**
-         * @param {?} error
-         * @return {?}
-         */
-        (error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error))))))))));
+        ]), catchError((error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error)))))));
     }
 }
 DaffCategoryPageFilterEffects.decorators = [
@@ -1295,115 +552,28 @@ __decorate([
     Effect(),
     __metadata("design:type", Function)
 ], DaffCategoryPageFilterEffects.prototype, "updateFilters$", void 0);
-if (false) {
-    /**
-     * 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.
-     * @type {?}
-     */
-    DaffCategoryPageFilterEffects.prototype.updateFilters$;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageFilterEffects.prototype.actions$;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageFilterEffects.prototype.driver;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageFilterEffects.prototype.errorMatcher;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageFilterEffects.prototype.facade;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: effects/category-page.effects.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template V, W
- */
 class DaffCategoryPageEffects {
-    /**
-     * @param {?} actions$
-     * @param {?} driver
-     * @param {?} errorMatcher
-     * @param {?} store
-     */
     constructor(actions$, driver, errorMatcher, store) {
         this.actions$ = actions$;
         this.driver = driver;
         this.errorMatcher = errorMatcher;
         this.store = store;
         this.categorySelectors = getDaffCategorySelectors();
-        this.loadCategoryPage$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageLoadAction), switchMap((/**
-         * @param {?} action
-         * @return {?}
-         */
-        (action) => this.processCategoryGetRequest(action.request))));
-        this.loadCategoryPageByUrl$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction), switchMap((/**
-         * @param {?} action
-         * @return {?}
-         */
-        (action) => this.driver.getByUrl(action.request).pipe(switchMap((/**
-         * @param {?} resp
-         * @return {?}
-         */
-        (resp) => [
+        this.loadCategoryPage$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageLoadAction), switchMap((action) => this.processCategoryGetRequest(action.request)));
+        this.loadCategoryPageByUrl$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction), switchMap((action) => this.driver.getByUrl(action.request).pipe(switchMap((resp) => [
             new DaffProductGridLoadSuccess(resp.products),
             new DaffCategoryPageLoadSuccess(resp),
-        ])), catchError((/**
-         * @param {?} error
-         * @return {?}
-         */
-        (error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error)))))))));
-        this.changeCategoryPageSize$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeSizeAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap((/**
-         * @param {?} __0
-         * @return {?}
-         */
-        ([action, metadata]) => this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: DaffCategoryRequestKind.ID, filter_requests: daffCategoryFiltersToRequests(metadata.filters), page_size: action.pageSize })))));
-        this.changeCategoryCurrentPage$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap((/**
-         * @param {?} __0
-         * @return {?}
-         */
-        ([action, metadata]) => this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: DaffCategoryRequestKind.ID, filter_requests: daffCategoryFiltersToRequests(metadata.filters), current_page: action.currentPage })))));
-        this.changeCategorySort$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap((/**
-         * @param {?} __0
-         * @return {?}
-         */
-        ([action, metadata]) => this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: DaffCategoryRequestKind.ID, filter_requests: daffCategoryFiltersToRequests(metadata.filters), applied_sort_option: action.sort.option, applied_sort_direction: action.sort.direction })))));
+        ]), catchError((error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error)))))));
+        this.changeCategoryPageSize$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeSizeAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap(([action, metadata]) => this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: DaffCategoryRequestKind.ID, filter_requests: daffCategoryFiltersToRequests(metadata.filters), page_size: action.pageSize }))));
+        this.changeCategoryCurrentPage$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeCurrentPageAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap(([action, metadata]) => this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: DaffCategoryRequestKind.ID, filter_requests: daffCategoryFiltersToRequests(metadata.filters), current_page: action.currentPage }))));
+        this.changeCategorySort$ = this.actions$.pipe(ofType(DaffCategoryPageActionTypes.CategoryPageChangeSortingOptionAction), withLatestFrom(this.store.pipe(select(this.categorySelectors.selectCategoryPageMetadata))), switchMap(([action, metadata]) => this.processCategoryGetRequest(Object.assign(Object.assign({}, metadata), { kind: DaffCategoryRequestKind.ID, filter_requests: daffCategoryFiltersToRequests(metadata.filters), applied_sort_option: action.sort.option, applied_sort_direction: action.sort.direction }))));
     }
-    /**
-     * @private
-     * @param {?} payload
-     * @return {?}
-     */
     processCategoryGetRequest(payload) {
-        return this.driver.get(payload).pipe(switchMap((/**
-         * @param {?} resp
-         * @return {?}
-         */
-        (resp) => [
+        return this.driver.get(payload).pipe(switchMap((resp) => [
             new DaffProductGridLoadSuccess(resp.products),
             new DaffCategoryPageLoadSuccess(resp),
-        ])), catchError((/**
-         * @param {?} error
-         * @return {?}
-         */
-        (error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error))))));
+        ]), catchError((error) => of(new DaffCategoryPageLoadFailure(this.errorMatcher(error)))));
     }
 }
 DaffCategoryPageEffects.decorators = [
@@ -1436,75 +606,13 @@ __decorate([
     Effect(),
     __metadata("design:type", Observable)
 ], DaffCategoryPageEffects.prototype, "changeCategorySort$", void 0);
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageEffects.prototype.categorySelectors;
-    /** @type {?} */
-    DaffCategoryPageEffects.prototype.loadCategoryPage$;
-    /** @type {?} */
-    DaffCategoryPageEffects.prototype.loadCategoryPageByUrl$;
-    /** @type {?} */
-    DaffCategoryPageEffects.prototype.changeCategoryPageSize$;
-    /** @type {?} */
-    DaffCategoryPageEffects.prototype.changeCategoryCurrentPage$;
-    /** @type {?} */
-    DaffCategoryPageEffects.prototype.changeCategorySort$;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageEffects.prototype.actions$;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageEffects.prototype.driver;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageEffects.prototype.errorMatcher;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryPageEffects.prototype.store;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: effects/category.effects.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @template V, W
- */
 class DaffCategoryEffects {
-    /**
-     * @param {?} actions$
-     * @param {?} driver
-     * @param {?} errorMatcher
-     */
     constructor(actions$, driver, errorMatcher) {
         this.actions$ = actions$;
         this.driver = driver;
         this.errorMatcher = errorMatcher;
-        this.loadCategory$ = this.actions$.pipe(ofType(DaffCategoryActionTypes.CategoryLoadAction), mergeMap((/**
-         * @param {?} action
-         * @return {?}
-         */
-        (action) => this.driver.get(action.request).pipe(switchMap((/**
-         * @param {?} resp
-         * @return {?}
-         */
-        (resp) => of(new DaffProductGridLoadSuccess(resp.products), new DaffCategoryLoadSuccess(resp)))), catchError((/**
-         * @param {?} error
-         * @return {?}
-         */
-        (error) => of(new DaffCategoryLoadFailure(this.errorMatcher(error)))))))));
+        this.loadCategory$ = 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)))))));
     }
 }
 DaffCategoryEffects.decorators = [
@@ -1520,31 +628,7 @@ __decorate([
     Effect(),
     __metadata("design:type", Observable)
 ], DaffCategoryEffects.prototype, "loadCategory$", void 0);
-if (false) {
-    /** @type {?} */
-    DaffCategoryEffects.prototype.loadCategory$;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryEffects.prototype.actions$;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryEffects.prototype.driver;
-    /**
-     * @type {?}
-     * @private
-     */
-    DaffCategoryEffects.prototype.errorMatcher;
-}
 
-/**
- * @fileoverview added by tsickle
- * Generated from: category-state.module.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 /**
  * A module that provides default reducers and effects for the category redux state.
  */
@@ -1561,22 +645,8 @@ DaffCategoryStateModule.decorators = [
 ];
 
 /**
- * @fileoverview added by tsickle
- * Generated from: public_api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: index.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: daffodil-category-state.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * 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, DaffCategoryEffects as ɵa, DaffCategoryPageEffects as ɵb, DaffCategoryPageFilterEffects as ɵc };
+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, ɵ0$3 as ɵ0, ɵ1$2 as ɵ1, DaffCategoryEffects as ɵa, DaffCategoryPageEffects as ɵb, DaffCategoryPageFilterEffects as ɵc };
 //# sourceMappingURL=daffodil-category-state.js.map