@athoscommerce/snap-store-mobx 1.0.0

package/dist/esm/Autocomplete/AutocompleteStore.d.ts

@@ -0,0 +1,40 @@
+import { UrlManager } from '@athoscommerce/snap-url-manager';
+import { AbstractStore } from '../Abstract/AbstractStore';
+import { SearchFilterStore, SearchResultStore, SearchMerchandisingStore, SearchPaginationStore, SearchSortingStore } from '../Search/Stores';
+import { StorageStore } from '../Storage/StorageStore';
+import { AutocompleteStateStore, AutocompleteTermStore, AutocompleteQueryStore, AutocompleteFacetStore, AutocompleteTrendingStore, AutocompleteHistoryStore } from './Stores';
+import type { AutocompleteResponseModel, MetaResponseModel } from '@athoscommerce/snapi-types';
+import type { TrendingResponseModel } from '@athoscommerce/snap-client';
+import type { AutocompleteStoreConfig, StoreServices } from '../types';
+import { MetaStore } from '../Meta/MetaStore';
+export declare class AutocompleteStore extends AbstractStore<AutocompleteStoreConfig> {
+    services: StoreServices;
+    meta?: MetaStore;
+    merchandising: SearchMerchandisingStore;
+    search: AutocompleteQueryStore;
+    terms: AutocompleteTermStore;
+    facets: AutocompleteFacetStore;
+    filters: SearchFilterStore;
+    results: SearchResultStore;
+    pagination: SearchPaginationStore;
+    sorting: SearchSortingStore;
+    state: AutocompleteStateStore;
+    storage: StorageStore;
+    trending: AutocompleteTrendingStore;
+    history: AutocompleteHistoryStore;
+    constructor(config: AutocompleteStoreConfig, services: StoreServices);
+    get hasQuery(): boolean;
+    reset(): void;
+    initHistory(): void;
+    resetTerms(): void;
+    resetSuggestions(): void;
+    resetTrending(): void;
+    resetHistory(): void;
+    setService(name: keyof StoreServices, service: UrlManager): void;
+    updateTrendingTerms(trending: TrendingResponseModel): void;
+    update(data?: {
+        meta?: MetaResponseModel;
+        search?: AutocompleteResponseModel;
+    }): void;
+}
+//# sourceMappingURL=AutocompleteStore.d.ts.map

package/dist/esm/Autocomplete/AutocompleteStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutocompleteStore.d.ts","sourceRoot":"","sources":["../../../src/Autocomplete/AutocompleteStore.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EACN,iBAAiB,EACjB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,kBAAkB,EAElB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EACN,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,EACxB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,KAAK,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,qBAAa,iBAAkB,SAAQ,aAAa,CAAC,uBAAuB,CAAC;IACrE,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,aAAa,EAAG,wBAAwB,CAAC;IACzC,MAAM,EAAG,sBAAsB,CAAC;IAChC,KAAK,EAAG,qBAAqB,CAAC;IAC9B,MAAM,EAAG,sBAAsB,CAAC;IAChC,OAAO,EAAG,iBAAiB,CAAC;IAC5B,OAAO,EAAG,iBAAiB,CAAC;IAC5B,UAAU,EAAG,qBAAqB,CAAC;IACnC,OAAO,EAAG,kBAAkB,CAAC;IAC7B,KAAK,EAAE,sBAAsB,CAAC;IAC9B,OAAO,EAAE,YAAY,CAAC;IACtB,QAAQ,EAAE,yBAAyB,CAAC;IACpC,OAAO,EAAE,wBAAwB,CAAC;gBAE7B,MAAM,EAAE,uBAAuB,EAAE,QAAQ,EAAE,aAAa;IAoCpE,IAAI,QAAQ,YAEX;IAEM,KAAK,IAAI,IAAI;IAMb,WAAW,IAAI,IAAI;IA8BnB,UAAU,IAAI,IAAI;IAMlB,gBAAgB,IAAI,IAAI;IAIxB,aAAa,IAAI,IAAI;IAIrB,YAAY,IAAI,IAAI;IAIpB,UAAU,CAAC,IAAI,EAAE,MAAM,aAAa,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IAUhE,mBAAmB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,IAAI;IAiB1D,MAAM,CAAC,IAAI,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,iBAAiB,CAAC;QAAC,MAAM,CAAC,EAAE,yBAAyB,CAAA;KAAE,GAAG,IAAI;CA8G5F"}

