@daffodil/product-composite 0.66.1 → 0.67.0

package/fesm2015/daffodil-product-composite-state.mjs

@@ -1,520 +0,0 @@
-import * as i0 from '@angular/core';
-import { Injectable, InjectionToken, inject, NgModule } from '@angular/core';
-import * as i1 from '@ngrx/store';
-import { defaultMemoize, createFeatureSelector, createSelector, select, combineReducers, StoreModule } from '@ngrx/store';
-import { DaffProductTypeEnum, productPriceRangeHasDiscount, productPriceRangeHasPriceRange } from '@daffodil/product';
-import { daffAdd, daffMultiply, daffDivide, daffSubtract } from '@daffodil/core';
-import { getDaffProductEntitiesSelectors, DaffProductPageActionTypes, DaffProductActionTypes, DaffBestSellersActionTypes, DaffProductGridActionTypes, DaffProductLoadSuccess, DaffProductPageLoadSuccess, daffProductProvideMetaReducers } from '@daffodil/product/state';
-import { createEntityAdapter } from '@ngrx/entity';
-import { daffComposeReducers } from '@daffodil/core/state';
-
-/**
- * Action types for Composite Product Actions.
- */
-var DaffCompositeProductActionTypes;
-(function (DaffCompositeProductActionTypes) {
-    DaffCompositeProductActionTypes["CompositeProductApplyOptionAction"] = "[Composite Product] Composite Product Apply Option Action";
-})(DaffCompositeProductActionTypes || (DaffCompositeProductActionTypes = {}));
-/**
- * Applies a product option to a particular composite product.
- *
- * @param id - Id of the Composite Product
- * @param itemId - Id of the product item.
- * @param optionId - Id of the option of the product item that is chosen.
- */
-class DaffCompositeProductApplyOption {
-    constructor(id, itemId, optionId, qty) {
-        this.id = id;
-        this.itemId = itemId;
-        this.optionId = optionId;
-        this.qty = qty;
-        this.type = DaffCompositeProductActionTypes.CompositeProductApplyOptionAction;
-    }
-}
-
-/**
- * Composite Product Item Options Adapter for changing/overwriting entity state.
- */
-class DaffCompositeProductAppliedOptionsEntitiesAdapter {
-    constructor() {
-        /**
-         * @docs-private
-         */
-        this._adapter = createEntityAdapter();
-    }
-    /**
-     * Gets the initial entity state.
-     */
-    getInitialState() {
-        return this._adapter.getInitialState();
-    }
-    /**
-     * Get the entity selectors.
-     */
-    getSelectors() {
-        return this._adapter.getSelectors();
-    }
-    /**
-     * Upserts the given composite products into state.
-     */
-    upsertProducts(state, ...products) {
-        return this._adapter.upsertMany(this.mapOptionsEntities(products), state);
-    }
-    ;
-    /**
-     * Apply the specified option for the given composite product item.
-     */
-    applyOption(state, productId, itemId, optionId, qty) {
-        return this._adapter.upsertOne({
-            id: productId,
-            items: Object.assign(Object.assign({}, state.entities[productId].items), { [itemId]: {
-                    value: optionId,
-                    qty: qty !== null && qty !== void 0 ? qty : 1,
-                } }),
-        }, state);
-    }
-    /**
-     * @docs-private
-     */
-    mapOptionsEntities(products) {
-        return products.filter(product => product.type === DaffProductTypeEnum.Composite)
-            .map(product => this.buildCompositeProductAppliedOptionsEntity(product));
-    }
-    /**
-     * @docs-private
-     */
-    buildCompositeProductAppliedOptionsEntity(product) {
-        return {
-            id: product.id,
-            items: product.items.reduce((acc, item) => (Object.assign(Object.assign({}, acc), { [item.id]: this.getDefaultOption(item) })), {}),
-        };
-    }
-    /**
-     * Sets the default item option to the specified default option if it is in stock.
-     * Does not set a default option if a default is not specified.
-     * Does not set a default option but does set a default qty if the default is out of stock.
-     *
-     * @param item a DaffCompositeProductItem
-     * @docs-private
-     */
-    getDefaultOption(item) {
-        const defaultOptionIndex = item.options.findIndex(option => option.is_default);
-        if (defaultOptionIndex > -1) {
-            return {
-                value: item.options[defaultOptionIndex].in_stock ? item.options[defaultOptionIndex].id : null,
-                qty: item.options[defaultOptionIndex].quantity,
-            };
-        }
-        else {
-            return { value: null, qty: null };
-        }
-    }
-}
-/**
- * Gets the composite product entity adapter singleton.
- */
-const daffCompositeProductAppliedOptionsEntitiesAdapter = defaultMemoize(() => new DaffCompositeProductAppliedOptionsEntitiesAdapter()).memoized;
-
-const DAFF_COMPOSITE_PRODUCT_STORE_FEATURE_KEY = 'daffCompositeProduct';
-
-/**
- * A function that returns a selector for the composite product feature state.
- */
-const getDaffCompositeProductFeatureSelector = (() => {
-    let cache;
-    return () => cache = cache
-        ? cache
-        : { selectCompositeProductState: createFeatureSelector(DAFF_COMPOSITE_PRODUCT_STORE_FEATURE_KEY) };
-})();
-
-const createCompositeProductAppliedOptionsEntitiesSelectors = () => {
-    const { selectCompositeProductState, } = getDaffCompositeProductFeatureSelector();
-    const { selectProduct, } = getDaffProductEntitiesSelectors();
-    const adapterSelectors = daffCompositeProductAppliedOptionsEntitiesAdapter().getSelectors();
-    const selectCompositeProductAppliedOptionsEntitiesState = createSelector(selectCompositeProductState, (state) => state.compositeProductOptions);
-    const selectCompositeProductIds = createSelector(selectCompositeProductAppliedOptionsEntitiesState, adapterSelectors.selectIds);
-    const selectCompositeProductAppliedOptionsEntities = createSelector(selectCompositeProductAppliedOptionsEntitiesState, adapterSelectors.selectEntities);
-    const selectCompositeProductTotal = createSelector(selectCompositeProductAppliedOptionsEntitiesState, adapterSelectors.selectTotal);
-    const selectCompositeProductAppliedOptions = defaultMemoize((id) => createSelector(selectProduct(id), selectCompositeProductAppliedOptionsEntitiesState, (product, appliedOptions) => {
-        if (product.type !== DaffProductTypeEnum.Composite) {
-            return undefined;
-        }
-        return product.items.reduce((acc, item) => (Object.assign(Object.assign({}, acc), { [item.id]: appliedOptions.entities[product.id].items[item.id].value ? Object.assign(Object.assign({}, item.options.find(option => option.id === appliedOptions.entities[product.id].items[item.id].value)), { quantity: appliedOptions.entities[product.id].items[item.id].qty }) : null })), {});
-    })).memoized;
-    const selectIsCompositeProductItemRequired = defaultMemoize((id, item_id) => createSelector(selectProduct(id), (product) => {
-        if (product.type !== DaffProductTypeEnum.Composite) {
-            return undefined;
-        }
-        const productItem = product.items.find(item => item.id === item_id);
-        return productItem ? productItem.required : null;
-    })).memoized;
-    return {
-        selectCompositeProductAppliedOptionsEntitiesState,
-        selectCompositeProductIds,
-        selectCompositeProductAppliedOptionsEntities,
-        selectCompositeProductTotal,
-        selectCompositeProductAppliedOptions,
-        selectIsCompositeProductItemRequired,
-    };
-};
-/**
- * A function that returns all selectors related to composite product applied option entities.
- * Returns {@link DaffCompositeProductEntitiesMemoizedSelectors}.
- */
-const getDaffCompositeProductEntitiesSelectors = (() => {
-    let cache;
-    return () => cache = cache
-        ? cache
-        : createCompositeProductAppliedOptionsEntitiesSelectors();
-})();
-
-const createCompositeProductSelectors = () => {
-    const { selectProduct, } = getDaffProductEntitiesSelectors();
-    const { selectCompositeProductAppliedOptionsEntities, } = getDaffCompositeProductEntitiesSelectors();
-    const selectCompositeProductRequiredItemPricesForConfiguration = defaultMemoize((id, configuration) => createSelector(selectProduct(id), (product) => {
-        if (product.type !== DaffProductTypeEnum.Composite) {
-            return undefined;
-        }
-        const appliedOptions = configuration ? getAppliedOptionsForConfiguration(product, configuration) : {};
-        return {
-            minPrice: getMinPricesForConfiguration(product, appliedOptions),
-            maxPrice: getMaxPricesForConfiguration(product, appliedOptions),
-        };
-    })).memoized;
-    const selectCompositeProductOptionalItemPricesForConfiguration = defaultMemoize((id, configuration) => createSelector(selectProduct(id), (product) => {
-        if (product.type !== DaffProductTypeEnum.Composite) {
-            return undefined;
-        }
-        const appliedOptions = configuration ? getAppliedOptionsForConfiguration(product, configuration) : {};
-        return {
-            minPrice: getMinPricesForConfiguration(product, appliedOptions),
-            maxPrice: getMaxPricesForConfigurationIncludingOptionalItems(product, appliedOptions),
-        };
-    })).memoized;
-    const selectCompositeProductPricesAsCurrentlyConfigured = defaultMemoize((id) => createSelector(selectProduct(id), selectCompositeProductAppliedOptionsEntities, (product, appliedOptionsEntities) => { var _a; return selectCompositeProductRequiredItemPricesForConfiguration(id, ((_a = appliedOptionsEntities[id]) === null || _a === void 0 ? void 0 : _a.items) || null).projector(product); })).memoized;
-    const selectCompositeProductDiscountAmount = defaultMemoize((id) => createSelector(selectProduct(id), selectCompositeProductAppliedOptionsEntities, (product, appliedOptionsEntities) => {
-        if (product.type !== DaffProductTypeEnum.Composite) {
-            return undefined;
-        }
-        const appliedConfigurationItem = appliedOptionsEntities[product.id].items;
-        if (product.items.filter(item => item.required && appliedConfigurationItem[item.id].value === null).length > 0) {
-            return undefined;
-        }
-        const appliedOptions = getAppliedOptionsForConfiguration(product, appliedConfigurationItem);
-        return product.items.reduce((acc, item) => { var _a, _b; return ((_b = (_a = appliedOptions[item.id]) === null || _a === void 0 ? void 0 : _a.discount) === null || _b === void 0 ? void 0 : _b.amount) ? daffAdd(acc, daffMultiply(appliedOptions[item.id].discount.amount, appliedOptions[item.id].quantity)) : acc; }, product.discount.amount);
-    })).memoized;
-    const selectCompositeProductDiscountPercent = defaultMemoize((id) => createSelector(selectProduct(id), selectCompositeProductAppliedOptionsEntities, (product, appliedOptionsEntities) => {
-        if (product.type !== DaffProductTypeEnum.Composite) {
-            return undefined;
-        }
-        const appliedOptions = appliedOptionsEntities[product.id].items;
-        if (product.items.filter(item => item.required && appliedOptions[item.id].value === null).length > 0) {
-            return undefined;
-        }
-        const prices = getMinPricesForConfiguration(product, getAppliedOptionsForConfiguration(product, appliedOptions));
-        return daffMultiply(daffDivide(daffSubtract(prices.originalPrice, prices.discountedPrice), prices.originalPrice), 100);
-    })).memoized;
-    return {
-        selectCompositeProductRequiredItemPricesForConfiguration,
-        selectCompositeProductOptionalItemPricesForConfiguration,
-        selectCompositeProductPricesAsCurrentlyConfigured,
-        selectCompositeProductDiscountAmount,
-        selectCompositeProductDiscountPercent,
-    };
-};
-/**
- * A function that returns all selectors related to the composite product feature.
- *
- * Returns {@link DaffCompositeProductMemoizedSelectors}.
- */
-const getDaffCompositeProductPriceSelectors = (() => {
-    let cache;
-    return () => cache = cache
-        ? cache
-        : createCompositeProductSelectors();
-})();
-/**
- * The minimum price of an item is zero if the item is optional.
- *
- * @param item DaffCompositeProductItem
- */
-function getMinimumRequiredCompositeItemPrice(item, qty) {
-    return item.required ? daffMultiply(Math.min(...item.options.map(option => option.price)), qty) : 0;
-}
-/**
- * The maximum price for an item is zero if the item is optional.
- *
- * @param item DaffCompositeProductItem
- */
-function getMaximumRequiredCompositeItemPrice(item, qty) {
-    return item.required ? daffMultiply(Math.max(...item.options.map(option => option.price)), qty) : 0;
-}
-/**
- * The minimum discounted price of an item is zero if the item is optional.
- *
- * @param item DaffCompositeProductItem
- */
-function getMinimumRequiredCompositeItemDiscountedPrice(item, qty) {
-    return item.required ? daffMultiply(Math.min(...item.options.map(getDiscountedPrice)), qty) : 0;
-}
-/**
- * The maximum discounted price of an item is zero if the item is optional.
- *
- * @param item DaffCompositeProductItem
- */
-function getMaximumRequiredCompositeItemDiscountedPrice(item, qty) {
-    return item.required ? daffMultiply(Math.max(...item.options.map(getDiscountedPrice)), qty) : 0;
-}
-/**
- * Gets the minimum prices of a composite product for the configuration provided excluding unselected, optional item prices.
- *
- * @param product a DaffCompositeProduct
- * @param appliedOptions a Dictionary<DaffCompositeProductItemOption> that determines the current configuration of the composite product.
- */
-function getMinPricesForConfiguration(product, appliedOptions) {
-    return {
-        discountedPrice: product.items.reduce((acc, item) => daffAdd(acc, appliedOptionHasId(appliedOptions[item.id]) ?
-            daffMultiply(getDiscountedPrice(appliedOptions[item.id]), appliedOptions[item.id].quantity) :
-            getMinimumRequiredCompositeItemDiscountedPrice(item, getOptionQty(appliedOptions[item.id]))), getDiscountedPrice(product)),
-        discount: { amount: null, percent: null },
-        originalPrice: product.items.reduce((acc, item) => daffAdd(acc, appliedOptionHasId(appliedOptions[item.id]) ?
-            daffMultiply(appliedOptions[item.id].price, appliedOptions[item.id].quantity) :
-            getMinimumRequiredCompositeItemPrice(item, getOptionQty(appliedOptions[item.id]))), product.price),
-    };
-}
-/**
- * Gets the maximum prices of a composite product for the configuration provided excluding unselected, optional item prices.
- *
- * @param product a DaffCompositeProduct
- * @param appliedOptions a Dictionary<DaffCompositeProductItemOption> that determines the current configuration of the composite product.
- */
-function getMaxPricesForConfiguration(product, appliedOptions) {
-    return {
-        discountedPrice: product.items.reduce((acc, item) => daffAdd(acc, appliedOptionHasId(appliedOptions[item.id]) ?
-            daffMultiply(getDiscountedPrice(appliedOptions[item.id]), appliedOptions[item.id].quantity) :
-            getMaximumRequiredCompositeItemDiscountedPrice(item, getOptionQty(appliedOptions[item.id]))), getDiscountedPrice(product)),
-        discount: { amount: null, percent: null },
-        originalPrice: product.items.reduce((acc, item) => daffAdd(acc, appliedOptionHasId(appliedOptions[item.id]) ?
-            daffMultiply(appliedOptions[item.id].price, appliedOptions[item.id].quantity) :
-            getMaximumRequiredCompositeItemPrice(item, getOptionQty(appliedOptions[item.id]))), product.price),
-    };
-}
-function getDiscountedPrice(product) {
-    return product.discount ? daffSubtract(product.price, product.discount.amount) : product.price;
-}
-/**
- * Gets the maximum prices of a composite product including optional item prices.
- *
- * @param product a DaffCompositeProduct
- */
-function getMaxPricesForConfigurationIncludingOptionalItems(product, appliedOptions) {
-    return {
-        discountedPrice: product.items.reduce((acc, item) => daffAdd(acc, appliedOptionHasId(appliedOptions[item.id]) ?
-            daffMultiply(getDiscountedPrice(appliedOptions[item.id]), appliedOptions[item.id].quantity) :
-            appliedOptionHasQty(appliedOptions[item.id]) ?
-                daffMultiply(Math.max(...item.options.map(getDiscountedPrice)), appliedOptions[item.id].quantity) :
-                Math.max(...item.options.map(getDiscountedPrice))), getDiscountedPrice(product)),
-        discount: { amount: null, percent: null },
-        originalPrice: product.items.reduce((acc, item) => daffAdd(acc, appliedOptionHasId(appliedOptions[item.id]) ?
-            daffMultiply(appliedOptions[item.id].price, appliedOptions[item.id].quantity) :
-            appliedOptionHasQty(appliedOptions[item.id]) ?
-                daffMultiply(Math.max(...item.options.map(option => option.price)), appliedOptions[item.id].quantity) :
-                Math.max(...item.options.map(option => option.price))), product.price),
-    };
-}
-/**
- * Takes a product and a set of option configurations and convert it into a dictionary of the full option objects.
- *
- * @param product a DaffCompositeProduct
- * @param configuration a Dictionary<DaffCompositeConfigurationItem> used to build the appliedOptions object.
- */
-function getAppliedOptionsForConfiguration(product, configuration) {
-    return product.items.reduce((acc, item) => (Object.assign(Object.assign({}, acc), { [item.id]: configuration[item.id] ? Object.assign(Object.assign({}, item.options.find(option => option.id === configuration[item.id].value)), { quantity: (configuration[item.id].qty === null || configuration[item.id].qty === undefined) ? 1 : configuration[item.id].qty }) : null })), {});
-}
-function appliedOptionHasId(appliedOption) {
-    return !!(appliedOption === null || appliedOption === void 0 ? void 0 : appliedOption.id);
-}
-function getOptionQty(appliedOption) {
-    return appliedOptionHasQty(appliedOption) ? appliedOption.quantity : 1;
-}
-function appliedOptionHasQty(appliedOption) {
-    return (appliedOption === null || appliedOption === void 0 ? void 0 : appliedOption.quantity) !== null && (appliedOption === null || appliedOption === void 0 ? void 0 : appliedOption.quantity) !== undefined;
-}
-
-/**
- * A function that returns all selectors in the composite product feature area.
- * Returns {@link DaffCompositeProductAllSelectors}.
- */
-const getDaffCompositeProductSelectors = () => (Object.assign(Object.assign({}, getDaffCompositeProductEntitiesSelectors()), getDaffCompositeProductPriceSelectors()));
-
-/**
- * A facade for interacting with the composite product state.
- * Exposes many parts of the state for easy access and allows dispatching of actions.
- *
- * @inheritdoc
- */
-class DaffCompositeProductFacade {
-    constructor(store) {
-        this.store = store;
-        this.compositeProductSelectors = getDaffCompositeProductSelectors();
-        this.hasDiscount = productPriceRangeHasDiscount;
-        this.hasPriceRange = productPriceRangeHasPriceRange;
-    }
-    getRequiredItemPricesForConfiguration(id, configuration) {
-        return this.store.pipe(select(this.compositeProductSelectors.selectCompositeProductRequiredItemPricesForConfiguration(id, configuration)));
-    }
-    getOptionalItemPricesForConfiguration(id, configuration) {
-        return this.store.pipe(select(this.compositeProductSelectors.selectCompositeProductOptionalItemPricesForConfiguration(id, configuration)));
-    }
-    getPricesAsCurrentlyConfigured(id) {
-        return this.store.pipe(select(this.compositeProductSelectors.selectCompositeProductPricesAsCurrentlyConfigured(id)));
-    }
-    getAppliedOptions(id) {
-        return this.store.pipe(select(this.compositeProductSelectors.selectCompositeProductAppliedOptions(id)));
-    }
-    getDiscountAmount(id) {
-        return this.store.pipe(select(this.compositeProductSelectors.selectCompositeProductDiscountAmount(id)));
-    }
-    getDiscountPercent(id) {
-        return this.store.pipe(select(this.compositeProductSelectors.selectCompositeProductDiscountPercent(id)));
-    }
-    isItemRequired(id, item_id) {
-        return this.store.pipe(select(this.compositeProductSelectors.selectIsCompositeProductItemRequired(id, item_id)));
-    }
-    dispatch(action) {
-        this.store.dispatch(action);
-    }
-}
-/** @nocollapse */ DaffCompositeProductFacade.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DaffCompositeProductFacade, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ DaffCompositeProductFacade.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DaffCompositeProductFacade, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DaffCompositeProductFacade, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
-
-/**
- * Reducer function that catches actions and changes/overwrites composite product entities state.
- *
- * @param state current State of the redux store
- * @param action ProductGrid, BestSellers, Product, or Composite Product actions
- * @returns Product entities state
- */
-function daffCompositeProductEntitiesReducer(state = daffCompositeProductAppliedOptionsEntitiesAdapter().getInitialState(), action) {
-    const adapter = daffCompositeProductAppliedOptionsEntitiesAdapter();
-    switch (action.type) {
-        case DaffProductGridActionTypes.ProductGridLoadSuccessAction:
-        case DaffBestSellersActionTypes.BestSellersLoadSuccessAction:
-            return adapter.upsertProducts(state, ...action.payload);
-        case DaffProductActionTypes.ProductLoadSuccessAction:
-        case DaffProductPageActionTypes.ProductPageLoadSuccessAction:
-            return adapter.upsertProducts(state, ...action.payload.products);
-        case DaffCompositeProductActionTypes.CompositeProductApplyOptionAction:
-            return adapter.applyOption(state, action.id, action.itemId, action.optionId, action.qty);
-        default:
-            return state;
-    }
-}
-
-/**
- * Returns state values from all composite product related reducers.
- */
-const daffCompositeProductReducers = {
-    compositeProductOptions: daffCompositeProductEntitiesReducer,
-};
-
-/**
- * A token to hold the injectable extra reducers.
- *
- * Prefer using {@link daffProductCompositeProvideExtraReducers}.
- */
-const DAFF_PRODUCT_COMPOSITE_EXTRA_REDUCERS = new InjectionToken('DAFF_PRODUCT_COMPOSITE_EXTRA_REDUCERS', { factory: () => [] });
-/**
- * Provides additional reducers that run after the standard Daffodil cart reducers.
- *
- * ```ts
- * providers: [
- *   ...daffProductCompositeProvideExtraReducers(
- *     myReducer1,
- *     myReducer2
- *   )
- * ]
- * ```
- */
-function daffProductCompositeProvideExtraReducers(...reducers) {
-    return reducers.map(reducer => ({
-        provide: DAFF_PRODUCT_COMPOSITE_EXTRA_REDUCERS,
-        useValue: reducer,
-        multi: true,
-    }));
-}
-
-/**
- * Maps a list of products, ensuring that the composite products have a list of items.
- * If the incoming items is empty or nully, the items from state are intentionally used instead.
- */
-function daffProductCompositeEnsureItems(state, products) {
-    return products.map((product) => {
-        var _a, _b;
-        return product.type === DaffProductTypeEnum.Composite
-            ? Object.assign(Object.assign({}, product), { items: product.items.length > 0
-                    ? product.items
-                    : (_b = (_a = state.products.entities[product.id]) === null || _a === void 0 ? void 0 : _a.items) !== null && _b !== void 0 ? _b : [] }) : product;
-    });
-}
-
-function daffProductCompositeEnsureItemsMetaReducer(reducer) {
-    return (state, action) => {
-        switch (action.type) {
-            case DaffProductPageActionTypes.ProductPageLoadSuccessAction:
-                return reducer(state, new DaffProductPageLoadSuccess(Object.assign(Object.assign({}, action.payload), { products: daffProductCompositeEnsureItems(state, action.payload.products) })));
-            case DaffProductActionTypes.ProductLoadSuccessAction:
-                return reducer(state, new DaffProductLoadSuccess(Object.assign(Object.assign({}, action.payload), { products: daffProductCompositeEnsureItems(state, action.payload.products) })));
-            default:
-                return reducer(state, action);
-        }
-    };
-}
-
-/**
- * An internal token to hold the Daffodil composite product reducers.
- * Includes the extra and standard reducers.
- *
- * @docs-private
- */
-const DAFF_PRODUCT_COMPOSITE_REDUCERS = new InjectionToken('DAFF_PRODUCT_COMPOSITE_REDUCERS', {
-    factory: () => daffComposeReducers([
-        combineReducers(daffCompositeProductReducers),
-        ...inject(DAFF_PRODUCT_COMPOSITE_EXTRA_REDUCERS),
-    ]),
-});
-
-/**
- * A module that provides the default reducers and effects for composite product redux state.
- */
-class DaffCompositeProductStateModule {
-}
-/** @nocollapse */ DaffCompositeProductStateModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DaffCompositeProductStateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-/** @nocollapse */ DaffCompositeProductStateModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: DaffCompositeProductStateModule, imports: [i1.StoreFeatureModule] });
-/** @nocollapse */ DaffCompositeProductStateModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DaffCompositeProductStateModule, providers: [
-        ...daffProductProvideMetaReducers(daffProductCompositeEnsureItemsMetaReducer),
-    ], imports: [StoreModule.forFeature(DAFF_COMPOSITE_PRODUCT_STORE_FEATURE_KEY, DAFF_PRODUCT_COMPOSITE_REDUCERS)] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DaffCompositeProductStateModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    imports: [
-                        StoreModule.forFeature(DAFF_COMPOSITE_PRODUCT_STORE_FEATURE_KEY, DAFF_PRODUCT_COMPOSITE_REDUCERS),
-                    ],
-                    providers: [
-                        ...daffProductProvideMetaReducers(daffProductCompositeEnsureItemsMetaReducer),
-                    ],
-                }]
-        }] });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { DAFF_COMPOSITE_PRODUCT_STORE_FEATURE_KEY, DAFF_PRODUCT_COMPOSITE_EXTRA_REDUCERS, DaffCompositeProductActionTypes, DaffCompositeProductAppliedOptionsEntitiesAdapter, DaffCompositeProductApplyOption, DaffCompositeProductFacade, DaffCompositeProductStateModule, daffCompositeProductAppliedOptionsEntitiesAdapter, daffCompositeProductReducers, daffProductCompositeEnsureItems, daffProductCompositeProvideExtraReducers, getDaffCompositeProductEntitiesSelectors, getDaffCompositeProductFeatureSelector, getDaffCompositeProductPriceSelectors, getDaffCompositeProductSelectors };
-//# sourceMappingURL=daffodil-product-composite-state.mjs.map