@spartacus/storefront
Version:
Spartacus Storefront is a package that you can include in your application, which allows you to add default storefront features.
159 lines • 21.8 kB
JavaScript
import { Injectable } from '@angular/core';
import { combineLatest, using } from 'rxjs';
import { debounceTime, distinctUntilChanged, filter, map, shareReplay, tap, } from 'rxjs/operators';
import * as i0 from "@angular/core";
import * as i1 from "@spartacus/core";
import * as i2 from "@angular/router";
import * as i3 from "../../../../shared/config/view-config";
/**
* The `ProductListComponentService` is used to search products. The service is used
* on the Product Listing Page, for listing products and the facet navigation.
*
* The service exposes the product search results based on the category and search
* route parameters. The route parameters are used to query products by the help of
* the `ProductSearchService`.
*/
export class ProductListComponentService {
constructor(productSearchService, routing, activatedRoute, currencyService, languageService, router, config) {
this.productSearchService = productSearchService;
this.routing = routing;
this.activatedRoute = activatedRoute;
this.currencyService = currencyService;
this.languageService = languageService;
this.router = router;
this.config = config;
this.RELEVANCE_ALLCATEGORIES = ':relevance:allCategories:';
/**
* Emits the search results for the current search query.
*
* The `searchResults$` is _not_ concerned with querying, it only observes the
* `productSearchService.getResults()`
*/
this.searchResults$ = this.productSearchService
.getResults()
.pipe(filter((searchResult) => Object.keys(searchResult).length > 0));
/**
* Observes the route and performs a search on each route change.
*
* Context changes, such as language and currencies are also taken
* into account, so that the search is performed again.
*/
this.searchByRouting$ = combineLatest([
this.routing.getRouterState().pipe(distinctUntilChanged((x, y) => {
// router emits new value also when the anticipated `nextState` changes
// but we want to perform search only when current url changes
return x.state.url === y.state.url;
})),
...this.siteContext,
]).pipe(debounceTime(0), map(([routerState, ..._context]) => routerState.state), tap((state) => {
const criteria = this.getCriteriaFromRoute(state.params, state.queryParams);
this.search(criteria);
}));
/**
* This stream is used for the Product Listing and Product Facets.
*
* It not only emits search results, but also performs a search on every change
* of the route (i.e. route params or query params).
*
* When a user leaves the PLP route, the PLP component unsubscribes from this stream
* so no longer the search is performed on route change.
*/
this.model$ = using(() => this.searchByRouting$.subscribe(), () => this.searchResults$).pipe(shareReplay({ bufferSize: 1, refCount: true }));
}
/**
* Expose the `SearchCriteria`. The search criteria are driven by the route parameters.
*
* This search route configuration is not yet configurable
* (see https://github.com/SAP/spartacus/issues/7191).
*/
getCriteriaFromRoute(routeParams, queryParams) {
var _a;
return {
query: queryParams.query || this.getQueryFromRouteParams(routeParams),
pageSize: queryParams.pageSize || ((_a = this.config.view) === null || _a === void 0 ? void 0 : _a.defaultPageSize),
currentPage: queryParams.currentPage,
sortCode: queryParams.sortCode,
};
}
/**
* Resolves the search query from the given `ProductListRouteParams`.
*/
getQueryFromRouteParams({ query, categoryCode, brandCode, }) {
if (query) {
return query;
}
if (categoryCode) {
return this.RELEVANCE_ALLCATEGORIES + categoryCode;
}
// TODO: drop support for brands as they should be treated
// similarly as any category.
if (brandCode) {
return this.RELEVANCE_ALLCATEGORIES + brandCode;
}
}
/**
* Performs a search based on the given search criteria.
*
* The search is delegated to the `ProductSearchService`.
*/
search(criteria) {
const currentPage = criteria.currentPage;
const pageSize = criteria.pageSize;
const sort = criteria.sortCode;
this.productSearchService.search(criteria.query,
// TODO: consider dropping this complex passing of cleaned object
Object.assign({}, currentPage && { currentPage }, pageSize && { pageSize }, sort && { sort }));
}
/**
* Get items from a given page without using navigation
*/
getPageItems(pageNumber) {
this.routing
.getRouterState()
.subscribe((route) => {
const routeCriteria = this.getCriteriaFromRoute(route.state.params, route.state.queryParams);
const criteria = Object.assign(Object.assign({}, routeCriteria), { currentPage: pageNumber });
this.search(criteria);
})
.unsubscribe();
}
/**
* Sort the search results by the given sort code.
*/
sort(sortCode) {
this.route({ sortCode });
}
/**
* Routes to the next product listing page, using the given `queryParams`. The
* `queryParams` support sorting, pagination and querying.
*
* The `queryParams` are delegated to the Angular router `NavigationExtras`.
*/
route(queryParams) {
this.router.navigate([], {
queryParams,
queryParamsHandling: 'merge',
relativeTo: this.activatedRoute,
});
}
/**
* The site context is used to update the search query in case of a
* changing context. The context will typically influence the search data.
*
* We keep this private for now, as we're likely refactoring this in the next
* major version.
*/
get siteContext() {
// TODO: we should refactor this so that custom context will be taken
// into account automatically. Ideally, we drop the specific context
// from the constructor, and query a ContextService for all contexts.
return [this.languageService.getActive(), this.currencyService.getActive()];
}
}
ProductListComponentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: ProductListComponentService, deps: [{ token: i1.ProductSearchService }, { token: i1.RoutingService }, { token: i2.ActivatedRoute }, { token: i1.CurrencyService }, { token: i1.LanguageService }, { token: i2.Router }, { token: i3.ViewConfig }], target: i0.ɵɵFactoryTarget.Injectable });
ProductListComponentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: ProductListComponentService, providedIn: 'root' });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0, type: ProductListComponentService, decorators: [{
type: Injectable,
args: [{ providedIn: 'root' }]
}], ctorParameters: function () { return [{ type: i1.ProductSearchService }, { type: i1.RoutingService }, { type: i2.ActivatedRoute }, { type: i1.CurrencyService }, { type: i1.LanguageService }, { type: i2.Router }, { type: i3.ViewConfig }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"product-list-component.service.js","sourceRoot":"","sources":["../../../../../../../projects/storefrontlib/cms-components/product/product-list/container/product-list-component.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport {\n  ActivatedRouterStateSnapshot,\n  CurrencyService,\n  LanguageService,\n  ProductSearchPage,\n  ProductSearchService,\n  RouterState,\n  RoutingService,\n} from '@spartacus/core';\nimport { combineLatest, Observable, using } from 'rxjs';\nimport {\n  debounceTime,\n  distinctUntilChanged,\n  filter,\n  map,\n  shareReplay,\n  tap,\n} from 'rxjs/operators';\nimport { ProductListRouteParams, SearchCriteria } from './product-list.model';\nimport { ViewConfig } from '../../../../shared/config/view-config';\n\n/**\n * The `ProductListComponentService` is used to search products. The service is used\n * on the Product Listing Page, for listing products and the facet navigation.\n *\n * The service exposes the product search results based on the category and search\n * route parameters. The route parameters are used to query products by the help of\n * the `ProductSearchService`.\n */\n@Injectable({ providedIn: 'root' })\nexport class ProductListComponentService {\n  protected readonly RELEVANCE_ALLCATEGORIES = ':relevance:allCategories:';\n\n  constructor(\n    protected productSearchService: ProductSearchService,\n    protected routing: RoutingService,\n    protected activatedRoute: ActivatedRoute,\n    protected currencyService: CurrencyService,\n    protected languageService: LanguageService,\n    protected router: Router,\n    protected config: ViewConfig\n  ) {}\n\n  /**\n   * Emits the search results for the current search query.\n   *\n   * The `searchResults$` is _not_ concerned with querying, it only observes the\n   * `productSearchService.getResults()`\n   */\n  protected searchResults$: Observable<ProductSearchPage> =\n    this.productSearchService\n      .getResults()\n      .pipe(filter((searchResult) => Object.keys(searchResult).length > 0));\n\n  /**\n   * Observes the route and performs a search on each route change.\n   *\n   * Context changes, such as language and currencies are also taken\n   * into account, so that the search is performed again.\n   */\n  protected searchByRouting$: Observable<ActivatedRouterStateSnapshot> =\n    combineLatest([\n      this.routing.getRouterState().pipe(\n        distinctUntilChanged((x, y) => {\n          // router emits new value also when the anticipated `nextState` changes\n          // but we want to perform search only when current url changes\n          return x.state.url === y.state.url;\n        })\n      ),\n      ...this.siteContext,\n    ]).pipe(\n      debounceTime(0),\n      map(([routerState, ..._context]) => (routerState as RouterState).state),\n      tap((state: ActivatedRouterStateSnapshot) => {\n        const criteria = this.getCriteriaFromRoute(\n          state.params,\n          state.queryParams\n        );\n        this.search(criteria);\n      })\n    );\n\n  /**\n   * This stream is used for the Product Listing and Product Facets.\n   *\n   * It not only emits search results, but also performs a search on every change\n   * of the route (i.e. route params or query params).\n   *\n   * When a user leaves the PLP route, the PLP component unsubscribes from this stream\n   * so no longer the search is performed on route change.\n   */\n  readonly model$: Observable<ProductSearchPage> = using(\n    () => this.searchByRouting$.subscribe(),\n    () => this.searchResults$\n  ).pipe(shareReplay({ bufferSize: 1, refCount: true }));\n\n  /**\n   * Expose the `SearchCriteria`. The search criteria are driven by the route parameters.\n   *\n   * This search route configuration is not yet configurable\n   * (see https://github.com/SAP/spartacus/issues/7191).\n   */\n  protected getCriteriaFromRoute(\n    routeParams: ProductListRouteParams,\n    queryParams: SearchCriteria\n  ): SearchCriteria {\n    return {\n      query: queryParams.query || this.getQueryFromRouteParams(routeParams),\n      pageSize: queryParams.pageSize || this.config.view?.defaultPageSize,\n      currentPage: queryParams.currentPage,\n      sortCode: queryParams.sortCode,\n    };\n  }\n\n  /**\n   * Resolves the search query from the given `ProductListRouteParams`.\n   */\n  protected getQueryFromRouteParams({\n    query,\n    categoryCode,\n    brandCode,\n  }: ProductListRouteParams) {\n    if (query) {\n      return query;\n    }\n    if (categoryCode) {\n      return this.RELEVANCE_ALLCATEGORIES + categoryCode;\n    }\n\n    // TODO: drop support for brands as they should be treated\n    // similarly as any category.\n    if (brandCode) {\n      return this.RELEVANCE_ALLCATEGORIES + brandCode;\n    }\n  }\n\n  /**\n   * Performs a search based on the given search criteria.\n   *\n   * The search is delegated to the `ProductSearchService`.\n   */\n  protected search(criteria: SearchCriteria): void {\n    const currentPage = criteria.currentPage;\n    const pageSize = criteria.pageSize;\n    const sort = criteria.sortCode;\n\n    this.productSearchService.search(\n      criteria.query,\n      // TODO: consider dropping this complex passing of cleaned object\n      Object.assign(\n        {},\n        currentPage && { currentPage },\n        pageSize && { pageSize },\n        sort && { sort }\n      )\n    );\n  }\n\n  /**\n   * Get items from a given page without using navigation\n   */\n  getPageItems(pageNumber: number): void {\n    this.routing\n      .getRouterState()\n      .subscribe((route) => {\n        const routeCriteria = this.getCriteriaFromRoute(\n          route.state.params,\n          route.state.queryParams\n        );\n        const criteria = {\n          ...routeCriteria,\n          currentPage: pageNumber,\n        };\n        this.search(criteria);\n      })\n      .unsubscribe();\n  }\n\n  /**\n   * Sort the search results by the given sort code.\n   */\n  sort(sortCode: string): void {\n    this.route({ sortCode });\n  }\n\n  /**\n   * Routes to the next product listing page, using the given `queryParams`. The\n   * `queryParams` support sorting, pagination and querying.\n   *\n   * The `queryParams` are delegated to the Angular router `NavigationExtras`.\n   */\n  protected route(queryParams: SearchCriteria): void {\n    this.router.navigate([], {\n      queryParams,\n      queryParamsHandling: 'merge',\n      relativeTo: this.activatedRoute,\n    });\n  }\n\n  /**\n   * The site context is used to update the search query in case of a\n   * changing context. The context will typically influence the search data.\n   *\n   * We keep this private for now, as we're likely refactoring this in the next\n   * major version.\n   */\n  private get siteContext(): Observable<string>[] {\n    // TODO: we should refactor this so that custom context will be taken\n    // into account automatically. Ideally, we drop the specific context\n    // from the constructor, and query a ContextService for all contexts.\n\n    return [this.languageService.getActive(), this.currencyService.getActive()];\n  }\n}\n"]}