package/dist/esm/Autocomplete/AutocompleteStore.js

@@ -0,0 +1,210 @@
+import { makeObservable, observable } from 'mobx';
+import { AbstractStore } from '../Abstract/AbstractStore';
+import { SearchFilterStore, SearchResultStore, SearchMerchandisingStore, SearchPaginationStore, SearchSortingStore, SearchHistoryStore, } from '../Search/Stores';
+import { StorageStore } from '../Storage/StorageStore';
+import { AutocompleteStateStore, AutocompleteTermStore, AutocompleteQueryStore, AutocompleteFacetStore, AutocompleteTrendingStore, AutocompleteHistoryStore, } from './Stores';
+import { MetaStore } from '../Meta/MetaStore';
+export class AutocompleteStore extends AbstractStore {
+    constructor(config, services) {
+        super(config);
+        if (typeof services != 'object' || typeof services.urlManager?.subscribe != 'function') {
+            throw new Error(`Invalid service 'urlManager' passed to AutocompleteStore. Missing "subscribe" function.`);
+        }
+        this.services = services;
+        this.state = new AutocompleteStateStore({
+            services: this.services,
+        });
+        this.storage = new StorageStore();
+        this.trending = [];
+        this.history = [];
+        this.initHistory();
+        this.reset();
+        makeObservable(this, {
+            state: observable,
+            search: observable,
+            terms: observable,
+            facets: observable,
+            filters: observable,
+            merchandising: observable,
+            results: observable,
+            pagination: observable,
+            sorting: observable,
+            history: observable,
+            trending: observable,
+        });
+    }
+    get hasQuery() {
+        return Boolean((this.state.input && this.loaded) || this.search.query?.string);
+    }
+    reset() {
+        this.state.reset();
+        this.update();
+        this.resetTerms();
+    }
+    initHistory() {
+        const limit = this.config.settings?.history?.limit;
+        if (limit) {
+            const historyStore = new SearchHistoryStore({
+                services: this.services,
+                config: {
+                    id: this.config.id,
+                    globals: this.config.globals,
+                },
+            });
+            this.history = new AutocompleteHistoryStore({
+                services: this.services,
+                functions: {
+                    resetTerms: () => {
+                        this.resetTerms();
+                    },
+                },
+                state: {
+                    rootState: this.state,
+                },
+                data: {
+                    queries: historyStore.getStoredData(limit),
+                },
+            });
+        }
+        else {
+            this.history = [];
+        }
+    }
+    resetTerms() {
+        this.resetSuggestions();
+        this.resetTrending();
+        this.resetHistory();
+    }
+    resetSuggestions() {
+        this.terms?.forEach((term) => (term.active = false));
+    }
+    resetTrending() {
+        this.trending?.forEach((term) => (term.active = false));
+    }
+    resetHistory() {
+        this.history?.forEach((term) => (term.active = false));
+    }
+    setService(name, service) {
+        if (this.services[name] && service) {
+            this.services[name] = service;
+            if (name === 'urlManager') {
+                this.state.url = service;
+                this.initHistory();
+            }
+        }
+    }
+    updateTrendingTerms(trending) {
+        this.trending = new AutocompleteTrendingStore({
+            services: this.services,
+            functions: {
+                resetTerms: () => {
+                    this.resetTerms();
+                },
+            },
+            state: {
+                rootState: this.state,
+            },
+            data: {
+                trending,
+            },
+        });
+    }
+    update(data) {
+        const { meta, search } = data || {};
+        this.meta = new MetaStore({
+            data: { meta },
+        });
+        // set the query to match the actual queried term and not the input query
+        if (search?.search) {
+            this.state.url = this.services.urlManager = this.services.urlManager.set('query', search.search.query);
+        }
+        // only run if we want to update the terms (not locked)
+        if (!this.state.locks.terms.locked) {
+            this.terms = new AutocompleteTermStore({
+                config: this.config,
+                services: this.services,
+                functions: {
+                    resetTerms: () => {
+                        this.resetTerms();
+                    },
+                },
+                state: {
+                    rootState: this.state,
+                },
+                data: {
+                    autocomplete: search,
+                },
+            });
+            // only lock if there was data
+            search?.autocomplete && this.state.locks.terms.lock();
+        }
+        this.merchandising = new SearchMerchandisingStore({
+            data: {
+                search,
+            },
+        });
+        this.search = new AutocompleteQueryStore({
+            config: this.config,
+            services: this.services,
+            data: {
+                autocomplete: search,
+            },
+        });
+        // only run if we want to update the facets (not locked)
+        if (!this.state.locks.facets.locked) {
+            this.facets = new AutocompleteFacetStore({
+                config: this.config,
+                services: this.services,
+                stores: {
+                    storage: this.storage,
+                },
+                state: {
+                    autocomplete: this.state,
+                },
+                data: {
+                    search,
+                    meta: this.meta.data,
+                },
+            });
+        }
+        this.filters = new SearchFilterStore({
+            config: this.config,
+            services: this.services,
+            data: {
+                search,
+                meta: this.meta.data,
+            },
+        });
+        this.results = new SearchResultStore({
+            config: this.config,
+            state: {
+                loaded: this.loaded,
+            },
+            data: {
+                search,
+                meta: this.meta.data,
+            },
+        });
+        if ((this.results.length === 0 && !this.trending.filter((term) => term.active).length) || this.terms?.filter((term) => term.active).length) {
+            // if a trending term was selected and then a subsequent search yields no results, reset trending terms to remove active state
+            // OR if any terms are active, also reset to ensure only a single term or trending term is active
+            this.resetTrending();
+        }
+        this.pagination = new SearchPaginationStore({
+            services: this.services,
+            data: {
+                search,
+                meta: this.meta.data,
+            },
+        });
+        this.sorting = new SearchSortingStore({
+            services: this.services,
+            data: {
+                search,
+                meta: this.meta.data,
+            },
+        });
+        this.error = undefined;
+        this.loaded = Boolean(search?.pagination);
+    }
+}

