@daffodil/category 0.53.1 → 0.56.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daffodil/category",
-  "version": "0.53.1",
+  "version": "0.56.0",
   "description": "An ecommerce categories package that has multi-platform support and state management features.",
   "repository": {
     "type": "git",
@@ -18,8 +18,8 @@
   "peerDependencies": {
     "@angular/common": "^13.0.0",
     "@angular/core": "^13.0.0",
-    "@daffodil/core": "0.53.1",
-    "@daffodil/product": "0.53.1",
+    "@daffodil/core": "0.56.0",
+    "@daffodil/product": "0.56.0",
     "@ngrx/effects": "^13.0.0",
     "@ngrx/entity": "^13.0.0",
     "@ngrx/store": "^13.0.0",
@@ -27,7 +27,7 @@
   },
   "optionalDependencies": {
     "@apollo/client": "^3.0.0",
-    "@daffodil/driver": "0.53.1",
+    "@daffodil/driver": "0.56.0",
     "angular-in-memory-web-api": "^0.13.0",
     "apollo-angular": "^3.0.1",
     "@faker-js/faker": "^7.6.0"

package/routing/public_api.d.ts

@@ -1,3 +1,4 @@
 export * from './resolvers/public_api';
 export * from './injection-tokens/public_api';
+export * from './services/public_api';
 export { DaffCategoryRoutingModule } from './module';

package/routing/resolvers/category-page-url/category-page-url.resolver.d.ts

@@ -2,8 +2,7 @@ import { ActivatedRouteSnapshot, Resolve, RouterStateSnapshot } from '@angular/r
 import { ActionsSubject, Store } from '@ngrx/store';
 import { Observable } from 'rxjs';
 import { DaffCategoryReducersState } from '@daffodil/category/state';
-import { DaffRoutingUriNormalizer } from '@daffodil/core/routing';
-import { DaffCategoryRoutingRequestBuilder } from '../../injection-tokens/public_api';
+import { DaffCategoryRoutingUrlRequestBuilder } from '../../services/public_api';
 import * as i0 from "@angular/core";
 /**
  * Resolves category data for category pages, and will only resolve the url
@@ -13,11 +12,10 @@ import * as i0 from "@angular/core";
  */
 export declare class DaffCategoryPageUrlResolver implements Resolve<Observable<boolean>> {
     private platformId;
-    private requestBuilder;
     private store;
     private dispatcher;
-    private urlNormalizer;
-    constructor(platformId: string, requestBuilder: DaffCategoryRoutingRequestBuilder, store: Store<DaffCategoryReducersState>, dispatcher: ActionsSubject, urlNormalizer: DaffRoutingUriNormalizer);
+    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>;

package/routing/services/public_api.d.ts

@@ -0,0 +1 @@
+export { DaffCategoryRoutingUrlRequestBuilder } from './url-request-builder.service';

package/routing/services/url-request-builder.service.d.ts

@@ -0,0 +1,17 @@
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { DaffCategoryUrlRequest } from '@daffodil/category';
+import { DaffRoutingUriNormalizer } from '@daffodil/core/routing';
+import { DaffCategoryRoutingRequestBuilder } from '../injection-tokens/public_api';
+import * as i0 from "@angular/core";
+export 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>;
+}

package/state/facades/page/category-facade.interface.d.ts

@@ -1,50 +1,21 @@
-import { Action } from '@ngrx/store';
 import { Observable } from 'rxjs';
 import { DaffGenericCategory, DaffCategory } from '@daffodil/category';
-import { DaffStoreFacade, DaffStateError } from '@daffodil/core/state';
+import { DaffOperationStateFacadeInterface } from '@daffodil/core/state';
 import { DaffProduct } from '@daffodil/product';
 import { DaffCategoryReducerState } from '../../reducers/category/category-reducer-state.interface';
 /**
  * A facade for interacting with the category state.
  * This facade exposes many parts of the state for easy access and allows dispatching of actions.
  */
-export interface DaffCategoryFacadeInterface<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct> extends DaffStoreFacade<Action> {
+export interface DaffCategoryFacadeInterface<V extends DaffGenericCategory<V> = DaffCategory, W extends DaffProduct = DaffProduct> extends DaffOperationStateFacadeInterface<DaffCategoryReducerState> {
     /**
      * The currently selected category.
      */
     category$: Observable<V>;
-    /**
-     * The loading state of the current category page.
-     */
-    pageLoadingState$: Observable<DaffCategoryReducerState['daffState']>;
-    /**
-     * Whether the current category is in a mutating state.
-     */
-    isPageMutating$: Observable<boolean>;
-    /**
-     * Whether the current category is in a resolving state.
-     */
-    isPageResolving$: Observable<boolean>;
     /**
      * Products of the current category.
      */
     products$: Observable<W[]>;
-    /**
-     * The loading state for retrieving a single category.
-     *
-     * @deprecated Use isPageResolving$ instead
-     */
-    categoryLoading$: Observable<boolean>;
-    /**
-     * The loading state for retrieving only the products of the category.
-     *
-     * @deprecated Use isPageResolving$ and isPageMutating$ instead
-     */
-    productsLoading$: Observable<boolean>;
-    /**
-     * Errors associated with retrieving a single category.
-     */
-    errors$: Observable<DaffStateError[]>;
     /**
      * Is the category page empty of products.
      */

package/state/facades/page/category.facade.d.ts

@@ -16,13 +16,13 @@ export declare class DaffCategoryFacade<V extends DaffGenericCategory<V> = DaffC
     private store;
     private categorySelectors;
     category$: Observable<V>;
-    pageLoadingState$: Observable<DaffCategoryReducerState['daffState']>;
-    isPageMutating$: Observable<boolean>;
-    isPageResolving$: Observable<boolean>;
+    loadingState$: Observable<DaffCategoryReducerState['daffState']>;
+    loading$: Observable<boolean>;
+    mutating$: Observable<boolean>;
+    resolving$: Observable<boolean>;
     products$: Observable<W[]>;
-    categoryLoading$: Observable<boolean>;
-    productsLoading$: Observable<boolean>;
     errors$: Observable<DaffStateError[]>;
+    hasErrors$: Observable<boolean>;
     isCategoryEmpty$: Observable<boolean>;
     getCategoryById(id: V['id']): Observable<V>;
     getProductsByCategory(categoryId: V['id']): Observable<W[]>;

package/state/product-state.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@daffodil/product/state";
+/**
+ * A module that provides injectable reducers into product state.
+ */
+export declare class DaffCategoryProductStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCategoryProductStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffCategoryProductStateModule, never, [typeof i1.DaffProductStateModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DaffCategoryProductStateModule>;
+}

package/state/public_api.d.ts

@@ -1,4 +1,5 @@
 export { DaffCategoryStateModule } from './category-state.module';
+export { DaffCategoryProductStateModule } from './product-state.module';
 export * from './selectors/category.selector';
 export * from './reducers/public_api';
 export * from './facades/public_api';

package/state/reducers/category/category-reducer-state.interface.d.ts

@@ -1,18 +1,6 @@
 import { DaffCategory } from '@daffodil/category';
-import { DaffStateError, DaffMutableLoadingState, DaffStateable } from '@daffodil/core/state';
-export interface DaffCategoryReducerState extends DaffStateable<DaffMutableLoadingState> {
-    /**
-     * @deprecated
-     */
-    categoryLoading: boolean;
-    /**
-     * @deprecated
-     */
-    productsLoading: boolean;
-    /**
-     * Errors associated with loading categories.
-     */
-    errors: DaffStateError[];
+import { DaffOperationState } from '@daffodil/core/state';
+export interface DaffCategoryReducerState extends DaffOperationState {
     /**
      * The ID of the currently loaded category.
      */

package/state/reducers/product-reducers.d.ts

@@ -0,0 +1,3 @@
+import { ActionReducerMap } from '@ngrx/store';
+import { DaffProductReducersState } from '@daffodil/product/state';
+export declare const daffCategoryProductReducers: ActionReducerMap<DaffProductReducersState>;

package/state/reducers/product.reducer.d.ts

@@ -0,0 +1,10 @@
+import { DaffGenericCategory } from '@daffodil/category';
+import { DaffProduct } from '@daffodil/product';
+import { DaffProductReducerState } from '@daffodil/product/state';
+import { DaffCategoryPageProductCollectionActions } from '../actions/category-page-filter.actions';
+import { DaffCategoryPageActions } from '../actions/category-page.actions';
+import { DaffCategoryActions } from '../actions/category.actions';
+/**
+ * Modifies product state for category actions.
+ */
+export declare function daffCategoryProductReducer<U extends DaffGenericCategory<U>, W extends DaffProduct>(state: DaffProductReducerState, action: DaffCategoryActions<U, W> | DaffCategoryPageActions<U, W> | DaffCategoryPageProductCollectionActions): DaffProductReducerState;

package/state/selectors/category-page/category-page.selector.d.ts

@@ -1,11 +1,11 @@
 import { MemoizedSelector } from '@ngrx/store';
 import { DaffGenericCategory, DaffCategory, DaffCategoryPageMetadata } from '@daffodil/category';
-import { DaffStateError } from '@daffodil/core/state';
+import { DaffOperationStateSelectors } from '@daffodil/core/state';
 import { DaffCategoryReducerState, DaffCategoryStateRootSlice } from '../../reducers/public_api';
 /**
  * An interface to describe all selectors related to the category page metadata, category loading, and errors.
  */
-export interface DaffCategoryPageMemoizedSelectors<V extends DaffGenericCategory<V> = DaffCategory> {
+export 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.
      */
@@ -18,34 +18,10 @@ export interface DaffCategoryPageMemoizedSelectors<V extends DaffGenericCategory
      * Selects whether the category page has no products.
      */
     selectIsCategoryPageEmpty: MemoizedSelector<DaffCategoryStateRootSlice<V>, boolean>;
-    /**
-     * Selects the loading state of the current category; e.g. mutating, resolving, stable.
-     */
-    selectCategoryPageState: MemoizedSelector<DaffCategoryStateRootSlice<V>, DaffCategoryReducerState['daffState']>;
     /**
      * Selects the id of the current category.
      */
     selectCurrentCategoryId: MemoizedSelector<DaffCategoryStateRootSlice<V>, DaffCategoryPageMetadata['id']>;
-    /**
-     * @deprecated Use selectIsCategoryPageResolving instead
-     */
-    selectCategoryLoading: MemoizedSelector<DaffCategoryStateRootSlice<V>, boolean>;
-    /**
-     * @deprecated Use selectIsCategoryPageResolving and selectIsCategoryPageMutating instead
-     */
-    selectCategoryProductsLoading: MemoizedSelector<DaffCategoryStateRootSlice<V>, boolean>;
-    /**
-     * Selects all errors associated with loading a category.
-     */
-    selectCategoryErrors: MemoizedSelector<DaffCategoryStateRootSlice<V>, DaffStateError[]>;
-    /**
-     * Selects whether the current category page is mutating; e.g. when a filter is applied to it.
-     */
-    selectIsCategoryPageMutating: MemoizedSelector<DaffCategoryStateRootSlice<V>, boolean>;
-    /**
-     * Selects whether the current category is resolving; e.g. when the category first loads.
-     */
-    selectIsCategoryPageResolving: MemoizedSelector<DaffCategoryStateRootSlice<V>, boolean>;
 }
 /**
  * A function that returns all selectors related to the category page metadata, category loading, and errors.

package/state/testing/mock-category-facade.d.ts

@@ -13,12 +13,12 @@ import * as i0 from "@angular/core";
  */
 export declare class MockDaffCategoryFacade implements DaffCategoryFacadeInterface {
     category$: BehaviorSubject<DaffCategory>;
-    pageLoadingState$: BehaviorSubject<DaffCategoryReducerState['daffState']>;
-    isPageMutating$: BehaviorSubject<boolean>;
-    isPageResolving$: BehaviorSubject<boolean>;
+    loadingState$: BehaviorSubject<DaffCategoryReducerState['daffState']>;
+    loading$: BehaviorSubject<boolean>;
+    mutating$: BehaviorSubject<boolean>;
+    resolving$: BehaviorSubject<boolean>;
+    hasErrors$: BehaviorSubject<boolean>;
     products$: BehaviorSubject<DaffProduct[]>;
-    categoryLoading$: BehaviorSubject<boolean>;
-    productsLoading$: BehaviorSubject<boolean>;
     errors$: BehaviorSubject<DaffStateError[]>;
     isCategoryEmpty$: BehaviorSubject<boolean>;
     getCategoryById(id: DaffCategory['id']): BehaviorSubject<DaffCategory>;