@athoscommerce/snap-store-mobx 1.0.0

package/dist/esm/Search/Stores/SearchResultStore.js

@@ -0,0 +1,648 @@
+import { computed, makeObservable, observable } from 'mobx';
+import deepmerge from 'deepmerge';
+import { isPlainObject } from 'is-plain-object';
+const VARIANT_ATTRIBUTE = 'ss-variant-option';
+const VARIANT_ATTRIBUTE_SELECTED = 'ss-variant-option-selected';
+export class SearchResultStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(params) {
+        const { config, data, state, stores } = params || {};
+        const { search, meta, previousSearch } = data || {};
+        const { results, merchandising, pagination } = search || {};
+        const { previousResults } = stores || {};
+        const { loaded } = state || {};
+        let resultsArr = (results || []).map((result, idx) => {
+            return new Product({
+                config,
+                data: { result, meta },
+                position: idx + 1,
+                responseId: params.data.search?.tracking?.responseId || '',
+            });
+        });
+        const variantConfig = config?.settings?.variants;
+        // preselected variant options
+        if (variantConfig?.realtime?.enabled) {
+            // attach click events - ONLY happens once (known limitation)
+            if (!loaded && resultsArr?.length) {
+                const processedSelects = new Set();
+                document.querySelectorAll(`[${VARIANT_ATTRIBUTE}]`).forEach((elem) => {
+                    if (elem.tagName == 'OPTION') {
+                        const parentSelect = elem.closest('select');
+                        if (parentSelect) {
+                            if (!processedSelects.has(parentSelect)) {
+                                processedSelects.add(parentSelect);
+                                parentSelect.addEventListener('change', (e) => {
+                                    const val = e.target?.value;
+                                    const clickedOption = Array.from(parentSelect.querySelectorAll(`[${VARIANT_ATTRIBUTE}]`)).filter((elem) => elem.value == val);
+                                    if (clickedOption.length > 0) {
+                                        variantOptionClick(clickedOption[0], variantConfig, resultsArr);
+                                    }
+                                });
+                            }
+                        }
+                        else {
+                            console.warn('Warning: unable to add realtime variant event listener for element - ', elem);
+                        }
+                    }
+                    else {
+                        elem.addEventListener('click', () => {
+                            variantOptionClick(elem, variantConfig, resultsArr);
+                        });
+                    }
+                });
+            }
+            // check for attributes for preselection
+            if (resultsArr.length) {
+                const options = {};
+                // grab values from elements on the page to form preselected elements
+                document.querySelectorAll(`[${VARIANT_ATTRIBUTE_SELECTED}]`).forEach((elem) => {
+                    const attr = elem.getAttribute(VARIANT_ATTRIBUTE);
+                    if (attr) {
+                        const [option, value] = attr.split(':');
+                        if (option && value) {
+                            options[option.toLowerCase()] = [value.toLowerCase()];
+                        }
+                    }
+                });
+                makeVariantSelections(variantConfig, options, resultsArr);
+            }
+        }
+        // only when infinite is enabled
+        if (config?.settings?.infinite?.enabled && previousResults) {
+            // logic to determine when to concatenate previous results
+            // this logic is not bullet proof, but it is highly unlikely that the current and previous pagination data would ever be sequential unless paginating
+            // TODO: implement "load previous" with a limit to how many total products can be displayed
+            // the limit would be enforced by unloading (trimming) results based on the direction of the new search (previous page, next page)
+            if (pagination?.page && previousSearch?.pagination?.page && pagination.page == previousSearch.pagination.page + 1) {
+                resultsArr = (previousResults || []).concat(resultsArr);
+            }
+        }
+        // add banners to results - banner data includes ALL banners within the entire search results (even if not on the current page)
+        if (pagination && merchandising?.content?.inline) {
+            // ensure banners are sorted by index
+            const banners = merchandising.content.inline
+                .sort(function (a, b) {
+                return a.config.position.index - b.config.position.index;
+            })
+                .map((banner) => {
+                return new Banner({
+                    data: { banner, responseId: params.data.search?.tracking?.responseId || '' },
+                });
+            });
+            if (banners && pagination.totalResults) {
+                resultsArr = addBannersToResults(config, resultsArr, banners, pagination);
+            }
+        }
+        super(...resultsArr);
+    }
+}
+export class Banner {
+    constructor(bannerData) {
+        this.type = 'banner';
+        this.attributes = {};
+        this.mappings = {
+            core: {},
+        };
+        this.custom = {};
+        const { banner, responseId } = bannerData?.data || {};
+        const htmlString = banner.value;
+        const match = typeof htmlString === 'string' && htmlString.match(/data-banner-id="(\d+)"/);
+        const uid = match ? match[1] : 'ss-ib-' + banner.config.position.index;
+        this.id = uid;
+        this.responseId = responseId;
+        this.config = banner.config;
+        this.value = banner.value;
+        makeObservable(this, {
+            id: observable,
+            mappings: observable,
+            attributes: observable,
+        });
+    }
+}
+export class Product {
+    constructor(productData) {
+        this.type = 'product';
+        this.attributes = {};
+        this.mappings = {
+            core: {},
+        };
+        this.custom = {};
+        this.quantity = 1;
+        this.mask = new ProductMask();
+        const { config } = productData || {};
+        const { result, meta } = productData?.data || {};
+        this.id = result.id;
+        this.attributes = result.attributes;
+        this.mappings = result.mappings;
+        this.position = productData.position;
+        this.badges = new Badges({
+            data: {
+                meta,
+                result,
+            },
+        });
+        this.responseId = result.responseId || productData.responseId;
+        // @ts-ignore - need to add bundleSeed to snapi-types
+        if (result.bundleSeed) {
+            // @ts-ignore - need to add bundleSeed to snapi-types
+            this.bundleSeed = Boolean(result.bundleSeed);
+        }
+        if (result.variants && result.variants.data) {
+            // if variants are already parsed, use them
+            this.variants = new Variants({
+                data: {
+                    mask: this.mask,
+                    variants: result.variants.data,
+                    optionConfig: result.variants.optionConfig,
+                    preferences: result.variants?.preferences, // TODO: fix typing
+                    meta: meta,
+                },
+                config: config?.settings?.variants,
+            });
+        }
+        makeObservable(this, {
+            id: observable,
+            display: computed,
+            mappings: observable,
+            attributes: observable,
+            custom: observable,
+            quantity: observable,
+        });
+    }
+    get display() {
+        return deepmerge({ id: this.id, mappings: this.mappings, attributes: this.attributes, badges: this.badges }, this.mask.data, {
+            isMergeableObject: isPlainObject,
+        });
+    }
+}
+export class Badges {
+    constructor(badgesData) {
+        this.all = [];
+        const { data } = badgesData || {};
+        const { meta, result } = data || {};
+        this.all = (result.badges || [])
+            .filter((badge) => {
+            // remove badges that are not in the meta or are disabled
+            return !!(badge?.tag && meta.badges?.tags && meta.badges?.tags[badge.tag] && meta.badges?.tags[badge.tag].enabled);
+        })
+            .map((badge) => {
+            // merge badge with badge meta data
+            const metaBadgeData = meta.badges?.tags?.[badge.tag];
+            return {
+                ...badge,
+                ...metaBadgeData,
+            };
+        })
+            .sort((a, b) => {
+            return a.priority - b.priority;
+        });
+        makeObservable(this, {
+            all: observable,
+            tags: computed,
+            locations: computed,
+        });
+    }
+    // get all the result badges that are in a specific location
+    atLocation(location) {
+        const locations = Array.isArray(location) ? location : [location];
+        return this.all.filter((badge) => {
+            // filter location
+            return locations.some((location) => badge.location.startsWith(`${location}/`) || badge.location == location);
+        });
+    }
+    get tags() {
+        return this.all.reduce((badgeMap, badge) => {
+            badgeMap[badge.tag] = badge;
+            return badgeMap;
+        }, {});
+    }
+    get locations() {
+        return this.all.reduce((locationMap, badge) => {
+            // put badge in location by path
+            const [section, tag] = badge.location.split('/');
+            locationMap[section] = locationMap[section] || {};
+            locationMap[section][tag] = (locationMap[section][tag] || []).concat(badge);
+            return locationMap;
+        }, {});
+    }
+}
+// Mask is used to power the product display for quick attribute swapping
+export class ProductMask {
+    constructor() {
+        this.data = {};
+        makeObservable(this, {
+            data: observable,
+        });
+    }
+    merge(mask) {
+        // TODO: look into making more performant
+        // needed to prevent infinite re-render on merge with same data
+        if (JSON.stringify(deepmerge(this.data, mask)) != JSON.stringify(this.data)) {
+            this.data = deepmerge(this.data, mask);
+        }
+    }
+    set(mask) {
+        // TODO: look into making more performant
+        // needed to prevent infinite re-render on set with same data
+        if (JSON.stringify(mask) != JSON.stringify(this.data)) {
+            this.data = mask;
+        }
+    }
+    reset() {
+        this.data = {};
+    }
+}
+export class Variants {
+    constructor(variantData) {
+        this.data = [];
+        this.selections = [];
+        const { config, data } = variantData || {};
+        const { variants, mask, meta } = data || {};
+        const preferences = variantData?.data?.preferences || {};
+        // setting function in constructor to prevent exposing mask as class property
+        this.setActive = (variant) => {
+            this.active = variant;
+            const activeBadges = new Badges({
+                data: {
+                    meta: meta,
+                    result: variant,
+                },
+            });
+            mask.set({ mappings: this.active.mappings, attributes: this.active.attributes, badges: activeBadges });
+        };
+        if (config) {
+            this.config = config;
+        }
+        if (data.optionConfig) {
+            this.optionConfig = data.optionConfig;
+        }
+        this.update(variants, config, preferences);
+    }
+    update(variantData, config = this.config, preferences) {
+        try {
+            const options = [];
+            // create variants objects
+            this.data = variantData
+                .filter((variant) => this.config?.showDisabledSelectionValues || variant.mappings.core?.available !== false)
+                .map((variant) => {
+                // normalize price fields ensuring they are numbers
+                if (variant.mappings.core?.price) {
+                    variant.mappings.core.price = Number(variant.mappings.core?.price);
+                }
+                if (variant.mappings.core?.msrp) {
+                    variant.mappings.core.msrp = Number(variant.mappings.core?.msrp);
+                }
+                return variant;
+            })
+                .map((variant) => {
+                Object.keys(variant.options).forEach((variantOption) => {
+                    if (!options.includes(variantOption)) {
+                        options.push(variantOption);
+                    }
+                });
+                return new Variant({
+                    data: { variant },
+                });
+            });
+            //need to reset this.selections first
+            this.selections = [];
+            options.map((option) => {
+                const variantOptionConfig = this.config?.options && this.config.options[option];
+                this.selections.push(new VariantSelection({
+                    config: variantOptionConfig,
+                    optionConfig: this.optionConfig?.[option],
+                    data: {
+                        variants: this,
+                        selectorField: option,
+                    },
+                }));
+            });
+            const preselectedOptions = {};
+            //api preferences
+            if (preferences) {
+                Object.keys(preferences).forEach((option) => {
+                    preselectedOptions[option] = preferences[option];
+                });
+            }
+            //user defined preferences - these override API preferences
+            if (config?.options) {
+                Object.keys(config?.options).forEach((option) => {
+                    if (config.options[option].preSelected) {
+                        preselectedOptions[option] = config.options[option].preSelected;
+                    }
+                });
+            }
+            if (config?.autoSelect) {
+                // select first available
+                this.makeSelections(preselectedOptions);
+            }
+        }
+        catch (err) {
+            // failed to parse the variant JSON
+            console.error(err, `Invalid variant JSON for: ${variantData}`);
+        }
+    }
+    makeSelections(options) {
+        // options = {color: 'Blue', size: 'L'};
+        if (!options || !Object.keys(options).length) {
+            // select first available for each selection
+            this.selections.forEach((selection) => {
+                const firstAvailableOption = selection.values.find((value) => value.available);
+                if (firstAvailableOption) {
+                    selection.select(firstAvailableOption.value, true);
+                }
+            });
+        }
+        else {
+            this.selections.forEach((selection, idx) => {
+                // filter by first available, then by preselected option preference
+                //make all options available for first selection.
+                const availableOptions = selection.values.filter((value) => (idx == 0 ? true : value.available));
+                const preferedOptions = options[selection.field.toLowerCase()];
+                let preferencedOption = selection.selected || availableOptions[0];
+                // if theres a preference for that field
+                if (preferedOptions) {
+                    const checkIfAvailable = (preference) => {
+                        //see if that option is in the available options
+                        const availablePreferedOptions = availableOptions.find((value) => value.value.toString().toLowerCase() == preference?.toString().toLowerCase());
+                        //use it
+                        if (availablePreferedOptions) {
+                            preferencedOption = availablePreferedOptions;
+                        }
+                    };
+                    if (Array.isArray(preferedOptions)) {
+                        //loop through each preference option
+                        preferedOptions.forEach((preference) => {
+                            checkIfAvailable(preference);
+                        });
+                    }
+                    else {
+                        checkIfAvailable(preferedOptions);
+                    }
+                }
+                if (preferencedOption) {
+                    selection.select(preferencedOption.value, true);
+                }
+            });
+        }
+    }
+    refineSelections(fromSelection) {
+        // need to ensure the update originator is at the BOTTOM of the list for refinement
+        const orderedSelections = [...this.selections];
+        orderedSelections.sort((a) => {
+            if (a.field == fromSelection.field) {
+                return 1;
+            }
+            return -1;
+        });
+        // refine selections ensuring that the selection that triggered the update refines LAST
+        orderedSelections.forEach((selection) => selection.refineValues(this));
+        // check to see if we have enough selections made to update the display
+        const selectedSelections = this.selections.filter((selection) => selection.selected?.value?.length);
+        if (selectedSelections.length) {
+            let availableVariants = this.data;
+            // loop through selectedSelections and only include available products that match current selections
+            for (const selectedSelection of selectedSelections) {
+                availableVariants = availableVariants.filter((variant) => selectedSelection.selected?.value == variant.options[selectedSelection.field]?.value && variant.available);
+            }
+            // set active variant
+            if (availableVariants.length == 1) {
+                const variantToSet = availableVariants[0];
+                //need to update all unselected selections to match the single result
+                const unselectedSelections = this.selections.filter((selection) => !selection.selected);
+                unselectedSelections.forEach((selection) => {
+                    const field = selection.field;
+                    const valueToSet = variantToSet.options[field].value;
+                    selection.select(valueToSet);
+                });
+                this.setActive(variantToSet);
+            }
+        }
+    }
+}
+export class VariantSelection {
+    constructor(variantSelectionData) {
+        this.selected = undefined;
+        this.previouslySelected = undefined;
+        this.values = [];
+        const { data, config, optionConfig } = variantSelectionData || {};
+        const { variants, selectorField } = data || {};
+        this.field = selectorField;
+        this.type = optionConfig?.type;
+        this.count = optionConfig?.count;
+        this.label = config?.label || selectorField;
+        this.config = config || {};
+        // needed to prevent attaching variants as class property
+        this.variantsUpdate = () => variants.refineSelections(this);
+        // create possible values from the data and refine them
+        this.refineValues(variants);
+        makeObservable(this, {
+            selected: observable,
+            values: observable,
+        });
+    }
+    refineValues(variants) {
+        // current selection should only consider OTHER selections for availability
+        const selectedSelections = variants.selections.filter((selection) => selection.field != this.field && selection.selected);
+        let availableVariants = variants.data.filter((variant) => variant.available);
+        // loop through selectedSelections and remove products that do not match
+        for (const selectedSelection of selectedSelections) {
+            availableVariants = availableVariants.filter((variant) => selectedSelection.selected?.value == variant.options?.[selectedSelection.field]?.value && variant.available);
+        }
+        const newValues = variants.data
+            .filter((variant) => variant.options[this.field])
+            .reduce((values, variant) => {
+            if (!values.some((val) => variant.options[this.field].value == val.value)) {
+                const value = variant.options[this.field].value;
+                const thumbnailImageUrl = variant.mappings.core?.thumbnailImageUrl;
+                // A value should only be disabled if there are NO available variants in the entire dataset that have this value for the current field
+                const allAvailableVariants = variants.data.filter((variant) => variant.available);
+                const disabledValue = !allAvailableVariants.some((availableVariant) => {
+                    return availableVariant.options[this.field].value === value;
+                });
+                const mappedValue = {
+                    value: value,
+                    label: value,
+                    thumbnailImageUrl: thumbnailImageUrl,
+                    available: Boolean(availableVariants.some((availableVariant) => availableVariant.options[this.field].value == variant.options[this.field].value)),
+                    disabled: disabledValue,
+                };
+                if (this.config.thumbnailBackgroundImages) {
+                    mappedValue.backgroundImageUrl = thumbnailImageUrl;
+                }
+                else if (variant.options[this.field].backgroundImageUrl) {
+                    mappedValue.backgroundImageUrl = variant.options[this.field].backgroundImageUrl;
+                }
+                if (variant.options[this.field].background) {
+                    mappedValue.background = variant.options[this.field].background;
+                }
+                if (this.config.mappings && this.config.mappings && this.config.mappings[value.toString().toLowerCase()]) {
+                    const mapping = this.config.mappings[value.toString().toLowerCase()];
+                    if (mapping.label) {
+                        mappedValue.label = mapping.label;
+                    }
+                    if (mapping.background) {
+                        mappedValue.background = mapping.background;
+                    }
+                    if (mapping.backgroundImageUrl) {
+                        mappedValue.backgroundImageUrl = mapping.backgroundImageUrl;
+                    }
+                }
+                values.push(mappedValue);
+            }
+            // TODO: use sorting function from config
+            return values;
+        }, []);
+        // if selection has been made
+        if (this.selected) {
+            // check if the selection is stil available
+            if (!newValues.some((val) => val.value == this.selected?.value && val.available)) {
+                // the selection is no longer available, attempt to select previous selection
+                if (this.selected !== this.previouslySelected &&
+                    this.previouslySelected &&
+                    newValues.some((val) => val.value == this.previouslySelected?.value && val.available)) {
+                    this.select(this.previouslySelected.value, true);
+                }
+                else {
+                    // choose the first available option if previous seletions are unavailable
+                    const availableValues = newValues.filter((val) => val.available);
+                    if (newValues.length && availableValues.length) {
+                        const nextAvailableValue = availableValues[0].value;
+                        if (this.selected.value !== nextAvailableValue) {
+                            this.select(nextAvailableValue, true);
+                        }
+                    }
+                }
+            }
+        }
+        this.values = newValues;
+    }
+    reset() {
+        this.selected = undefined;
+        this.values.forEach((val) => (val.available = false));
+    }
+    select(value, internalSelection = false) {
+        const valueExist = this.values.find((val) => val.value == value);
+        if (valueExist) {
+            if (!internalSelection) {
+                this.previouslySelected = this.selected;
+            }
+            this.selected = valueExist;
+            this.variantsUpdate();
+        }
+    }
+}
+export class Variant {
+    constructor(variantData) {
+        this.type = 'variant';
+        this.attributes = {};
+        this.mappings = {
+            core: {},
+        };
+        this.custom = {};
+        const { data } = variantData || {};
+        const { variant } = data || {};
+        this.attributes = variant.attributes || {};
+        this.mappings = variant.mappings;
+        this.options = variant.options;
+        // construct badges from data (need meta)
+        this.badges = variant.badges || [];
+        this.available = this.mappings.core?.available ?? true;
+        makeObservable(this, {
+            attributes: observable,
+            mappings: observable,
+            custom: observable,
+            available: observable,
+        });
+    }
+}
+function addBannersToResults(config, results, allBanners, paginationData) {
+    const bannersAndResults = [...results];
+    let paginationBegin = paginationData.pageSize * (paginationData.page - 1) + 1;
+    let paginationEnd = paginationData.pageSize * paginationData.page;
+    // if infinite scroll is enabled, we need to adjust the begin position
+    if (config?.settings?.infinite?.enabled)
+        paginationBegin = 1;
+    // if the end of the page is greater than the total results, adjust the end
+    if (paginationData.pageSize * paginationData.page > paginationData.totalResults)
+        paginationEnd = paginationData.totalResults;
+    // banners that have not allready been injected
+    const bannersNotInResults = allBanners.filter((banner) => !bannersAndResults.some((result) => result.id == banner.id));
+    // banners that have an index position within the current set of results
+    const bannersToInject = bannersNotInResults.filter((banner) => {
+        // find banners that are within the current pagination set
+        const index = banner.config.position.index;
+        return index >= paginationBegin - 1 && index <= paginationEnd - 1;
+    });
+    // banners can have an index greater than the total results, these should be injected at the end
+    const bannersToInjectAtEnd = bannersNotInResults.filter((banner) => {
+        const index = banner.config.position.index;
+        return index >= paginationData.totalResults;
+    });
+    // inject banners that have index position within current set into the results
+    bannersToInject.forEach((banner) => {
+        const adjustedIndex = banner.config.position.index - (paginationBegin - 1);
+        bannersAndResults.splice(adjustedIndex, 0, banner);
+    });
+    // inject banners at the end that fall within the current pagination set (but ensure there is room based on the begin and end indexes)
+    bannersToInjectAtEnd.forEach((banner, index) => {
+        const resultIndex = paginationData.totalResults - (bannersToInjectAtEnd.length - index);
+        if (resultIndex >= paginationBegin - 1 && resultIndex <= paginationEnd - 1) {
+            bannersAndResults.splice(resultIndex, 0, banner);
+        }
+    });
+    // when using infinite, need to adjust the inline banner responseIds
+    if (config?.settings?.infinite) {
+        bannersAndResults.forEach((item, index) => {
+            if (item.type === 'banner') {
+                // need to determine what the correctResponseId is based on the index position, pageSize (current page) and adjacent product responseIds
+                const pageSize = paginationData.pageSize;
+                const currentPage = Math.floor(index / pageSize) + 1;
+                const firstItemIndexOnPage = (currentPage - 1) * pageSize;
+                const lastItemIndexOnPage = firstItemIndexOnPage + pageSize - 1;
+                // find the first product on the current page to grab its responseId
+                for (let i = firstItemIndexOnPage; i < lastItemIndexOnPage; i++) {
+                    if (bannersAndResults[i].type === 'product') {
+                        item.responseId = bannersAndResults[i].responseId;
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    return bannersAndResults;
+}
+function variantOptionClick(elem, variantConfig, results) {
+    const options = {};
+    const attr = elem.getAttribute(VARIANT_ATTRIBUTE);
+    if (attr) {
+        const [option, value] = attr.split(':');
+        if (!option || !value) {
+            console.error('Error!: realtime variant is missing option or value (option:value)!', elem, attr);
+        }
+        else {
+            options[option.toLowerCase()] = [value.toLowerCase()];
+            makeVariantSelections(variantConfig, options, results);
+        }
+    }
+}
+function makeVariantSelections(variantConfig, options, results) {
+    let filteredResults = results;
+    // filter based on config
+    variantConfig.realtime?.filters?.forEach((filter) => {
+        if (filter == 'first') {
+            filteredResults = [filteredResults[0]];
+        }
+        if (filter == 'unaltered') {
+            filteredResults = filteredResults.filter((result) => !result.variants?.selections.some((selection) => selection.previouslySelected));
+        }
+    });
+    filteredResults.forEach((result) => {
+        // no banner types
+        if (result.type == 'product') {
+            result.variants?.makeSelections(options);
+        }
+    });
+}

package/dist/esm/Search/Stores/SearchSortingStore.d.ts

@@ -0,0 +1,32 @@
+import type { UrlManager } from '@athoscommerce/snap-url-manager';
+import type { StoreServices } from '../../types';
+import type { MetaResponseModel, MetaResponseModelSortOption, SearchResponseModel } from '@athoscommerce/snapi-types';
+type MetaResponseModelSortOptionMutated = MetaResponseModelSortOption & {
+    active?: boolean;
+    default?: boolean;
+};
+type SearchSortingStoreConfig = {
+    services: StoreServices;
+    data: {
+        search?: SearchResponseModel;
+        meta: MetaResponseModel;
+    };
+};
+export declare class SearchSortingStore {
+    options: Option[];
+    constructor(params: SearchSortingStoreConfig);
+    get current(): Option | undefined;
+}
+declare class Option {
+    active: boolean;
+    default: boolean;
+    field: string;
+    label: string;
+    direction: string;
+    type: string;
+    value: string;
+    url: UrlManager;
+    constructor(services: StoreServices, option: MetaResponseModelSortOptionMutated, index: number);
+}
+export {};
+//# sourceMappingURL=SearchSortingStore.d.ts.map

package/dist/esm/Search/Stores/SearchSortingStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchSortingStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/SearchSortingStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtH,KAAK,kCAAkC,GAAG,2BAA2B,GAAG;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC/B,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE;QACL,MAAM,CAAC,EAAE,mBAAmB,CAAC;QAC7B,IAAI,EAAE,iBAAiB,CAAC;KACxB,CAAC;CACF,CAAC;AAEF,qBAAa,kBAAkB;IACvB,OAAO,EAAE,MAAM,EAAE,CAAM;gBAElB,MAAM,EAAE,wBAAwB;IA0C5C,IAAW,OAAO,IAAI,MAAM,GAAG,SAAS,CAEvC;CACD;AAED,cAAM,MAAM;IACJ,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,UAAU,CAAC;gBAEX,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,kCAAkC,EAAE,KAAK,EAAE,MAAM;CAuB9F"}