package/dist/esm/Autocomplete/Stores/AutocompleteFacetStore.d.ts

@@ -0,0 +1,13 @@
+import { SearchFacetStoreConfig } from '../../Search/Stores/SearchFacetStore';
+import { AutocompleteStateStore } from './AutocompleteStateStore';
+type AutocompleteFacetStoreConfig = SearchFacetStoreConfig & {
+    state: {
+        autocomplete: AutocompleteStateStore;
+    };
+};
+export declare class AutocompleteFacetStore extends Array {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(params: AutocompleteFacetStoreConfig);
+}
+export {};
+//# sourceMappingURL=AutocompleteFacetStore.d.ts.map

package/dist/esm/Autocomplete/Stores/AutocompleteFacetStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutocompleteFacetStore.d.ts","sourceRoot":"","sources":["../../../../src/Autocomplete/Stores/AutocompleteFacetStore.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AAC9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,KAAK,4BAA4B,GAAG,sBAAsB,GAAG;IAC5D,KAAK,EAAE;QACN,YAAY,EAAE,sBAAsB,CAAC;KACrC,CAAC;CACF,CAAC;AACF,qBAAa,sBAAuB,SAAQ,KAAK;IAChD,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAEW,MAAM,EAAE,4BAA4B;CAkChD"}

package/dist/esm/Autocomplete/Stores/AutocompleteFacetStore.js

@@ -0,0 +1,35 @@
+import { SearchFacetStore } from '../../Search/Stores';
+export class AutocompleteFacetStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(params) {
+        const { services, state } = params || {};
+        // allow for only a singular facet option selection at a time
+        const facets = new SearchFacetStore({
+            ...params,
+            services: {
+                ...services,
+                urlManager: services.urlManager.remove('filter'),
+            },
+        });
+        // mutate facet values to add 'preview' function
+        facets.forEach((facet) => {
+            facet.values?.forEach((value) => {
+                value.preview = () => {
+                    facets.map((facet) => {
+                        facet.filtered = false;
+                        facet.values?.map((value) => {
+                            value.filtered = false;
+                        });
+                    });
+                    facet.filtered = true;
+                    value.filtered = true;
+                    state?.autocomplete.locks.facets.lock();
+                    value.url.go();
+                };
+            });
+        });
+        super(...facets);
+    }
+}

package/dist/esm/Autocomplete/Stores/AutocompleteHistoryStore.d.ts

