@daffodil/category 0.88.1 → 0.89.0

package/package.json

@@ -1 +1 @@
-{"name":"@daffodil/category","nx":{"targets":{"build":{"outputs":["{workspaceRoot}/dist/category"]}}},"version":"0.88.1","description":"An ecommerce categories package that has multi-platform support and state management features.","repository":{"type":"git","url":"https://github.com/graycoreio/daffodil"},"author":"Graycore LLC","license":"MIT","bugs":{"url":"https://github.com/graycoreio/daffodil/issues"},"publishConfig":{"directory":"../../dist/category"},"homepage":"https://github.com/graycoreio/daffodil","peerDependencies":{"@angular/common":"^19.0.0","@angular/core":"^19.0.0","@daffodil/core":"0.88.1","@daffodil/product":"0.88.1","@ngrx/effects":"^19.0.0","@ngrx/entity":"^19.0.0","@ngrx/store":"^19.0.0","rxjs":"7.8.1"},"optionalDependencies":{"@apollo/client":"^3.12.6","@daffodil/driver":"0.88.1","angular-in-memory-web-api":"^0.19.0","apollo-angular":"^10.0.3","@faker-js/faker":"^9.8.0"},"module":"fesm2022/daffodil-category.mjs","typings":"index.d.ts","exports":{"./package.json":{"default":"./package.json"},".":{"types":"./index.d.ts","default":"./fesm2022/daffodil-category.mjs"},"./driver":{"types":"./driver/index.d.ts","default":"./fesm2022/daffodil-category-driver.mjs"},"./routing":{"types":"./routing/index.d.ts","default":"./fesm2022/daffodil-category-routing.mjs"},"./state":{"types":"./state/index.d.ts","default":"./fesm2022/daffodil-category-state.mjs"},"./testing":{"types":"./testing/index.d.ts","default":"./fesm2022/daffodil-category-testing.mjs"},"./driver/in-memory":{"types":"./driver/in-memory/index.d.ts","default":"./fesm2022/daffodil-category-driver-in-memory.mjs"},"./driver/magento":{"types":"./driver/magento/index.d.ts","default":"./fesm2022/daffodil-category-driver-magento.mjs"},"./driver/testing":{"types":"./driver/testing/index.d.ts","default":"./fesm2022/daffodil-category-driver-testing.mjs"},"./state/testing":{"types":"./state/testing/index.d.ts","default":"./fesm2022/daffodil-category-state-testing.mjs"},"./driver/magento/testing":{"types":"./driver/magento/testing/index.d.ts","default":"./fesm2022/daffodil-category-driver-magento-testing.mjs"}},"sideEffects":false,"dependencies":{"tslib":"^2.3.0"}}
+{"name":"@daffodil/category","nx":{"targets":{"build":{"outputs":["{workspaceRoot}/dist/category"]}}},"version":"0.89.0","description":"An ecommerce categories package that has multi-platform support and state management features.","repository":{"type":"git","url":"https://github.com/graycoreio/daffodil"},"author":"Graycore LLC","license":"MIT","bugs":{"url":"https://github.com/graycoreio/daffodil/issues"},"publishConfig":{"directory":"../../dist/category"},"homepage":"https://github.com/graycoreio/daffodil","peerDependencies":{"@angular/common":"^20.0.0","@angular/core":"^20.0.0","@daffodil/core":"0.89.0","@daffodil/product":"0.89.0","@ngrx/effects":"^20.0.0","@ngrx/entity":"^20.0.0","@ngrx/store":"^20.0.0","rxjs":"7.8.1"},"optionalDependencies":{"@apollo/client":"^3.12.6","@daffodil/driver":"0.89.0","angular-in-memory-web-api":"^0.20.0","apollo-angular":"^11.0.0","@faker-js/faker":"^9.8.0"},"module":"fesm2022/daffodil-category.mjs","typings":"index.d.ts","exports":{"./package.json":{"default":"./package.json"},".":{"types":"./index.d.ts","default":"./fesm2022/daffodil-category.mjs"},"./driver":{"types":"./driver/index.d.ts","default":"./fesm2022/daffodil-category-driver.mjs"},"./routing":{"types":"./routing/index.d.ts","default":"./fesm2022/daffodil-category-routing.mjs"},"./state":{"types":"./state/index.d.ts","default":"./fesm2022/daffodil-category-state.mjs"},"./testing":{"types":"./testing/index.d.ts","default":"./fesm2022/daffodil-category-testing.mjs"},"./driver/in-memory":{"types":"./driver/in-memory/index.d.ts","default":"./fesm2022/daffodil-category-driver-in-memory.mjs"},"./driver/magento":{"types":"./driver/magento/index.d.ts","default":"./fesm2022/daffodil-category-driver-magento.mjs"},"./driver/testing":{"types":"./driver/testing/index.d.ts","default":"./fesm2022/daffodil-category-driver-testing.mjs"},"./state/testing":{"types":"./state/testing/index.d.ts","default":"./fesm2022/daffodil-category-state-testing.mjs"},"./driver/magento/testing":{"types":"./driver/magento/testing/index.d.ts","default":"./fesm2022/daffodil-category-driver-magento-testing.mjs"}},"sideEffects":false,"dependencies":{"tslib":"^2.3.0"}}

