{"version":3,"file":"static/js/32f59b3446712c08d870.bundle.js","mappings":"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","sources":["webpack://henrys-ecommerce/../../src/get-selected-variant.ts?f0c0","webpack://henrys-ecommerce/../../../src/utilities/QueryResultSettingsProxy.ts?5e44","webpack://henrys-ecommerce/../../../../src/utilities/data-structures/dictionary.ts?bab3","webpack://henrys-ecommerce/../../../../src/utilities/events/event.ts?15a9","webpack://henrys-ecommerce/../../../../src/utilities/extensions/array-extensions.ts?1a2a","webpack://henrys-ecommerce/../../../../src/utilities/extensions/enum-extensions.ts?cf51","webpack://henrys-ecommerce/../../../../src/utilities/extensions/string-extensions.ts?ab9f","webpack://henrys-ecommerce/../../../../src/utilities/extensions/object-extensions.ts?6388","webpack://henrys-ecommerce/../../../src/utilities/input-data-parser.ts?027a","webpack://henrys-ecommerce/../../../src/utilities/product-inventory-information.ts?0ec6","webpack://henrys-ecommerce/../../../src/utilities/product-inventory-utils.ts?58b5","webpack://henrys-ecommerce/../../../../src/utilities/promise-queue/finite-promise-queue.ts?77bf","webpack://henrys-ecommerce/../../../../src/utilities/promise-queue/promise-queue.ts?e362","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce-modules/retail-actions/node_modules/uuid/dist/esm-browser/rng.js?b47d","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce-modules/retail-actions/node_modules/uuid/dist/esm-browser/regex.js?08ba","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce-modules/retail-actions/node_modules/uuid/dist/esm-browser/validate.js?acea","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce-modules/retail-actions/node_modules/uuid/dist/esm-browser/stringify.js?6cb1","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce-modules/retail-actions/node_modules/uuid/dist/esm-browser/v4.js?0101","webpack://henrys-ecommerce/../../../../src/utilities/random/guid.ts?1947","webpack://henrys-ecommerce/../../../../src/utilities/random/index.ts?1f9d","webpack://henrys-ecommerce/../../../../src/utilities/regex/email-regex.ts?6a6a","webpack://henrys-ecommerce/../../../../src/utilities/regex/password-regex.ts?456d","webpack://henrys-ecommerce/../../../../src/utilities/regex/phone-regex.ts?9ada","webpack://henrys-ecommerce/../../../src/utilities/utils.ts?fbc0","webpack://henrys-ecommerce/../../../src/utilities/validate-cartlines-inventory.ts?8b82","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/internals/array-buffer-basic-detection.js?0429","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/internals/array-buffer-view-core.js?20bf","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/internals/array-fill.js?9b0a","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/internals/to-big-int.js?5a38","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/internals/to-offset.js?9e69","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/internals/to-positive-integer.js?6846","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/modules/es.typed-array.fill.js?1565","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/modules/es.typed-array.set.js?bcef","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/modules/es.typed-array.sort.js?d3e0","webpack://henrys-ecommerce/./node_modules/@msdyn365-commerce/bootloader/node_modules/core-js/modules/es.typed-array.to-locale-string.js?151d"],"sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { IProductDimensionsWithAvailabilitiesFull } from '@msdyn365-commerce/commerce-entities';\nimport {\n    CacheType,\n    createObservableDataAction,\n    getCatalogId,\n    IAction,\n    IActionContext,\n    IActionInput,\n    IAny,\n    ICreateActionContext,\n    IGeneric,\n    IRequestContext\n} from '@msdyn365-commerce/core';\nimport {\n    BypassCache,\n    ProductDimension,\n    ProductDimensionAvailabilitySearchCriteria,\n    ProductsDataActions,\n    SimpleProduct\n} from '@msdyn365-commerce/retail-proxy';\n\nimport { ArrayExtensions } from './utilities';\nimport { createInventoryAvailabilitySearchCriteria } from './utilities/product-inventory-utils';\nimport { QueryResultSettingsProxy } from './utilities/QueryResultSettingsProxy';\nimport { generateProductImageUrl, getDimensionValuesFromQuery, getSelectedProductIdFromActionInput } from './utilities/utils';\n\n/**\n * Stores data about the selected product.\n */\nexport interface ISelectedProduct extends SimpleProduct {\n    productVariant?: SimpleProduct;\n}\n\n/**\n * Get selected variant action input class.\n */\nexport class SelectedVariantInput implements IActionInput {\n    public productId: number;\n\n    public channelId: number;\n\n    public matchingDimensionValues?: ProductDimension[];\n\n    public bypassCache?: BypassCache;\n\n    public catalogId?: number;\n\n    public constructor(\n        productId: number,\n        channelId: number,\n        matchingDimensionValues?: ProductDimension[],\n        bypassCache?: BypassCache,\n        requestContext?: IRequestContext\n    ) {\n        this.productId = productId;\n        this.channelId = channelId;\n        this.matchingDimensionValues = matchingDimensionValues;\n        this.bypassCache = bypassCache;\n\n        if (requestContext) {\n            this.catalogId = getCatalogId(requestContext);\n        }\n    }\n\n    /**\n     * Cache key.\n     * @returns String.\n     */\n    public getCacheKey: () => string = () => 'SelectedVariant';\n\n    /**\n     * Cache object type.\n     * @returns String.\n     */\n    public getCacheObjectType: () => string = () => 'SimpleProduct';\n\n    /**\n     * Cache type.\n     * @returns String.\n     */\n    public dataCacheType = (): CacheType => 'none';\n}\n\n/**\n * CreateInput method for the getSelectedVariant data action.\n * @param inputData - The input data passed to the createInput method.\n * @returns The input for the ata action getSelectedVariantNewAction.\n */\nconst createInput = (inputData: ICreateActionContext<IGeneric<IAny>>): SelectedVariantInput => {\n    const productId = getSelectedProductIdFromActionInput(inputData);\n\n    if (productId) {\n        return new SelectedVariantInput(\n            +productId,\n            +inputData.requestContext.apiSettings.channelId,\n            undefined,\n            undefined,\n            inputData.requestContext\n        );\n    }\n    throw new Error('Unable to create SelectedVariantInput, no productId found on module config or query');\n};\n\n/**\n * Checks if given product has any unmatched dimensions.\n * Modifies product entity to use matched dimension values.\n * @param product - The product to analyze and modify.\n * @param matchingDimensionValues - Matched dimensions.\n * @returns True if has any unmatched dimension, false if all dimensions are specified.\n */\nconst checkIfHasUnmatchedDimensions = (product: SimpleProduct, matchingDimensionValues: ProductDimension[]): boolean => {\n    let hasUnmatchedDimension: boolean = false;\n    if (product.Dimensions) {\n        product.Dimensions = product.Dimensions.map(dimension => {\n            return { ...dimension };\n        });\n        for (const dimension of product.Dimensions) {\n            const matchedTargetDimension = matchingDimensionValues.find(\n                targetDimension => targetDimension.DimensionTypeValue === dimension.DimensionTypeValue\n            );\n\n            if (matchedTargetDimension) {\n                dimension.DimensionValue = matchedTargetDimension.DimensionValue;\n            } else {\n                hasUnmatchedDimension = true;\n            }\n        }\n    }\n    return hasUnmatchedDimension;\n};\n\n/**\n * Retrieves product dimensions with availabilities.\n * @param product - Product for which the dimensions need to be retrieved.\n * @param matchingDimensionValues - Selected dimensions - filter criteria for the dimensions API.\n * @param context - Action context.\n * @param catalogId - Catalog id.\n * @returns Array of dimensions.\n */\nconst getFullDimensions = async (\n    product: SimpleProduct,\n    matchingDimensionValues: ProductDimension[],\n    context: IActionContext,\n    catalogId?: number\n) => {\n    let fullDimensions: IProductDimensionsWithAvailabilitiesFull[] = [];\n    const fullDimensionPromises = (product.Dimensions ?? []).map(dimension => {\n        const shippingInventoryConfiguration = createInventoryAvailabilitySearchCriteria(context, [], true, undefined, undefined);\n        const searchCriteria: ProductDimensionAvailabilitySearchCriteria = {\n            RequestedDimensionTypeValue: dimension.DimensionTypeValue,\n            MatchingDimensionValues: matchingDimensionValues,\n            DefaultWarehouseOnly: shippingInventoryConfiguration.DefaultWarehouseOnly,\n            FilterByChannelFulfillmentGroup: shippingInventoryConfiguration.FilterByChannelFulfillmentGroup,\n            DeliveryModeTypeFilterValue: shippingInventoryConfiguration.DeliveryModeTypeFilterValue,\n            CatalogId: catalogId\n        };\n        const dimensionValuesPromise = ProductsDataActions.getDimensionValuesWithEstimatedAvailabilitiesAsync(\n            { callerContext: context, queryResultSettings: QueryResultSettingsProxy.getPagingFromInputDataOrDefaultValue(context) },\n            product.MasterProductId ? product.MasterProductId : product.RecordId,\n            searchCriteria\n        );\n\n        return dimensionValuesPromise.then(dimensionValues => {\n            const fullDimension: IProductDimensionsWithAvailabilitiesFull = {\n                ...dimension,\n                dimensionValuesWithInventory: dimensionValues\n            };\n            return fullDimension;\n        });\n    });\n    fullDimensions = await Promise.all(fullDimensionPromises);\n    return fullDimensions;\n};\n\n/**\n * Retrieves product variant for the given input or undefined if not found.\n * @param input - Action input.\n * @param context - Action context.\n * @param fullDimensions - Product dimensions with availabilities.\n * @returns A product variant that is available or undefined.\n */\nconst getProductVariant = async (\n    input: SelectedVariantInput,\n    context: IActionContext,\n    fullDimensions: IProductDimensionsWithAvailabilitiesFull[]\n) => {\n    let productVariant: SimpleProduct | undefined;\n    if (\n        ArrayExtensions.hasElements(fullDimensions) &&\n        ArrayExtensions.hasElements(fullDimensions[0].dimensionValuesWithInventory) &&\n        ArrayExtensions.hasElements(fullDimensions[0].dimensionValuesWithInventory[0].ProductIds)\n    ) {\n        const variantProductId = fullDimensions[0].dimensionValuesWithInventory[0].ProductIds[0];\n        const result = await ProductsDataActions.getByIdsAsync(\n            {\n                callerContext: context,\n                queryResultSettings: QueryResultSettingsProxy.getPagingFromInputDataOrDefaultValue(context),\n                bypassCache: input.bypassCache\n            },\n            input.channelId,\n            [variantProductId],\n            null,\n            input.catalogId ?? 0\n        );\n        productVariant = result[0];\n        productVariant = { ...productVariant };\n        const variantImageUrl = generateProductImageUrl(productVariant, context.requestContext.apiSettings);\n\n        if (variantImageUrl) {\n            productVariant.PrimaryImageUrl = variantImageUrl;\n        }\n    }\n\n    return productVariant;\n};\n\n/**\n * Action method for the getSelectedVariant data action.\n * @param input - The action input class.\n * @param context - The action context.\n * @returns Simple product.\n */\nasync function getSelectedVariantAction(input: SelectedVariantInput, context: IActionContext): Promise<ISelectedProduct | null> {\n    const matchingDimensionValues = input.matchingDimensionValues ?? getDimensionValuesFromQuery(context.requestContext.url.requestUrl);\n\n    const result = await ProductsDataActions.getByIdsAsync(\n        {\n            callerContext: context,\n            queryResultSettings: QueryResultSettingsProxy.getPagingFromInputDataOrDefaultValue(context),\n            bypassCache: input.bypassCache\n        },\n        input.channelId,\n        [input.productId],\n        null,\n        input.catalogId ?? 0\n    );\n    let product = result[0];\n\n    // Need to dereference this before editing it. Otherwise we might not\n    // properly get the mobx events because if things aren't properly observable\n    // they won't fire when you set them, and then if you don't deref the value in\n    // the cache will match the value when you try to save it, so it won't detect any\n    // changes there either\n    product = { ...product };\n    const hasUnmatchedDimension = checkIfHasUnmatchedDimensions(product, matchingDimensionValues);\n\n    const newImageUrl = generateProductImageUrl(product, context.requestContext.apiSettings);\n\n    if (newImageUrl) {\n        product.PrimaryImageUrl = newImageUrl;\n    }\n\n    const fullDimensions: IProductDimensionsWithAvailabilitiesFull[] = await getFullDimensions(\n        product,\n        matchingDimensionValues,\n        context,\n        input.catalogId\n    );\n\n    // Retrieve product variants only if matching dimensions are provided.\n    const productVariant: SimpleProduct | undefined = ArrayExtensions.hasElements(matchingDimensionValues)\n        ? await getProductVariant(input, context, fullDimensions)\n        : undefined;\n\n    // Update dimension value back to the one that comes from API since the URL query might have a different format for the dimension values.\n    if (productVariant?.Dimensions && product.Dimensions) {\n        for (const dimension of product.Dimensions) {\n            const matchedTargetDimensionFromApi = productVariant.Dimensions.find(\n                targetDimension => targetDimension.DimensionTypeValue === dimension.DimensionTypeValue\n            );\n            const matchedTargetDimensionFromSearch = matchingDimensionValues.find(\n                targetDimension => targetDimension.DimensionTypeValue === dimension.DimensionTypeValue\n            );\n\n            if (matchedTargetDimensionFromSearch && matchedTargetDimensionFromApi) {\n                dimension.DimensionValue = matchedTargetDimensionFromApi.DimensionValue;\n            }\n        }\n    }\n\n    if (!hasUnmatchedDimension && ArrayExtensions.hasElements(matchingDimensionValues) && productVariant) {\n        return productVariant;\n    }\n\n    const selectedProduct: ISelectedProduct = product;\n    selectedProduct.productVariant = productVariant;\n    return selectedProduct;\n}\n\n/**\n * The complete getSelectedVariant data action.\n */\nexport const getSelectedVariantActionDataAction = createObservableDataAction({\n    id: '@msdyn365-commerce-modules/retail-actions/get-selected-variant',\n    action: getSelectedVariantAction as IAction<ISelectedProduct | null>,\n    input: createInput\n});\n\nexport default getSelectedVariantActionDataAction;\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { IAny, ICreateActionContext, IGeneric, IRequestContext } from '@msdyn365-commerce/core';\nimport { QueryResultSettings, SortColumn } from '@msdyn365-commerce/retail-proxy';\n\nimport { IQueryResultSettingsModuleConfig } from './IQueryResultSettingsModuleConfig';\n\n/**\n * Wrapper for query result settings, which guarantees some properties that are optional in the real subject\n * and includes some common utilities for data actions.\n */\nexport class QueryResultSettingsProxy {\n    // Real subject\n    private readonly queryResultSettings: QueryResultSettings;\n\n    /**\n     * Factory method for data actions.\n     * @param inputData - Input data.\n     * @returns - Returns query result settings proxy.\n     */\n    public static fromInputData(inputData: ICreateActionContext<IGeneric<IAny>>): QueryResultSettingsProxy {\n        const { requestContext, config } = inputData;\n        return QueryResultSettingsProxy.fromModuleData(requestContext, config as IQueryResultSettingsModuleConfig);\n    }\n\n    /**\n     * Factory method for modules.\n     * @param requestContext - RequestContext.\n     * @param config - Module config from props.\n     * @returns - Returns query result settings proxy.\n     */\n    public static fromModuleData(requestContext: IRequestContext, config: IQueryResultSettingsModuleConfig): QueryResultSettingsProxy {\n        const sortingCriteria = (config && config.sortingCriteria) || undefined;\n        const query = requestContext && requestContext.query;\n        const top = (query && query.top) || undefined;\n        const skip = (query && query.skip) || undefined;\n\n        const queryResultSettings = {\n            Paging: {\n                Skip: (skip && Number(skip)) || 0,\n                Top: (top && Number(top)) || config?.itemsPerPage || 50\n            },\n            Sorting: sortingCriteria || {}\n        };\n\n        return new QueryResultSettingsProxy(queryResultSettings);\n    }\n\n    /**\n     * Return the query result settings with default paging or with the passed value.\n     * @param inputData - Input Data.\n     * @returns - Query Result settings.\n     */\n    public static getPagingFromInputDataOrDefaultValue(inputData: ICreateActionContext<IGeneric<IAny>>): QueryResultSettings {\n        const config: IQueryResultSettingsModuleConfig | undefined = inputData.config;\n        const defaultPageSize: number = 100;\n        const queryResultSettings: QueryResultSettings = {\n            Paging: {\n                // eslint-disable-next-line max-len -- Disable max length for next line.\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unnecessary-condition -- Reading from config.\n                Top:\n                    config?.itemsPerPage ??\n                    Number.parseInt(inputData.requestContext?.app?.platform?.defaultPageSizeForAPI ?? defaultPageSize, 10)\n            }\n        };\n        return queryResultSettings;\n    }\n\n    /**\n     * Factory method.\n     * @returns - Returns query result settings proxy.\n     */\n    public static getDefault(): QueryResultSettingsProxy {\n        return new QueryResultSettingsProxy({ Paging: {}, Sorting: {} });\n    }\n\n    /**\n     * Private constructor, expect instances to be created with the factory method.\n     * @param queryResultSettings - Query result setting.\n     */\n    private constructor(queryResultSettings: QueryResultSettings) {\n        this.queryResultSettings = queryResultSettings;\n    }\n\n    public get QueryResultSettings(): QueryResultSettings {\n        return this.queryResultSettings;\n    }\n\n    /**\n     * Gets the hints for the cache key based on query result settings.\n     * @returns - Returns cache key hint.\n     */\n    public get cacheKeyHint(): string {\n        // The factory method guarantees values are defined\n        const topHint = `top-${this.queryResultSettings.Paging!.Top!}`;\n        const skipHint = `skip-${this.queryResultSettings.Paging!.Skip!}`;\n        const sortingHintData =\n            (this.queryResultSettings.Sorting!.Columns || [])\n                .map((column: SortColumn) => {\n                    return `${column.ColumnName}--${(column.IsDescending && 'desc') || 'asc'}`;\n                })\n                .join(',') || undefined;\n        const sortingHint = `sortBy-${sortingHintData}`;\n        return `${topHint}|${skipHint}|${sortingHint}`;\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\n/**\n * Represents a pair of two fields: key and value.\n * Used to initialize a dictionary.\n */\nexport interface IKeyValuePair<Key, Value> {\n    readonly key: Key;\n    readonly value: Value;\n}\n\n/**\n * Represents a dictionary in memory storage.\n */\nexport class Dictionary<Key extends string, Value> {\n    /**\n     * Values stored in the dictionary.\n     */\n    private _values: { [eventName: string]: Value };\n\n    /**\n     * The number of values stored in the dictionary (does not include keys).\n     */\n    private _length: number;\n\n    /**\n     * Initializes an empty dictionary or a dictionary with the given key value pairs.\n     * @param {IKeyValuePair<Key, Value>[]} entries The key value pairs which should be stored in the dictionary initially.\n     */\n    public constructor(...entries: IKeyValuePair<Key, Value>[]) {\n        this._values = {};\n        this._length = 0;\n        entries.forEach(keyValuePair => {\n            this.setValue(keyValuePair.key, keyValuePair.value);\n        });\n    }\n\n    /**\n     * Removes value from the dictionary for the given key.\n     * @param {Key} key The key to retrieve the value.\n     * @remark Does nothing in case the key is not present in the dictionary.\n     */\n    public removeValue(key: Key): void {\n        if (!this.hasValue(key)) {\n            return;\n        }\n\n        --this._length;\n        delete this._values[key];\n    }\n\n    /**\n     * Retrieves a value from the dictionary or returns undefined in case it's not found.\n     * @param {Key} key The key to retrieve the value.\n     * @returns {Value | undefined} The value stored in the dictionary or undefined in case it's not found.\n     */\n    public getValue(key: Key): Value | undefined {\n        return this._values[key];\n    }\n\n    /**\n     * Retrieves a value from the dictionary.\n     * In case it's not found, adds the default value to the dictionary and returns it.\n     * @param {Key} key The key to retrieve the value.\n     * @param defaultValue\n     * @returns {Value} The value stored in the dictionary or the default value in case it's not found.\n     */\n    public getValueWithDefaultValue(key: Key, defaultValue: Value): Value {\n        if (!this.hasValue(key)) {\n            this.setValue(key, defaultValue);\n        }\n        return this.getValue(key)!;\n    }\n\n    /**\n     * Sets the value to the dictionary for the given key.\n     * @remarks In case undefined was passed, removes the value from the dictionary instead.\n     * @param {Key} key The key under which the value should be stored.\n     * @param {Value} value The value which should be stored in the dictionary.\n     */\n    public setValue(key: Key, value: Value): void {\n        if (value === undefined) {\n            this.removeValue(key);\n            return;\n        }\n\n        if (!this.hasValue(key)) {\n            ++this._length;\n        }\n\n        this._values[key] = value;\n    }\n\n    /**\n     * Checks if the dictionary stores some value (except undefined) for the given key.\n     * @param {Key} key  The key to retrieve the value.\n     * @returns {boolean} True in case the value is present, false otherwise or if it's undefined.\n     */\n    public hasValue(key: Key): boolean {\n        return this._values[key] !== undefined;\n    }\n\n    /**\n     * Checks if the dictionary is empty.\n     * @returns {boolean} True if the dictionary is empty, false otherwise.\n     */\n    public isEmpty(): boolean {\n        return this.length === 0;\n    }\n\n    /**\n     * Retrieves the number of values stored in the dictionary.\n     * @remark Use `isEmpty` to check if the dictionary has any elements.\n     * @returns {number} The number of values stored.\n     */\n    public get length(): number {\n        return this._length;\n    }\n\n    /**\n     * Clears the dictionary by removing all elements from the storage.\n     */\n    public clear(): void {\n        this._values = {};\n        this._length = 0;\n    }\n\n    /**\n     * Returns all values stored in the dictionary.\n     * @returns {Value[]} List of values.\n     */\n    public getValues(): Value[] {\n        return this.getKeys().map(key => this._values[key]);\n    }\n\n    /**\n     * Returns all keys stored in the dictionary.\n     * @returns {string[]} List of keys.\n     */\n    public getKeys(): Key[] {\n        return <Key[]>Object.keys(this._values);\n    }\n\n    /**\n     * Returns all key value pairs stored in the dictionary.\n     * @returns {IKeyValuePair<Key, Value>[]} List of key value pairs.\n     */\n    public getKeyValuePairs(): IKeyValuePair<Key, Value>[] {\n        return this.getKeys().map(key => {\n            return { key, value: this._values[key] };\n        });\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { IEventSubscriber } from './event-subscriber';\n\n/**\n * Represents a simple event with subscribers. Notifies the subscribers once the event is triggered.\n */\nexport class Event {\n    /**\n     * The list of subscribers.\n     */\n    private _subscribers: IEventSubscriber[];\n\n    /**\n     * Initializes the event with a empty subscribers list.\n     */\n    public constructor() {\n        this._subscribers = [];\n    }\n\n    /**\n     * Subscribes given instance to the event.\n     * @param {IEventSubscriber} instance The info about the subscriber.\n     */\n    public subscribe(instance: IEventSubscriber): void {\n        this._subscribers.push(instance);\n    }\n\n    /**\n     * Removes the subscriber from the list of subscribers watching the event.\n     * @param {string} instanceId The unique identifier of the subscriber which was earlier passed in `subscribe` method in `IEventSubscriber`.\n     */\n    public unsubscribe(instanceId: string): void {\n        this._subscribers = this._subscribers.filter(element => element.instanceId !== instanceId);\n    }\n\n    /**\n     * Clears the list of subscriber removing all instances watching the event.\n     */\n    public unsubscribeAll(): void {\n        this._subscribers = [];\n    }\n\n    /**\n     * Triggers the event.\n     * Notifies the subscribers that the event is triggered by calling `handler` method.\n     */\n    public trigger(): void {\n        this._subscribers.forEach(subscriber => {\n            subscriber.handler();\n        });\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { ObjectExtensions } from './object-extensions';\n\n/**\n * Represents an array which is defined with at least one value.\n */\nexport type NonEmptyArray<T> = [T, ...T[]];\n\n/**\n * Namespace which extends Array functionality.\n */\nexport namespace ArrayExtensions {\n    /**\n     * Verifies whether the object array has elements.\n     * @param value - The array to examine.\n     * @returns True if the object has at least one element in the array, false otherwise (if array is not defined or empty).\n     */\n    export function hasElements<T>(value: NonEmptyArray<T> | T[] | null | undefined): value is NonEmptyArray<T> {\n        const emptyArrayLength = 0;\n        return !ObjectExtensions.isNullOrUndefined(value) && value.length > emptyArrayLength;\n    }\n\n    /**\n     * Retrieves the first element in the array or default value if the array is empty.\n     * @param values - The array with values.\n     * @param defaultValue - Optional parameter to specify default value. If not specified, undefined will be used.\n     * @returns First element or default value.\n     */\n    export function firstOrDefault<T>(values: NonEmptyArray<T> | T[] | null | undefined, defaultValue?: T): T | undefined {\n        if (hasElements(values)) {\n            return values[0];\n        }\n        return defaultValue;\n    }\n\n    /**\n     * Remove duplicate elements in the array.\n     * @param value - The array to examine.\n     * @returns An array with only unique elements.\n     */\n    export function unique<T>(value: T[]): T[] {\n        if (!hasElements(value)) {\n            return [];\n        }\n\n        return Array.from(new Set(value));\n    }\n\n    /**\n     * Checks if all elements satisfy given condition.\n     * @param value - The array to examine.\n     * @param predicate - The function which checks an element.\n     * @returns True if the array is empty or all the inner elements satisfy given condition,\n     * false if at least one element does not pass the condition.\n     */\n    export function all<T>(value: T[] | null | undefined, predicate: (value: T, index: number, array: T[]) => boolean): boolean {\n        if (!hasElements(value)) {\n            return true;\n        }\n\n        return value.filter(predicate).length === value.length;\n    }\n\n    /**\n     * Filters out null and undefined values from the given array.\n     * @param value - The array with possibly undefined/null items.\n     * @returns All items which are not null or undefined.\n     */\n    export function validValues<T>(value: (T | undefined | null)[] | undefined | null): T[] {\n        if (!hasElements(value)) {\n            return [];\n        }\n\n        return value.filter(item => !ObjectExtensions.isNullOrUndefined(item)) as T[];\n    }\n\n    /**\n     * Merges items from 2-dimensional array into one array with all items.\n     * @param value - The 2-dimensional array with the items.\n     * @returns All items retrieved from all inner arrays.\n     */\n    export function flatten<T>(value: ((T | undefined | null)[] | undefined | null)[]): T[] {\n        let result: T[] = [];\n\n        if (!hasElements(value)) {\n            return result;\n        }\n\n        for (const arrayLine of value) {\n            if (!ObjectExtensions.isNullOrUndefined(arrayLine)) {\n                result = result.concat(validValues(arrayLine));\n            }\n        }\n\n        return result;\n    }\n\n    /**\n     * Check if two arrays are equal.\n     * @param firstArray - The array with the items.\n     * @param secondArray - Another array with the items.\n     * @param comparator - The comparator which compares the values and returns true if two objects are equal, false otherwise.\n     * @returns True if arrays have the same items, false otherwise.\n     */\n    export function equals<T>(\n        firstArray: T[],\n        secondArray: T[],\n        comparator?: (valueFromFirstArray: T, valueFromSecondArray: T) => boolean\n    ): boolean {\n        if (firstArray.length !== secondArray.length) {\n            return false;\n        }\n\n        if (comparator === undefined) {\n            return JSON.stringify(firstArray) === JSON.stringify(secondArray);\n        }\n\n        for (let index = 0; index < firstArray.length; ++index) {\n            if (!comparator(firstArray[index], secondArray[index])) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    /**\n     * Check if two arrays have the same elements irrespective of the order.\n     * @param firstArray - The array with the items.\n     * @param secondArray - Another array with the items.\n     * @param comparator - The comparator which compares the values and returns true if two objects are equal, false otherwise.\n     * @returns True if arrays have the same items, false otherwise.\n     */\n    export function haveSameItems<T>(\n        firstArray: T[],\n        secondArray: T[],\n        comparator: (valueFromFirstArray: T, valueFromSecondArray: T) => boolean = (valueFromFirstArray: T, valueFromSecondArray: T) =>\n            valueFromFirstArray === valueFromSecondArray\n    ): boolean {\n        if (firstArray.length !== secondArray.length) {\n            return false;\n        }\n\n        for (const item of firstArray) {\n            if (!secondArray.some(otherItem => comparator(item, otherItem))) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    /**\n     * Calculates a sum of elements in the given array.\n     * @param data - List of items.\n     * @returns Sum of elements.\n     */\n    export function calculateSum(data: NonEmptyArray<number>): number {\n        let result = data[0];\n        for (let index = 1; index < data.length; ++index) {\n            result += data[index];\n        }\n\n        return result;\n    }\n\n    /**\n     * Reverses the elements in the array without modifying the original one.\n     * @param array - The array with the items.\n     * @returns A new array with reversed order.\n     */\n    export function reverse<T>(array: T[]): T[] {\n        const newArray: T[] = [];\n\n        for (let index = array.length - 1; index >= 0; --index) {\n            newArray.push(array[index]);\n        }\n\n        return newArray;\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { ObjectExtensions } from './object-extensions';\n\n/**\n * Namespace which extends enum functionality.\n */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nexport namespace EnumExtensions {\n    /**\n     * @description Returns a list of numeric values and enum names for the specified enum.\n     * @param enumClass\n     * @param {any} value The enum to examine.\n     * @returns {(number | string)[]} An array of numeric values and enum names.\n     */\n    export function getValues(enumClass: any): (number | string)[] {\n        if (ObjectExtensions.isNullOrUndefined(enumClass)) {\n            return [];\n        }\n\n        return Object.keys(enumClass).map(item => enumClass[item]);\n    }\n\n    /**\n     * @description Returns a list of enum names for the specified enum.\n     * @param enumClass\n     * @param {any} value The enum to examine.\n     * @returns {(number | string)[]} An array of string values.\n     */\n    export function getNames(enumClass: any): string[] {\n        return getValues(enumClass).filter(ObjectExtensions.isString);\n    }\n\n    /**\n     * @description Returns a list of numeric values for the specified enum.\n     * @param enumClass\n     * @param {any} value The enum to examine.\n     * @returns {number[]} An array of numeric values.\n     */\n    export function getNumericValues(enumClass: any): number[] {\n        return getValues(enumClass).filter(ObjectExtensions.isNumber);\n    }\n\n    /**\n     * @description Returns a list of enum values for the specified enum.\n     * @param enumClass\n     * @param {any} value The enum to examine.\n     * @returns {number[]} An array of enum values.\n     */\n    export function getEnumValues<T extends number>(enumClass: any): T[] {\n        return getNumericValues(enumClass).map(value => <T>value);\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { ObjectExtensions } from './object-extensions';\n\n/**\n * Namespace which extends string functionality.\n */\nexport namespace StringExtensions {\n    /**\n     * Checks if string is null, undefined, empty, or whitespace.\n     * @param {string | null | undefined} value The string to examine.\n     * @returns {boolean} True if it's null, undefined, empty, or whitespace; false otherwise.\n     */\n    export function isNullOrWhitespace(value: string | null | undefined): boolean {\n        return isNullOrEmpty(value) || value!.trim() === '';\n    }\n\n    /**\n     * Checks if string is null, undefined, or empty.\n     * @param {string | null | undefined} value The string to examine.\n     * @returns {boolean} True if it's null, undefined, empty, or whitespace; false otherwise.\n     */\n    export function isNullOrEmpty(value: string | null | undefined): boolean {\n        if (ObjectExtensions.isNullOrUndefined(value)) {\n            return true;\n        }\n\n        if (!ObjectExtensions.isString(value)) {\n            throw new Error('StringExtensions has received a non-string input.');\n        }\n\n        return value === '';\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\n/**\n * Namespace which extends Object functionality.\n */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nexport namespace ObjectExtensions {\n    /**\n     * @description Verifies whether the value is null or undefined.\n     * @param {any} value The value to examine.\n     * @returns {boolean} True if the value is null or undefined, false otherwise.\n     */\n    export function isNullOrUndefined(value: any): value is null | undefined {\n        return value === null || value === undefined;\n    }\n\n    /**\n     * @description Verifies whether the value is of type string.\n     * @param {any} value The value to examine.\n     * @returns {boolean} True if the value is a string, false otherwise.\n     */\n    export function isString(value: any): value is string {\n        return typeof value === 'string';\n    }\n\n    /**\n     * @description Verifies whether the value is of type number.\n     * @param {any} value The value to examine.\n     * @returns {boolean} True if the value is a number, false otherwise.\n     */\n    export function isNumber(value: any): value is number {\n        return typeof value === 'number';\n    }\n\n    /**\n     * Verifies whether the object is a function.\n     * @param {any} object The object.\n     * @param value\n     * @returns {boolean} True if the object is a function, false otherwise.\n     */\n    export function isFunction(value: any): boolean {\n        return typeof value === 'function';\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { IAny, ICreateActionContext, IGeneric } from '@msdyn365-commerce/core';\nimport { QueryResultSettings } from '@msdyn365-commerce/retail-proxy';\n\nimport { QueryResultSettingsProxy } from './QueryResultSettingsProxy';\n\nexport interface ISearchData {\n    q: string;\n    skip: number;\n    top: number;\n    itemsPerPage: string;\n    maxItems: string;\n    channelId: number;\n    queryResultSettings: QueryResultSettings;\n}\n\nexport const parseSearchData = (inputData: ICreateActionContext<IGeneric<IAny>>): ISearchData => {\n    // Query is of type 'IDictionary<string> | undefined', so that q and skip are not recognized by tsc\n    const {\n        requestContext: {\n            // @ts-expect-error:2339\n            query: { q, top, skip },\n            apiSettings: { channelId }\n        },\n        // @ts-expect-error:2339\n        config: { maxItems, itemsPerPage }\n    } = inputData;\n    const queryResultSettings = QueryResultSettingsProxy.fromInputData(inputData).QueryResultSettings;\n    return {\n        q,\n        skip: (skip && Number(skip)) || 0,\n        top: (top && Number(top)) || 50,\n        itemsPerPage, // TODO BUGBUG 21667361\n        maxItems, // TODO BUGBUG 21667361\n        channelId,\n        queryResultSettings\n    };\n};\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport {\n    ProductAvailableQuantity,\n    ProductDimensionValueInventoryAvailability,\n    ProductInventoryAvailability\n} from '@msdyn365-commerce/retail-proxy';\n\n/**\n * This setting defines the delivery modes supported.\n */\nexport enum DeliveryMode {\n    allWareHouses = 0,\n    shipping = 1,\n    pickup = 2\n}\n\n/**\n * This setting defines the inventory levels supported.\n */\nexport enum InventoryLevels {\n    physicalAvailable = 'physicalAvailable',\n    totalAvailable = 'totalAvailable',\n    threshold = 'inventoryThreshold'\n}\n\n/**\n * Product inventory information class.\n */\nexport interface IProductInventoryInformation {\n    ProductAvailableQuantity: ProductAvailableQuantity;\n    StockLevelCode?: string;\n    StockLevelLabel?: string;\n    IsProductAvailable: boolean;\n    InventLocationId?: string;\n    deliveryType?: DeliveryMode;\n}\n\n/**\n * This setting defines the inventory level values return by the API.\n */\nexport enum InventoryLevelValues {\n    outOfStock = 'OOS',\n    available = 'AVAIL'\n}\n\n/**\n * Retrieves inventory level code from the dimension based on the app config setting.\n * @param dimensionValuesWithInventory - The dimension info.\n * @param inventoryLevel - App config setting for inventory level.\n * @returns Inventory level code value.\n */\nexport const getInventoryLevelCodeFromDimensionValue = (\n    dimensionValuesWithInventory: ProductDimensionValueInventoryAvailability,\n    inventoryLevel?: InventoryLevels | undefined\n): InventoryLevelValues | undefined => {\n    if (inventoryLevel === InventoryLevels.totalAvailable) {\n        return dimensionValuesWithInventory.TotalAvailableInventoryLevelCode as InventoryLevelValues | undefined;\n    }\n    if (inventoryLevel === InventoryLevels.physicalAvailable) {\n        return dimensionValuesWithInventory.PhysicalAvailableInventoryLevelCode as InventoryLevelValues | undefined;\n    }\n    return undefined;\n};\n\n/**\n * Retrieves inventory level code from the product availability based on the app config setting.\n * @param productAvailability - The product availability info.\n * @param inventoryLevel - App config setting for inventory level.\n * @returns Inventory level code value.\n */\nexport const getInventoryLevelCodeFromProductAvailability = (\n    productAvailability: ProductInventoryAvailability,\n    inventoryLevel?: InventoryLevels | undefined\n): InventoryLevelValues | undefined => {\n    if (inventoryLevel === InventoryLevels.totalAvailable) {\n        return productAvailability.TotalAvailableInventoryLevelCode as InventoryLevelValues | undefined;\n    }\n    if (inventoryLevel === InventoryLevels.physicalAvailable) {\n        return productAvailability.PhysicalAvailableInventoryLevelCode as InventoryLevelValues | undefined;\n    }\n    return undefined;\n};\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { IActionContext } from '@msdyn365-commerce/core';\nimport {\n    InventoryAvailabilitySearchCriteria,\n    ProductAvailableQuantity,\n    ProductWarehouseInventoryAvailability,\n    ProductWarehouseInventoryInformation,\n    SearchArea\n} from '@msdyn365-commerce/retail-proxy';\n\nimport { DeliveryMode, InventoryLevels, InventoryLevelValues, IProductInventoryInformation } from './product-inventory-information';\n\n/**\n * The function defines whether the inventory label should be displayed or not.\n * @param context - The action context.\n * @param inventoryCode - The inventory code.\n * @returns Boolean.\n */\nexport function displayLabelEnabled(context: IActionContext, inventoryCode?: string): boolean {\n    if (!inventoryCode) {\n        return false;\n    }\n\n    // eslint-disable-next-line default-case\n    switch (context.requestContext.app.config.inventoryRanges) {\n        case 'lowAndOutofStock':\n            if (inventoryCode !== InventoryLevelValues.available) {\n                return true;\n            }\n            break;\n        case 'outOfStock':\n            if (inventoryCode === InventoryLevelValues.outOfStock) {\n                return true;\n            }\n            break;\n        case 'all':\n            return true;\n    }\n    return false;\n}\n\n/**\n * The function that maps a ProductWareHouse object into a ProductAvailabilityQuantity.\n * @param context - The action context.\n * @param productsWarehouseInventory - The product warehouse inventory information.\n * @returns IProductInventoryInformation[].\n */\nexport function mapProductInventoryInformation(\n    context: IActionContext,\n    productsWarehouseInventory?: ProductWarehouseInventoryAvailability[]\n): IProductInventoryInformation[] {\n    const productInventoryInformation: IProductInventoryInformation[] = [];\n\n    if (context.requestContext.app.config.enableStockCheck === undefined || context.requestContext.app.config.enableStockCheck === false) {\n        return productInventoryInformation;\n    }\n\n    if (productsWarehouseInventory && productsWarehouseInventory.length > 0) {\n        for (const product of productsWarehouseInventory) {\n            switch (context.requestContext.app.config.inventoryLevel) {\n                case InventoryLevels.physicalAvailable:\n                    // Inventory level is enabled with Physical inventory\n                    const physicalProductMap = mapInventoryWithPhysicalBufferEnabled(context, product);\n                    if (physicalProductMap) {\n                        productInventoryInformation.push(physicalProductMap);\n                    }\n                    break;\n                case InventoryLevels.totalAvailable:\n                    // Inventory level is enabled with Total available inventory\n                    const totalAvailableProductMap = mapInventoryWithTotalAvailableBufferEnabled(context, product);\n                    if (totalAvailableProductMap) {\n                        productInventoryInformation.push(totalAvailableProductMap);\n                    }\n                    break;\n                default:\n                    // When inventory level is inventoryThreshold or not defined\n                    const productMap = mapInventoryWithThresholdEnabled(context, product);\n                    if (productMap) {\n                        productInventoryInformation.push(productMap);\n                    }\n                    break;\n            }\n        }\n    }\n\n    return productInventoryInformation;\n}\n\n/**\n * The function that maps inventory for when threshold is selected.\n * @param context - The action context.\n * @param productWarehouseInventoryAvailability - The product warehouse inventory information.\n * @returns IProductInventoryInformation.\n */\nexport function mapInventoryWithThresholdEnabled(\n    context: IActionContext,\n    productWarehouseInventoryAvailability: ProductWarehouseInventoryAvailability\n): IProductInventoryInformation | null {\n    if (productWarehouseInventoryAvailability.ProductId && productWarehouseInventoryAvailability.TotalAvailable !== undefined) {\n        const productQty = productWarehouseInventoryAvailability.TotalAvailable - context.requestContext.app.config.outOfStockThreshold;\n        const productAvailableQuantity: ProductAvailableQuantity = {\n            ProductId: productWarehouseInventoryAvailability.ProductId,\n            AvailableQuantity: productQty > 0 ? productQty : 0\n        };\n\n        return {\n            ProductAvailableQuantity: productAvailableQuantity,\n            IsProductAvailable: !!(productAvailableQuantity.AvailableQuantity && productAvailableQuantity.AvailableQuantity > 0),\n            InventLocationId: productWarehouseInventoryAvailability.InventLocationId\n        };\n    }\n\n    return null;\n}\n\n/**\n * The function that maps inventory for when physical available is selected.\n * @param context - The action context.\n * @param productWarehouseInventoryAvailability - The product warehouse inventory information.\n * @returns IProductInventoryInformation.\n */\nexport function mapInventoryWithPhysicalBufferEnabled(\n    context: IActionContext,\n    productWarehouseInventoryAvailability: ProductWarehouseInventoryAvailability\n): IProductInventoryInformation | null {\n    const shouldRenderLabel = displayLabelEnabled(context, productWarehouseInventoryAvailability.PhysicalAvailableInventoryLevelCode);\n\n    if (productWarehouseInventoryAvailability.ProductId && productWarehouseInventoryAvailability.TotalAvailable !== undefined) {\n        // As per the new buffer logic from RS,\n        // if code is out of stock then we set the available quantity to 0 regardless of the actual value from API\n        let productQuantity: number | undefined = 0;\n        if (productWarehouseInventoryAvailability.PhysicalAvailableInventoryLevelCode !== InventoryLevelValues.outOfStock) {\n            productQuantity =\n                productWarehouseInventoryAvailability.MaximumPurchasablePhysicalAvailableQuantity ??\n                productWarehouseInventoryAvailability.PhysicalAvailable;\n        }\n\n        const productAvailableQuantity: ProductAvailableQuantity = {\n            ProductId: productWarehouseInventoryAvailability.ProductId,\n            AvailableQuantity: productQuantity\n        };\n        return {\n            ProductAvailableQuantity: productAvailableQuantity,\n            StockLevelCode: shouldRenderLabel ? productWarehouseInventoryAvailability.PhysicalAvailableInventoryLevelCode : undefined,\n            StockLevelLabel: shouldRenderLabel ? productWarehouseInventoryAvailability.PhysicalAvailableInventoryLevelLabel : undefined,\n            IsProductAvailable: productAvailableQuantity.AvailableQuantity !== undefined && productAvailableQuantity.AvailableQuantity > 0,\n            InventLocationId: productWarehouseInventoryAvailability.InventLocationId\n        };\n    }\n\n    return null;\n}\n\n/**\n * The function that maps inventory for when total available is selected.\n * @param context - The action context.\n * @param productWarehouseInventoryAvailability - The product warehouse inventory information.\n * @returns IProductInventoryInformation.\n */\nexport function mapInventoryWithTotalAvailableBufferEnabled(\n    context: IActionContext,\n    productWarehouseInventoryAvailability: ProductWarehouseInventoryAvailability\n): IProductInventoryInformation | null {\n    const shouldRenderLabel = displayLabelEnabled(context, productWarehouseInventoryAvailability.TotalAvailableInventoryLevelCode);\n    if (productWarehouseInventoryAvailability.ProductId && productWarehouseInventoryAvailability.TotalAvailable !== undefined) {\n        // As per the new buffer logic from RS,\n        // if code is out of stock then we set the available quantity to 0 regardless of the actual value from API\n        let productQuantity: number | undefined = 0;\n        if (productWarehouseInventoryAvailability.TotalAvailableInventoryLevelCode !== InventoryLevelValues.outOfStock) {\n            productQuantity =\n                productWarehouseInventoryAvailability.MaximumPurchasableTotalAvailableQuantity ??\n                productWarehouseInventoryAvailability.TotalAvailable;\n        }\n\n        const productAvailableQuantity: ProductAvailableQuantity = {\n            ProductId: productWarehouseInventoryAvailability.ProductId,\n            AvailableQuantity: productQuantity\n        };\n        return {\n            ProductAvailableQuantity: productAvailableQuantity,\n            StockLevelCode: shouldRenderLabel ? productWarehouseInventoryAvailability.TotalAvailableInventoryLevelCode : undefined,\n            StockLevelLabel: shouldRenderLabel ? productWarehouseInventoryAvailability.TotalAvailableInventoryLevelLabel : undefined,\n            // eslint-disable-next-line eqeqeq\n            IsProductAvailable: productAvailableQuantity.AvailableQuantity != undefined && productAvailableQuantity.AvailableQuantity > 0,\n            InventLocationId: productWarehouseInventoryAvailability.InventLocationId\n        };\n    }\n\n    return null;\n}\n\n/**\n * The function created a InventoryAvailabilitySearchCriteria object for getEstimatedAvailability API.\n * @param context - The action context.\n * @returns Boolean.\n */\nexport function isAggregatedInventory(context: IActionContext): boolean {\n    // If warehouse aggregated is true then query inventory from multiple warehouses\n    // else query from single warehouse\n    return (\n        (context.requestContext.app.config.inventoryLevel === InventoryLevels.totalAvailable ||\n            context.requestContext.app.config.inventoryLevel === InventoryLevels.physicalAvailable) &&\n        context.requestContext.app.config.warehouseAggregation === 'multiple'\n    );\n}\n\n/**\n * The function created a InventoryAvailabilitySearchCriteria object for getEstimatedAvailability API.\n * @param context - The action context.\n * @param productWarehouseInventoryInformation - The product ware house inventory information.\n * @returns ProductWarehouseInventoryInformation.\n */\nexport function mapAggregatedProductInventoryInformation(\n    context: IActionContext,\n    productWarehouseInventoryInformation: ProductWarehouseInventoryInformation\n): IProductInventoryInformation[] {\n    if (isAggregatedInventory(context)) {\n        const productInventoryMapping:\n            | ProductWarehouseInventoryAvailability[]\n            | undefined = productWarehouseInventoryInformation.AggregatedProductInventoryAvailabilities?.map(product => {\n            return {\n                DataAreaId: product.DataAreaId,\n                MaximumPurchasablePhysicalAvailableQuantity:\n                    product.MaximumPurchasablePhysicalAvailableQuantity ?? product.PhysicalAvailableQuantity,\n                MaximumPurchasableTotalAvailableQuantity:\n                    product.MaximumPurchasableTotalAvailableQuantity ?? product.TotalAvailableQuantity,\n                ProductId: product.ProductId,\n                PhysicalAvailable: product.PhysicalAvailableQuantity,\n                PhysicalAvailableInventoryLevelCode: product.PhysicalAvailableInventoryLevelCode,\n                PhysicalAvailableInventoryLevelLabel: product.PhysicalAvailableInventoryLevelLabel,\n                TotalAvailable: product.TotalAvailableQuantity,\n                TotalAvailableInventoryLevelCode: product.TotalAvailableInventoryLevelCode,\n                TotalAvailableInventoryLevelLabel: product.TotalAvailableInventoryLevelLabel\n            };\n        });\n        return mapProductInventoryInformation(context, productInventoryMapping);\n    }\n\n    return mapProductInventoryInformation(context, productWarehouseInventoryInformation.ProductWarehouseInventoryAvailabilities);\n}\n\n/**\n * The function created a InventoryAvailabilitySearchCriteria object for getEstimatedAvailability API.\n * @param context - The action context.\n * @param productIds - The product id collection.\n * @param isDefaultWareHouse - Flag to define whether inventory is from default warehouse or not.\n * @param isFilterByChannelFulfillmentGroup - Filter by fulfillment group.\n * @param searchArea - The search area.\n * @param defaultDeliveryMode - The delivery mode.\n * @returns InventoryAvailabilitySearchCriteria.\n */\nexport function createInventoryAvailabilitySearchCriteria(\n    context: IActionContext,\n    productIds: number[],\n    isDefaultWareHouse?: boolean,\n    isFilterByChannelFulfillmentGroup?: boolean,\n    searchArea?: SearchArea,\n    defaultDeliveryMode?: DeliveryMode\n): InventoryAvailabilitySearchCriteria {\n    const salesUnitType = 2;\n    const deliveryMode = defaultDeliveryMode ? defaultDeliveryMode : DeliveryMode.shipping;\n\n    const inventoryAvailabilitySearchCriteria: InventoryAvailabilitySearchCriteria = {\n        ProductIds: productIds,\n        QuantityUnitTypeValue: salesUnitType,\n        SearchArea: searchArea\n    };\n\n    if (isAggregatedInventory(context)) {\n        inventoryAvailabilitySearchCriteria.FilterByChannelFulfillmentGroup = true;\n        inventoryAvailabilitySearchCriteria.DeliveryModeTypeFilterValue = deliveryMode;\n    } else {\n        inventoryAvailabilitySearchCriteria.DefaultWarehouseOnly = isDefaultWareHouse;\n        inventoryAvailabilitySearchCriteria.FilterByChannelFulfillmentGroup = isFilterByChannelFulfillmentGroup;\n    }\n\n    return inventoryAvailabilitySearchCriteria;\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { PromiseBodyWrapper } from './base-promise-queue';\nimport { PromiseQueue } from './promise-queue';\n\nexport enum FinitePromiseQueueError {\n    InvalidMaxQueueLengthPassed = 'Invalid maxQueueLength value passed to FinitePromiseQueue. maxQueueLength should be more or equal to 2.',\n    ProcessWasDiscardedFromTheQueue = 'The process was discarded from FinitePromiseQueue.'\n}\n\n/**\n * Represents a FIFO queue over promises with a limited number of elements waiting for execution.\n * @remark\n * In case the queue reaches the limit,\n * before adding a new element the queue discards the oldest added element which is waiting to be processed.\n * Does not discard elements which are in progress under execution.\n * The discarded element will not be processed and executed.\n * @author Bohdan Yevchenko <boyevche>\n */\nexport class FinitePromiseQueue<PromiseResultType> extends PromiseQueue<PromiseResultType> {\n    /**\n     * @see constructor\n     */\n    private readonly _maxQueueLength: number;\n\n    /**\n     * Initializes the queue with the given limit.\n     * @param {number} maxQueueLength\n     * Defines the limit of maximum number of elements in the queue.\n     * @remarks Includes both the number of elements waiting for the execution\n     * and the element processed by the queue at the moment (in case there is some).\n     * Value can't be less than 2.\n     */\n    public constructor(maxQueueLength: number) {\n        if (maxQueueLength < 2) {\n            throw new Error(FinitePromiseQueueError.InvalidMaxQueueLengthPassed);\n        }\n\n        super();\n        this._maxQueueLength = maxQueueLength;\n    }\n\n    /**\n     * Adds promise to the queue and automatically starts the queue execution.\n     * @remarks In case the queue has reached the limit, also discards the oldest added element.\n     * @param {PromiseBodyWrapper<PromiseResultType>} promiseBody\n     * The body of a function which contains a call to the promise which has to be executed in the queue.\n     */\n    public async enqueue(promiseBody: PromiseBodyWrapper<PromiseResultType>): Promise<PromiseResultType> {\n        let totalElementsCount = this._queue.length;\n\n        // If queue hasn't finished processing an element,\n        // consider this element as pending.\n        if (this._isBusy) {\n            ++totalElementsCount;\n        }\n\n        // Discards the oldest added element from the queue to meet the given limitations.\n        // The very first element in the queue is considered as oldest added.\n        // Can't discard the element which is under execution as the promise can't be cancelled.\n        if (totalElementsCount === this._maxQueueLength) {\n            const element = this._queue.shift();\n            if (element) {\n                element.reject(FinitePromiseQueueError.ProcessWasDiscardedFromTheQueue);\n            }\n        }\n\n        return super.enqueue(promiseBody);\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { IPromiseQueue, PromiseBodyWrapper, PromiseRejectType, PromiseResolveType } from './base-promise-queue';\n\n/**\n * Represents an inner node which is stored in a promise queue.\n * Used internally in the PromiseQueue implementation.\n * @author Bohdan Yevchenko <boyevche>\n */\nclass PromiseQueueElement<PromiseResultType> {\n    /**\n     * The body of a wrapper-function which contains a call to the promise which has to be executed in the queue.\n     */\n    public readonly body: PromiseBodyWrapper<PromiseResultType>;\n\n    /**\n     * Method that resolves the promise after the promise from the body is resolved.\n     */\n    public readonly resolve: PromiseResolveType<PromiseResultType>;\n\n    /**\n     * Method that rejects the promise after the promise from the body is rejected.\n     */\n    public readonly reject: PromiseRejectType;\n\n    /**\n     * Initializes queue element with the given data.\n     * @param {PromiseBodyWrapper<PromiseResultType>} body The body of a wrapper-function which contains a call to the promise which has to be executed in the queue.\n     * @param {PromiseResolveType<PromiseResultType>} resolve Method that resolves the promise after the promise from the body is resolved.\n     * @param {PromiseRejectType} reject Method that rejects the promise after the promise from the body is rejected.\n     */\n    public constructor(\n        body: PromiseBodyWrapper<PromiseResultType>,\n        resolve: PromiseResolveType<PromiseResultType>,\n        reject: PromiseRejectType\n    ) {\n        this.body = body;\n        this.resolve = resolve;\n        this.reject = reject;\n    }\n}\n\n/**\n * Represents a FIFO basic queue over promises.\n * @author Bohdan Yevchenko <boyevche>\n */\nexport class PromiseQueue<PromiseResultType> implements IPromiseQueue<PromiseResultType> {\n    /**\n     * A list of promises waiting for execution.\n     */\n    protected readonly _queue: PromiseQueueElement<PromiseResultType>[];\n\n    /**\n     * Defines whether the queue is processing some element.\n     */\n    protected _isBusy: boolean;\n\n    /**\n     * Defines whether the queue can start processing new element.\n     */\n    private get _canProcess(): boolean {\n        return !this._isBusy && this._queue.length > 0;\n    }\n\n    /**\n     * Creates a new instance of PromiseQueue.\n     */\n    public constructor() {\n        this._queue = [];\n        this._isBusy = false;\n    }\n\n    /**\n     * Adds promise to the queue and automatically starts the queue execution.\n     * @param {PromiseBodyWrapper<PromiseResultType>} promiseBody\n     * The body of a function which contains a call to the promise which has to be executed in the queue.\n     */\n    public async enqueue(promiseBody: PromiseBodyWrapper<PromiseResultType>): Promise<PromiseResultType> {\n        return new Promise<PromiseResultType>(async (resolve, reject) => {\n            this._queue.push(new PromiseQueueElement(promiseBody, resolve, reject));\n            await this._dequeue();\n        });\n    }\n\n    /**\n     * If the queue is free, starts processing the first element in the queue and waits until all the elements are processed.\n     * Otherwise (if busy or has no elements to process), does nothing.\n     */\n    private async _dequeue(): Promise<void> {\n        // Skip if queue is not able to process any elements.\n        if (!this._canProcess) {\n            return;\n        }\n\n        // Lock queue to prevent parallel execution.\n        this._isBusy = true;\n\n        // Retrieve an element from the waiting queue and start processing.\n        const element: PromiseQueueElement<PromiseResultType> = this._queue.shift()!;\n        await this._processElement(element);\n\n        // Continue executing the subsequent queue elements.\n        await this._processNext();\n    }\n\n    /**\n     * Executes the given wrapper over the promise and calls initial resolve/reject correspondingly.\n     * @param {PromiseQueueElement<PromiseResultType>} element The queue element which should be processed now.\n     */\n    private async _processElement(element: PromiseQueueElement<PromiseResultType>): Promise<void> {\n        try {\n            await element\n                .body()\n                .then(element.resolve)\n                .catch(element.reject);\n        } catch (error) {\n            element.reject(error);\n        }\n    }\n\n    /**\n     * Unlocks the queue and tries to process the next element in the queue.\n     */\n    private async _processNext(): Promise<void> {\n        this._isBusy = false;\n        await this._dequeue();\n    }\n}\n","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { v4 as uuidv4 } from 'uuid';\n\n/**\n * Namespace which provides functionality for GUID.\n */\nexport namespace Guid {\n    export function generateGuid(): string {\n        return uuidv4();\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { Guid as _guid } from './guid';\n\nexport namespace Random {\n    export import Guid = _guid;\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\n/**\n * Regular expressions to validate emails.\n */\n// eslint-disable-next-line @typescript-eslint/no-extraneous-class\nexport abstract class EmailRegex {\n    /**\n     * Represents a HTML5 Validation Regex.\n     *\n     * A valid email address is a string that matches the email production of the following ABNF, the character set for which is Unicode.\n     * This ABNF implements the extensions described in RFC 1123.\n     *\n     * For more info: https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address.\n     */\n    public static readonly html5EmailRegex = /^[a-zA-Z0-9.!#$%&'*+=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z])?)+$/;\n\n    /**\n     * Returns a default regex which should be used for most email validation cases.\n     *\n     * As of now, the default regex is HTML5 email regex standard.\n     * @see EmailRegex.html5EmailRegex - The regex which is set to be default right now.\n     *\n     * @returns Regular expression for email validation.\n     */\n    public static get defaultRegex(): RegExp {\n        return EmailRegex.html5EmailRegex;\n    }\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\n/**\n * Regular expressions to validate passwords.\n */\n// eslint-disable-next-line @typescript-eslint/no-extraneous-class\nexport abstract class PasswordRegex {\n    // eslint-disable-next-line max-len\n    public static readonly defaultRegex = /^((?=.*[a-z])(?=.*[A-Z])(?=.*\\d)|(?=.*[a-z])(?=.*[A-Z])(?=.*[^A-Za-z0-9])|(?=.*[a-z])(?=.*\\d)(?=.*[^A-Za-z0-9])|(?=.*[A-Z])(?=.*\\d)(?=.*[^A-Za-z0-9]))([A-Za-z\\d@#$%^&*\\-_+=[\\]{}|\\\\:',?/`~'();!]|\\.(?!@)){8,16}$/;\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\n/**\n * Regular expressions to validate phone number.\n */\n// eslint-disable-next-line @typescript-eslint/no-extraneous-class\nexport abstract class PhoneRegex {\n    public static readonly defaultRegex = '^$|^[- +()]*[0-9][- +()0-9]*$';\n}\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport msdyn365Commerce, {\n    IAny,\n    ICommerceApiSettings,\n    ICoreContext,\n    ICreateActionContext,\n    IGeneric,\n    IRequestContext,\n    generateImageUrl as generateImageUrlFromSdk\n} from '@msdyn365-commerce/core';\nimport {\n    AsyncResult,\n    AttributeValue,\n    CartLine,\n    ChannelDeliveryOptionConfiguration,\n    ChannelInventoryConfiguration,\n    CommerceListLine,\n    ProductDimension,\n    ProductDimensionType,\n    ProductSearchResult,\n    QueryResultSettings,\n    SimpleProduct\n} from '@msdyn365-commerce/retail-proxy';\n\nimport { ProductDetailsCriteria } from '../get-full-products';\nimport { IKeyValuePair } from './data-structures';\nimport { ArrayExtensions, StringExtensions } from './extensions';\nimport { parseSearchData } from './input-data-parser';\nimport { InventoryLevels } from './product-inventory-information';\n\nexport const wrapInResolvedAsyncResult = <T = unknown>(input: T | null | undefined): AsyncResult<T> => {\n    return <AsyncResult<T>>{\n        status: 'SUCCESS',\n        result: input,\n        metadata: {}\n    };\n};\n\nexport const wrapInRejectedAsyncResult = <T = unknown>(input: T | null | undefined): AsyncResult<T> => {\n    return <AsyncResult<T>>{\n        status: 'FAILED',\n        result: input,\n        metadata: {}\n    };\n};\n\nexport const buildQueryResultSettings = (inputData: ICreateActionContext<IGeneric<IAny>, IGeneric<IAny>>): QueryResultSettings => {\n    try {\n        const searchInputData = parseSearchData(inputData);\n        const search = searchInputData.q;\n        if (!search) {\n            throw new Error('Query string ?q={searchText} is needed for search actions.');\n        }\n        const top = (searchInputData.maxItems && Number(searchInputData.maxItems)) || searchInputData.top;\n        return { Paging: { Top: top, Skip: searchInputData.skip } };\n    } catch {\n        return {};\n    }\n};\n\n/**\n * Utility function to extract the active productId in the following priority:\n * First query param (productId), then UrlToken (itemId), then module config.\n * @param inputData - The Action Input data.\n * @returns Productid or undefined.\n */\nexport const getSelectedProductIdFromActionInput = (inputData: ICreateActionContext<IGeneric<IAny>>): string | undefined => {\n    const context = inputData.requestContext;\n    if (context.query?.productId) {\n        return context.query.productId;\n        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Exsiting code.\n    } else if (\n        context.urlTokens &&\n        inputData.requestContext.urlTokens.itemId &&\n        inputData.requestContext.urlTokens.pageType === 'Product'\n    ) {\n        return context.urlTokens.itemId;\n    } else if (inputData && inputData.config && inputData.config.productId) {\n        return inputData.config.productId;\n    }\n    return undefined;\n};\n\n/**\n * Generates a Image URL based on data return from retail server.\n * @param imageUrl The image url returned by Retail Server.\n * @param ctx The request context.\n * @param apiSettings\n */\nexport const generateImageUrl = (imageUrl: string | undefined, apiSettings: ICommerceApiSettings): string | undefined => {\n    return generateImageUrlFromSdk(apiSettings, imageUrl);\n};\n\n/**\n * Represents app configuration for dimensions.\n */\nexport interface IDimensionsConfig {\n    dimensionsAsSwatchType?: DimensionTypes[];\n    dimensionsInProductCard?: DimensionTypes[];\n    inventoryLevel?: InventoryLevels;\n    dimensionToPreSelectInProductCard?: DimensionTypes;\n    enableStockCheck?: boolean;\n    warehouseAggregation?: string;\n}\n\n/**\n * Represents app configuration for dimensions.\n */\nexport interface IDimensionsApp {\n    config: IDimensionsConfig;\n}\n\n/**\n * Represents product dimension types.\n */\nexport enum DimensionTypes {\n    none = 'none',\n    color = 'color',\n    configuration = 'configuration',\n    size = 'size',\n    style = 'style'\n}\n\n/**\n * Defines display configuration types.\n */\nexport enum DimensionSwatchDisplayTypes {\n    default = 'default',\n    productCard = 'productCard'\n}\n\n/**\n * Checks if rendering the particular dimensions is allowed.\n * @param dimensionType - Dimension to be displayed.\n * @param context - Core application context.\n * @param displayType - The swatch location, the component from which it comes from.\n * @returns Updates the state with new product page url.\n */\nexport const checkIfShouldDisplayAsSwatch = (\n    dimensionType: DimensionTypes,\n    context: ICoreContext<IDimensionsApp>,\n    displayType: DimensionSwatchDisplayTypes = DimensionSwatchDisplayTypes.default\n): boolean => {\n    // Additional checks for the product card since it has a separate config setting.\n    if (displayType === DimensionSwatchDisplayTypes.productCard) {\n        const dimensionsToDisplayOnProductCard = context.app.config.dimensionsInProductCard;\n        if (\n            !ArrayExtensions.hasElements(dimensionsToDisplayOnProductCard) ||\n            dimensionsToDisplayOnProductCard.includes(DimensionTypes.none) ||\n            !dimensionsToDisplayOnProductCard.includes(dimensionType)\n        ) {\n            return false;\n        }\n    }\n\n    const dimensionsToDisplayAsSwatch = context.app.config.dimensionsAsSwatchType;\n    return (\n        ArrayExtensions.hasElements(dimensionsToDisplayAsSwatch) &&\n        !dimensionsToDisplayAsSwatch.includes(DimensionTypes.none) &&\n        dimensionsToDisplayAsSwatch.includes(dimensionType)\n    );\n};\n\n/**\n * Generates an image URL for a swatch.\n * @param imageUrl - The image url returned by Retail Server.\n * @param apiSettings - The request context.\n * @returns Full image url.\n */\nexport const generateSwatchImageUrl = (imageUrl: string, apiSettings: ICommerceApiSettings): string => {\n    if (imageUrl.startsWith('http')) {\n        return imageUrl;\n    }\n\n    return apiSettings.baseImageUrl + encodeURIComponent(imageUrl);\n};\n\n/**\n * Generates a Image URL for a product based on data return from retail server.\n * @param product The Product returned by Retail Server.\n * @param ctx The request context.\n * @param apiSettings\n */\nexport const generateProductImageUrl = (\n    product: SimpleProduct | ProductSearchResult,\n    apiSettings: ICommerceApiSettings\n): string | undefined => {\n    return generateImageUrl(product.PrimaryImageUrl, apiSettings);\n};\n\n/**\n * Creates a CartLine object from the passed data.\n * @param product The product.\n * @param quantity The quantity.\n * @param catalogId The catalog.\n */\nexport const buildCartLine = (product: SimpleProduct, quantity?: number, catalogId?: number): CartLine => {\n    return {\n        CatalogId: catalogId || 0,\n        Description: product.Description,\n\n        // TODO: Investigate this value and what it represents\n        EntryMethodTypeValue: 3,\n        ItemId: product.ItemId,\n        ProductId: product.RecordId,\n        Quantity: quantity || 1,\n        TrackingId: '',\n        UnitOfMeasureSymbol: product.DefaultUnitOfMeasure\n    };\n};\n\n/**\n * Creates a CommerceListLine (also know as WishlistLine) object from the passed data.\n * @param productId The RecordId of the Product to be added.\n * @param customerId The account number of the customer.\n * @param wishlistId The Id of the commerce list.\n */\nexport const buildWishlistLine = (productId: number, customerId: string, wishlistId: number): CommerceListLine => {\n    return {\n        CommerceListId: wishlistId,\n        ProductId: productId,\n        CustomerId: customerId\n    };\n};\n\n/**\n * Utility function to prepare the product details criteria before getting full product:\n * @param inputData The Action Input data\n */\nexport const getProductDetailsCriteriaFromActionInput = (inputData: ICreateActionContext<IGeneric<IAny>>): ProductDetailsCriteria => {\n    if (inputData && inputData.config) {\n        return {\n            getPrice: !inputData.config.hidePrice,\n            getRating: !inputData.config.hideRating\n        };\n    }\n    return {\n        getPrice: true,\n        getRating: true\n    };\n};\n\n/**\n * Transforms search text into the expected 'search terms' format, expected by refiner APIs.\n * @param searchText Free-form text used for searching for products or categories of products.\n */\nexport const ensureSearchTextIsFormedProperly = (searchText: string): string => {\n    const prefix = searchText.startsWith(\"'\") ? '' : \"'\";\n    const suffix = searchText.endsWith(\"'\") ? '' : \"'\";\n    return `${prefix}${searchText}${suffix}`;\n};\n\nexport const ensureSafeSearchText = (searchText: string): string => {\n    return searchText.replace(/[^\\d\\sA-Za-z]+/g, '');\n};\n\n/**\n * @deprecated Please use `generateCacheKey` instead.\n */\nexport const buildCacheKey = (base: string, apiSettings: ICommerceApiSettings, locale?: string): string => {\n    return `${base}-chanId:${apiSettings.channelId}-catId:${apiSettings.catalogId}${locale ? `-${locale}` : ''}`;\n};\n\n/**\n * Represents a list of keys for general parameters used in the cache key.\n */\nenum DefaultCacheKeyParameterKeys {\n    channelIdKey = 'CHANNELID',\n    appSettingsCatalogIdKey = 'APPSETTINGSCATALOGID'\n}\n\n/**\n * Generates a key from set of arguments\n * @param apiSettings - Request context API settings.\n * @param entries - Cache key parameters.\n * @returns String which represents the cache key.\n */\nexport const generateCacheKey = (\n    apiSettings?: ICommerceApiSettings,\n    ...entries: IKeyValuePair<string, TKeyTypes | TKeyTypes[]>[]\n): string => {\n    const parsedEntries: IKeyValuePair<string, TKeyTypes | TKeyTypes[]>[] = entries.map(pair => {\n        return { key: pair.key.toLocaleUpperCase(), value: pair.value };\n    });\n\n    const cacheKeyArgumentsKeys = parsedEntries.map(pair => pair.key);\n\n    if (apiSettings) {\n        if (!cacheKeyArgumentsKeys.includes(DefaultCacheKeyParameterKeys.channelIdKey)) {\n            parsedEntries.push({ key: DefaultCacheKeyParameterKeys.channelIdKey, value: apiSettings.channelId });\n        }\n\n        if (!cacheKeyArgumentsKeys.includes(DefaultCacheKeyParameterKeys.appSettingsCatalogIdKey) && apiSettings.catalogId) {\n            parsedEntries.push({ key: DefaultCacheKeyParameterKeys.appSettingsCatalogIdKey, value: apiSettings.catalogId });\n        }\n    }\n\n    return parsedEntries\n        .sort((a, b) => a.key.localeCompare(b.key))\n        .map(pair => `${pair.key}:{${pair.value}}`)\n        .join('-');\n};\n\nexport const buildCacheKeyWithUrlTokens = (base: string, requestContext: IRequestContext): string => {\n    const urlTokens = requestContext.urlTokens;\n    const defaultCacheKey = buildCacheKey(base, requestContext.apiSettings, requestContext.locale);\n    return urlTokens ? `${defaultCacheKey}-${urlTokens.itemId}-${urlTokens.recordId}-${urlTokens.pageType}` : defaultCacheKey;\n};\n\n/**\n * Generates a key from set of arguments as inputs.\n *\n * @param args Argument list of pivots to generate key from.\n * @param handler Handler function for null/undefined values.\n */\n\ntype TKeyTypes = string | number | boolean | null | undefined;\ninterface IGenerateKeyOptions {\n    separator?: string;\n    handler?(input: null | undefined): string;\n}\nexport const generateKey = (args: TKeyTypes[], options?: IGenerateKeyOptions): string => {\n    const { handler, separator }: IGenerateKeyOptions = { ...{ separator: '-', handler: undefined }, ...(options || {}) };\n    return args\n        .map(arg => {\n            if (arg === null || arg === undefined) {\n                if (handler) {\n                    return handler(arg);\n                }\n            }\n            return arg;\n        })\n        .join(separator);\n};\n\n/**\n * Gets the fall back image url for a variant image.\n * @param itemId Item id of a product.\n * @param apiSettings Api setting from request context.\n */\nexport const getFallbackImageUrl = (\n    itemId: string | undefined,\n    apiSettings: ICommerceApiSettings,\n    isOmniFeatureEnabled?: boolean\n): string | undefined => {\n    if (!itemId || isOmniFeatureEnabled) {\n        return '';\n    }\n\n    const parsedItemId = itemId.trim().split(' ')[0];\n\n    const productUrl = `Products/${parsedItemId}_000_001.png`;\n    return generateImageUrl(productUrl, apiSettings);\n};\n\n/**\n * Converts retail proxy product dimension type to display dimension type.\n * @param productDimensionType - Product dimension type from retail proxy.\n * @returns Local dimension type.\n */\nexport const convertProductDimensionTypeToDimensionTypes = (productDimensionType: ProductDimensionType): DimensionTypes => {\n    switch (productDimensionType) {\n        case ProductDimensionType.Color:\n            return DimensionTypes.color;\n        case ProductDimensionType.Configuration:\n            return DimensionTypes.configuration;\n        case ProductDimensionType.Size:\n            return DimensionTypes.size;\n        case ProductDimensionType.Style:\n            return DimensionTypes.style;\n        default:\n            return DimensionTypes.none;\n    }\n};\n\n/**\n * Converts display dimension type to retail proxy product dimension type.\n * @param dimensionType - Local dimension type.\n * @returns Product dimension type from retail proxy.\n */\nexport const convertDimensionTypeToProductDimensionType = (dimensionType: DimensionTypes): ProductDimensionType => {\n    switch (dimensionType) {\n        case DimensionTypes.color:\n            return ProductDimensionType.Color;\n        case DimensionTypes.configuration:\n            return ProductDimensionType.Configuration;\n        case DimensionTypes.size:\n            return ProductDimensionType.Size;\n        case DimensionTypes.style:\n            return ProductDimensionType.Style;\n        default:\n            return ProductDimensionType.None;\n    }\n};\n\n/**\n * Sets dimensions to url.\n * @param inputUrl - Url to update.\n * @param productDimensions - Dimensions to set.\n */\nexport const setDimensionValuesToQuery = (inputUrl: URL, productDimensions: ProductDimension[]): void => {\n    for (const dimension of productDimensions) {\n        const dimensionValue = dimension.DimensionValue?.Value;\n        if (!StringExtensions.isNullOrWhitespace(dimensionValue)) {\n            inputUrl.searchParams.set(convertProductDimensionTypeToDimensionTypes(dimension.DimensionTypeValue), dimensionValue!);\n        }\n    }\n\n    if (msdyn365Commerce.isBrowser) {\n        window.history.replaceState(window.history.state, '', inputUrl.toString().replace(inputUrl.host, window.location.host));\n    }\n};\n\n/**\n * Retrieves dimension value stored in url.\n * @param urlParameters - Url parameters.\n * @param productDimensionType - The dimension type to retrieve.\n * @returns Product dimension item.\n */\nconst parseDimensionFromUrl = (\n    urlParameters: URLSearchParams,\n    productDimensionType: ProductDimensionType\n): ProductDimension | undefined => {\n    const localDimensionType = convertProductDimensionTypeToDimensionTypes(productDimensionType);\n    const value = urlParameters.get(localDimensionType);\n    if (!value) {\n        return undefined;\n    }\n    return {\n        DimensionTypeValue: productDimensionType,\n        DimensionValue: {\n            RecordId: 0,\n            Value: value\n        }\n    };\n};\n\n/**\n * Retrieves all dimensions from URL.\n * @param urlParameters - Url parameters.\n * @returns Product dimensions stored in url.\n */\nconst parseDimensionsFromUrl = (urlParameters: URLSearchParams): ProductDimension[] => {\n    const dimensionsToParse: ProductDimensionType[] = [\n        ProductDimensionType.Color,\n        ProductDimensionType.Configuration,\n        ProductDimensionType.Size,\n        ProductDimensionType.Style\n    ];\n    const parsedDimensions = dimensionsToParse.map(dimension => parseDimensionFromUrl(urlParameters, dimension));\n    return ArrayExtensions.validValues(parsedDimensions);\n};\n\n/**\n * Utility function to extract the dimension values from input url querystring.\n * @param inputUrl -  The request url.\n * @returns The selected dimension values.\n */\nexport const getDimensionValuesFromQuery = (inputUrl: URL): ProductDimension[] => {\n    const urlWithIgnoredCase = new URL(inputUrl.toString().toLocaleLowerCase());\n    const urlParameters = urlWithIgnoredCase.searchParams;\n    const dimensions: ProductDimension[] = parseDimensionsFromUrl(urlParameters);\n    return dimensions;\n};\n\n/**\n * Get attribute values by channel inventory configuration.\n * @param attributeValues - The attributeValues.\n * @param channelInventoryConfiguration - The channelInventoryConfiguration.\n * @returns The attributeValues filter by channel inventory configuration.\n */\nexport const getAttributeValuesByConfiguration = (\n    attributeValues: AttributeValue[] | null,\n    channelInventoryConfiguration: ChannelInventoryConfiguration | null\n): AttributeValue[] => {\n    if (!attributeValues) {\n        return [];\n    }\n    if (!channelInventoryConfiguration) {\n        return attributeValues;\n    }\n\n    return attributeValues.filter(\n        attribute =>\n            attribute.RecordId !== channelInventoryConfiguration.InventoryProductAttributeRecordId &&\n            attribute.RecordId !== channelInventoryConfiguration.ProductAvailabilitySortableAttributeRecordId\n    );\n};\n\n/**\n * Utility function to remove domain querystring parameter from url.\n * @param inputUrl -  The request url.\n * @returns The yrl after dropping domain querystring.\n */\nexport const removeDomainQspFromUrl = (inputUrl: string, requestContext: IRequestContext): string => {\n    if (requestContext?.features && requestContext.features.remove_domain_qsp) {\n        const Url = new URL(inputUrl);\n        const urlParams: URLSearchParams = new URLSearchParams(Url.search);\n        if (urlParams.has('domain')) {\n            urlParams.delete('domain');\n        }\n        Url.search = urlParams.toString();\n        return Url.toString();\n    }\n    return inputUrl;\n};\n\n/**\n * Utility function to validate catalog Id for B2B user .\n * @param catalogId -  The catalog.\n */\nexport const validateCatalogId = (catalogId?: number | undefined) => {\n    if (catalogId === -1) {\n        throw new Error(\n            'Catalog id is -1. It means no valid catalogs were found for the user. Make sure the user has some valid catalogs assigned.'\n        );\n    }\n};\n\n/**\n * Utility function to check deliveryMode .\n * @param cartline - CartLine item.\n * @param retailMulitplePickupFeatureState - pickUp feature state, default to false.\n * @param channelDeliveryOptionConfig - Channel Delivery Option Configuration.\n * @param pickupDeliveryModeCode -pickUp delivery mode code string.\n * @returns true id cartline item is pickUp item else false.\n */\nexport const getDeliveryMode = (\n    cartLine: CartLine,\n    featureSate: boolean = false,\n    channelDeliveryOptionConfig?: ChannelDeliveryOptionConfiguration,\n    pickupDeliveryMode?: string\n) => {\n    if (!featureSate) {\n        return cartLine.DeliveryMode === pickupDeliveryMode;\n    }\n    return (\n        cartLine.DeliveryMode ===\n        channelDeliveryOptionConfig?.PickupDeliveryModeCodes?.find(deliveryMode => deliveryMode === cartLine.DeliveryMode)\n    );\n};\n\n/**\n * Utility function to check if cartline item is pickupitem .\n * @param cartline - CartLine item.\n * @param retailMulitplePickupFeatureState - pickUp feature state.\n * @param channelDeliveryOptionConfig - Channel Delivery Option Configuration.\n * @param pickupDeliveryModeCode -pickUp delivery mode code string.\n * @returns true id cartline item is pickUp item else false.\n */\nexport const isCartLineItemPickUpType = (\n    cartline: CartLine,\n    retailMulitplePickupFeatureState: boolean = false,\n    channelDeliveryOptionConfig?: ChannelDeliveryOptionConfiguration,\n    pickupDeliveryModeCode?: string\n): boolean => {\n    // check if cartlineitem is pickup item\n    if (\n        cartline.DeliveryMode &&\n        cartline.DeliveryMode !== '' &&\n        getDeliveryMode(cartline, retailMulitplePickupFeatureState, channelDeliveryOptionConfig, pickupDeliveryModeCode)\n    ) {\n        return true;\n    }\n    return false;\n};\n","/*!\n * Copyright (c) Microsoft Corporation.\n * All rights reserved. See LICENSE in the project root for license information.\n */\n\nimport { IActionContext } from '@msdyn365-commerce/core';\nimport { CartLine } from '@msdyn365-commerce/retail-proxy';\nimport { SimpleProduct } from '@msdyn365-commerce/retail-proxy/dist/Entities/CommerceTypes.g';\n\nimport { ArrayExtensions } from './extensions/array-extensions';\nimport { IProductInventoryInformation } from './product-inventory-information';\n\n/**\n * Cart line inventory validation result interface.\n */\nexport interface ICartLineInventoryValidationResult {\n    /**\n     * Define whether the cart lines inventory is valid across multiple cart lines.\n     */\n    readonly isValid: boolean;\n\n    /**\n     * Defines the list of product id with invalid inventory.\n     */\n    readonly productIdWithErrors: number[];\n}\n\n/**\n * Validates inventory across cart lines.\n * @param cartLines - The cart lines.\n * @param productAvailabilities - The product availability collection.\n * @param actionContext - The action context.\n * @param products - The products.\n * @param emailDeliveryModeCode - The emailDeliveryModeCode.\n * @returns True if all product quantity are available, false otherwise.\n */\n// eslint-disable-next-line complexity -- existing code.\nexport function validateCartLinesInventory(\n    cartLines: CartLine[],\n    productAvailabilities: IProductInventoryInformation[],\n    actionContext: IActionContext,\n    products?: SimpleProduct[],\n    emailDeliveryModeCode?: string | undefined\n): ICartLineInventoryValidationResult {\n    const cartLineMap = new Map<number, number>();\n    const defaultCartLineQuantity = 1;\n    if (!actionContext.requestContext.app.config.enableStockCheck) {\n        return {\n            isValid: true,\n            productIdWithErrors: []\n        };\n    }\n    const productIdWithErrors = [];\n    let isValid = true;\n\n    if (ArrayExtensions.hasElements(cartLines) && ArrayExtensions.hasElements(productAvailabilities)) {\n        // Consolidate products in different cart lines into single entry with the total cart quantity\n        for (const cartLine of cartLines) {\n            // Skip validation if is an invoice inline.\n            if (cartLine.ProductId && !cartLine.IsInvoiceLine && !cartLine.IsGiftCardLine) {\n                if (!cartLineMap.has(cartLine.ProductId)) {\n                    cartLineMap.set(cartLine.ProductId, cartLine.Quantity ?? defaultCartLineQuantity);\n                } else {\n                    const cartLineTotal = cartLineMap.get(cartLine.ProductId) ?? 0;\n                    cartLineMap.delete(cartLine.ProductId);\n                    cartLineMap.set(cartLine.ProductId, cartLineTotal + (cartLine.Quantity ?? defaultCartLineQuantity));\n                }\n            }\n        }\n\n        // Hashing product availability object by product ID.\n        const productAvailabilityMap = new Map<number, IProductInventoryInformation>();\n        for (const productAvailability of productAvailabilities) {\n            if (\n                productAvailability.ProductAvailableQuantity.ProductId &&\n                !productAvailabilityMap.has(productAvailability.ProductAvailableQuantity.ProductId)\n            ) {\n                productAvailabilityMap.set(productAvailability.ProductAvailableQuantity.ProductId, productAvailability);\n            }\n        }\n\n        // Compare total quantity with the available quantity from the inventory API, also validate that the product is available.\n        for (const productId of Array.from(cartLineMap.keys())) {\n            const cartLineQty = cartLineMap.get(productId) ?? defaultCartLineQuantity;\n            const productAvailability = productAvailabilityMap.get(productId);\n            const availableQuantity = productAvailability?.ProductAvailableQuantity.AvailableQuantity ?? undefined;\n\n            // If product is non-stocked or cartLine is electronic delivery, then no inventory check\n            const cartLine = cartLines.find(line => line.ProductId === productId);\n            const cartLineProduct = products?.find(product => product.RecordId === productId);\n            let isStockedItem = true;\n            if (cartLineProduct) {\n                isStockedItem = !!cartLineProduct.Behavior?.IsStockedProduct;\n            }\n            const isEmailDelivery =\n                cartLine?.DeliveryMode && cartLine.DeliveryMode !== '' ? cartLine.DeliveryMode === emailDeliveryModeCode : false;\n            const shouldSkipInventoryCheck = !isStockedItem || isEmailDelivery;\n\n            // If product is non-stocked or cartLine is electronic delivery, then no inventory check\n            if (shouldSkipInventoryCheck) {\n                continue;\n            }\n            if (!productAvailability?.IsProductAvailable || (availableQuantity && cartLineQty > availableQuantity)) {\n                productIdWithErrors.push(productId);\n                isValid = false;\n            }\n        }\n    }\n    return {\n        isValid,\n        productIdWithErrors\n    };\n}\n","'use strict';\n// eslint-disable-next-line es/no-typed-arrays -- safe\nmodule.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';\n","'use strict';\nvar NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-basic-detection');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar classof = require('../internals/classof');\nvar tryToString = require('../internals/try-to-string');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar uid = require('../internals/uid');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar Int8Array = global.Int8Array;\nvar Int8ArrayPrototype = Int8Array && Int8Array.prototype;\nvar Uint8ClampedArray = global.Uint8ClampedArray;\nvar Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;\nvar TypedArray = Int8Array && getPrototypeOf(Int8Array);\nvar TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);\nvar ObjectPrototype = Object.prototype;\nvar TypeError = global.TypeError;\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');\nvar TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';\n// Fixing native typed arrays in Opera Presto crashes the browser, see #595\nvar NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';\nvar TYPED_ARRAY_TAG_REQUIRED = false;\nvar NAME, Constructor, Prototype;\n\nvar TypedArrayConstructorsList = {\n  Int8Array: 1,\n  Uint8Array: 1,\n  Uint8ClampedArray: 1,\n  Int16Array: 2,\n  Uint16Array: 2,\n  Int32Array: 4,\n  Uint32Array: 4,\n  Float32Array: 4,\n  Float64Array: 8\n};\n\nvar BigIntArrayConstructorsList = {\n  BigInt64Array: 8,\n  BigUint64Array: 8\n};\n\nvar isView = function isView(it) {\n  if (!isObject(it)) return false;\n  var klass = classof(it);\n  return klass === 'DataView'\n    || hasOwn(TypedArrayConstructorsList, klass)\n    || hasOwn(BigIntArrayConstructorsList, klass);\n};\n\nvar getTypedArrayConstructor = function (it) {\n  var proto = getPrototypeOf(it);\n  if (!isObject(proto)) return;\n  var state = getInternalState(proto);\n  return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto);\n};\n\nvar isTypedArray = function (it) {\n  if (!isObject(it)) return false;\n  var klass = classof(it);\n  return hasOwn(TypedArrayConstructorsList, klass)\n    || hasOwn(BigIntArrayConstructorsList, klass);\n};\n\nvar aTypedArray = function (it) {\n  if (isTypedArray(it)) return it;\n  throw new TypeError('Target is not a typed array');\n};\n\nvar aTypedArrayConstructor = function (C) {\n  if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;\n  throw new TypeError(tryToString(C) + ' is not a typed array constructor');\n};\n\nvar exportTypedArrayMethod = function (KEY, property, forced, options) {\n  if (!DESCRIPTORS) return;\n  if (forced) for (var ARRAY in TypedArrayConstructorsList) {\n    var TypedArrayConstructor = global[ARRAY];\n    if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {\n      delete TypedArrayConstructor.prototype[KEY];\n    } catch (error) {\n      // old WebKit bug - some methods are non-configurable\n      try {\n        TypedArrayConstructor.prototype[KEY] = property;\n      } catch (error2) { /* empty */ }\n    }\n  }\n  if (!TypedArrayPrototype[KEY] || forced) {\n    defineBuiltIn(TypedArrayPrototype, KEY, forced ? property\n      : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);\n  }\n};\n\nvar exportTypedArrayStaticMethod = function (KEY, property, forced) {\n  var ARRAY, TypedArrayConstructor;\n  if (!DESCRIPTORS) return;\n  if (setPrototypeOf) {\n    if (forced) for (ARRAY in TypedArrayConstructorsList) {\n      TypedArrayConstructor = global[ARRAY];\n      if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {\n        delete TypedArrayConstructor[KEY];\n      } catch (error) { /* empty */ }\n    }\n    if (!TypedArray[KEY] || forced) {\n      // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable\n      try {\n        return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);\n      } catch (error) { /* empty */ }\n    } else return;\n  }\n  for (ARRAY in TypedArrayConstructorsList) {\n    TypedArrayConstructor = global[ARRAY];\n    if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {\n      defineBuiltIn(TypedArrayConstructor, KEY, property);\n    }\n  }\n};\n\nfor (NAME in TypedArrayConstructorsList) {\n  Constructor = global[NAME];\n  Prototype = Constructor && Constructor.prototype;\n  if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;\n  else NATIVE_ARRAY_BUFFER_VIEWS = false;\n}\n\nfor (NAME in BigIntArrayConstructorsList) {\n  Constructor = global[NAME];\n  Prototype = Constructor && Constructor.prototype;\n  if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;\n}\n\n// WebKit bug - typed arrays constructors prototype is Object.prototype\nif (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {\n  // eslint-disable-next-line no-shadow -- safe\n  TypedArray = function TypedArray() {\n    throw new TypeError('Incorrect invocation');\n  };\n  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {\n    if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);\n  }\n}\n\nif (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {\n  TypedArrayPrototype = TypedArray.prototype;\n  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {\n    if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);\n  }\n}\n\n// WebKit bug - one more object in Uint8ClampedArray prototype chain\nif (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {\n  setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);\n}\n\nif (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {\n  TYPED_ARRAY_TAG_REQUIRED = true;\n  defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, {\n    configurable: true,\n    get: function () {\n      return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;\n    }\n  });\n  for (NAME in TypedArrayConstructorsList) if (global[NAME]) {\n    createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);\n  }\n}\n\nmodule.exports = {\n  NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,\n  TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,\n  aTypedArray: aTypedArray,\n  aTypedArrayConstructor: aTypedArrayConstructor,\n  exportTypedArrayMethod: exportTypedArrayMethod,\n  exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,\n  getTypedArrayConstructor: getTypedArrayConstructor,\n  isView: isView,\n  isTypedArray: isTypedArray,\n  TypedArray: TypedArray,\n  TypedArrayPrototype: TypedArrayPrototype\n};\n","'use strict';\nvar toObject = require('../internals/to-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.fill` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.fill\nmodule.exports = function fill(value /* , start = 0, end = @length */) {\n  var O = toObject(this);\n  var length = lengthOfArrayLike(O);\n  var argumentsLength = arguments.length;\n  var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length);\n  var end = argumentsLength > 2 ? arguments[2] : undefined;\n  var endPos = end === undefined ? length : toAbsoluteIndex(end, length);\n  while (endPos > index) O[index++] = value;\n  return O;\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\n\nvar $TypeError = TypeError;\n\n// `ToBigInt` abstract operation\n// https://tc39.es/ecma262/#sec-tobigint\nmodule.exports = function (argument) {\n  var prim = toPrimitive(argument, 'number');\n  if (typeof prim == 'number') throw new $TypeError(\"Can't convert number to bigint\");\n  // eslint-disable-next-line es/no-bigint -- safe\n  return BigInt(prim);\n};\n","'use strict';\nvar toPositiveInteger = require('../internals/to-positive-integer');\n\nvar $RangeError = RangeError;\n\nmodule.exports = function (it, BYTES) {\n  var offset = toPositiveInteger(it);\n  if (offset % BYTES) throw new $RangeError('Wrong offset');\n  return offset;\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar $RangeError = RangeError;\n\nmodule.exports = function (it) {\n  var result = toIntegerOrInfinity(it);\n  if (result < 0) throw new $RangeError(\"The argument can't be less than 0\");\n  return result;\n};\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar $fill = require('../internals/array-fill');\nvar toBigInt = require('../internals/to-big-int');\nvar classof = require('../internals/classof');\nvar call = require('../internals/function-call');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar slice = uncurryThis(''.slice);\n\n// V8 ~ Chrome < 59, Safari < 14.1, FF < 55, Edge <=18\nvar CONVERSION_BUG = fails(function () {\n  var count = 0;\n  // eslint-disable-next-line es/no-typed-arrays -- safe\n  new Int8Array(2).fill({ valueOf: function () { return count++; } });\n  return count !== 1;\n});\n\n// `%TypedArray%.prototype.fill` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill\nexportTypedArrayMethod('fill', function fill(value /* , start, end */) {\n  var length = arguments.length;\n  aTypedArray(this);\n  var actualValue = slice(classof(this), 0, 3) === 'Big' ? toBigInt(value) : +value;\n  return call($fill, this, actualValue, length > 1 ? arguments[1] : undefined, length > 2 ? arguments[2] : undefined);\n}, CONVERSION_BUG);\n","'use strict';\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar toOffset = require('../internals/to-offset');\nvar toIndexedObject = require('../internals/to-object');\nvar fails = require('../internals/fails');\n\nvar RangeError = global.RangeError;\nvar Int8Array = global.Int8Array;\nvar Int8ArrayPrototype = Int8Array && Int8Array.prototype;\nvar $set = Int8ArrayPrototype && Int8ArrayPrototype.set;\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\n\nvar WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS = !fails(function () {\n  // eslint-disable-next-line es/no-typed-arrays -- required for testing\n  var array = new Uint8ClampedArray(2);\n  call($set, array, { length: 1, 0: 3 }, 1);\n  return array[1] !== 3;\n});\n\n// https://bugs.chromium.org/p/v8/issues/detail?id=11294 and other\nvar TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS && fails(function () {\n  var array = new Int8Array(2);\n  array.set(1);\n  array.set('2', 1);\n  return array[0] !== 0 || array[1] !== 2;\n});\n\n// `%TypedArray%.prototype.set` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.set\nexportTypedArrayMethod('set', function set(arrayLike /* , offset */) {\n  aTypedArray(this);\n  var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1);\n  var src = toIndexedObject(arrayLike);\n  if (WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS) return call($set, this, src, offset);\n  var length = this.length;\n  var len = lengthOfArrayLike(src);\n  var index = 0;\n  if (len + offset > length) throw new RangeError('Wrong length');\n  while (index < len) this[offset + index] = src[index++];\n}, !WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS || TO_OBJECT_BUG);\n","'use strict';\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar fails = require('../internals/fails');\nvar aCallable = require('../internals/a-callable');\nvar internalSort = require('../internals/array-sort');\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar FF = require('../internals/engine-ff-version');\nvar IE_OR_EDGE = require('../internals/engine-is-ie-or-edge');\nvar V8 = require('../internals/engine-v8-version');\nvar WEBKIT = require('../internals/engine-webkit-version');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar Uint16Array = global.Uint16Array;\nvar nativeSort = Uint16Array && uncurryThis(Uint16Array.prototype.sort);\n\n// WebKit\nvar ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort && !(fails(function () {\n  nativeSort(new Uint16Array(2), null);\n}) && fails(function () {\n  nativeSort(new Uint16Array(2), {});\n}));\n\nvar STABLE_SORT = !!nativeSort && !fails(function () {\n  // feature detection can be too slow, so check engines versions\n  if (V8) return V8 < 74;\n  if (FF) return FF < 67;\n  if (IE_OR_EDGE) return true;\n  if (WEBKIT) return WEBKIT < 602;\n\n  var array = new Uint16Array(516);\n  var expected = Array(516);\n  var index, mod;\n\n  for (index = 0; index < 516; index++) {\n    mod = index % 4;\n    array[index] = 515 - index;\n    expected[index] = index - 2 * mod + 3;\n  }\n\n  nativeSort(array, function (a, b) {\n    return (a / 4 | 0) - (b / 4 | 0);\n  });\n\n  for (index = 0; index < 516; index++) {\n    if (array[index] !== expected[index]) return true;\n  }\n});\n\nvar getSortCompare = function (comparefn) {\n  return function (x, y) {\n    if (comparefn !== undefined) return +comparefn(x, y) || 0;\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (y !== y) return -1;\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (x !== x) return 1;\n    if (x === 0 && y === 0) return 1 / x > 0 && 1 / y < 0 ? 1 : -1;\n    return x > y;\n  };\n};\n\n// `%TypedArray%.prototype.sort` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort\nexportTypedArrayMethod('sort', function sort(comparefn) {\n  if (comparefn !== undefined) aCallable(comparefn);\n  if (STABLE_SORT) return nativeSort(this, comparefn);\n\n  return internalSort(aTypedArray(this), getSortCompare(comparefn));\n}, !STABLE_SORT || ACCEPT_INCORRECT_ARGUMENTS);\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar fails = require('../internals/fails');\nvar arraySlice = require('../internals/array-slice');\n\nvar Int8Array = global.Int8Array;\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar $toLocaleString = [].toLocaleString;\n\n// iOS Safari 6.x fails here\nvar TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () {\n  $toLocaleString.call(new Int8Array(1));\n});\n\nvar FORCED = fails(function () {\n  return [1, 2].toLocaleString() !== new Int8Array([1, 2]).toLocaleString();\n}) || !fails(function () {\n  Int8Array.prototype.toLocaleString.call([1, 2]);\n});\n\n// `%TypedArray%.prototype.toLocaleString` method\n// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tolocalestring\nexportTypedArrayMethod('toLocaleString', function toLocaleString() {\n  return apply(\n    $toLocaleString,\n    TO_LOCALE_STRING_BUG ? arraySlice(aTypedArray(this)) : aTypedArray(this),\n    arraySlice(arguments)\n  );\n}, FORCED);\n"],"names":["SelectedVariantInput","constructor","productId","channelId","matchingDimensionValues","bypassCache","requestContext","getCacheKey","getCacheObjectType","dataCacheType","this","catalogId","getCatalogId","getSelectedVariantActionDataAction","createObservableDataAction","id","action","async","input","context","_input$matchingDimens","_input$catalogId2","getDimensionValuesFromQuery","url","requestUrl","product","ProductsDataActions","callerContext","queryResultSettings","QueryResultSettingsProxy","getPagingFromInputDataOrDefaultValue","_objectSpread","hasUnmatchedDimension","checkIfHasUnmatchedDimensions","Dimensions","map","dimension","matchedTargetDimension","find","targetDimension","DimensionTypeValue","DimensionValue","newImageUrl","generateProductImageUrl","apiSettings","PrimaryImageUrl","fullDimensions","_product$Dimensions","fullDimensionPromises","shippingInventoryConfiguration","createInventoryAvailabilitySearchCriteria","undefined","searchCriteria","RequestedDimensionTypeValue","MatchingDimensionValues","DefaultWarehouseOnly","FilterByChannelFulfillmentGroup","DeliveryModeTypeFilterValue","CatalogId","MasterProductId","RecordId","then","dimensionValues","dimensionValuesWithInventory","Promise","all","getFullDimensions","productVariant","ArrayExtensions","hasElements","ProductIds","_input$catalogId","variantProductId","variantImageUrl","getProductVariant","matchedTargetDimensionFromApi","selectedProduct","inputData","getSelectedProductIdFromActionInput","Error","config","fromModuleData","sortingCriteria","query","top","skip","Paging","Skip","Number","Top","itemsPerPage","Sorting","_config$itemsPerPage","_inputData$requestCon","_inputData$requestCon2","parseInt","app","platform","defaultPageSizeForAPI","Columns","column","ColumnName","IsDescending","join","Dictionary","_values","_length","_len","arguments","length","entries","Array","_key","forEach","keyValuePair","setValue","key","value","removeValue","hasValue","getValue","getValueWithDefaultValue","defaultValue","isEmpty","clear","getValues","getKeys","Object","keys","getKeyValuePairs","Event","_subscribers","subscribe","instance","push","unsubscribe","instanceId","filter","element","unsubscribeAll","trigger","subscriber","handler","ObjectExtensions","isNullOrUndefined","validValues","item","firstOrDefault","values","unique","from","Set","predicate","flatten","result","arrayLine","concat","equals","firstArray","secondArray","comparator","JSON","stringify","index","haveSameItems","valueFromFirstArray","valueFromSecondArray","some","otherItem","calculateSum","data","reverse","array","newArray","EnumExtensions","StringExtensions","enumClass","getNumericValues","isNumber","getNames","isString","getEnumValues","isNullOrEmpty","isNullOrWhitespace","trim","isFunction","parseSearchData","q","maxItems","fromInputData","QueryResultSettings","DeliveryMode","InventoryLevels","InventoryLevelValues","getInventoryLevelCodeFromDimensionValue","inventoryLevel","totalAvailable","TotalAvailableInventoryLevelCode","physicalAvailable","PhysicalAvailableInventoryLevelCode","getInventoryLevelCodeFromProductAvailability","productAvailability","displayLabelEnabled","inventoryCode","inventoryRanges","available","outOfStock","mapProductInventoryInformation","productsWarehouseInventory","productInventoryInformation","enableStockCheck","physicalProductMap","mapInventoryWithPhysicalBufferEnabled","totalAvailableProductMap","mapInventoryWithTotalAvailableBufferEnabled","productMap","mapInventoryWithThresholdEnabled","productWarehouseInventoryAvailability","ProductId","TotalAvailable","productQty","outOfStockThreshold","productAvailableQuantity","AvailableQuantity","ProductAvailableQuantity","IsProductAvailable","InventLocationId","shouldRenderLabel","productQuantity","_productWarehouseInve","MaximumPurchasablePhysicalAvailableQuantity","PhysicalAvailable","StockLevelCode","StockLevelLabel","PhysicalAvailableInventoryLevelLabel","_productWarehouseInve2","MaximumPurchasableTotalAvailableQuantity","TotalAvailableInventoryLevelLabel","isAggregatedInventory","warehouseAggregation","mapAggregatedProductInventoryInformation","productWarehouseInventoryInformation","_productWarehouseInve3","AggregatedProductInventoryAvailabilities","_product$MaximumPurch","_product$MaximumPurch2","DataAreaId","PhysicalAvailableQuantity","TotalAvailableQuantity","ProductWarehouseInventoryAvailabilities","productIds","isDefaultWareHouse","isFilterByChannelFulfillmentGroup","searchArea","defaultDeliveryMode","deliveryMode","shipping","inventoryAvailabilitySearchCriteria","QuantityUnitTypeValue","SearchArea","FinitePromiseQueueError","FinitePromiseQueue","PromiseQueue","maxQueueLength","InvalidMaxQueueLengthPassed","super","_maxQueueLength","promiseBody","totalElementsCount","_queue","_isBusy","shift","reject","ProcessWasDiscardedFromTheQueue","enqueue","PromiseQueueElement","body","resolve","_dequeue","_canProcess","_processElement","_processNext","catch","error","getRandomValues","rnds8","Uint8Array","rng","crypto","bind","msCrypto","uuid","REGEX","test","byteToHex","i","toString","substr","arr","offset","toLowerCase","validate","TypeError","options","buf","rnds","random","Guid","Random","generateGuid","uuidv4","_guid","EmailRegex","html5EmailRegex","PasswordRegex","defaultRegex","PhoneRegex","_context$query","urlTokens","itemId","pageType","generateImageUrl","imageUrl","generateImageUrlFromSdk","DimensionTypes","DimensionSwatchDisplayTypes","checkIfShouldDisplayAsSwatch","dimensionType","displayType","default","productCard","dimensionsToDisplayOnProductCard","dimensionsInProductCard","includes","none","dimensionsToDisplayAsSwatch","dimensionsAsSwatchType","generateSwatchImageUrl","startsWith","baseImageUrl","encodeURIComponent","buildWishlistLine","customerId","wishlistId","CommerceListId","CustomerId","getProductDetailsCriteriaFromActionInput","getPrice","hidePrice","getRating","hideRating","buildCacheKey","base","locale","DefaultCacheKeyParameterKeys","generateCacheKey","parsedEntries","pair","toLocaleUpperCase","cacheKeyArgumentsKeys","channelIdKey","appSettingsCatalogIdKey","sort","a","b","localeCompare","buildCacheKeyWithUrlTokens","defaultCacheKey","recordId","getFallbackImageUrl","isOmniFeatureEnabled","parsedItemId","split","convertProductDimensionTypeToDimensionTypes","productDimensionType","ProductDimensionType","Color","color","Configuration","configuration","Size","size","Style","style","convertDimensionTypeToProductDimensionType","None","setDimensionValuesToQuery","inputUrl","productDimensions","_dimension$DimensionV","dimensionValue","Value","searchParams","set","msdyn365Commerce","isBrowser","window","history","replaceState","state","replace","host","location","parseDimensionsFromUrl","urlParameters","parsedDimensions","parseDimensionFromUrl","localDimensionType","get","URL","toLocaleLowerCase","getAttributeValuesByConfiguration","attributeValues","channelInventoryConfiguration","attribute","InventoryProductAttributeRecordId","ProductAvailabilitySortableAttributeRecordId","removeDomainQspFromUrl","features","remove_domain_qsp","Url","urlParams","URLSearchParams","search","has","delete","validateCatalogId","getDeliveryMode","cartLine","_channelDeliveryOptio","featureSate","channelDeliveryOptionConfig","pickupDeliveryMode","PickupDeliveryModeCodes","isCartLineItemPickUpType","cartline","retailMulitplePickupFeatureState","pickupDeliveryModeCode","validateCartLinesInventory","cartLines","productAvailabilities","actionContext","products","emailDeliveryModeCode","cartLineMap","Map","isValid","productIdWithErrors","IsInvoiceLine","IsGiftCardLine","_cartLineMap$get","_cartLine$Quantity2","cartLineTotal","Quantity","_cartLine$Quantity","productAvailabilityMap","_cartLineMap$get2","_productAvailability$","cartLineQty","availableQuantity","line","cartLineProduct","isStockedItem","_cartLineProduct$Beha","Behavior","IsStockedProduct","isEmailDelivery","module","exports","ArrayBuffer","DataView","NAME","Constructor","Prototype","NATIVE_ARRAY_BUFFER","DESCRIPTORS","global","isCallable","isObject","hasOwn","classof","tryToString","createNonEnumerableProperty","defineBuiltIn","defineBuiltInAccessor","isPrototypeOf","getPrototypeOf","setPrototypeOf","wellKnownSymbol","uid","InternalStateModule","enforceInternalState","enforce","getInternalState","Int8Array","Int8ArrayPrototype","prototype","Uint8ClampedArray","Uint8ClampedArrayPrototype","TypedArray","TypedArrayPrototype","ObjectPrototype","TO_STRING_TAG","TYPED_ARRAY_TAG","TYPED_ARRAY_CONSTRUCTOR","NATIVE_ARRAY_BUFFER_VIEWS","opera","TYPED_ARRAY_TAG_REQUIRED","TypedArrayConstructorsList","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","BigIntArrayConstructorsList","BigInt64Array","BigUint64Array","getTypedArrayConstructor","it","proto","isTypedArray","klass","Function","configurable","aTypedArray","aTypedArrayConstructor","C","exportTypedArrayMethod","KEY","property","forced","ARRAY","TypedArrayConstructor","error2","exportTypedArrayStaticMethod","isView","toObject","toAbsoluteIndex","lengthOfArrayLike","O","argumentsLength","end","endPos","toPrimitive","$TypeError","argument","prim","BigInt","toPositiveInteger","$RangeError","RangeError","BYTES","toIntegerOrInfinity","ArrayBufferViewCore","$fill","toBigInt","call","uncurryThis","fails","slice","actualValue","count","fill","valueOf","toOffset","toIndexedObject","$set","WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS","0","TO_OBJECT_BUG","arrayLike","src","len","aCallable","internalSort","FF","IE_OR_EDGE","V8","WEBKIT","nativeSort","ACCEPT_INCORRECT_ARGUMENTS","STABLE_SORT","mod","expected","comparefn","x","y","getSortCompare","apply","arraySlice","$toLocaleString","toLocaleString","TO_LOCALE_STRING_BUG"],"sourceRoot":""}