@athoscommerce/snap-store-mobx 1.0.0

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

@@ -0,0 +1,292 @@
+import deepmerge from 'deepmerge';
+import { makeObservable, observable, action, computed, reaction } from 'mobx';
+export class SearchFacetStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(params) {
+        const config = params?.config || {};
+        const { services, stores, data } = params || {};
+        const { search, meta } = data || {};
+        const { facets, merchandising, pagination } = search || {};
+        const { storage } = stores || {};
+        const facetsArr = facets
+            ?.filter((facet) => {
+            const facetMeta = facet.field && meta.facets && meta.facets[facet.field];
+            // exclude facets that have no meta data
+            if (!facetMeta)
+                return false;
+            // exclude facets that have mismatched meta data
+            if ((facetMeta.display == 'slider' && facet.type !== 'range') || (facet.type == 'range' && facetMeta.display !== 'slider')) {
+                return false;
+            }
+            // trim facets - remove facets that have no use
+            const facetConfig = config.settings?.facets?.fields && facet.field && config.settings?.facets?.fields[facet.field];
+            const shouldTrim = typeof facetConfig?.trim == 'boolean' ? facetConfig?.trim : config.settings?.facets?.trim;
+            if (shouldTrim) {
+                if (facet.type === 'range' &&
+                    facet?.range?.low == facet?.range?.high) {
+                    return false;
+                }
+                else if (facet.values?.length == 0) {
+                    return false;
+                }
+                else if (!facet.filtered && facet.values?.length == 1) {
+                    if (merchandising?.content?.inline) {
+                        return facet.values[0].count + merchandising.content?.inline.length != pagination.totalResults;
+                    }
+                    else {
+                        return facet.values[0].count != pagination.totalResults;
+                    }
+                }
+            }
+            return true;
+        })
+            .map((facet) => {
+            const facetMeta = facet.field && meta.facets && meta.facets[facet.field];
+            const facetConfig = deepmerge({ ...config.settings?.facets, fields: undefined }, (config.settings?.facets?.fields && facet.field && config.settings?.facets?.fields[facet.field]) || {});
+            delete facetConfig.fields;
+            switch (facet.type) {
+                case 'range':
+                    return new RangeFacet(services, storage, facet, facetMeta || {}, facetConfig);
+                case 'value':
+                case 'range-buckets':
+                default:
+                    return new ValueFacet(services, storage, facet, facetMeta || {}, facetConfig);
+            }
+        }) || [];
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        super(...facetsArr);
+    }
+}
+export class Facet {
+    constructor(services, storage, facet, facetMeta, config) {
+        this.filtered = false;
+        this.custom = {};
+        this.collapsed = false;
+        this.display = '';
+        this.label = '';
+        this.services = services;
+        this.storage = storage;
+        Object.assign(this, facetMeta, facet);
+        makeObservable(this, {
+            type: observable,
+            field: observable,
+            filtered: observable,
+            custom: observable,
+            collapsed: observable,
+            display: observable,
+            label: observable,
+            clear: computed,
+            toggleCollapse: action,
+        });
+        const collapseData = this.storage.get(`facets.${this.field}.collapsed`);
+        this.collapsed = collapseData ?? this.collapsed;
+        if (this.filtered && this.collapsed && typeof collapseData == 'undefined' && config.autoOpenActive) {
+            this.toggleCollapse();
+        }
+    }
+    get clear() {
+        return {
+            url: this.services.urlManager.remove('page').remove(`filter.${this.field}`),
+        };
+    }
+    toggleCollapse() {
+        this.collapsed = !this.collapsed;
+        this.storage.set(`facets.${this.field}.collapsed`, this.collapsed);
+    }
+}
+export class RangeFacet extends Facet {
+    constructor(services, storage, facet, facetMeta, config) {
+        super(services, storage, facet, facetMeta, config);
+        this.range = {
+            low: 0,
+            high: 0,
+        };
+        this.active = {
+            low: 0,
+            high: 0,
+        };
+        this.step = facet?.step;
+        const storedRange = config.storeRange && this.storage.get(`facets.${this.field}.range`);
+        if (storedRange && facet.filtered && (facet.range?.low > storedRange.low || facet.range?.high < storedRange.high)) {
+            // range from API has shrunk
+            this.range = this.storage.get(`facets.${this.field}.range`);
+        }
+        else {
+            this.storage.set(`facets.${this.field}.range`, facet.range);
+            this.range = facet.range;
+        }
+        // TODO: Fix api
+        // needed when API returns no active (only seems to be when range.low == range.high)
+        this.active = facet.active || facet.range;
+        this.formatSeparator = facetMeta?.formatSeparator || '-';
+        this.formatValue = facetMeta?.formatValue || '%01.2f';
+        makeObservable(this, {
+            step: observable,
+            range: observable,
+            active: observable,
+            formatSeparator: observable,
+            formatValue: observable,
+        });
+    }
+    get filteredCount() {
+        return Number(this.filtered);
+    }
+}
+export class ValueFacet extends Facet {
+    constructor(services, storage, facet, facetMeta, config) {
+        super(services, storage, facet, facetMeta, config);
+        this.values = [];
+        this.search = {
+            input: '',
+        };
+        this.overflow = {
+            enabled: false,
+            limited: true,
+            limit: 0,
+            remaining: undefined,
+            setLimit: function (limit) {
+                if (limit != this.limit) {
+                    this.enabled = true;
+                    this.limit = limit;
+                    this.calculate();
+                }
+            },
+            toggle: (val) => {
+                if (typeof val != 'undefined') {
+                    this.overflow.limited = val;
+                }
+                else {
+                    this.overflow.limited = !this.overflow.limited;
+                }
+                this.storage.set(`facets.${this.field}.overflow.limited`, this.overflow.limited);
+                this.overflow.calculate();
+            },
+            calculate: () => {
+                if (this.overflow.limit > 0) {
+                    const remaining = this.values.length - this.overflow.limit;
+                    if (remaining > 0 && !this.search.input) {
+                        this.overflow.enabled = true;
+                        if (this.overflow.limited) {
+                            this.overflow.remaining = remaining;
+                        }
+                        else {
+                            this.overflow.remaining = 0;
+                        }
+                    }
+                    else {
+                        this.overflow.enabled = false;
+                    }
+                }
+            },
+        };
+        this.multiple = this.multiple;
+        this.values =
+            (facet.values &&
+                facet.values.map((value) => {
+                    switch (facet.type) {
+                        case 'value':
+                            if (facetMeta.display === 'hierarchy') {
+                                const filteredValues = facet?.values?.filter((value) => value.filtered) || [];
+                                return new FacetHierarchyValue(services, this, value, filteredValues);
+                            }
+                            else {
+                                // converting values to strings to ensure UrlManager state matches state created from URL
+                                value.value = value?.value?.toString();
+                                return new FacetValue(services, this, value);
+                            }
+                        case 'range-buckets':
+                            return new FacetRangeValue(services, this, value);
+                    }
+                })) ||
+                [];
+        if (config.pinFiltered && facetMeta.display !== 'hierarchy') {
+            this.values.sort((a, b) => Number(b.filtered) - Number(a.filtered));
+        }
+        const overflowLimitedState = this.storage.get(`facets.${this.field}.overflow.limited`);
+        if (typeof overflowLimitedState != 'undefined') {
+            this.overflow.toggle(overflowLimitedState);
+        }
+        makeObservable(this, {
+            values: observable,
+            search: observable,
+            multiple: observable,
+            overflow: observable,
+            refinedValues: computed,
+        });
+        reaction(() => this.search.input, () => {
+            this.overflow.calculate();
+        });
+    }
+    get filteredCount() {
+        return this.values.filter((value) => value?.filtered).length;
+    }
+    get refinedValues() {
+        let values = this.values || [];
+        if (this.search.input) {
+            const search = new RegExp(escapeRegExp(this.search.input), 'i');
+            values = this.values.filter((value) => String(value?.label || '').match(search));
+        }
+        if (this.overflow.enabled && this.overflow.limited) {
+            values = values.slice(0, this.overflow.limit);
+        }
+        return values;
+    }
+}
+export class FacetValue {
+    constructor(services, facet, value) {
+        Object.assign(this, value);
+        if (this.filtered) {
+            this.url = services.urlManager.remove('page').remove(`filter.${facet.field}`, value.value);
+        }
+        else {
+            let valueUrl = services.urlManager.remove('page');
+            if (facet.multiple == 'single') {
+                valueUrl = valueUrl?.remove(`filter.${facet.field}`);
+            }
+            this.url = valueUrl?.merge(`filter.${facet.field}`, value.value);
+        }
+    }
+}
+export class FacetHierarchyValue extends FacetValue {
+    constructor(services, facet, value, filteredValues) {
+        super(services, facet, value);
+        this.level = 0;
+        this.history = false;
+        if (value.value && facet.hierarchyDelimiter) {
+            this.level = value.value.split(facet.hierarchyDelimiter).length;
+        }
+        if (facet.filtered && filteredValues?.length) {
+            const filteredLevel = facet?.hierarchyDelimiter && filteredValues[0].value?.split(facet.hierarchyDelimiter).length;
+            if (filteredLevel && this.level <= filteredLevel) {
+                this.history = true;
+            }
+        }
+        if (value.value) {
+            this.url = services.urlManager.remove('page').set(`filter.${facet.field}`, value.value);
+        }
+        else {
+            this.url = services.urlManager.remove('page').remove(`filter.${facet.field}`);
+        }
+    }
+}
+export class FacetRangeValue {
+    constructor(services, facet, value) {
+        Object.assign(this, value);
+        if (this.filtered) {
+            this.url = services.urlManager.remove('page').remove(`filter.${facet.field}`, [{ low: this.low, high: this.high }]);
+        }
+        else {
+            let valueUrl = services.urlManager.remove('page');
+            if (facet.multiple == 'single') {
+                valueUrl = valueUrl?.remove(`filter.${facet.field}`);
+            }
+            this.url = valueUrl?.merge(`filter.${facet.field}`, [{ low: this.low, high: this.high }]);
+        }
+    }
+}
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}

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

