@daffodil/product-composite 0.88.1 → 0.89.0

package/fesm2022/daffodil-product-composite.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"daffodil-product-composite.mjs","sources":["../../../libs/product-composite/src/helpers/build-selection-payload.ts","../../../libs/product-composite/src/models/composite-product-item.ts","../../../libs/product-composite/src/daffodil-product-composite.ts"],"sourcesContent":["import {\n  DaffCompositeProductItem,\n  DaffCompositeProductItemOption,\n  DaffProductCompositeSelectionPayload,\n} from '../models/public_api';\n\nexport function daffProductCompositeBuildSelectionPayload(appliedOptions: Record<DaffCompositeProductItem['id'], DaffCompositeProductItemOption>): DaffProductCompositeSelectionPayload {\n  return Object.keys(appliedOptions).reduce<DaffProductCompositeSelectionPayload>(\n    (selection, itemId) => {\n      const optionId = appliedOptions[itemId].id;\n\n      if (optionId) {\n        selection[itemId] = [optionId];\n      }\n\n      return selection;\n    },\n    {},\n  );\n}\n","import { DaffIdentifiable } from '@daffodil/core';\nimport { DaffProduct } from '@daffodil/product';\n\n/**\n * An enum for whether a composite product item should be displayed as a radio or select input.\n */\nexport enum DaffCompositeProductItemInputEnum {\n  select = 'select',\n  radio = 'radio'\n}\n\n/**\n * The composite product item describes one set of product options that the user can add to the composite product.\n * A composite product item can be required or optional. If it is required, an option _must_ be chosen in order to add the product to the cart.\n * If the item is optional, the product can be added to the cart without an option having been chosen.\n * For example, if a composite product is a toolbox bundle, a composite product item might be a screw driver, and the options contained in that\n * item might be a phillips head and a flathead. The customer could choose to add either a phillips head or a flathead to the\n * composite product, or neither if the item is optional.\n */\nexport interface DaffCompositeProductItem extends DaffIdentifiable {\n  /**\n   * Whether the item is required or optional.\n   */\n  required: boolean;\n  /**\n   * The title label for the item.\n   */\n  title: string;\n  /**\n   * Describes how the item should be displayed.\n   */\n  input_type: DaffCompositeProductItemInputEnum;\n  /**\n   * The options that may be chosen for the item.\n   */\n  options: DaffCompositeProductItemOption[];\n}\n\n/**\n * The composite product item option is a DaffProduct that can be added to a composite product.\n */\nexport interface DaffCompositeProductItemOption extends DaffProduct {\n  /**\n   * Whether the option is the default option for its parent {@link DaffCompositeProductItem}.\n   */\n  is_default: boolean;\n  /**\n   * The quantity chosen for the option.\n   */\n  quantity: number;\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"AAMM,SAAU,yCAAyC,CAAC,cAAsF,EAAA;AAC9I,IAAA,OAAO,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,MAAM,CACvC,CAAC,SAAS,EAAE,MAAM,KAAI;QACpB,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE;QAE1C,IAAI,QAAQ,EAAE;AACZ,YAAA,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;;AAGhC,QAAA,OAAO,SAAS;KACjB,EACD,EAAE,CACH;AACH;;AChBA;;AAEG;IACS;AAAZ,CAAA,UAAY,iCAAiC,EAAA;AAC3C,IAAA,iCAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;AACjB,IAAA,iCAAA,CAAA,OAAA,CAAA,GAAA,OAAe;AACjB,CAAC,EAHW,iCAAiC,KAAjC,iCAAiC,GAG5C,EAAA,CAAA,CAAA;;ACTD;;AAEG;;;;"}
+{"version":3,"file":"daffodil-product-composite.mjs","sources":["../../../libs/product-composite/src/helpers/build-selection-payload.ts","../../../libs/product-composite/src/models/composite-product-item.ts","../../../libs/product-composite/src/daffodil-product-composite.ts"],"sourcesContent":["import {\n  DaffCompositeProductItem,\n  DaffCompositeProductItemOption,\n  DaffProductCompositeSelectionPayload,\n} from '../models/public_api';\n\nexport function daffProductCompositeBuildSelectionPayload(appliedOptions: Record<DaffCompositeProductItem['id'], DaffCompositeProductItemOption>): DaffProductCompositeSelectionPayload {\n  return Object.keys(appliedOptions).reduce<DaffProductCompositeSelectionPayload>(\n    (selection, itemId) => {\n      const optionId = appliedOptions[itemId].id;\n\n      if (optionId) {\n        selection[itemId] = [optionId];\n      }\n\n      return selection;\n    },\n    {},\n  );\n}\n","import { DaffIdentifiable } from '@daffodil/core';\nimport { DaffProduct } from '@daffodil/product';\n\n/**\n * An enum for whether a composite product item should be displayed as a radio or select input.\n */\nexport enum DaffCompositeProductItemInputEnum {\n  select = 'select',\n  radio = 'radio'\n}\n\n/**\n * The composite product item describes one set of product options that the user can add to the composite product.\n * A composite product item can be required or optional. If it is required, an option _must_ be chosen in order to add the product to the cart.\n * If the item is optional, the product can be added to the cart without an option having been chosen.\n * For example, if a composite product is a toolbox bundle, a composite product item might be a screw driver, and the options contained in that\n * item might be a phillips head and a flathead. The customer could choose to add either a phillips head or a flathead to the\n * composite product, or neither if the item is optional.\n */\nexport interface DaffCompositeProductItem extends DaffIdentifiable {\n  /**\n   * Whether the item is required or optional.\n   */\n  required: boolean;\n  /**\n   * The title label for the item.\n   */\n  title: string;\n  /**\n   * Describes how the item should be displayed.\n   */\n  input_type: DaffCompositeProductItemInputEnum;\n  /**\n   * The options that may be chosen for the item.\n   */\n  options: DaffCompositeProductItemOption[];\n}\n\n/**\n * The composite product item option is a DaffProduct that can be added to a composite product.\n */\nexport interface DaffCompositeProductItemOption extends DaffProduct {\n  /**\n   * Whether the option is the default option for its parent {@link DaffCompositeProductItem}.\n   */\n  is_default: boolean;\n  /**\n   * The quantity chosen for the option.\n   */\n  quantity: number;\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"AAMM,SAAU,yCAAyC,CAAC,cAAsF,EAAA;AAC9I,IAAA,OAAO,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,MAAM,CACvC,CAAC,SAAS,EAAE,MAAM,KAAI;QACpB,MAAM,QAAQ,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,EAAE;QAE1C,IAAI,QAAQ,EAAE;AACZ,YAAA,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAChC;AAEA,QAAA,OAAO,SAAS;IAClB,CAAC,EACD,EAAE,CACH;AACH;;AChBA;;AAEG;IACS;AAAZ,CAAA,UAAY,iCAAiC,EAAA;AAC3C,IAAA,iCAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;AACjB,IAAA,iCAAA,CAAA,OAAA,CAAA,GAAA,OAAe;AACjB,CAAC,EAHW,iCAAiC,KAAjC,iCAAiC,GAAA,EAAA,CAAA,CAAA;;ACN7C;;AAEG;;;;"}

package/index.d.ts

@@ -1 +1,88 @@
-export * from './public_api';
+import { ID, DaffIdentifiable } from '@daffodil/core';
+import { DaffProduct } from '@daffodil/product';
+
+/**
+ * An object to denote the configuration chosen for a particular {@link DaffCompositeProductItem}.
+ */
+interface DaffCompositeConfigurationItem {
+    /**
+     * The quantity chosen for the configuration of the {@link DaffCompositeProductItem}.
+     */
+    qty?: number;
+    /**
+     * The value of the {@link DaffCompositeProductItemOption} chosen for the configuration of the {@link DaffCompositeProductItem}.
+     */
+    value?: ID;
+}
+
+/**
+ * An enum for whether a composite product item should be displayed as a radio or select input.
+ */
+declare enum DaffCompositeProductItemInputEnum {
+    select = "select",
+    radio = "radio"
+}
+/**
+ * The composite product item describes one set of product options that the user can add to the composite product.
+ * A composite product item can be required or optional. If it is required, an option _must_ be chosen in order to add the product to the cart.
+ * If the item is optional, the product can be added to the cart without an option having been chosen.
+ * For example, if a composite product is a toolbox bundle, a composite product item might be a screw driver, and the options contained in that
+ * item might be a phillips head and a flathead. The customer could choose to add either a phillips head or a flathead to the
+ * composite product, or neither if the item is optional.
+ */
+interface DaffCompositeProductItem extends DaffIdentifiable {
+    /**
+     * Whether the item is required or optional.
+     */
+    required: boolean;
+    /**
+     * The title label for the item.
+     */
+    title: string;
+    /**
+     * Describes how the item should be displayed.
+     */
+    input_type: DaffCompositeProductItemInputEnum;
+    /**
+     * The options that may be chosen for the item.
+     */
+    options: DaffCompositeProductItemOption[];
+}
+/**
+ * The composite product item option is a DaffProduct that can be added to a composite product.
+ */
+interface DaffCompositeProductItemOption extends DaffProduct {
+    /**
+     * Whether the option is the default option for its parent {@link DaffCompositeProductItem}.
+     */
+    is_default: boolean;
+    /**
+     * The quantity chosen for the option.
+     */
+    quantity: number;
+}
+
+/**
+ * A composite product is a group of products sold together. It includes one primary product and many accessory "items".
+ * The composite product items are additional products the customer might want to purchase with the primary product,
+ * and each item has a number of options from which the user can choose. Composite product items can be optional or required.
+ * For example, a toolbox bundle might have a primary product of the toolbox. The items could be a hammer and a screw driver,
+ * and the options for these items could be two different hammers and two different screwdrivers between which the customer could choose.
+ * All of these items could have different prices/discounts/etc which would cause the composite products to have ranged prices.
+ */
+interface DaffCompositeProduct extends DaffProduct {
+    /**
+     * The available items for the composite product.
+     */
+    items: DaffCompositeProductItem[];
+}
+
+/**
+ * Denotes a particular configuration for a composite item.
+ */
+type DaffProductCompositeSelectionPayload = Record<DaffCompositeProductItem['id'], DaffCompositeProductItemOption['id'][]>;
+
+declare function daffProductCompositeBuildSelectionPayload(appliedOptions: Record<DaffCompositeProductItem['id'], DaffCompositeProductItemOption>): DaffProductCompositeSelectionPayload;
+
+export { DaffCompositeProductItemInputEnum, daffProductCompositeBuildSelectionPayload };
+export type { DaffCompositeConfigurationItem, DaffCompositeProduct, DaffCompositeProductItem, DaffCompositeProductItemOption, DaffProductCompositeSelectionPayload };

package/package.json

@@ -1 +1 @@
-{"name":"@daffodil/product-composite","nx":{"targets":{"build":{"outputs":["{workspaceRoot}/dist/product-composite"]}}},"version":"0.88.1","description":"Interfaces built for daffodil/state","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/product-composite"},"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","@daffodil/product":"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-product-composite.mjs","typings":"index.d.ts","exports":{"./package.json":{"default":"./package.json"},".":{"types":"./index.d.ts","default":"./fesm2022/daffodil-product-composite.mjs"},"./routing":{"types":"./routing/index.d.ts","default":"./fesm2022/daffodil-product-composite-routing.mjs"},"./state":{"types":"./state/index.d.ts","default":"./fesm2022/daffodil-product-composite-state.mjs"},"./testing":{"types":"./testing/index.d.ts","default":"./fesm2022/daffodil-product-composite-testing.mjs"},"./driver/in-memory":{"types":"./driver/in-memory/index.d.ts","default":"./fesm2022/daffodil-product-composite-driver-in-memory.mjs"},"./driver/magento":{"types":"./driver/magento/index.d.ts","default":"./fesm2022/daffodil-product-composite-driver-magento.mjs"},"./driver/testing":{"types":"./driver/testing/index.d.ts","default":"./fesm2022/daffodil-product-composite-driver-testing.mjs"},"./state/testing":{"types":"./state/testing/index.d.ts","default":"./fesm2022/daffodil-product-composite-state-testing.mjs"},"./driver/magento/testing":{"types":"./driver/magento/testing/index.d.ts","default":"./fesm2022/daffodil-product-composite-driver-magento-testing.mjs"}},"sideEffects":false,"dependencies":{"tslib":"^2.3.0"}}
+{"name":"@daffodil/product-composite","nx":{"targets":{"build":{"outputs":["{workspaceRoot}/dist/product-composite"]}}},"version":"0.89.0","description":"Interfaces built for daffodil/state","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/product-composite"},"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","@daffodil/product":"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-product-composite.mjs","typings":"index.d.ts","exports":{"./package.json":{"default":"./package.json"},".":{"types":"./index.d.ts","default":"./fesm2022/daffodil-product-composite.mjs"},"./routing":{"types":"./routing/index.d.ts","default":"./fesm2022/daffodil-product-composite-routing.mjs"},"./state":{"types":"./state/index.d.ts","default":"./fesm2022/daffodil-product-composite-state.mjs"},"./testing":{"types":"./testing/index.d.ts","default":"./fesm2022/daffodil-product-composite-testing.mjs"},"./driver/in-memory":{"types":"./driver/in-memory/index.d.ts","default":"./fesm2022/daffodil-product-composite-driver-in-memory.mjs"},"./driver/magento":{"types":"./driver/magento/index.d.ts","default":"./fesm2022/daffodil-product-composite-driver-magento.mjs"},"./driver/testing":{"types":"./driver/testing/index.d.ts","default":"./fesm2022/daffodil-product-composite-driver-testing.mjs"},"./state/testing":{"types":"./state/testing/index.d.ts","default":"./fesm2022/daffodil-product-composite-state-testing.mjs"},"./driver/magento/testing":{"types":"./driver/magento/testing/index.d.ts","default":"./fesm2022/daffodil-product-composite-driver-magento-testing.mjs"}},"sideEffects":false,"dependencies":{"tslib":"^2.3.0"}}

package/routing/index.d.ts

@@ -1 +1,75 @@
-export * from './public_api';
+import * as i0 from '@angular/core';
+import { InjectionToken, ModuleWithProviders } from '@angular/core';
+import { DaffBase64Service } from '@daffodil/core';
+import { DaffCompositeProduct, DaffProductCompositeSelectionPayload } from '@daffodil/product-composite';
+import * as i1 from '@ngrx/effects';
+import { Actions } from '@ngrx/effects';
+import { Observable, EMPTY } from 'rxjs';
+import { DaffCompositeProductApplyOption } from '@daffodil/product-composite/state';
+
+/**
+ * An interface for providing `@daffodil/product-composite/routing` with necessary config values.
+ */
+interface DaffProductCompositeRoutingConfig {
+    /**
+     * The name of the query param for which a composite product page preselection can be defined.
+     * The value of this query param should be a {@link DaffProductCompositeSelectionPayload} after being base64 decoded and JSON parsed.
+     *
+     * Defaults to `composite_selection`.
+     */
+    compositeSelectionQueryParam?: string;
+    /**
+     * The function used to decode the value of the {@link DaffProductCompositeStateConfig#compositeSelectionQueryParam}
+     * into a {@link DaffProductCompositeSelectionPayload}.
+     *
+     * Defaults to `(queryParam: string) => JSON.parse(atob(queryParam))`.
+     */
+    compositeSelectionQueryParamDecode?: (queryParam: string, product: DaffCompositeProduct) => DaffProductCompositeSelectionPayload;
+}
+
+/**
+ * The default configuration for the {@link DaffProductCompositeRoutingConfig}.
+ */
+declare const daffProductCompositeRoutingConfigDefaultFactory: (base64: DaffBase64Service) => DaffProductCompositeRoutingConfig;
+declare const DAFF_PRODUCT_COMPOSITE_ROUTING_CONFIG_DEFAULT: InjectionToken<DaffProductCompositeRoutingConfig>;
+
+declare const DAFF_PRODUCT_COMPOSITE_ROUTING_CONFIG: i0.InjectionToken<DaffProductCompositeRoutingConfig>;
+declare const provideDaffProductCompositeRoutingConfig: <R extends DaffProductCompositeRoutingConfig = DaffProductCompositeRoutingConfig>(config: Partial<R> | i0.InjectionToken<Partial<R>>) => i0.FactoryProvider;
+
+declare class DaffProductCompositeQueryParamService {
+    private document;
+    private config;
+    constructor(document: any, config: DaffProductCompositeRoutingConfig);
+    /**
+     * Get the value of the configured composite selection query param.
+     */
+    get(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffProductCompositeQueryParamService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffProductCompositeQueryParamService>;
+}
+
+/**
+ * Handles composite product specific actions for the product page.
+ */
+declare class DaffProductCompositePageEffects<T extends DaffCompositeProduct = DaffCompositeProduct> {
+    private actions$;
+    private paramGetter;
+    private config;
+    constructor(actions$: Actions, paramGetter: DaffProductCompositeQueryParamService, config: DaffProductCompositeRoutingConfig);
+    /**
+     * Applies composite item options based on the value of the configured query param.
+     */
+    preselectCompositeOptions$: Observable<typeof EMPTY | DaffCompositeProductApplyOption<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffProductCompositePageEffects<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffProductCompositePageEffects<any>>;
+}
+
+declare class DaffProductCompositeRoutingModule {
+    static withConfig(config?: DaffProductCompositeRoutingConfig): ModuleWithProviders<DaffProductCompositeRoutingModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffProductCompositeRoutingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffProductCompositeRoutingModule, never, [typeof i1.EffectsFeatureModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DaffProductCompositeRoutingModule>;
+}
+
+export { DAFF_PRODUCT_COMPOSITE_ROUTING_CONFIG, DAFF_PRODUCT_COMPOSITE_ROUTING_CONFIG_DEFAULT, DaffProductCompositePageEffects, DaffProductCompositeRoutingModule, daffProductCompositeRoutingConfigDefaultFactory, provideDaffProductCompositeRoutingConfig };
+export type { DaffProductCompositeRoutingConfig };

package/state/index.d.ts

@@ -1 +1,321 @@
-export * from './public_api';
+import * as _ngrx_store from '@ngrx/store';
+import { Action, Store, ActionReducerMap, ActionReducer, MemoizedSelector } from '@ngrx/store';
+import { DaffCompositeProduct, DaffCompositeProductItem, DaffCompositeProductItemOption, DaffCompositeConfigurationItem } from '@daffodil/product-composite';
+import { Dictionary, EntityState } from '@ngrx/entity';
+import { Observable } from 'rxjs';
+import { DaffStoreFacade } from '@daffodil/core/state';
+import { DaffPriceRange, DaffProduct } from '@daffodil/product';
+import * as _daffodil_product_composite_state from '@daffodil/product-composite/state';
+import { DaffProductStateRootSlice, DaffProductReducersState } from '@daffodil/product/state';
+import * as i0 from '@angular/core';
+import * as node_modules__ngrx_entity_src_models from 'node_modules/@ngrx/entity/src/models';
+
+/**
+ * Action types for Composite Product Actions.
+ */
+declare enum DaffCompositeProductActionTypes {
+    CompositeProductApplyOptionAction = "[@daffodil/product-composite] Composite Product Apply Option Action"
+}
+/**
+ * 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.
+ */
+declare class DaffCompositeProductApplyOption<T extends DaffCompositeProduct = DaffCompositeProduct> implements Action {
+    id: T['id'];
+    itemId: DaffCompositeProductItem['id'];
+    optionId: DaffCompositeProductItemOption['id'];
+    qty?: number;
+    readonly type = DaffCompositeProductActionTypes.CompositeProductApplyOptionAction;
+    constructor(id: T['id'], itemId: DaffCompositeProductItem['id'], optionId: DaffCompositeProductItemOption['id'], qty?: number);
+}
+type DaffCompositeProductActions<T extends DaffCompositeProduct = DaffCompositeProduct> = DaffCompositeProductApplyOption<T>;
+
+/**
+ * A facade for interacting with the composite product state.
+ * Exposes many parts of the state for easy access and allows dispatching of actions.
+ */
+interface DaffCompositeProductFacadeInterface extends DaffStoreFacade<Action> {
+    /**
+     * Get a DaffPriceRange for a composite product based on the configuration provided excluding unselected, optional item prices.
+     *
+     * @param id an id for a composite product
+     * @param configuration a Dictionary of DaffCompositeConfigurationItems
+     */
+    getRequiredItemPricesForConfiguration(id: DaffCompositeProduct['id'], configuration?: Dictionary<DaffCompositeConfigurationItem>): Observable<DaffPriceRange>;
+    /**
+     * Get the broadest possible DaffPriceRange for a composite product based on the configuration provided including optional item prices.
+     *
+     * @param id the id of the composite product.
+     * @param configuration a Dictionary of DaffCompositeConfigurationItems
+     */
+    getOptionalItemPricesForConfiguration(id: DaffCompositeProduct['id'], configuration?: Dictionary<DaffCompositeConfigurationItem>): Observable<DaffPriceRange>;
+    /**
+     * Get the DaffPriceRange for a composite product based on the current configuration of selected item options in redux state and
+     * excluding unselected, optional item prices.
+     *
+     * @param id the id of the composite product.
+     */
+    getPricesAsCurrentlyConfigured(id: DaffCompositeProduct['id']): Observable<DaffPriceRange>;
+    /**
+     * Returns the applied options for a composite product.
+     *
+     * @param id the id of the composite product.
+     */
+    getAppliedOptions(id: DaffCompositeProduct['id']): Observable<Dictionary<DaffCompositeProductItemOption>>;
+    /**
+     * Returns whether the item of a composite product is required.
+     *
+     * @param id the id of the composite product.
+     * @param item_id the id of the item_id.
+     */
+    isItemRequired(id: DaffCompositeProduct['id'], item_id: DaffCompositeProductItem['id']): Observable<boolean>;
+    /**
+     * Returns whether a DaffPriceRange has a discount.
+     *
+     * @param priceRange a DaffPriceRange
+     */
+    hasDiscount(priceRange: DaffPriceRange): boolean;
+    /**
+     * Returns the discount amount of a composite product based on the current configuration of the selected item options in redux
+     * state and excluding unselected, optional item prices. Will return undefined if all required options are not chosen.
+     *
+     * @param id the id of the composite product.
+     */
+    getDiscountAmount(id: DaffCompositeProduct['id']): Observable<number>;
+    /**
+     * Returns the discount percent of a composite product based on the current configuration of the selected item options in redux
+     * state and excluding unselected, optional item prices. Will return undefined if all required options are not chosen.
+     * Note: This percent is computed client-side and should be treated as an estimate rather than an exact value.
+     *
+     * @param id the id of the composite product.
+     */
+    getDiscountPercent(id: DaffCompositeProduct['id']): Observable<number>;
+    /**
+     * Returns whether the min and max prices of a DaffPriceRange are different.
+     *
+     * @param priceRange a DaffPriceRange
+     */
+    hasPriceRange(priceRange: DaffPriceRange): boolean;
+}
+
+/**
+ * Describes how composite product configurations are stored in rxjs entity state.
+ */
+interface DaffCompositeProductEntity {
+    /**
+     * The id of the composite product.
+     */
+    id: DaffProduct['id'];
+    /**
+     * A dictionary of the configurations set for a composite product.
+     */
+    items: Dictionary<DaffCompositeConfigurationItem>;
+}
+
+declare const DAFF_COMPOSITE_PRODUCT_STORE_FEATURE_KEY = "daffCompositeProduct";
+
+/**
+ * Interface for the redux store of the composite product feature area.
+ */
+interface DaffCompositeProductReducersState {
+    compositeProductOptions: EntityState<DaffCompositeProductEntity>;
+}
+interface DaffCompositeProductStateRootSlice<T extends DaffProduct = DaffProduct> extends DaffProductStateRootSlice<T> {
+    [DAFF_COMPOSITE_PRODUCT_STORE_FEATURE_KEY]: DaffCompositeProductReducersState;
+}
+
+/**
+ * A facade for interacting with the composite product state.
+ * Exposes many parts of the state for easy access and allows dispatching of actions.
+ *
+ * @inheritdoc
+ */
+declare class DaffCompositeProductFacade<T extends DaffProduct = DaffProduct> implements DaffCompositeProductFacadeInterface {
+    private store;
+    constructor(store: Store<DaffCompositeProductStateRootSlice<T>>);
+    compositeProductSelectors: _daffodil_product_composite_state.DaffCompositeProductAllSelectors<T>;
+    hasDiscount: (priceRange: DaffPriceRange) => boolean;
+    hasPriceRange: (priceRange: DaffPriceRange) => boolean;
+    getRequiredItemPricesForConfiguration(id: T['id'], configuration?: Dictionary<DaffCompositeConfigurationItem>): Observable<DaffPriceRange>;
+    getOptionalItemPricesForConfiguration(id: T['id'], configuration?: Dictionary<DaffCompositeConfigurationItem>): Observable<DaffPriceRange>;
+    getPricesAsCurrentlyConfigured(id: T['id']): Observable<DaffPriceRange>;
+    getAppliedOptions(id: T['id']): Observable<Dictionary<DaffCompositeProductItemOption>>;
+    getDiscountAmount(id: T['id']): Observable<number>;
+    getDiscountPercent(id: T['id']): Observable<number>;
+    isItemRequired(id: T['id'], item_id: DaffCompositeProductItem['id']): Observable<boolean>;
+    dispatch(action: Action): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCompositeProductFacade<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCompositeProductFacade<any>>;
+}
+
+/**
+ * Returns state values from all composite product related reducers.
+ */
+declare const daffCompositeProductReducers: ActionReducerMap<DaffCompositeProductReducersState>;
+
+/**
+ * Composite Product Item Options Adapter for changing/overwriting entity state.
+ */
+declare class DaffCompositeProductAppliedOptionsEntitiesAdapter<T extends EntityState<DaffCompositeProductEntity> = EntityState<DaffCompositeProductEntity>> {
+    /**
+     * @docs-private
+     */
+    private _adapter;
+    /**
+     * Gets the initial entity state.
+     */
+    getInitialState(): EntityState<DaffCompositeProductEntity>;
+    /**
+     * Get the entity selectors.
+     */
+    getSelectors(): node_modules__ngrx_entity_src_models.EntitySelectors<DaffCompositeProductEntity, EntityState<DaffCompositeProductEntity>>;
+    /**
+     * Upserts the given composite products into state.
+     */
+    upsertProducts(state: T, ...products: DaffCompositeProduct[]): T;
+    /**
+     * Apply the specified option for the given composite product item.
+     */
+    applyOption(state: T, productId: DaffCompositeProduct['id'], itemId: DaffCompositeProductItem['id'], optionId: DaffCompositeProductItemOption['id'], qty?: number): T;
+    /**
+     * @docs-private
+     */
+    private mapOptionsEntities;
+    /**
+     * @docs-private
+     */
+    private buildCompositeProductAppliedOptionsEntity;
+    /**
+     * 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
+     */
+    private getDefaultOption;
+}
+/**
+ * Gets the composite product entity adapter singleton.
+ */
+declare const daffCompositeProductAppliedOptionsEntitiesAdapter: () => DaffCompositeProductAppliedOptionsEntitiesAdapter;
+
+declare const DAFF_PRODUCT_COMPOSITE_EXTRA_REDUCERS: i0.InjectionToken<ActionReducer<DaffCompositeProductReducersState, _ngrx_store.Action<string>>[]>;
+declare const daffProductCompositeProvideExtraReducers: <R extends ActionReducer<DaffCompositeProductReducersState, _ngrx_store.Action<string>> = ActionReducer<DaffCompositeProductReducersState, _ngrx_store.Action<string>>>(...values: R[]) => Array<i0.ValueProvider>;
+
+/**
+ * An interface describing selectors unique to the composite product, such as pricing and discounts.
+ */
+interface DaffCompositeProductMemoizedSelectors<T extends DaffProduct = DaffProduct> {
+    /**
+     * Get a DaffPriceRange for a composite product based on the configuration provided excluding unselected, optional item prices.
+     */
+    selectCompositeProductRequiredItemPricesForConfiguration: (id: DaffCompositeProduct['id'], configuration?: Dictionary<DaffCompositeConfigurationItem>) => MemoizedSelector<DaffCompositeProductStateRootSlice<T>, DaffPriceRange>;
+    /**
+     * Get the broadest possible DaffPriceRange for a composite product based on the configuration provided including optional item prices.
+     */
+    selectCompositeProductOptionalItemPricesForConfiguration: (id: DaffCompositeProduct['id'], configuration?: Dictionary<DaffCompositeConfigurationItem>) => MemoizedSelector<DaffCompositeProductStateRootSlice<T>, DaffPriceRange>;
+    /**
+     * Get the DaffPriceRange for a composite product based on the current configuration of selected item options in redux state and
+     * excluding unselected, optional item prices.
+     */
+    selectCompositeProductPricesAsCurrentlyConfigured: (id: DaffCompositeProduct['id']) => MemoizedSelector<DaffCompositeProductStateRootSlice<T>, DaffPriceRange>;
+    /**
+     * Get the discount amount for a composite product. This value will be undefined if all required options are not chosen.
+     */
+    selectCompositeProductDiscountAmount: (id: DaffCompositeProduct['id']) => MemoizedSelector<DaffCompositeProductStateRootSlice<T>, number>;
+    /**
+     * Get the discount percent for a composite product. This value will be undefined if all required options are not chosen.
+     * Note: this percent is computed client-side and should be treated as an estimate rather than an exact value.
+     */
+    selectCompositeProductDiscountPercent: (id: DaffCompositeProduct['id']) => MemoizedSelector<DaffCompositeProductStateRootSlice<T>, number>;
+}
+/**
+ * A function that returns all selectors related to the composite product feature.
+ *
+ * Returns {@link DaffCompositeProductMemoizedSelectors}.
+ */
+declare const getDaffCompositeProductPriceSelectors: <T extends DaffProduct = DaffProduct>() => DaffCompositeProductMemoizedSelectors<T>;
+
+/**
+ * An interface for selectors related to the composite product applied options.
+ */
+interface DaffCompositeProductEntitiesMemoizedSelectors<T extends DaffProduct = DaffProduct> {
+    /**
+     * The ngrx entities state for composite product applied options.
+     */
+    selectCompositeProductAppliedOptionsEntitiesState: MemoizedSelector<DaffCompositeProductStateRootSlice<T>, EntityState<DaffCompositeProductEntity>>;
+    /**
+     * A selector for all composite product ids in state.
+     */
+    selectCompositeProductIds: MemoizedSelector<DaffCompositeProductStateRootSlice<T>, EntityState<DaffCompositeProductEntity>['ids']>;
+    /**
+     * The ngrx entities for the composite product appllied options.
+     */
+    selectCompositeProductAppliedOptionsEntities: MemoizedSelector<DaffCompositeProductStateRootSlice<T>, EntityState<DaffCompositeProductEntity>['entities']>;
+    /**
+     * The total number of composite products in state.
+     */
+    selectCompositeProductTotal: MemoizedSelector<DaffCompositeProductStateRootSlice<T>, number>;
+    /**
+     * Selects the applied options for a composite product.
+     *
+     * @param id the id of the composite product.
+     */
+    selectCompositeProductAppliedOptions: (id: T['id']) => MemoizedSelector<DaffCompositeProductStateRootSlice<T>, Dictionary<DaffCompositeProductItemOption>>;
+    /**
+     * Selects whether the particular item of a composite product is required in order for the product to be valid, i.e. addable to the cart.
+     *
+     * @param id the id of the composite product.
+     * @param item_id the id of the composite product item.
+     */
+    selectIsCompositeProductItemRequired: (id: T['id'], item_id: DaffCompositeProductItem['id']) => MemoizedSelector<DaffCompositeProductStateRootSlice<T>, boolean>;
+}
+/**
+ * A function that returns all selectors related to composite product applied option entities.
+ * Returns {@link DaffCompositeProductEntitiesMemoizedSelectors}.
+ */
+declare const getDaffCompositeProductEntitiesSelectors: <T extends DaffProduct>() => DaffCompositeProductEntitiesMemoizedSelectors<T>;
+
+/**
+ * An interface for all selectors in the composite product feature area.
+ */
+interface DaffCompositeProductAllSelectors<T extends DaffProduct = DaffProduct> extends DaffCompositeProductEntitiesMemoizedSelectors<T>, DaffCompositeProductMemoizedSelectors<T> {
+}
+/**
+ * A function that returns all selectors in the composite product feature area.
+ * Returns {@link DaffCompositeProductAllSelectors}.
+ */
+declare const getDaffCompositeProductSelectors: <T extends DaffProduct>() => DaffCompositeProductAllSelectors<T>;
+
+/**
+ * An interface for the composite product feature state.
+ */
+interface DaffCompositeProductFeatureMemoizedSelector {
+    selectCompositeProductState: MemoizedSelector<Record<string, any>, DaffCompositeProductReducersState>;
+}
+/**
+ * A function that returns a selector for the composite product feature state.
+ */
+declare const getDaffCompositeProductFeatureSelector: () => DaffCompositeProductFeatureMemoizedSelector;
+
+/**
+ * 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.
+ */
+declare function daffProductCompositeEnsureItems<T extends DaffCompositeProduct = DaffCompositeProduct>(state: DaffProductReducersState<T>, products: T[]): T[];
+
+/**
+ * A module that provides the default reducers and effects for composite product redux state.
+ */
+declare class DaffCompositeProductStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCompositeProductStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffCompositeProductStateModule, never, [typeof _ngrx_store.StoreFeatureModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DaffCompositeProductStateModule>;
+}
+
+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 };
+export type { DaffCompositeProductActions, DaffCompositeProductAllSelectors, DaffCompositeProductEntitiesMemoizedSelectors, DaffCompositeProductEntity, DaffCompositeProductFacadeInterface, DaffCompositeProductFeatureMemoizedSelector, DaffCompositeProductMemoizedSelectors, DaffCompositeProductReducersState, DaffCompositeProductStateRootSlice };

package/state/testing/index.d.ts

@@ -1 +1,32 @@
-export * from './public_api';
+import { Dictionary } from '@ngrx/entity';
+import { BehaviorSubject } from 'rxjs';
+import { DaffPriceRange } from '@daffodil/product';
+import { DaffCompositeProduct, DaffCompositeConfigurationItem, DaffCompositeProductItemOption, DaffCompositeProductItem } from '@daffodil/product-composite';
+import { DaffCompositeProductFacadeInterface } from '@daffodil/product-composite/state';
+import * as i0 from '@angular/core';
+
+/**
+ * @inheritdoc
+ */
+declare class MockDaffCompositeProductFacade implements DaffCompositeProductFacadeInterface {
+    getRequiredItemPricesForConfiguration(id: DaffCompositeProduct['id'], configuration?: Dictionary<DaffCompositeConfigurationItem>): BehaviorSubject<DaffPriceRange>;
+    getOptionalItemPricesForConfiguration(id: DaffCompositeProduct['id'], configuration?: Dictionary<DaffCompositeConfigurationItem>): BehaviorSubject<DaffPriceRange>;
+    getPricesAsCurrentlyConfigured(id: DaffCompositeProduct['id']): BehaviorSubject<DaffPriceRange>;
+    getAppliedOptions(id: DaffCompositeProduct['id']): BehaviorSubject<Dictionary<DaffCompositeProductItemOption>>;
+    getDiscountAmount(id: DaffCompositeProduct['id']): BehaviorSubject<number>;
+    getDiscountPercent(id: DaffCompositeProduct['id']): BehaviorSubject<number>;
+    isItemRequired(id: DaffCompositeProduct['id'], item_id: DaffCompositeProductItem['id']): BehaviorSubject<boolean>;
+    dispatch(action: any): void;
+    hasDiscount(priceRange: DaffPriceRange): boolean;
+    hasPriceRange(priceRange: DaffPriceRange): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MockDaffCompositeProductFacade, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MockDaffCompositeProductFacade>;
+}
+
+declare class DaffCompositeProductStateTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCompositeProductStateTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffCompositeProductStateTestingModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DaffCompositeProductStateTestingModule>;
+}
+
+export { DaffCompositeProductStateTestingModule, MockDaffCompositeProductFacade };

package/testing/index.d.ts

@@ -1 +1,64 @@
-export * from './public_api';
+import * as _daffodil_product_composite from '@daffodil/product-composite';
+import { DaffCompositeProductItemOption, DaffCompositeProductItem, DaffCompositeProductItemInputEnum, DaffCompositeProduct } from '@daffodil/product-composite';
+import { DaffModelFactory } from '@daffodil/core/testing';
+import { DaffProductTypeEnum } from '@daffodil/product';
+import { DaffProductImageFactory, MockProduct } from '@daffodil/product/testing';
+import * as i0 from '@angular/core';
+
+/**
+ * Mocked DaffCompositeProductItemOption object.
+ */
+declare class MockCompositeProductItemOption extends MockProduct implements DaffCompositeProductItemOption {
+    quantity: number;
+    is_default: boolean;
+}
+/**
+ * Factory for creating DaffCompositeProductItemOptions.
+ */
+declare class DaffCompositeProductItemOptionFactory extends DaffModelFactory<DaffCompositeProductItemOption> {
+    constructor(imageFactory: DaffProductImageFactory);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCompositeProductItemOptionFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCompositeProductItemOptionFactory>;
+}
+
+/**
+ * Mocked DaffCompositeProductItem object.
+ */
+declare class MockCompositeProductItem implements DaffCompositeProductItem {
+    protected optionFactory: DaffCompositeProductItemOptionFactory;
+    id: string;
+    url: string;
+    required: boolean;
+    title: string;
+    input_type: DaffCompositeProductItemInputEnum;
+    options: _daffodil_product_composite.DaffCompositeProductItemOption[];
+    constructor(optionFactory: DaffCompositeProductItemOptionFactory);
+}
+/**
+ * Factory for creating DaffCompositeProductItems.
+ */
+declare class DaffCompositeProductItemFactory extends DaffModelFactory<DaffCompositeProductItem> {
+    constructor(optionFactory: DaffCompositeProductItemOptionFactory);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCompositeProductItemFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCompositeProductItemFactory>;
+}
+
+/**
+ * Mocked DaffCompositeProduct object.
+ */
+declare class MockCompositeProduct extends MockProduct implements DaffCompositeProduct {
+    protected itemFactory: DaffCompositeProductItemFactory;
+    type: DaffProductTypeEnum;
+    items: _daffodil_product_composite.DaffCompositeProductItem[];
+    constructor(itemFactory: DaffCompositeProductItemFactory, imageFactory: DaffProductImageFactory);
+}
+/**
+ * Factory for creating DaffCompositeProducts.
+ */
+declare class DaffCompositeProductFactory extends DaffModelFactory<DaffCompositeProduct> {
+    constructor(itemFactory: DaffCompositeProductItemFactory, imageFactory: DaffProductImageFactory);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCompositeProductFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DaffCompositeProductFactory>;
+}
+
+export { DaffCompositeProductFactory, DaffCompositeProductItemFactory, DaffCompositeProductItemOptionFactory, MockCompositeProduct, MockCompositeProductItem, MockCompositeProductItemOption };

package/driver/in-memory/in-memory.module.d.ts

@@ -1,12 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-/**
- * Module for providing the composite product factory to the product kind factory.
- */
-export declare class DaffCompositeProductInMemoryDriverModule {
-    static forRoot(): ModuleWithProviders<DaffCompositeProductInMemoryDriverModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DaffCompositeProductInMemoryDriverModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DaffCompositeProductInMemoryDriverModule, never, [typeof i1.CommonModule], never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<DaffCompositeProductInMemoryDriverModule>;
-}

package/driver/in-memory/public_api.d.ts

@@ -1 +0,0 @@
-export { DaffCompositeProductInMemoryDriverModule } from './in-memory.module';