@daffodil/category 0.39.13 → 0.42.0

package/fesm2020/daffodil-category-driver-magento.mjs

@@ -0,0 +1,567 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, NgModule } from '@angular/core';
+import * as i1 from 'apollo-angular';
+import { gql } from 'apollo-angular';
+import { combineLatest } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { DaffCategoryFilterType, daffCategoryFilterArrayToDict, daffApplyRequestsToFilters, DaffCategoryRequestKind } from '@daffodil/category';
+import * as i3 from '@daffodil/product/driver/magento';
+import { magentoProductFragment, MAGENTO_PRODUCT_CONFIG_TOKEN, DAFF_PRODUCT_MAGENTO_EXTRA_PRODUCT_PREVIEW_FRAGMENTS } from '@daffodil/product/driver/magento';
+import { daffUriTruncateLeadingSlash, daffUriTruncateFileExtension, daffUriTruncateQueryFragment } from '@daffodil/core/routing';
+import { daffBuildFragmentNameSpread, daffBuildFragmentDefinition } from '@daffodil/core/graphql';
+import { DaffSortDirectionEnum } from '@daffodil/core/state';
+import { CommonModule } from '@angular/common';
+import { DaffCategoryDriver } from '@daffodil/category/driver';
+import { DAFF_MAGENTO_CACHEABLE_OPERATIONS } from '@daffodil/driver/magento';
+
+/**
+ * Truncates leading slash, file extension, query params, and fragments.
+ */
+const magentoCategoryTruncateUrl = (url) => daffUriTruncateLeadingSlash(daffUriTruncateFileExtension(daffUriTruncateQueryFragment(url)));
+
+/**
+ * The default configuration for the {@link DaffCategoryMagentoDriverConfig}.
+ */
+const MAGENTO_CATEGORY_CONFIG_DEFAULT = {
+    truncateUrl: true,
+    uriTruncationStrategy: magentoCategoryTruncateUrl,
+};
+
+/**
+ * The token used to provide @daffodil/category/driver/magento config data.
+ * Mandatory for the Magento driver.
+ */
+const MAGENTO_CATEGORY_CONFIG_TOKEN = new InjectionToken('MAGENTO_CATEGORY_CONFIG_TOKEN', { factory: () => MAGENTO_CATEGORY_CONFIG_DEFAULT });
+
+const DAFF_MAGENTO_GET_FILTER_TYPES_QUERY_NAME = 'MagentoGetFilterFieldTypesForCategory';
+const MagentoGetCategoryFilterTypes = gql `
+query ${DAFF_MAGENTO_GET_FILTER_TYPES_QUERY_NAME} {
+  __type (name: "ProductAttributeFilterInput") {
+    inputFields {
+      name
+      type {
+        name
+      }
+    }
+  }
+}
+`;
+
+const magentoCategoryTreeFragment = gql `
+  fragment categoryTree on CategoryTree {
+    uid
+    url_path
+    url_suffix
+    canonical_url
+		name
+		level
+		meta_title
+		meta_description
+		description
+		breadcrumbs {
+			category_uid
+			category_name
+			category_level
+			category_url_path
+		}
+		products {
+			items {
+				sku
+			}
+		}
+		children_count
+  }
+`;
+
+const DAFF_MAGENTO_GET_CATEGORY_QUERY_NAME = 'MagentoGetCategoryQuery';
+const MagentoGetCategoryQuery = gql `
+query ${DAFF_MAGENTO_GET_CATEGORY_QUERY_NAME}($filters: CategoryFilterInput){
+	categoryList(filters: $filters) {
+		...categoryTree
+	}
+}
+${magentoCategoryTreeFragment}
+`;
+
+const DAFF_MAGENTO_GET_PRODUCTS_QUERY_NAME = 'MagentoGetProducts';
+/**
+ * This query only exists because products and their associated aggregations/filter cannot
+ * be retrieved through a category call.
+ */
+const MagentoGetProductsQuery = (extraProductFragments = []) => gql `
+query ${DAFF_MAGENTO_GET_PRODUCTS_QUERY_NAME}($filter: ProductAttributeFilterInput!, $search: String, $pageSize: Int, $currentPage: Int, $sort: ProductAttributeSortInput)
+{
+	products(filter: $filter, search: $search, pageSize: $pageSize, currentPage: $currentPage, sort: $sort)
+	{
+		total_count
+		items {
+			...product
+      ${daffBuildFragmentNameSpread(...extraProductFragments)}
+		}
+		page_info {
+			page_size
+			current_page
+			total_pages
+		}
+		aggregations {
+			label
+			count
+			attribute_code
+      options {
+        count
+        label
+        value
+			}
+		}
+		sort_fields {
+			default
+			options {
+				label
+				value
+			}
+		}
+	}
+}
+${magentoProductFragment}
+${daffBuildFragmentDefinition(...extraProductFragments)}
+`;
+
+var MagentoCategoryFilterActionEnum;
+(function (MagentoCategoryFilterActionEnum) {
+    MagentoCategoryFilterActionEnum["Equal"] = "eq";
+    MagentoCategoryFilterActionEnum["To"] = "to";
+    MagentoCategoryFilterActionEnum["From"] = "from";
+    MagentoCategoryFilterActionEnum["In"] = "in";
+    MagentoCategoryFilterActionEnum["Match"] = "match";
+})(MagentoCategoryFilterActionEnum || (MagentoCategoryFilterActionEnum = {}));
+
+var MagentoSortDirectionEnum;
+(function (MagentoSortDirectionEnum) {
+    MagentoSortDirectionEnum["Ascending"] = "ASC";
+    MagentoSortDirectionEnum["Decending"] = "DESC";
+})(MagentoSortDirectionEnum || (MagentoSortDirectionEnum = {}));
+
+// maybe this shoould be in @daffodil/product/driver/magento?
+var MagentoCategoryFilterType;
+(function (MagentoCategoryFilterType) {
+    MagentoCategoryFilterType["Equal"] = "FilterEqualTypeInput";
+    MagentoCategoryFilterType["Match"] = "FilterEqualTypeInput";
+    MagentoCategoryFilterType["Range"] = "FilterRangeTypeInput";
+})(MagentoCategoryFilterType || (MagentoCategoryFilterType = {}));
+
+class DaffMagentoAppliedFiltersTransformService {
+    transform(categoryId, daffFilters) {
+        const magentoFilters = {
+            category_uid: {
+                [MagentoCategoryFilterActionEnum.Equal]: categoryId,
+            },
+        };
+        if (!daffFilters) {
+            return magentoFilters;
+        }
+        daffFilters.forEach(filter => {
+            // The FromTo filter needs special treatment, because Magento accepts the "from" and "to" filters
+            // separately (it also outputs FromTo filter pairs together)
+            if (filter.type === DaffCategoryFilterType.RangeNumeric) {
+                magentoFilters[filter.name] = {
+                    ...magentoFilters[filter.name],
+                    ...this.getRangeFromValue(filter.value.min.toString()),
+                    ...this.getRangeToValue(filter.value.max.toString()),
+                };
+            }
+            else {
+                magentoFilters[filter.name] = {
+                    ...magentoFilters[filter.name],
+                    [this.getFilterAction(filter.type)]: this.getFilterValue(filter.type, filter.value),
+                };
+            }
+        });
+        return magentoFilters;
+    }
+    /**
+     * Returns an In action for Equal type and a Match action for Match type.
+     */
+    getFilterAction(type) {
+        return type === DaffCategoryFilterType.Equal
+            ? MagentoCategoryFilterActionEnum.In
+            : MagentoCategoryFilterActionEnum.Match;
+    }
+    /**
+     * Returns an array for Equal type and a string for Match type.
+     */
+    getFilterValue(type, value) {
+        return type === DaffCategoryFilterType.Equal ? value : value[0];
+    }
+    getRangeFromValue(fromValue) {
+        return fromValue !== '*' ? { [MagentoCategoryFilterActionEnum.From]: fromValue } : null;
+    }
+    getRangeToValue(toValue) {
+        return toValue !== '*' ? { [MagentoCategoryFilterActionEnum.To]: toValue } : null;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffMagentoAppliedFiltersTransformService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoAppliedFiltersTransformService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffMagentoAppliedFiltersTransformService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoAppliedFiltersTransformService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoAppliedFiltersTransformService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class DaffMagentoAppliedSortOptionTransformService {
+    transform(appliedOption, appliedDirection) {
+        return {
+            [appliedOption]: this.transformDirection(appliedDirection),
+        };
+    }
+    transformDirection(direction) {
+        if (direction === DaffSortDirectionEnum.Ascending) {
+            return MagentoSortDirectionEnum.Ascending;
+        }
+        else if (direction === DaffSortDirectionEnum.Descending) {
+            return MagentoSortDirectionEnum.Decending;
+        }
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffMagentoAppliedSortOptionTransformService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoAppliedSortOptionTransformService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffMagentoAppliedSortOptionTransformService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoAppliedSortOptionTransformService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoAppliedSortOptionTransformService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+const transformAggregateEqual = (aggregate) => ({
+    label: aggregate.label,
+    type: DaffCategoryFilterType.Equal,
+    name: aggregate.attribute_code,
+    options: aggregate.options.reduce((acc, option) => {
+        acc[option.value] = {
+            applied: false,
+            label: option.label,
+            count: option.count,
+            value: option.value,
+        };
+        return acc;
+    }, {}),
+});
+
+/**
+ * The char that Magento uses to separate individual elements of the buckets
+ * they return for range elements
+ */
+const magentoBucketSeparator = '-';
+const transformAggregateRange = (aggregate) => ({
+    label: aggregate.label,
+    type: DaffCategoryFilterType.RangeNumeric,
+    name: aggregate.attribute_code,
+    min: parseInt(aggregate.options[0].value.split('-')[0], 10),
+    max: parseInt(aggregate.options[aggregate.options.length - 1].value.split(magentoBucketSeparator)[1], 10),
+    options: {},
+});
+
+const transformAggregate = (aggregate) => {
+    switch (aggregate.type) {
+        case MagentoCategoryFilterType.Range:
+            return transformAggregateRange(aggregate);
+        case MagentoCategoryFilterType.Equal:
+        case MagentoCategoryFilterType.Match:
+        default:
+            return transformAggregateEqual(aggregate);
+    }
+};
+
+function coerceDefaultSortOptionFirst(sort_fields) {
+    const index = sort_fields.options.findIndex(option => sort_fields.default === option.value);
+    return {
+        ...sort_fields,
+        options: [
+            sort_fields.options[index],
+            ...sort_fields.options.slice(0, index),
+            ...sort_fields.options.slice(index + 1),
+        ],
+    };
+}
+
+class DaffMagentoCategoryPageConfigTransformerService {
+    transform(categoryResponse) {
+        const aggregatesWithoutCategories = categoryResponse.aggregates.filter(aggregate => aggregate.attribute_code !== 'category_id');
+        return {
+            id: categoryResponse.category.uid,
+            page_size: categoryResponse.page_info.page_size,
+            current_page: categoryResponse.page_info.current_page,
+            total_pages: categoryResponse.page_info.total_pages,
+            total_products: categoryResponse.total_count,
+            filters: daffCategoryFilterArrayToDict(aggregatesWithoutCategories.map(transformAggregate)),
+            sort_options: {
+                default: categoryResponse.sort_fields.default,
+                options: coerceDefaultSortOptionFirst(categoryResponse.sort_fields).options,
+            },
+            product_ids: categoryResponse.products.map(product => product.sku),
+            // TODO: implement?
+            applied_sort_direction: null,
+            applied_sort_option: null,
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffMagentoCategoryPageConfigTransformerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryPageConfigTransformerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffMagentoCategoryPageConfigTransformerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryPageConfigTransformerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryPageConfigTransformerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class DaffMagentoCategoryTransformerService {
+    transform(category, products) {
+        return {
+            id: category.uid,
+            url: `/${category.url_path}${category.url_suffix}`,
+            canonicalUrl: category.canonical_url,
+            name: category.name,
+            description: category.description,
+            meta_title: category.meta_title,
+            meta_description: category.meta_description,
+            children_count: category.children_count,
+            breadcrumbs: category.breadcrumbs
+                ?.map(breadcrumb => this.transformBreadcrumb(breadcrumb, category))
+                .sort((a, b) => a.level - b.level) || null,
+            product_ids: products.map(product => product.sku),
+            total_products: products.length,
+        };
+    }
+    transformBreadcrumb(breadcrumb, category) {
+        return {
+            id: breadcrumb.category_uid,
+            name: breadcrumb.category_name,
+            level: breadcrumb.category_level,
+            url: `/${breadcrumb.category_url_path}${category.url_suffix}`,
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffMagentoCategoryTransformerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryTransformerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffMagentoCategoryTransformerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryTransformerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryTransformerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class DaffMagentoCategoryResponseTransformService {
+    constructor(magentoCategoryTransformerService, magentoCategoryPageConfigurationTransformerService, magentoProductsTransformService) {
+        this.magentoCategoryTransformerService = magentoCategoryTransformerService;
+        this.magentoCategoryPageConfigurationTransformerService = magentoCategoryPageConfigurationTransformerService;
+        this.magentoProductsTransformService = magentoProductsTransformService;
+    }
+    transform(completeCategory, mediaUrl) {
+        return {
+            ...{ magentoCompleteCategoryResponse: completeCategory },
+            category: this.magentoCategoryTransformerService.transform(completeCategory.category, completeCategory.products),
+            categoryPageMetadata: this.magentoCategoryPageConfigurationTransformerService.transform(completeCategory),
+            products: this.magentoProductsTransformService.transformManyMagentoProducts(completeCategory.products, mediaUrl),
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffMagentoCategoryResponseTransformService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryResponseTransformService, deps: [{ token: DaffMagentoCategoryTransformerService }, { token: DaffMagentoCategoryPageConfigTransformerService }, { token: i3.DaffMagentoProductsTransformer }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffMagentoCategoryResponseTransformService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryResponseTransformService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryResponseTransformService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: DaffMagentoCategoryTransformerService }, { type: DaffMagentoCategoryPageConfigTransformerService }, { type: i3.DaffMagentoProductsTransformer }]; } });
+
+const getMatchedAttributeType = (aggregate, attributes) => attributes.__type.inputFields.filter(item => item.name === aggregate.attribute_code)[0].type.name;
+
+function addMetadataTypesToAggregates(attributeResponse, aggregationResponse) {
+    return {
+        ...aggregationResponse,
+        products: {
+            ...aggregationResponse.products,
+            aggregations: [
+                ...aggregationResponse.products.aggregations.map((aggregate) => ({
+                    ...aggregate,
+                    type: getMatchedAttributeType(aggregate, attributeResponse),
+                })),
+            ],
+        },
+    };
+}
+
+const applyFiltersOnResponse = (requests, response) => ({
+    ...response,
+    categoryPageMetadata: {
+        ...response.categoryPageMetadata,
+        filters: daffApplyRequestsToFilters(requests, response.categoryPageMetadata.filters),
+    },
+});
+/**
+ * A service for making magento apollo queries for categories. Should be provided via the {@link DaffCategoryDriver} token.
+ *
+ * @inheritdoc
+ */
+class DaffMagentoCategoryService {
+    constructor(apollo, magentoCategoryResponseTransformer, magentoAppliedFiltersTransformer, magentoAppliedSortTransformer, config, productConfig, extraPreviewFragments) {
+        this.apollo = apollo;
+        this.magentoCategoryResponseTransformer = magentoCategoryResponseTransformer;
+        this.magentoAppliedFiltersTransformer = magentoAppliedFiltersTransformer;
+        this.magentoAppliedSortTransformer = magentoAppliedSortTransformer;
+        this.config = config;
+        this.productConfig = productConfig;
+        this.extraPreviewFragments = extraPreviewFragments;
+    }
+    //todo the MagentoGetCategoryQuery needs to get its own product ids.
+    get(categoryRequest) {
+        return combineLatest([
+            this.apollo.query({
+                query: MagentoGetCategoryQuery,
+                variables: { filters: { category_uid: { eq: categoryRequest.id } } },
+            }),
+            this.apollo.query({
+                query: MagentoGetCategoryFilterTypes,
+            }),
+            this.apollo.query({
+                query: MagentoGetProductsQuery(this.extraPreviewFragments),
+                variables: this.getProductsQueryVariables(categoryRequest),
+            }),
+        ]).pipe(map(([category, filterTypes, products,]) => this.transformCategory(category.data, filterTypes.data, products.data, this.productConfig.baseMediaUrl)), map(result => categoryRequest.filter_requests
+            ? applyFiltersOnResponse(categoryRequest.filter_requests, result)
+            : result));
+    }
+    getByUrl(categoryRequest) {
+        return combineLatest([
+            this.apollo.query({
+                query: MagentoGetCategoryQuery,
+                variables: { filters: { url_path: {
+                            eq: this.config.truncateUrl
+                                ? this.config.uriTruncationStrategy(categoryRequest.url)
+                                : categoryRequest.url,
+                        } } },
+            }),
+            this.apollo.query({
+                query: MagentoGetCategoryFilterTypes,
+            }),
+        ]).pipe(switchMap(([category, filterTypes,]) => this.apollo.query({
+            query: MagentoGetProductsQuery(this.extraPreviewFragments),
+            variables: this.getProductsQueryVariables({
+                ...categoryRequest,
+                id: category.data.categoryList[0]?.uid,
+                kind: DaffCategoryRequestKind.ID,
+            }),
+        }).pipe(map(products => this.transformCategory(category.data, filterTypes.data, products.data, this.productConfig.baseMediaUrl)), map(result => categoryRequest.filter_requests
+            ? applyFiltersOnResponse(categoryRequest.filter_requests, result)
+            : result))));
+    }
+    getProductsQueryVariables(request) {
+        const queryVariables = {
+            filter: this.magentoAppliedFiltersTransformer.transform(request.id, request.filter_requests),
+        };
+        if (request.page_size) {
+            queryVariables['pageSize'] = request.page_size;
+        }
+        if (request.current_page) {
+            queryVariables['currentPage'] = request.current_page;
+        }
+        if (request.applied_sort_option && request.applied_sort_direction) {
+            queryVariables['sort'] = this.magentoAppliedSortTransformer.transform(request.applied_sort_option, request.applied_sort_direction);
+        }
+        return queryVariables;
+    }
+    transformCategory(categoryResponse, filterTypesResponse, productsResponse, mediaUrl) {
+        const aggregations = addMetadataTypesToAggregates(filterTypesResponse, productsResponse);
+        const completeCategory = {
+            category: categoryResponse.categoryList[0],
+            products: productsResponse.products.items,
+            aggregates: aggregations.products.aggregations,
+            sort_fields: aggregations.products.sort_fields,
+            total_count: productsResponse.products.total_count,
+            page_info: productsResponse.products.page_info,
+        };
+        return this.magentoCategoryResponseTransformer.transform(completeCategory, mediaUrl);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffMagentoCategoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryService, deps: [{ token: i1.Apollo }, { token: DaffMagentoCategoryResponseTransformService }, { token: DaffMagentoAppliedFiltersTransformService }, { token: DaffMagentoAppliedSortOptionTransformService }, { token: MAGENTO_CATEGORY_CONFIG_TOKEN }, { token: MAGENTO_PRODUCT_CONFIG_TOKEN }, { token: DAFF_PRODUCT_MAGENTO_EXTRA_PRODUCT_PREVIEW_FRAGMENTS }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffMagentoCategoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffMagentoCategoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: DaffMagentoCategoryResponseTransformService }, { type: DaffMagentoAppliedFiltersTransformService }, { type: DaffMagentoAppliedSortOptionTransformService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAGENTO_CATEGORY_CONFIG_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAGENTO_PRODUCT_CONFIG_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DAFF_PRODUCT_MAGENTO_EXTRA_PRODUCT_PREVIEW_FRAGMENTS]
+                }] }]; } });
+
+/**
+ * A module that provides the {@link DaffCategoryDriver} and {@link MAGENTO_CATEGORY_CONFIG_TOKEN} as the {@link DaffMagentoCategoryService} and
+ * {@link MAGENTO_CATEGORY_CONFIG_DEFAULT} respectively
+ */
+class DaffCategoryMagentoDriverModule {
+    static forRoot(config = MAGENTO_CATEGORY_CONFIG_DEFAULT) {
+        return {
+            ngModule: DaffCategoryMagentoDriverModule,
+            providers: [
+                {
+                    provide: DaffCategoryDriver,
+                    useExisting: DaffMagentoCategoryService,
+                },
+                DaffMagentoCategoryPageConfigTransformerService,
+                DaffMagentoCategoryResponseTransformService,
+                DaffMagentoCategoryTransformerService,
+                DaffMagentoAppliedFiltersTransformService,
+                DaffMagentoAppliedSortOptionTransformService,
+                {
+                    provide: DAFF_MAGENTO_CACHEABLE_OPERATIONS,
+                    useValue: DAFF_MAGENTO_GET_CATEGORY_QUERY_NAME,
+                    multi: true,
+                },
+                {
+                    provide: DAFF_MAGENTO_CACHEABLE_OPERATIONS,
+                    useValue: DAFF_MAGENTO_GET_FILTER_TYPES_QUERY_NAME,
+                    multi: true,
+                },
+                {
+                    provide: DAFF_MAGENTO_CACHEABLE_OPERATIONS,
+                    useValue: DAFF_MAGENTO_GET_PRODUCTS_QUERY_NAME,
+                    multi: true,
+                },
+                {
+                    provide: MAGENTO_CATEGORY_CONFIG_TOKEN,
+                    useValue: {
+                        ...MAGENTO_CATEGORY_CONFIG_DEFAULT,
+                        ...config,
+                    },
+                },
+            ],
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffCategoryMagentoDriverModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryMagentoDriverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ DaffCategoryMagentoDriverModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryMagentoDriverModule, imports: [CommonModule] });
+/** @nocollapse */ /** @nocollapse */ DaffCategoryMagentoDriverModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryMagentoDriverModule, imports: [[
+            CommonModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffCategoryMagentoDriverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DAFF_MAGENTO_GET_CATEGORY_QUERY_NAME, DAFF_MAGENTO_GET_FILTER_TYPES_QUERY_NAME, DAFF_MAGENTO_GET_PRODUCTS_QUERY_NAME, DaffCategoryMagentoDriverModule, DaffMagentoAppliedFiltersTransformService, DaffMagentoAppliedSortOptionTransformService, DaffMagentoCategoryPageConfigTransformerService, DaffMagentoCategoryResponseTransformService, DaffMagentoCategoryService, DaffMagentoCategoryTransformerService, MAGENTO_CATEGORY_CONFIG_DEFAULT, MAGENTO_CATEGORY_CONFIG_TOKEN, MagentoCategoryFilterActionEnum, MagentoCategoryFilterType, MagentoGetCategoryFilterTypes, MagentoGetCategoryQuery, MagentoGetProductsQuery, MagentoSortDirectionEnum, magentoCategoryTreeFragment };
+//# sourceMappingURL=daffodil-category-driver-magento.mjs.map