@@ -0,0 +1,44 @@
+import type { UrlManager } from '@athoscommerce/snap-url-manager';
+import type { AutocompleteStoreConfig, SearchStoreConfig, StoreServices } from '../../types';
+import type { SearchResponseModelFilterRange, SearchResponseModelFilterValue, MetaResponseModelFacetDefaults, MetaResponseModelFacet, SearchResponseModel, MetaResponseModel } from '@athoscommerce/snapi-types';
+type SearchFilterStoreConfig = {
+    services: StoreServices;
+    config?: SearchStoreConfig | AutocompleteStoreConfig;
+    data: {
+        search?: SearchResponseModel;
+        meta: MetaResponseModel;
+    };
+};
+export declare class SearchFilterStore extends Array<RangeFilter | Filter> {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(params: SearchFilterStoreConfig);
+}
+export declare class Filter {
+    label: string;
+    facet: {
+        field?: string;
+        label?: string;
+    };
+    value: {
+        value?: string;
+        label?: string;
+    };
+    url: UrlManager;
+    constructor(services: StoreServices, filter: SearchResponseModelFilterValue, meta: MetaResponseModelFacet & MetaResponseModelFacetDefaults);
+}
+export declare class RangeFilter {
+    label: string;
+    facet: {
+        field?: string;
+        label?: string;
+    };
+    value: {
+        low?: number;
+        high?: number;
+        label: string;
+    };
+    url: UrlManager;
+    constructor(services: StoreServices, filter: SearchResponseModelFilterRange, meta: MetaResponseModelFacet & MetaResponseModelFacetDefaults);
+}
+export {};
+//# sourceMappingURL=SearchFilterStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SearchFilterStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/SearchFilterStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7F,OAAO,KAAK,EACX,8BAA8B,EAC9B,8BAA8B,EAC9B,8BAA8B,EAC9B,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,MAAM,4BAA4B,CAAC;AAGpC,KAAK,uBAAuB,GAAG;IAC9B,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,CAAC,EAAE,iBAAiB,GAAG,uBAAuB,CAAC;IACrD,IAAI,EAAE;QACL,MAAM,CAAC,EAAE,mBAAmB,CAAC;QAC7B,IAAI,EAAE,iBAAiB,CAAC;KACxB,CAAC;CACF,CAAC;AAEF,qBAAa,iBAAkB,SAAQ,KAAK,CAAC,WAAW,GAAG,MAAM,CAAC;IACjE,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAEW,MAAM,EAAE,uBAAuB;CA8B3C;AAED,qBAAa,MAAM;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACK,KAAK,EAAE;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IAEK,GAAG,EAAE,UAAU,CAAC;gBAEX,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,8BAA8B,EAAE,IAAI,EAAE,sBAAsB,GAAG,8BAA8B;CAmB1I;AAED,qBAAa,WAAW;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACK,KAAK,EAAE;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACd,CAAC;IAEK,GAAG,EAAE,UAAU,CAAC;gBAEX,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,8BAA8B,EAAE,IAAI,EAAE,sBAAsB,GAAG,8BAA8B;CAoB1I"}

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