package/routing/index.d.ts

@@ -1 +1,68 @@
-export * from './public_api';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { Store, ActionsSubject } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { DaffCategoryReducersState } from '@daffodil/category/state';
+import * as i0 from '@angular/core';
+import { DaffCollectionRequest } from '@daffodil/core';
+import { DaffCategoryUrlRequest } from '@daffodil/category';
+import { DaffRoutingUriNormalizer } from '@daffodil/core/routing';
+import * as i1 from '@daffodil/product/routing';
+import * as i2 from '@ngrx/effects';
+
+type DaffCategoryRoutingRequestBuilder<T extends DaffCollectionRequest = DaffCollectionRequest> = (route: ActivatedRouteSnapshot) => T;
+declare const DAFF_CATEGORY_ROUTING_OPTIONS_BUILDERS: i0.InjectionToken<DaffCategoryRoutingRequestBuilder<DaffCollectionRequest>[]>;
+declare const provideDaffCategoryRoutingRequestBuilders: <R extends DaffCategoryRoutingRequestBuilder<DaffCollectionRequest> = DaffCategoryRoutingRequestBuilder<DaffCollectionRequest>>(...values: R[]) => Array<i0.ValueProvider>;
+
+/**
+ * Resolves category data for category pages, and will only resolve the url after a category request succeeds or fails. This resolver expects a url
+ * of the form `some/url/{id}` where `{id}` is the category id.
+ */
+declare class DaffCategoryPageIdResolver {
+    private platformId;
+    private requestBuilder;
+    private store;
+    private dispatcher;
+    constructor(platformId: string, requestBuilder: DaffCategoryRoutingRequestBuilder, store: Store<DaffCategoryReducersState>, dispatcher: ActionsSubject);
+    resolve(route: ActivatedRouteSnapshot): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryPageIdResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCategoryPageIdResolver>;
+}
+
+declare class DaffCategoryRoutingUrlRequestBuilder {
+    private requestBuilder;
+    private urlNormalizer;
+    constructor(requestBuilder: DaffCategoryRoutingRequestBuilder, urlNormalizer: DaffRoutingUriNormalizer);
+    /**
+     * Builds a category URL request from the provided route and router state that
+     * is suitable for passing to {@link DaffCategoryPageLoadByUrl}.
+     */
+    build(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): DaffCategoryUrlRequest;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryRoutingUrlRequestBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCategoryRoutingUrlRequestBuilder>;
+}
+
+/**
+ * Resolves category data for category pages, and will only resolve the url
+ * after a category request succeeds or fails. This resolver will take a full
+ * a url of the form `some/url.html(secondary:outlet)?query=param#fragment` and attempt to resolve a product from it.
+ * Assumes that the URL to be resolved is the primary outlet.
+ */
+declare class DaffCategoryPageUrlResolver {
+    private platformId;
+    private store;
+    private dispatcher;
+    private requestBuilder;
+    constructor(platformId: string, store: Store<DaffCategoryReducersState>, dispatcher: ActionsSubject, requestBuilder: DaffCategoryRoutingUrlRequestBuilder);
+    resolve(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryPageUrlResolver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCategoryPageUrlResolver>;
+}
+
+declare class DaffCategoryRoutingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryRoutingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffCategoryRoutingModule, never, [typeof i1.DaffProductRoutingModule, typeof i2.EffectsFeatureModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DaffCategoryRoutingModule>;
+}
+
+export { DAFF_CATEGORY_ROUTING_OPTIONS_BUILDERS, DaffCategoryPageIdResolver, DaffCategoryPageUrlResolver, DaffCategoryRoutingModule, DaffCategoryRoutingUrlRequestBuilder, provideDaffCategoryRoutingRequestBuilders };
+export type { DaffCategoryRoutingRequestBuilder };

package/state/index.d.ts

@@ -1 +1,456 @@
-export * from './public_api';
+import * as i0 from '@angular/core';
+import * as _ngrx_store from '@ngrx/store';
+import { ActionReducerMap, Action, ActionReducer, MemoizedSelector, Store } from '@ngrx/store';
+import * as i2 from '@ngrx/effects';
+import * as i3 from '@daffodil/product/state';
+import { DaffProductStateRootSlice } from '@daffodil/product/state';
+import * as _daffodil_category from '@daffodil/category';
+import { DaffCategory, DaffCategoryPageMetadata, DaffGenericCategory, DaffCategoryRequest, DaffCategoryIdRequest, DaffCategoryUrlRequest, DaffGetCategoryResponse } from '@daffodil/category';
+import { DaffProduct } from '@daffodil/product';
+import { EntityState, Dictionary } from '@ngrx/entity';
+import { DaffOperationState, DaffStateError, DaffOperationStateSelectors, DaffCollectionMemoizedSelectors, DaffOperationStateFacadeInterface, DaffCollectionFacade, DaffCollectionFacadeInterface, daffTransformErrorToStateError } from '@daffodil/core/state';
+import { DaffFilterRequest, DaffFilterToggleRequest } from '@daffodil/core';
+import { Observable } from 'rxjs';
+
+/**
+ * A module that provides default reducers and effects for the category redux state.
+ */
+declare class DaffCategoryStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffCategoryStateModule, never, [typeof _ngrx_store.StoreFeatureModule, typeof i2.EffectsFeatureModule, typeof i3.DaffProductStateModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DaffCategoryStateModule>;
+}
+
+/**
+ * A module that provides injectable reducers into product state.
+ */
+declare class DaffCategoryProductStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryProductStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffCategoryProductStateModule, never, [typeof i3.DaffProductStateModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DaffCategoryProductStateModule>;
+}
+
+interface DaffCategoryReducerState extends DaffOperationState {
+    /**
+     * The ID of the currently loaded category.
+     */
+    id: DaffCategory['id'];
+}
+
+/**
+ * The key for the slice of category related redux state in the global redux state object.
+ */
+declare const DAFF_CATEGORY_STORE_FEATURE_KEY = "daffCategory";
+
+type DaffCategoryPageMetadataReducerState = DaffCategoryPageMetadata;
+
+/**
+ * An interface to describe all of category state.
+ */
+interface DaffCategoryReducersState<V extends DaffGenericCategory<V> = DaffCategory> {
+    /**
+     * Redux state for category page metadata, category loading state, and errors associated with loading a category.
+     */
+    category: DaffCategoryReducerState;
+    /**
+     * Redux state for category entities.
+     */
+    categoryEntities: EntityState<V>;
+    /**
+     * The product collection metadata for the category page.
+     */
+    pageMetadata: DaffCategoryPageMetadataReducerState;
+}
+interface DaffCategoryStateRootSlice<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct> extends DaffProductStateRootSlice<W> {
+    [DAFF_CATEGORY_STORE_FEATURE_KEY]: DaffCategoryReducersState<V>;
+}
+
+/**
+ * All daffodil defined category reducers.
+ */
+declare const daffCategoryReducers: ActionReducerMap<DaffCategoryReducersState>;
+
+/**
+ * The possible types of category page filter actions.
+ */
+declare enum DaffCategoryPageProductCollectionActionTypes {
+    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",
+    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"
+}
+/**
+ * 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.
+ */
+declare class DaffCategoryPageReplaceFilters implements Action {
+    filters: DaffFilterRequest[];
+    readonly type = DaffCategoryPageProductCollectionActionTypes.CategoryPageReplaceFiltersAction;
+    constructor(filters: DaffFilterRequest[]);
+}
+/**
+ * An action for applying the specified filters for the current category.
+ *
+ * @param filters - Filters to be applied to the current category.
+ */
+declare class DaffCategoryPageApplyFilters implements Action {
+    filters: DaffFilterRequest[];
+    readonly type = DaffCategoryPageProductCollectionActionTypes.CategoryPageApplyFiltersAction;
+    constructor(filters: DaffFilterRequest[]);
+}
+/**
+ * An action for removing the specified filters for the current category.
+ *
+ * @param filters - Filters to be removed from the current category.
+ */
+declare class DaffCategoryPageRemoveFilters implements Action {
+    filters: DaffFilterRequest[];
+    readonly type = DaffCategoryPageProductCollectionActionTypes.CategoryPageRemoveFiltersAction;
+    constructor(filters: DaffFilterRequest[]);
+}
+/**
+ * An action for removing all the filters for the current category.
+ */
+declare class DaffCategoryPageClearFilters implements Action {
+    readonly type = DaffCategoryPageProductCollectionActionTypes.CategoryPageClearFiltersAction;
+}
+/**
+ * An action for toggling a filters for the current category.
+ *
+ * @param filter - Filter to be toggled on the current category.
+ */
+declare class DaffCategoryPageToggleFilter implements Action {
+    filter: DaffFilterToggleRequest;
+    readonly type = DaffCategoryPageProductCollectionActionTypes.CategoryPageToggleFilterAction;
+    constructor(filter: DaffFilterToggleRequest);
+}
+/**
+ * An action for changing the number of products shown on each page for the selected category.
+ *
+ * @param pageSize - The number of products per page.
+ */
+declare class DaffCategoryPageChangePageSize implements Action {
+    pageSize: number;
+    readonly type = DaffCategoryPageProductCollectionActionTypes.CategoryPageChangeSizeAction;
+    constructor(pageSize: number);
+}
+/**
+ * An action for changing the current page of products for the selected category.
+ *
+ * @param currentPage - The current page of products for the selected category.
+ */
+declare class DaffCategoryPageChangeCurrentPage implements Action {
+    currentPage: number;
+    readonly type = DaffCategoryPageProductCollectionActionTypes.CategoryPageChangeCurrentPageAction;
+    constructor(currentPage: number);
+}
+/**
+ * An action for changing the sorting option for the selected category.
+ *
+ * @param sort - The sort option to be applied.
+ */
+declare class DaffCategoryPageChangeSortingOption implements Action {
+    sort: {
+        option: DaffCategoryRequest['appliedSortOption'];
+        direction: DaffCategoryRequest['appliedSortDirection'];
+    };
+    readonly type = DaffCategoryPageProductCollectionActionTypes.CategoryPageChangeSortingOptionAction;
+    constructor(sort: {
+        option: DaffCategoryRequest['appliedSortOption'];
+        direction: DaffCategoryRequest['appliedSortDirection'];
+    });
+}
+type DaffCategoryPageProductCollectionActions = DaffCategoryPageReplaceFilters | DaffCategoryPageApplyFilters | DaffCategoryPageRemoveFilters | DaffCategoryPageClearFilters | DaffCategoryPageToggleFilter | DaffCategoryPageChangePageSize | DaffCategoryPageChangeCurrentPage | DaffCategoryPageChangeSortingOption;
+
+/**
+ * The possible types of category page actions.
+ */
+declare enum 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"
+}
+/**
+ * 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
+ */
+declare class DaffCategoryPageLoad implements Action {
+    request: DaffCategoryIdRequest;
+    readonly type = DaffCategoryPageActionTypes.CategoryPageLoadAction;
+    constructor(request: DaffCategoryIdRequest);
+}
+/**
+ * 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
+ */
+declare class DaffCategoryPageLoadByUrl implements Action {
+    request: DaffCategoryUrlRequest;
+    readonly type = DaffCategoryPageActionTypes.CategoryPageLoadByUrlAction;
+    constructor(request: DaffCategoryUrlRequest);
+}
+/**
+ * An action triggered upon a successful category page request.
+ *
+ * @param response - DaffGetCategoryResponse object
+ */
+declare class DaffCategoryPageLoadSuccess<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct> implements Action {
+    response: DaffGetCategoryResponse<V, W>;
+    readonly type = DaffCategoryPageActionTypes.CategoryPageLoadSuccessAction;
+    constructor(response: DaffGetCategoryResponse<V, W>);
+}
+/**
+ * An action triggered upon a failed category page request.
+ *
+ * @param errorMessage - an error message
+ */
+declare class DaffCategoryPageLoadFailure implements Action {
+    errorMessage: DaffStateError;
+    readonly type = DaffCategoryPageActionTypes.CategoryPageLoadFailureAction;
+    constructor(errorMessage: DaffStateError);
+}
+type DaffCategoryPageActions<U extends DaffGenericCategory<U> = DaffCategory, W extends DaffProduct = DaffProduct> = DaffCategoryPageLoad | DaffCategoryPageLoadByUrl | DaffCategoryPageLoadSuccess<U, W> | DaffCategoryPageLoadFailure;
+
+/**
+ * The possible types of category actions.
+ */
+declare enum DaffCategoryActionTypes {
+    CategoryLoadAction = "[@daffodil/category] Category Load Action",
+    CategoryLoadSuccessAction = "[@daffodil/category] Category Load Success Action",
+    CategoryLoadFailureAction = "[@daffodil/category] Category Load Failure Action"
+}
+/**
+ * An action triggered to initialize a category load request.
+ *
+ * @param request - DaffCategoryRequest object
+ */
+declare class DaffCategoryLoad implements Action {
+    request: DaffCategoryIdRequest;
+    readonly type = DaffCategoryActionTypes.CategoryLoadAction;
+    constructor(request: DaffCategoryIdRequest);
+}
+/**
+ * An action triggered upon a successful category request.
+ *
+ * @param response - DaffGetCategoryResponse object
+ */
+declare class DaffCategoryLoadSuccess<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct> implements Action {
+    response: DaffGetCategoryResponse<V, W>;
+    readonly type = DaffCategoryActionTypes.CategoryLoadSuccessAction;
+    constructor(response: DaffGetCategoryResponse<V, W>);
+}
+/**
+ * An action triggered upon a failed category request.
+ *
+ * @param errorMessage - an error message
+ */
+declare class DaffCategoryLoadFailure implements Action {
+    errorMessage: DaffStateError;
+    readonly type = DaffCategoryActionTypes.CategoryLoadFailureAction;
+    constructor(errorMessage: DaffStateError);
+}
+type DaffCategoryActions<U extends DaffGenericCategory<U> = DaffCategory, W extends DaffProduct = DaffProduct> = DaffCategoryLoad | DaffCategoryLoadSuccess<U, W> | DaffCategoryLoadFailure;
+
+/**
+ * Returns the state for category data except for category entities.
+ */
+declare function daffCategoryReducer<U extends DaffGenericCategory<U>, W extends DaffProduct>(state: DaffCategoryReducerState, action: DaffCategoryActions<U, W> | DaffCategoryPageActions<U, W> | DaffCategoryPageProductCollectionActions): DaffCategoryReducerState;
+
+/**
+ * Returns the state for category data except for category entities.
+ */
+declare function daffCategoryPageMetadataReducer<U extends DaffGenericCategory<U>, W extends DaffProduct>(state: _daffodil_category.DaffCategoryPageMetadata, action: DaffCategoryActions<U, W> | DaffCategoryPageActions<U, W> | DaffCategoryPageProductCollectionActions): DaffCategoryPageMetadataReducerState;
+
+/**
+ * A reducer function to store category entities from DaffCategoryLoadSuccess and DaffCategoryPageLoadSuccess actions.
+ */
+declare function daffCategoryEntitiesReducer<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct>(state: EntityState<V>, action: DaffCategoryActions<V, W> | DaffCategoryPageActions<V, W>): EntityState<V>;
+
+declare const DAFF_CATEGORY_EXTRA_REDUCERS: i0.InjectionToken<ActionReducer<DaffCategoryReducersState<_daffodil_category.DaffCategory>, _ngrx_store.Action<string>>[]>;
+declare const daffCategoryProvideExtraReducers: <R extends ActionReducer<DaffCategoryReducersState<_daffodil_category.DaffCategory>, _ngrx_store.Action<string>> = ActionReducer<DaffCategoryReducersState<_daffodil_category.DaffCategory>, _ngrx_store.Action<string>>>(...values: R[]) => Array<i0.ValueProvider>;
+
+/**
+ * An interface to describe all selectors related to category ngrx entities state.
+ */
+interface DaffCategoryEntitiesMemoizedSelectors<V extends DaffGenericCategory<V> = DaffCategory> {
+    /**
+     * Selects ngrx category entities state.
+     */
+    selectCategoryEntitiesState: MemoizedSelector<DaffCategoryStateRootSlice<V>, EntityState<V>>;
+    /**
+     * Selects the ids of all categories in state.
+     */
+    selectCategoryIds: MemoizedSelector<DaffCategoryStateRootSlice<V>, string[] | number[]>;
+    /**
+     * Selects all categories in state as a dictionary.
+     */
+    selectCategoryEntities: MemoizedSelector<DaffCategoryStateRootSlice<V>, Dictionary<V>>;
+    /**
+     * Selects all categories in state as an array.
+     */
+    selectAllCategories: MemoizedSelector<DaffCategoryStateRootSlice<V>, V[]>;
+    /**
+     * Selects the total number of categories in state.
+     */
+    selectCategoryTotal: MemoizedSelector<DaffCategoryStateRootSlice<V>, number>;
+}
+
+/**
+ * An interface for the entire category feature state.
+ */
+interface DaffCategoryFeatureMemoizedSelectors<V extends DaffGenericCategory<V> = DaffCategory> {
+    selectCategoryFeatureState: MemoizedSelector<DaffCategoryStateRootSlice<V>, DaffCategoryReducersState<V>>;
+}
+
+/**
+ * An interface to describe all selectors related to the category page metadata, category loading, and errors.
+ */
+interface DaffCategoryPageMemoizedSelectors<V extends DaffGenericCategory<V> = DaffCategory> extends DaffOperationStateSelectors<DaffCategoryStateRootSlice<V>, DaffCategoryReducerState> {
+    /**
+     * Selects all state related to the category page metadata, category loading, and errors.
+     */
+    selectCategoryState: MemoizedSelector<DaffCategoryStateRootSlice<V>, DaffCategoryReducerState>;
+    /**
+     * Selects the ids of all products in the current category page.
+     */
+    selectCategoryPageProductIds: MemoizedSelector<DaffCategoryStateRootSlice<V>, DaffCategoryPageMetadata['ids']>;
+    /**
+     * Selects whether the category page has no products.
+     */
+    selectIsCategoryPageEmpty: MemoizedSelector<DaffCategoryStateRootSlice<V>, boolean>;
+    /**
+     * Selects the id of the current category.
+     */
+    selectCurrentCategoryId: MemoizedSelector<DaffCategoryStateRootSlice<V>, DaffCategoryPageMetadata['id']>;
+}
+
+type DaffCategoryPageProductCollectionSelectors = DaffCollectionMemoizedSelectors<DaffCategoryStateRootSlice, DaffCategoryPageMetadata>;
+
+/**
+ * An interface for selectors that combine category metadata and category entities selectors.
+ */
+interface DaffCategoryMemoizedSelectors<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct> extends DaffCategoryFeatureMemoizedSelectors<V>, DaffCategoryPageMemoizedSelectors<V>, DaffCategoryPageProductCollectionSelectors, DaffCategoryEntitiesMemoizedSelectors<V> {
+    /**
+     * Selects the current category
+     */
+    selectCurrentCategory: MemoizedSelector<DaffCategoryStateRootSlice<V>, V>;
+    /**
+     * Selects the products of the current category.
+     */
+    selectCategoryPageProducts: MemoizedSelector<DaffCategoryStateRootSlice<V, W>, W[]>;
+    /**
+     * Selects a category by id.
+     *
+     * @param categoryId a category id.
+     */
+    selectCategory: (categoryId: V['id']) => MemoizedSelector<DaffCategoryStateRootSlice<V>, V>;
+    /**
+     * Selects products by category id.
+     *
+     * @param categoryId a category id.
+     */
+    selectProductsByCategory: (categoryId: V['id']) => MemoizedSelector<DaffCategoryStateRootSlice<V, W>, W[]>;
+    /**
+     * Selects the total number of products in a category.
+     *
+     * @param categoryId a category id.
+     */
+    selectTotalProductsByCategory: (categoryId: V['id']) => MemoizedSelector<DaffCategoryStateRootSlice<V>, number>;
+}
+/**
+ * A function that returns all combinatoric category selectors.
+ */
+declare const getDaffCategorySelectors: <V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct>() => DaffCategoryMemoizedSelectors<V, W>;
+
+/**
+ * A facade for interacting with the category state.
+ * This facade exposes many parts of the state for easy access and allows dispatching of actions.
+ */
+interface DaffCategoryFacadeInterface<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct> extends DaffOperationStateFacadeInterface<DaffCategoryReducerState> {
+    /**
+     * The currently selected category.
+     */
+    category$: Observable<V>;
+    /**
+     * Products of the current category.
+     */
+    products$: Observable<W[]>;
+    /**
+     * Is the category page empty of products.
+     */
+    isCategoryEmpty$: Observable<boolean>;
+    /**
+     * Get a category by the provided Id.
+     *
+     * @param id
+     */
+    getCategoryById(id: V['id']): Observable<V>;
+    /**
+     * Get products by a category Id.
+     *
+     * @param categoryId
+     */
+    getProductsByCategory(categoryId: V['id']): Observable<W[]>;
+    /**
+     * Get products by a category Id.
+     *
+     * @param categoryId
+     */
+    getTotalProductsByCategory(categoryId: V['id']): Observable<number>;
+}
+
+/**
+ * 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
+ */
+declare class DaffCategoryFacade<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct> implements DaffCategoryFacadeInterface<V, W> {
+    private store;
+    private categorySelectors;
+    category$: Observable<V>;
+    loadingState$: Observable<DaffCategoryReducerState['daffState']>;
+    loading$: Observable<boolean>;
+    mutating$: Observable<boolean>;
+    resolving$: Observable<boolean>;
+    products$: Observable<W[]>;
+    errors$: Observable<DaffStateError[]>;
+    hasErrors$: Observable<boolean>;
+    isCategoryEmpty$: Observable<boolean>;
+    getCategoryById(id: V['id']): Observable<V>;
+    getProductsByCategory(categoryId: V['id']): Observable<W[]>;
+    getTotalProductsByCategory(categoryId: V['id']): Observable<number>;
+    constructor(store: Store<DaffCategoryStateRootSlice<V, W>>);
+    /**
+     * Dispatches the given action.
+     *
+     * @param action action to dispatch.
+     */
+    dispatch(action: Action): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryFacade<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCategoryFacade<any, any>>;
+}
+
+declare class DaffCategoryProductCollectionFacade extends DaffCollectionFacade<DaffCategoryStateRootSlice> implements DaffCollectionFacadeInterface {
+    constructor(store: Store<DaffCategoryStateRootSlice>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryProductCollectionFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCategoryProductCollectionFacade>;
+}
+
+declare const DAFF_CATEGORY_ERROR_MATCHER: i0.InjectionToken<typeof daffTransformErrorToStateError>;
+declare const provideDaffCategoryErrorMatcher: <R extends typeof daffTransformErrorToStateError = typeof daffTransformErrorToStateError>(value: R) => i0.ValueProvider;
+
+export { DAFF_CATEGORY_ERROR_MATCHER, DAFF_CATEGORY_EXTRA_REDUCERS, DAFF_CATEGORY_STORE_FEATURE_KEY, DaffCategoryActionTypes, DaffCategoryFacade, DaffCategoryLoad, DaffCategoryLoadFailure, DaffCategoryLoadSuccess, DaffCategoryPageActionTypes, DaffCategoryPageApplyFilters, DaffCategoryPageChangeCurrentPage, DaffCategoryPageChangePageSize, DaffCategoryPageChangeSortingOption, DaffCategoryPageClearFilters, DaffCategoryPageLoad, DaffCategoryPageLoadByUrl, DaffCategoryPageLoadFailure, DaffCategoryPageLoadSuccess, DaffCategoryPageProductCollectionActionTypes, DaffCategoryPageRemoveFilters, DaffCategoryPageReplaceFilters, DaffCategoryPageToggleFilter, DaffCategoryProductCollectionFacade, DaffCategoryProductStateModule, DaffCategoryStateModule, daffCategoryEntitiesReducer, daffCategoryPageMetadataReducer, daffCategoryProvideExtraReducers, daffCategoryReducer, daffCategoryReducers, getDaffCategorySelectors, provideDaffCategoryErrorMatcher };
+export type { DaffCategoryActions, DaffCategoryFacadeInterface, DaffCategoryMemoizedSelectors, DaffCategoryPageActions, DaffCategoryPageMetadataReducerState, DaffCategoryPageProductCollectionActions, DaffCategoryReducerState, DaffCategoryReducersState, DaffCategoryStateRootSlice };

package/state/testing/index.d.ts

@@ -1 +1,41 @@
-export * from './public_api';
+import * as i0 from '@angular/core';
+import { Action } from '@ngrx/store';
+import { BehaviorSubject } from 'rxjs';
+import { DaffCategory } from '@daffodil/category';
+import { DaffCategoryFacadeInterface, DaffCategoryReducerState } from '@daffodil/category/state';
+import { DaffStateError } from '@daffodil/core/state';
+import { DaffProduct } from '@daffodil/product';
+
+/**
+ * A module that mocks out the {@link DaffCategoryFacade} with {@link MockDaffCategoryFacade} for testing environments.
+ */
+declare class DaffCategoryStateTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryStateTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffCategoryStateTestingModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DaffCategoryStateTestingModule>;
+}
+
+/**
+ * Can be used to mock out the {@link DaffCategoryFacade} in testing environments.
+ *
+ * @inheritdoc
+ */
+declare class MockDaffCategoryFacade implements DaffCategoryFacadeInterface {
+    category$: BehaviorSubject<DaffCategory>;
+    loadingState$: BehaviorSubject<DaffCategoryReducerState['daffState']>;
+    loading$: BehaviorSubject<boolean>;
+    mutating$: BehaviorSubject<boolean>;
+    resolving$: BehaviorSubject<boolean>;
+    hasErrors$: BehaviorSubject<boolean>;
+    products$: BehaviorSubject<DaffProduct[]>;
+    errors$: BehaviorSubject<DaffStateError[]>;
+    isCategoryEmpty$: BehaviorSubject<boolean>;
+    getCategoryById(id: DaffCategory['id']): BehaviorSubject<DaffCategory>;
+    getProductsByCategory(categoryId: DaffCategory['id']): BehaviorSubject<DaffProduct[]>;
+    getTotalProductsByCategory(categoryId: DaffCategory['id']): BehaviorSubject<number>;
+    dispatch(action: Action): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MockDaffCategoryFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MockDaffCategoryFacade>;
+}
+
+export { DaffCategoryStateTestingModule, MockDaffCategoryFacade };