@@ -0,0 +1,19 @@
+import { Term, TermData } from './AutocompleteTermStore';
+import type { AutocompleteStateStore } from './AutocompleteStateStore';
+type AutocompleteHistoryStoreConfig = Omit<TermData, 'data' | 'type'> & {
+    data: {
+        queries: string[];
+    };
+    functions: {
+        resetTerms: () => void;
+    };
+    state: {
+        rootState: AutocompleteStateStore;
+    };
+};
+export declare class AutocompleteHistoryStore extends Array<Term> {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(params: AutocompleteHistoryStoreConfig);
+}
+export {};
+//# sourceMappingURL=AutocompleteHistoryStore.d.ts.map

package/dist/esm/Autocomplete/Stores/AutocompleteHistoryStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutocompleteHistoryStore.d.ts","sourceRoot":"","sources":["../../../../src/Autocomplete/Stores/AutocompleteHistoryStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAEvE,KAAK,8BAA8B,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IACvE,IAAI,EAAE;QACL,OAAO,EAAE,MAAM,EAAE,CAAC;KAClB,CAAC;IACF,SAAS,EAAE;QACV,UAAU,EAAE,MAAM,IAAI,CAAC;KACvB,CAAC;IACF,KAAK,EAAE;QACN,SAAS,EAAE,sBAAsB,CAAC;KAClC,CAAC;CACF,CAAC;AAEF,qBAAa,wBAAyB,SAAQ,KAAK,CAAC,IAAI,CAAC;IACxD,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAEW,MAAM,EAAE,8BAA8B;CAyBlD"}

package/dist/esm/Autocomplete/Stores/AutocompleteHistoryStore.js

@@ -0,0 +1,27 @@
+import { Term } from './AutocompleteTermStore';
+export class AutocompleteHistoryStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(params) {
+        const { data } = params || {};
+        const { queries } = data || {};
+        const terms = [];
+        queries?.map((query) => {
+            terms.push(new Term({
+                ...params,
+                data: {
+                    term: {
+                        active: false,
+                        value: query,
+                    },
+                    terms,
+                },
+                functions: params.functions,
+                state: params.state,
+                type: 'historical',
+            }));
+        });
+        super(...terms);
+    }
+}

package/dist/esm/Autocomplete/Stores/AutocompleteQueryStore.d.ts

@@ -0,0 +1,25 @@
+import type { UrlManager } from '@athoscommerce/snap-url-manager';
+import type { SearchResponseModelSearchMatchTypeEnum } from '@athoscommerce/snapi-types';
+import type { AutocompleteStoreConfig, StoreServices } from '../../types';
+import { AutocompleteResponseModel } from '@athoscommerce/snapi-types';
+type AutocompleteQueryStoreConfig = {
+    config: AutocompleteStoreConfig;
+    services: StoreServices;
+    data: {
+        autocomplete?: AutocompleteResponseModel;
+    };
+};
+export declare class AutocompleteQueryStore {
+    query?: Query;
+    originalQuery?: Query;
+    correctedQuery?: Query;
+    matchType: SearchResponseModelSearchMatchTypeEnum;
+    constructor(params: AutocompleteQueryStoreConfig);
+}
+declare class Query {
+    string: string;
+    url: UrlManager;
+    constructor(urlManager: UrlManager, query: string);
+}
+export {};
+//# sourceMappingURL=AutocompleteQueryStore.d.ts.map

package/dist/esm/Autocomplete/Stores/AutocompleteQueryStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutocompleteQueryStore.d.ts","sourceRoot":"","sources":["../../../../src/Autocomplete/Stores/AutocompleteQueryStore.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,sCAAsC,EAAE,MAAM,4BAA4B,CAAC;AACzF,OAAO,KAAK,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,KAAK,4BAA4B,GAAG;IACnC,MAAM,EAAE,uBAAuB,CAAC;IAChC,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE;QACL,YAAY,CAAC,EAAE,yBAAyB,CAAC;KACzC,CAAC;CACF,CAAC;AAEF,qBAAa,sBAAsB;IAC3B,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,cAAc,CAAC,EAAE,KAAK,CAAC;IACvB,SAAS,EAAE,sCAAsC,CAAC;gBAE7C,MAAM,EAAE,4BAA4B;CAoBhD;AASD,cAAM,KAAK;IACH,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,UAAU,CAAC;gBAEX,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM;CASjD"}

package/dist/esm/Autocomplete/Stores/AutocompleteQueryStore.js

