@searchspring/snap-store-mobx 0.20.0

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

@@ -0,0 +1,264 @@
+import { makeObservable, observable, action, computed, reaction } from 'mobx';
+export class FacetStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(config, services, storage, facetsData = [], pagination, meta) {
+        const facets = facetsData
+            .filter((facet) => {
+            const facetMeta = meta.facets[facet.field];
+            if (config.settings?.facets?.trim) {
+                if ((facetMeta.display == 'slider' && facet.type !== 'range') || (facet.type == 'range' && facetMeta.display !== 'slider')) {
+                    return false;
+                }
+                else 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) {
+                    return facet.values[0].count != pagination.totalResults;
+                }
+            }
+            return true;
+        })
+            .map((facet) => {
+            const facetMeta = meta.facets[facet.field];
+            switch (facet.type) {
+                case 'range':
+                    return new RangeFacet(services, storage, facet, facetMeta);
+                case 'value':
+                case 'range-buckets':
+                default:
+                    return new ValueFacet(config, services, storage, facet, facetMeta);
+            }
+        });
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        super(...facets);
+    }
+}
+class Facet {
+    constructor(services, storage, facet, facetMeta) {
+        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') {
+            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);
+    }
+}
+class RangeFacet extends Facet {
+    constructor(services, storage, facet, facetMeta) {
+        super(services, storage, facet, facetMeta);
+        this.range = {
+            low: 0,
+            high: 0,
+        };
+        this.active = {
+            low: 0,
+            high: 0,
+        };
+        this.step = facet.step;
+        const storedRange = 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,
+        });
+    }
+}
+class ValueFacet extends Facet {
+    constructor(config, services, storage, facet, facetMeta) {
+        super(services, storage, facet, facetMeta);
+        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 HierarchyValue(services, this, value, filteredValues);
+                            }
+                            else {
+                                return new Value(services, this, value);
+                            }
+                        case 'range-buckets':
+                            return new RangeValue(services, this, value);
+                    }
+                })) ||
+                [];
+        if (config.settings?.facets?.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 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;
+    }
+}
+class Value {
+    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);
+        }
+    }
+}
+class HierarchyValue extends Value {
+    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 = filteredValues[0].value.split(facet.hierarchyDelimiter).length;
+            if (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}`);
+        }
+    }
+}
+class RangeValue {
+    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/FilterStore.d.ts

@@ -0,0 +1,7 @@
+import type { StoreServices } from '../../types';
+import type { SearchResponseModelFilter, MetaResponseModel } from '@searchspring/snapi-types';
+export declare class FilterStore extends Array {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(services: StoreServices, filtersData: SearchResponseModelFilter[], meta: MetaResponseModel);
+}
+//# sourceMappingURL=FilterStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FilterStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/FilterStore.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EACX,yBAAyB,EACzB,iBAAiB,EAKjB,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,WAAY,SAAQ,KAAK;IACrC,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAEW,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,yBAAyB,EAAO,EAAE,IAAI,EAAE,iBAAiB;CAuC3G"}

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

@@ -0,0 +1,68 @@
+import { makeObservable, observable } from 'mobx';
+export class FilterStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(services, filtersData = [], meta) {
+        const filters = filtersData.map((filter) => {
+            const facetMeta = meta.facets[filter.field];
+            switch (filter.type) {
+                case 'range':
+                    const rangeFilter = filter;
+                    return new RangeFilter(services, {
+                        facet: {
+                            field: rangeFilter.field,
+                            label: facetMeta?.label || rangeFilter.field,
+                        },
+                        value: {
+                            low: rangeFilter.value.low,
+                            high: rangeFilter.value.high,
+                            label: rangeFilter.label || `${rangeFilter.value.low} - ${rangeFilter.value.high}`,
+                        },
+                    });
+                case 'value':
+                default:
+                    const valueFilter = filter;
+                    return new Filter(services, {
+                        facet: {
+                            field: valueFilter.field,
+                            label: facetMeta?.label || valueFilter.field,
+                        },
+                        value: {
+                            value: valueFilter.value,
+                            label: valueFilter.label,
+                        },
+                    });
+            }
+        });
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        super(...filters);
+    }
+}
+class Filter {
+    constructor(services, filter) {
+        this.facet = filter.facet;
+        this.value = filter.value;
+        this.label = `${filter.facet.label}: ${filter.value.label}`;
+        this.url = services?.urlManager?.remove('page').remove(`filter.${this.facet.field}`, this.value.value);
+        makeObservable(this, {
+            facet: observable,
+            value: observable,
+            label: observable,
+        });
+    }
+}
+class RangeFilter {
+    constructor(services, filter) {
+        this.facet = filter.facet;
+        this.value = filter.value;
+        this.label = `${filter.facet.label}: ${filter.value.label}`;
+        this.url = services?.urlManager?.remove('page').remove(`filter.${filter.facet.field}`, { low: filter.value.low, high: filter.value.high });
+        makeObservable(this, {
+            facet: observable,
+            value: observable,
+            label: observable,
+        });
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { StoreServices } from '../../types';
+import type { SearchResponseModelMerchandising } from '@searchspring/snapi-types';
+declare enum ContentType {
+    HEADER = "header",
+    BANNER = "banner",
+    FOOTER = "footer",
+    LEFT = "left",
+    INLINE = "inline"
+}
+export declare class MerchandisingStore {
+    redirect: string;
+    content: Partial<Record<ContentType, Content[]>>;
+    constructor(services: StoreServices, merchData: SearchResponseModelMerchandising);
+}
+declare class Content extends Array {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(content: any);
+}
+export {};
+//# sourceMappingURL=MerchandisingStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MerchandisingStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/MerchandisingStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,2BAA2B,CAAC;AAElF,aAAK,WAAW;IACf,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,MAAM,WAAW;CACjB;AACD,qBAAa,kBAAkB;IAC9B,QAAQ,SAAM;IACd,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC,CAAM;gBAE1C,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,gCAAgC;CAahF;AAED,cAAM,OAAQ,SAAQ,KAAK;IAC1B,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAEW,OAAO,KAAA;CAGnB"}

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

@@ -0,0 +1,32 @@
+var ContentType;
+(function (ContentType) {
+    ContentType["HEADER"] = "header";
+    ContentType["BANNER"] = "banner";
+    ContentType["FOOTER"] = "footer";
+    ContentType["LEFT"] = "left";
+    ContentType["INLINE"] = "inline";
+})(ContentType || (ContentType = {}));
+export class MerchandisingStore {
+    constructor(services, merchData) {
+        this.redirect = '';
+        this.content = {};
+        if (merchData) {
+            this.redirect = merchData.redirect || '';
+            if (merchData.content) {
+                Object.values(ContentType).forEach((type) => {
+                    if (merchData.content[type]) {
+                        this.content[type] = new Content(merchData.content[type]);
+                    }
+                });
+            }
+        }
+    }
+}
+class Content extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(content) {
+        super(...content);
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { SearchStoreConfig, StoreServices } from '../../types';
+import type { SearchResponseModelPagination } from '@searchspring/snapi-types';
+import type { UrlManager } from '@searchspring/snap-url-manager';
+export declare class PaginationStore {
+    private services;
+    page: number;
+    pageSize: number;
+    pageSizeOptions: {
+        label: string;
+        value: number;
+    }[];
+    defaultPageSize: number;
+    totalResults: number;
+    totalPages: number;
+    infinite: boolean;
+    controllerConfig: SearchStoreConfig;
+    constructor(config: SearchStoreConfig, services: StoreServices, paginationData?: SearchResponseModelPagination);
+    get begin(): number;
+    get end(): number;
+    get multiplePages(): boolean;
+    get current(): Page;
+    get first(): Page;
+    get last(): Page;
+    get next(): Page;
+    get previous(): Page;
+    getPages(min?: number, max?: number): Page[];
+    setPageSize(num: number): void;
+}
+export declare class Page {
+    services: StoreServices;
+    number: number;
+    active: boolean;
+    url: UrlManager;
+    key: string;
+    constructor(services: StoreServices, page: {
+        number: number;
+        active?: boolean;
+    });
+}
+//# sourceMappingURL=PaginationStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PaginationStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/PaginationStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAEjE,qBAAa,eAAe;IAC3B,OAAO,CAAC,QAAQ,CAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;KACd,EAAE,CAAC;IACJ,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,EAAE,iBAAiB,CAAC;gBAGnC,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,aAAa,EACvB,cAAc,GAAE,6BAMf;IA4CF,IAAI,KAAK,IAAI,MAAM,CAKlB;IAED,IAAI,GAAG,IAAI,MAAM,CAMhB;IAED,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED,IAAI,OAAO,IAAI,IAAI,CAKlB;IAED,IAAI,KAAK,IAAI,IAAI,CAKhB;IAED,IAAI,IAAI,IAAI,IAAI,CAKf;IAED,IAAI,IAAI,IAAI,IAAI,CAMf;IAED,IAAI,QAAQ,IAAI,IAAI,CAMnB;IAED,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE;IAmD5C,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAK9B;AAED,qBAAa,IAAI;IAChB,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,EAAE,UAAU,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;gBAGX,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE;QACL,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,OAAO,CAAC;KACjB;CAQF"}

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

@@ -0,0 +1,148 @@
+import { observable, action, computed, makeObservable } from 'mobx';
+export class PaginationStore {
+    constructor(config, services, paginationData = {
+        page: undefined,
+        pageSize: undefined,
+        totalResults: undefined,
+        defaultPageSize: 24,
+        totalPages: undefined,
+    }) {
+        this.services = services;
+        this.controllerConfig = config;
+        this.page = paginationData.page;
+        this.pageSize = paginationData.pageSize;
+        this.totalResults = paginationData.totalResults;
+        this.defaultPageSize = paginationData.defaultPageSize;
+        this.totalPages = paginationData.totalPages;
+        this.pageSizeOptions = [
+            {
+                label: `Show ${this.defaultPageSize}`,
+                value: this.defaultPageSize,
+            },
+            {
+                label: `Show ${this.defaultPageSize * 2}`,
+                value: this.defaultPageSize * 2,
+            },
+            {
+                label: `Show ${this.defaultPageSize * 3}`,
+                value: this.defaultPageSize * 3,
+            },
+        ];
+        makeObservable(this, {
+            page: observable,
+            pageSize: observable,
+            totalResults: observable,
+            totalPages: observable,
+            begin: computed,
+            end: computed,
+            multiplePages: computed,
+            current: computed,
+            first: computed,
+            last: computed,
+            next: computed,
+            previous: computed,
+            getPages: action,
+            setPageSize: action,
+        });
+    }
+    get begin() {
+        if (this.controllerConfig.settings?.infinite) {
+            return 1;
+        }
+        return this.pageSize * (this.page - 1) + 1;
+    }
+    get end() {
+        if (this.pageSize * this.page > this.totalResults) {
+            return this.totalResults;
+        }
+        return this.pageSize * this.page;
+    }
+    get multiplePages() {
+        return this.pageSize < this.totalResults;
+    }
+    get current() {
+        return new Page(this.services, {
+            number: this.page,
+            active: true,
+        });
+    }
+    get first() {
+        return new Page(this.services, {
+            number: 1,
+            active: this.page == 1,
+        });
+    }
+    get last() {
+        return new Page(this.services, {
+            number: this.totalPages,
+            active: this.totalPages == this.page,
+        });
+    }
+    get next() {
+        if (this.page < this.totalPages) {
+            return new Page(this.services, {
+                number: this.page + 1,
+            });
+        }
+    }
+    get previous() {
+        if (this.page > 1) {
+            return new Page(this.services, {
+                number: this.page - 1,
+            });
+        }
+    }
+    getPages(min, max) {
+        if (!Number.isInteger(min)) {
+            return [];
+        }
+        if (!Number.isInteger(max)) {
+            const surrounding = min - 1;
+            let from = this.page;
+            let to = this.page;
+            let last = to - from;
+            do {
+                last = to - from;
+                if (to < this.totalPages) {
+                    to++;
+                }
+                if (to - from >= surrounding) {
+                    break;
+                }
+                if (from > 1) {
+                    from--;
+                }
+            } while (last != to - from && to - from < surrounding);
+            min = from - this.page;
+            max = to - this.page;
+        }
+        else {
+            min = -Math.abs(min);
+            max = Math.abs(max);
+        }
+        const pages = [];
+        for (let i = this.page + min; i <= this.page + max; i++) {
+            if (i > 0 && i <= this.totalPages) {
+                pages.push(new Page(this.services, {
+                    number: i,
+                    active: i == this.page,
+                }));
+            }
+        }
+        return pages;
+    }
+    setPageSize(num) {
+        if (num) {
+            this.services.urlManager.remove('page').set('pageSize', num).go();
+        }
+    }
+}
+export class Page {
+    constructor(services, page) {
+        this.services = services;
+        this.number = page.number;
+        this.active = page.active || false;
+        this.url = this.services?.urlManager?.set('page', this.number);
+        this.key = this.url.href;
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { UrlManager } from '@searchspring/snap-url-manager';
+import type { StoreServices } from '../../types';
+import type { SearchResponseModelSearch } from '@searchspring/snapi-types';
+export declare class QueryStore {
+    query: Query;
+    didYouMean: Query;
+    originalQuery: Query;
+    constructor(services: StoreServices, search: SearchResponseModelSearch);
+}
+declare class Query {
+    string: string;
+    url: UrlManager;
+    constructor(services: StoreServices, query: string);
+}
+export {};
+//# sourceMappingURL=QueryStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QueryStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/QueryStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAE3E,qBAAa,UAAU;IACtB,KAAK,EAAE,KAAK,CAAC;IACb,UAAU,EAAE,KAAK,CAAC;IAClB,aAAa,EAAE,KAAK,CAAC;gBAET,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,yBAAyB;CAoBtE;AAQD,cAAM,KAAK;IACV,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,UAAU,CAAC;gBAEJ,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM;CASlD"}

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

@@ -0,0 +1,28 @@
+import { observable, makeObservable } from 'mobx';
+export class QueryStore {
+    constructor(services, search) {
+        const observables = {};
+        if (search?.query) {
+            this.query = new Query(services, search.query);
+            observables.query = observable;
+        }
+        if (search?.didYouMean) {
+            this.didYouMean = new Query(services, search.didYouMean);
+            observables.didYouMean = observable;
+        }
+        if (search?.originalQuery) {
+            this.originalQuery = new Query(services, search.originalQuery);
+            observables.originalQuery = observable;
+        }
+        makeObservable(this, observables);
+    }
+}
+class Query {
+    constructor(services, query) {
+        this.string = query;
+        this.url = services.urlManager.remove('page').remove('filter').set('query', this.string);
+        makeObservable(this, {
+            string: observable,
+        });
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { SearchStoreConfig, AutocompleteStoreConfig, StoreServices } from '../../types';
+import type { SearchResponseModelResult, SearchResponseModelPagination, SearchResponseModelMerchandising } from '@searchspring/snapi-types';
+export declare class ResultStore extends Array {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(config: SearchStoreConfig | AutocompleteStoreConfig, services: StoreServices, resultData: SearchResponseModelResult[], paginationData?: SearchResponseModelPagination, merchData?: SearchResponseModelMerchandising);
+}
+//# sourceMappingURL=ResultStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ResultStore.d.ts","sourceRoot":"","sources":["../../../../src/Search/Stores/ResultStore.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC7F,OAAO,KAAK,EACX,yBAAyB,EACzB,6BAA6B,EAC7B,gCAAgC,EAIhC,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,WAAY,SAAQ,KAAK;IACrC,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAGA,MAAM,EAAE,iBAAiB,GAAG,uBAAuB,EACnD,QAAQ,EAAE,aAAa,EACvB,UAAU,EAAE,yBAAyB,EAAE,EACvC,cAAc,CAAC,EAAE,6BAA6B,EAC9C,SAAS,CAAC,EAAE,gCAAgC;CAuB7C"}