package/testing/index.d.ts

@@ -1 +1,71 @@
-export * from './public_api';
+import * as _daffodil_category from '@daffodil/category';
+import { DaffCategoryBreadcrumb, DaffCategory, DaffCategoryPageMetadata } from '@daffodil/category';
+import { DaffModelFactory, MockCollectionMetadata, DaffNumericallyPaginableFactory, DaffSortableFactory, DaffFilterFactory } from '@daffodil/core/testing';
+import { DaffProduct } from '@daffodil/product';
+import * as i0 from '@angular/core';
+
+declare class MockCategoryBreadcrumb implements DaffCategoryBreadcrumb {
+    id: string;
+    name: string;
+    level: number;
+    url: string;
+}
+/**
+ * A factory for creating a {@link DaffCategoryBreadcrumb}.
+ */
+declare class DaffCategoryBreadcrumbFactory extends DaffModelFactory<DaffCategoryBreadcrumb, typeof MockCategoryBreadcrumb> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryBreadcrumbFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCategoryBreadcrumbFactory>;
+}
+
+declare class MockCategory implements DaffCategory {
+    protected breadcrumbFactory: DaffCategoryBreadcrumbFactory;
+    id: string;
+    url: string;
+    canonicalUrl: string;
+    name: string;
+    description: string;
+    meta_title: string;
+    meta_description: string;
+    breadcrumbs: _daffodil_category.DaffCategoryBreadcrumb[];
+    children_count: number;
+    total_products: number;
+    product_ids: string[];
+    constructor(breadcrumbFactory: DaffCategoryBreadcrumbFactory);
+}
+/**
+ * A factory for creating a {@link DaffCategory}.
+ */
+declare class DaffCategoryFactory extends DaffModelFactory<DaffCategory, typeof MockCategory> {
+    constructor(breadcrumbFactory: DaffCategoryBreadcrumbFactory);
+    /**
+     * Creates a category tree of specified depth, optionally using the passed product IDs.
+     * This is very useful for creating a category tree that closely resembles those found in the wild.
+     * Each child has a minimum of half of the parent's products.
+     */
+    createTree(depth: number, productIds?: DaffProduct['id'][], partial?: Partial<DaffCategory>): DaffCategory;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCategoryFactory>;
+}
+
+/**
+ * A helper function to verify that a model is a Category.
+ *
+ * @param category
+ */
+declare function isCategory(category: DaffCategory): boolean;
+
+declare class MockCategoryPageMetadata extends MockCollectionMetadata implements DaffCategoryPageMetadata {
+    id: string;
+}
+/**
+ * A factory for creating {@link DaffCategoryPageMetadata}.
+ */
+declare class DaffCategoryPageMetadataFactory extends DaffModelFactory<DaffCategoryPageMetadata> {
+    constructor(pageInfoFactory: DaffNumericallyPaginableFactory, sortFieldsFactory: DaffSortableFactory, filterFactory: DaffFilterFactory);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryPageMetadataFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCategoryPageMetadataFactory>;
+}
+
+export { DaffCategoryBreadcrumbFactory, DaffCategoryFactory, DaffCategoryPageMetadataFactory, MockCategory, MockCategoryBreadcrumb, MockCategoryPageMetadata, isCategory };