@@ -0,0 +1,28 @@
+import { observable, makeObservable } from 'mobx';
+export class AutocompleteQueryStore {
+    constructor(params) {
+        const { services, data } = params || {};
+        const { search, autocomplete } = data?.autocomplete || {};
+        const observables = {};
+        if (search?.query) {
+            this.query = new Query(services.urlManager, search.query);
+            observables.query = observable;
+        }
+        if (autocomplete?.correctedQuery) {
+            this.correctedQuery = new Query(services.urlManager, autocomplete.correctedQuery);
+            observables.correctedQuery = observable;
+        }
+        this.matchType = search?.matchType;
+        observables.matchType = observable;
+        makeObservable(this, observables);
+    }
+}
+class Query {
+    constructor(urlManager, query) {
+        this.string = query;
+        this.url = urlManager.set({ query: this.string });
+        makeObservable(this, {
+            string: observable,
+        });
+    }
+}

package/dist/esm/Autocomplete/Stores/AutocompleteStateStore.d.ts

@@ -0,0 +1,29 @@
+import type { UrlManager } from '@athoscommerce/snap-url-manager';
+import type { StoreServices } from '../../types';
+import type { AutocompleteRequestModelSearchSourceEnum } from '@athoscommerce/snapi-types';
+type AutocompleteStateStoreConfig = {
+    services: StoreServices;
+};
+export declare class AutocompleteStateStore {
+    locks: {
+        terms: Lock;
+        facets: Lock;
+    };
+    focusedInput: HTMLInputElement | undefined;
+    input: string | undefined;
+    source: AutocompleteRequestModelSearchSourceEnum;
+    url: UrlManager;
+    constructor(params: AutocompleteStateStoreConfig);
+    reset(): void;
+}
+export declare class Lock {
+    private state;
+    private startState;
+    constructor(state?: boolean);
+    reset(): void;
+    get locked(): boolean;
+    lock(): void;
+    unlock(): void;
+}
+export {};
+//# sourceMappingURL=AutocompleteStateStore.d.ts.map

package/dist/esm/Autocomplete/Stores/AutocompleteStateStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutocompleteStateStore.d.ts","sourceRoot":"","sources":["../../../../src/Autocomplete/Stores/AutocompleteStateStore.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,wCAAwC,EAAE,MAAM,4BAA4B,CAAC;AAE3F,KAAK,4BAA4B,GAAG;IACnC,QAAQ,EAAE,aAAa,CAAC;CACxB,CAAC;AAEF,qBAAa,sBAAsB;IAC3B,KAAK,EAAE;QACb,KAAK,EAAE,IAAI,CAAC;QACZ,MAAM,EAAE,IAAI,CAAC;KACb,CAAC;IAEK,YAAY,EAAE,gBAAgB,GAAG,SAAS,CAAa;IACvD,KAAK,EAAE,MAAM,GAAG,SAAS,CAAa;IACtC,MAAM,EAAE,wCAAwC,CAAuD;IACvG,GAAG,EAAE,UAAU,CAAC;gBAEX,MAAM,EAAE,4BAA4B;IAiBzC,KAAK,IAAI,IAAI;CAKpB;AAED,qBAAa,IAAI;IAChB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,UAAU,CAAU;gBAEhB,KAAK,UAAQ;IAIlB,KAAK,IAAI,IAAI;IAIpB,IAAW,MAAM,IAAI,OAAO,CAE3B;IAEM,IAAI,IAAI,IAAI;IAIZ,MAAM,IAAI,IAAI;CAGrB"}

package/dist/esm/Autocomplete/Stores/AutocompleteStateStore.js

@@ -0,0 +1,42 @@
+import { observable, action, makeObservable } from 'mobx';
+export class AutocompleteStateStore {
+    constructor(params) {
+        this.focusedInput = undefined;
+        this.input = undefined;
+        this.source = 'input';
+        const { services } = params || {};
+        this.locks = {
+            terms: new Lock(false),
+            facets: new Lock(false),
+        };
+        this.url = services.urlManager;
+        makeObservable(this, {
+            focusedInput: observable,
+            locks: observable,
+            input: observable,
+            reset: action,
+        });
+    }
+    reset() {
+        this.input = undefined;
+        this.locks.terms.reset();
+        this.locks.facets.reset();
+    }
+}
+export class Lock {
+    constructor(state = false) {
+        this.state = this.startState = state;
+    }
+    reset() {
+        this.state = this.startState;
+    }
+    get locked() {
+        return this.state;
+    }
+    lock() {
+        this.state = true;
+    }
+    unlock() {
+        this.state = false;
+    }
+}