@@ -0,0 +1,70 @@
+import { makeObservable, observable } from 'mobx';
+import { sprintf } from '@athoscommerce/snap-toolbox';
+export class SearchFilterStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(params) {
+        const { services, data, config } = params || {};
+        const { search, meta } = data || {};
+        const { filters } = search || {};
+        const filtersArr = filters?.map((filter) => {
+            const field = filter.field;
+            const facetMeta = meta.facets && meta.facets[field];
+            switch (filter.type) {
+                case 'range':
+                    const rangeFilter = filter;
+                    const format = config?.settings?.filters?.fields?.[filter.field]?.rangeFormatValue ||
+                        config?.settings?.filters?.rangeFormatValue;
+                    if (format) {
+                        rangeFilter.label = sprintf(format, rangeFilter.value?.low, rangeFilter.value?.high);
+                    }
+                    return new RangeFilter(services, rangeFilter, facetMeta);
+                case 'value':
+                default:
+                    const valueFilter = filter;
+                    return new Filter(services, valueFilter, facetMeta);
+            }
+        }) || [];
+        super(...filtersArr);
+    }
+}
+export class Filter {
+    constructor(services, filter, meta) {
+        this.facet = {
+            field: filter.field,
+            label: meta?.label || filter.field,
+        };
+        this.value = {
+            value: filter.value,
+            label: filter.label,
+        };
+        this.label = `${this.facet.label}: ${this.value.label}`;
+        this.url = services?.urlManager?.remove('page').remove(`filter.${this.facet.field}`, this.value.value);
+        makeObservable(this, {
+            facet: observable,
+            value: observable,
+            label: observable,
+        });
+    }
+}
+export class RangeFilter {
+    constructor(services, filter, meta) {
+        this.facet = {
+            field: filter.field,
+            label: meta?.label || filter.field,
+        };
+        this.value = {
+            low: filter?.value?.low,
+            high: filter?.value?.high,
+            label: filter.label || `${filter?.value?.low} - ${filter?.value?.high}`,
+        };
+        this.label = `${this.facet.label}: ${this.value.label}`;
+        this.url = services?.urlManager?.remove('page').remove(`filter.${this.facet.field}`, { low: this.value.low, high: this.value.high });
+        makeObservable(this, {
+            facet: observable,
+            value: observable,
+            label: observable,
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { AutocompleteStoreConfig, SearchStoreConfig, StoreServices } from '../../types';
+import { Query } from './SearchQueryStore';
+type SearchHistoryStoreConfig = {
+    services: StoreServices;
+    config: Partial<AutocompleteStoreConfig | SearchStoreConfig>;
+};
+export declare class SearchHistoryStore {
+    private config;
+    private storage;
+    private services;
+    private max;
+    constructor(params: SearchHistoryStoreConfig);
+    get queries(): Query[];
+    save(term: string): void;
+    remove(term: string): void;
+    reset(): void;
+    getStoredData(limit?: number): string[];
+}
+export {};
+//# sourceMappingURL=SearchHistoryStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SearchHistoryStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/SearchHistoryStore.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7F,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,KAAK,wBAAwB,GAAG;IAC/B,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,OAAO,CAAC,uBAAuB,GAAG,iBAAiB,CAAC,CAAC;CAC7D,CAAC;AAEF,qBAAa,kBAAkB;IAC9B,OAAO,CAAC,MAAM,CAAuD;IACrE,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,QAAQ,CAAgB;IAChC,OAAO,CAAC,GAAG,CAAS;gBAER,MAAM,EAAE,wBAAwB;IAoC5C,IAAI,OAAO,IAAI,KAAK,EAAE,CAGrB;IAEM,IAAI,CAAC,IAAI,EAAE,MAAM;IAoBjB,MAAM,CAAC,IAAI,EAAE,MAAM;IAWnB,KAAK,IAAI,IAAI;IAIb,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;CAmB9C"}

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

@@ -0,0 +1,85 @@
+import { StorageStore } from '../../Storage/StorageStore';
+import { Query } from './SearchQueryStore';
+export class SearchHistoryStore {
+    constructor(params) {
+        const { services, config } = params || {};
+        this.config = config;
+        this.services = services;
+        this.max = this.config.settings?.history?.max ?? 25;
+        if (this.config.settings?.history?.url) {
+            this.services.urlManager = this.services.urlManager.withConfig((translatorConfig) => {
+                return {
+                    ...translatorConfig,
+                    urlRoot: this.config.settings?.history?.url,
+                };
+            });
+        }
+        this.storage = new StorageStore({
+            type: 'local',
+            key: `athos-history${this.config.globals?.siteId ? `-${this.config.globals?.siteId}` : ``}`,
+        });
+        // reset to zero to clear any potentially existing terms
+        if (this.max === 0) {
+            this.reset();
+        }
+        // trim history if the current queries are more than config max
+        if (this.queries.length > this.max) {
+            this.getStoredData().forEach((term, index) => {
+                if (index > this.max - 1) {
+                    this.remove(term);
+                }
+            });
+        }
+    }
+    get queries() {
+        const queries = this.getStoredData();
+        return queries.map((query) => new Query(this.services, query));
+    }
+    save(term) {
+        // adding term to array if max is not zero
+        if (this.max) {
+            const history = this.getStoredData();
+            // removing term if already present
+            const index = history.indexOf(term);
+            if (index != -1) {
+                history.splice(index, 1);
+            }
+            history.unshift(term);
+            if (history.length > this.max) {
+                history.pop();
+            }
+            this.storage.set('history', JSON.stringify(history));
+        }
+    }
+    remove(term) {
+        const history = this.getStoredData();
+        // removing term if already present
+        const index = history.indexOf(term);
+        if (index != -1) {
+            history.splice(index, 1);
+            this.storage.set('history', JSON.stringify(history));
+        }
+    }
+    reset() {
+        this.storage.clear();
+    }
+    getStoredData(limit) {
+        const storedHistory = this.storage.get('history');
+        if (storedHistory) {
+            try {
+                const history = JSON.parse(storedHistory);
+                if (Array.isArray(history)) {
+                    if (limit && Number.isInteger(limit)) {
+                        return history.slice(0, limit);
+                    }
+                    return history;
+                }
+            }
+            catch (err) {
+                // storage corrupted - resetting it
+                this.reset();
+            }
+        }
+        return [];
+    }
+}

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

@@ -0,0 +1,36 @@
+import type { SearchResponseModelMerchandisingCampaigns, SearchResponseModel, SearchResponseModelMerchandisingExperiments, SearchResponseModelTracking } from '@athoscommerce/snapi-types';
+export declare enum ContentType {
+    HEADER = "header",
+    BANNER = "banner",
+    FOOTER = "footer",
+    LEFT = "left",
+    INLINE = "inline"
+}
+export type BannerContent = Partial<Record<ContentType, Content>>;
+type SearchMerchandisingStoreConfig = {
+    data: {
+        search?: SearchResponseModel;
+        tracking?: SearchResponseModelTracking;
+    };
+};
+export declare class SearchMerchandisingStore {
+    redirect: string;
+    responseId: string;
+    content: BannerContent;
+    campaigns: SearchResponseModelMerchandisingCampaigns[];
+    landingPage?: SearchResponseModelMerchandisingCampaigns;
+    personalized?: boolean;
+    experiments: SearchResponseModelMerchandisingExperiments[];
+    constructor(params: SearchMerchandisingStoreConfig);
+}
+export type MerchandisingContentBanner = {
+    value: string[];
+    uid: string;
+    responseId: string;
+};
+declare class Content extends Array<MerchandisingContentBanner> {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(content: MerchandisingContentBanner[]);
+}
+export {};
+//# sourceMappingURL=SearchMerchandisingStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SearchMerchandisingStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/SearchMerchandisingStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,yCAAyC,EACzC,mBAAmB,EACnB,2CAA2C,EAC3C,2BAA2B,EAC3B,MAAM,4BAA4B,CAAC;AAEpC,oBAAY,WAAW;IACtB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,MAAM,WAAW;CACjB;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC;AAElE,KAAK,8BAA8B,GAAG;IACrC,IAAI,EAAE;QACL,MAAM,CAAC,EAAE,mBAAmB,CAAC;QAC7B,QAAQ,CAAC,EAAE,2BAA2B,CAAC;KACvC,CAAC;CACF,CAAC;AAEF,qBAAa,wBAAwB;IAC7B,QAAQ,SAAM;IACd,UAAU,SAAM;IAChB,OAAO,EAAE,aAAa,CAAM;IAC5B,SAAS,EAAE,yCAAyC,EAAE,CAAM;IAC5D,WAAW,CAAC,EAAE,yCAAyC,CAAC;IACxD,YAAY,CAAC,EAAE,OAAO,CAAS;IAC/B,WAAW,EAAE,2CAA2C,EAAE,CAAM;gBAE3D,MAAM,EAAE,8BAA8B;CAyClD;AAED,MAAM,MAAM,0BAA0B,GAAG;IACxC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,cAAM,OAAQ,SAAQ,KAAK,CAAC,0BAA0B,CAAC;IACtD,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAEW,OAAO,EAAE,0BAA0B,EAAE;CAGjD"}

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

@@ -0,0 +1,61 @@
+export var ContentType;
+(function (ContentType) {
+    ContentType["HEADER"] = "header";
+    ContentType["BANNER"] = "banner";
+    ContentType["FOOTER"] = "footer";
+    ContentType["LEFT"] = "left";
+    ContentType["INLINE"] = "inline";
+})(ContentType || (ContentType = {}));
+export class SearchMerchandisingStore {
+    constructor(params) {
+        this.redirect = '';
+        this.responseId = '';
+        this.content = {};
+        this.campaigns = [];
+        this.personalized = false;
+        this.experiments = [];
+        const { merchandising } = params?.data?.search || {};
+        if (merchandising) {
+            this.redirect = merchandising.redirect || '';
+            this.responseId = params?.data?.search?.tracking?.responseId || params?.data?.tracking?.responseId || ''; // Autocomplete 'beforeSubmit' doesn't have a response reference
+            if (merchandising.content) {
+                Object.values(ContentType).forEach((type) => {
+                    if (merchandising.content && merchandising.content[type]) {
+                        // Extract data-banner-id from the HTML string
+                        const htmlString = merchandising.content[type]?.[0] || '';
+                        const match = typeof htmlString === 'string' && htmlString.match(/data-banner-id="(\d+)"/);
+                        const uid = match ? match[1] : '';
+                        this.content[type] = new Content([
+                            {
+                                value: merchandising.content[type],
+                                uid,
+                                responseId: this.responseId,
+                            },
+                        ]);
+                    }
+                });
+            }
+            if (merchandising.campaigns) {
+                this.campaigns = merchandising.campaigns;
+                // if we find a 'landing-page', get landingPage details from merchandising.campaigns
+                merchandising.campaigns.forEach((campaign) => {
+                    if (campaign.type == 'landing-page') {
+                        this.landingPage = campaign;
+                    }
+                });
+            }
+            if (merchandising.experiments) {
+                this.experiments = merchandising.experiments;
+            }
+            this.personalized = !!merchandising.personalized;
+        }
+    }
+}
+class Content extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(content) {
+        super(...content);
+    }
+}

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

@@ -0,0 +1,57 @@
+import type { StoreServices, SearchStoreConfig } from '../../types';
+import type { UrlManager } from '@athoscommerce/snap-url-manager';
+import { MetaResponseModel, SearchResponseModel } from '@athoscommerce/snapi-types';
+type SearchPaginationStoreConfig = {
+    config?: SearchStoreConfig;
+    services: StoreServices;
+    data: {
+        search?: SearchResponseModel;
+        meta: MetaResponseModel;
+    };
+};
+export declare class SearchPaginationStore {
+    services: StoreServices;
+    page: number;
+    pageSize: number;
+    pageSizeOption?: PageSizeOption;
+    pageSizeOptions: PageSizeOption[];
+    defaultPageSize: number;
+    totalResults: number;
+    totalPages: number;
+    controllerConfig?: SearchStoreConfig;
+    constructor(params: SearchPaginationStoreConfig);
+    get begin(): number;
+    get end(): number;
+    get multiplePages(): boolean;
+    get current(): Page;
+    get first(): Page;
+    get last(): Page;
+    get next(): Page | undefined;
+    get previous(): Page | undefined;
+    getPages(min?: number, max?: number): Page[];
+    setPageSize(num: number): void;
+}
+export declare class PageSizeOption {
+    private services;
+    value: number;
+    label: string;
+    url: UrlManager;
+    active: boolean;
+    constructor(services: StoreServices, currentPageSize: number, option: {
+        value: number;
+        label: string;
+    });
+}
+export declare class Page {
+    private services;
+    number: number;
+    active: boolean;
+    url: UrlManager;
+    key: string;
+    constructor(services: StoreServices, page: {
+        number: number;
+        active?: boolean;
+    });
+}
+export {};
+//# sourceMappingURL=SearchPaginationStore.d.ts.map