package/dist/esm/Autocomplete/Stores/AutocompleteTermStore.d.ts

@@ -0,0 +1,47 @@
+import type { UrlManager } from '@athoscommerce/snap-url-manager';
+import type { AutocompleteStoreConfig, StoreServices } from '../../types';
+import { AutocompleteStateStore } from './AutocompleteStateStore';
+import { AutocompleteResponseModel, AutocompleteRequestModelSearchSourceEnum } from '@athoscommerce/snapi-types';
+type AutocompleteTermStoreConfig = Omit<TermData, 'data' | 'type'> & {
+    config: AutocompleteStoreConfig;
+    data: {
+        autocomplete: AutocompleteResponseModel;
+    };
+    functions: {
+        resetTerms: () => void;
+    };
+    state: {
+        rootState: AutocompleteStateStore;
+    };
+};
+export declare class AutocompleteTermStore extends Array<Term> {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(params: AutocompleteTermStoreConfig);
+}
+export type TermData = {
+    services: StoreServices;
+    functions: {
+        resetTerms: () => void;
+    };
+    state: {
+        rootState: AutocompleteStateStore;
+    };
+    data: {
+        term: {
+            active: boolean;
+            value: string;
+        };
+        terms: Term[];
+    };
+    type: AutocompleteRequestModelSearchSourceEnum;
+};
+export declare class Term {
+    active: boolean;
+    value: string;
+    preview: () => void;
+    url: UrlManager;
+    type: AutocompleteRequestModelSearchSourceEnum;
+    constructor(params: TermData);
+}
+export {};
+//# sourceMappingURL=AutocompleteTermStore.d.ts.map

package/dist/esm/Autocomplete/Stores/AutocompleteTermStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutocompleteTermStore.d.ts","sourceRoot":"","sources":["../../../../src/Autocomplete/Stores/AutocompleteTermStore.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,KAAK,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,yBAAyB,EAAE,wCAAwC,EAAE,MAAM,4BAA4B,CAAC;AAEjH,KAAK,2BAA2B,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IACpE,MAAM,EAAE,uBAAuB,CAAC;IAChC,IAAI,EAAE;QACL,YAAY,EAAE,yBAAyB,CAAC;KACxC,CAAC;IACF,SAAS,EAAE;QACV,UAAU,EAAE,MAAM,IAAI,CAAC;KACvB,CAAC;IACF,KAAK,EAAE;QACN,SAAS,EAAE,sBAAsB,CAAC;KAClC,CAAC;CACF,CAAC;AAEF,qBAAa,qBAAsB,SAAQ,KAAK,CAAC,IAAI,CAAC;IACrD,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAEW,MAAM,EAAE,2BAA2B;CAkC/C;AAED,MAAM,MAAM,QAAQ,GAAG;IACtB,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,EAAE;QACV,UAAU,EAAE,MAAM,IAAI,CAAC;KACvB,CAAC;IACF,KAAK,EAAE;QACN,SAAS,EAAE,sBAAsB,CAAC;KAClC,CAAC;IACF,IAAI,EAAE;QACL,IAAI,EAAE;YACL,MAAM,EAAE,OAAO,CAAC;YAChB,KAAK,EAAE,MAAM,CAAC;SACd,CAAC;QACF,KAAK,EAAE,IAAI,EAAE,CAAC;KACd,CAAC;IACF,IAAI,EAAE,wCAAwC,CAAC;CAC/C,CAAC;AAEF,qBAAa,IAAI;IACT,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,GAAG,EAAE,UAAU,CAAC;IAChB,IAAI,EAAE,wCAAwC,CAAC;gBAE1C,MAAM,EAAE,QAAQ;CA4B5B"}

package/dist/esm/Autocomplete/Stores/AutocompleteTermStore.js

@@ -0,0 +1,56 @@
+import { observable, makeObservable } from 'mobx';
+export class AutocompleteTermStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(params) {
+        const { data } = params || {};
+        const { autocomplete, search } = data?.autocomplete || {};
+        const suggestions = [...(autocomplete?.alternatives ? autocomplete.alternatives : []).map((term) => term.text)];
+        if (autocomplete?.correctedQuery && search?.query && autocomplete.correctedQuery.toLowerCase() != search.query.toLowerCase()) {
+            // the query was corrected
+            suggestions.unshift(autocomplete.correctedQuery);
+        }
+        search?.query && suggestions.unshift(search.query);
+        const terms = [];
+        suggestions.map((term, index) => terms.push(new Term({
+            ...params,
+            data: {
+                term: {
+                    active: index === 0,
+                    value: term,
+                },
+                terms,
+            },
+            functions: params.functions,
+            state: params.state,
+            type: 'suggested',
+        })));
+        super(...terms);
+    }
+}
+export class Term {
+    constructor(params) {
+        const { services, functions, state, data, type } = params || {};
+        const { term, terms } = data || {};
+        this.active = term?.active;
+        this.value = term?.value;
+        this.type = type;
+        this.url = services?.urlManager?.set({ query: this.value });
+        this.preview = () => {
+            functions.resetTerms();
+            terms.map((term) => {
+                term.active = false;
+            });
+            state.rootState.source = type;
+            this.active = true;
+            state.rootState.locks.terms.lock();
+            state.rootState.locks.facets.unlock();
+            this.url?.set({ query: this.value }).go();
+        };
+        makeObservable(this, {
+            active: observable,
+            value: observable,
+        });
+    }
+}

package/dist/esm/Autocomplete/Stores/AutocompleteTrendingStore.d.ts

@@ -0,0 +1,20 @@
+import { TrendingResponseModel } from '@athoscommerce/snap-client';
+import { Term, TermData } from './AutocompleteTermStore';
+import { AutocompleteStateStore } from './AutocompleteStateStore';
+type AutocompleteTrendingStoreConfig = Omit<TermData, 'data' | 'type'> & {
+    data: {
+        trending: TrendingResponseModel;
+    };
+    functions: {
+        resetTerms: () => void;
+    };
+    state: {
+        rootState: AutocompleteStateStore;
+    };
+};
+export declare class AutocompleteTrendingStore extends Array<Term> {
+    static get [Symbol.species](): ArrayConstructor;
+    constructor(params: AutocompleteTrendingStoreConfig);
+}
+export {};
+//# sourceMappingURL=AutocompleteTrendingStore.d.ts.map

package/dist/esm/Autocomplete/Stores/AutocompleteTrendingStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AutocompleteTrendingStore.d.ts","sourceRoot":"","sources":["../../../../src/Autocomplete/Stores/AutocompleteTrendingStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,KAAK,+BAA+B,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG;IACxE,IAAI,EAAE;QACL,QAAQ,EAAE,qBAAqB,CAAC;KAChC,CAAC;IACF,SAAS,EAAE;QACV,UAAU,EAAE,MAAM,IAAI,CAAC;KACvB,CAAC;IACF,KAAK,EAAE;QACN,SAAS,EAAE,sBAAsB,CAAC;KAClC,CAAC;CACF,CAAC;AAEF,qBAAa,yBAA0B,SAAQ,KAAK,CAAC,IAAI,CAAC;IACzD,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,gBAAgB,CAE9C;gBAEW,MAAM,EAAE,+BAA+B;CAwBnD"}

package/dist/esm/Autocomplete/Stores/AutocompleteTrendingStore.js

@@ -0,0 +1,27 @@
+import { Term } from './AutocompleteTermStore';
+export class AutocompleteTrendingStore extends Array {
+    static get [Symbol.species]() {
+        return Array;
+    }
+    constructor(params) {
+        const terms = [];
+        const { data } = params || {};
+        const { trending } = data?.trending || {};
+        trending?.queries?.map((term) => {
+            terms.push(new Term({
+                ...params,
+                data: {
+                    term: {
+                        active: false,
+                        value: term.searchQuery,
+                    },
+                    terms,
+                },
+                functions: params.functions,
+                state: params.state,
+                type: 'popular',
+            }));
+        });
+        super(...terms);
+    }
+}

package/dist/esm/Autocomplete/Stores/index.d.ts

@@ -0,0 +1,7 @@
+export { AutocompleteFacetStore } from './AutocompleteFacetStore';
+export { AutocompleteQueryStore } from './AutocompleteQueryStore';
+export { AutocompleteStateStore } from './AutocompleteStateStore';
+export { AutocompleteTermStore, Term } from './AutocompleteTermStore';
+export { AutocompleteTrendingStore } from './AutocompleteTrendingStore';
+export { AutocompleteHistoryStore } from './AutocompleteHistoryStore';
+//# sourceMappingURL=index.d.ts.map