@searchspring/snap-controller 0.20.0

package/dist/esm/Recommendation/RecommendationController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecommendationController.d.ts","sourceRoot":"","sources":["../../../src/Recommendation/RecommendationController.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,8BAA8B,EAAkC,kBAAkB,EAAa,MAAM,UAAU,CAAC;AAE9H,aAAK,0BAA0B,GAAG;IACjC,OAAO,EAAE;QACR,KAAK,EAAE,CAAC,CAAC,KAAA,EAAE,MAAM,KAAA,KAAK,WAAW,CAAC;QAClC,MAAM,EAAE,CAAC,MAAM,KAAA,KAAK,WAAW,CAAC;QAChC,UAAU,EAAE,CAAC,MAAM,KAAA,KAAK,WAAW,CAAC;KACpC,CAAC;IACF,KAAK,EAAE,CAAC,CAAC,KAAA,KAAK,WAAW,CAAC;IAC1B,UAAU,EAAE,MAAM,WAAW,CAAC;IAC9B,MAAM,EAAE,MAAM,WAAW,CAAC;CAC1B,CAAC;AAUF,qBAAa,wBAAyB,SAAQ,kBAAkB;IACxD,IAAI,SAAoB;IACxB,KAAK,EAAE,mBAAmB,CAAC;IAClC,MAAM,EAAE,8BAA8B,CAAC;IACvC,MAAM;;;;;MAKJ;gBAEU,MAAM,EAAE,8BAA8B,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,kBAAkB;IA6B9I,KAAK,EAAE,0BAA0B,CAoK/B;IAEF,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAyBhC;IAED,MAAM,QAAa,QAAQ,IAAI,CAAC,CAqG9B;CACF"}

package/dist/esm/Recommendation/RecommendationController.js

@@ -0,0 +1,330 @@
+import deepmerge from 'deepmerge';
+import { BeaconType, BeaconCategory } from '@searchspring/snap-tracker';
+import { LogMode } from '@searchspring/snap-logger';
+import { AbstractController } from '../Abstract/AbstractController';
+import { ErrorType } from '@searchspring/snap-store-mobx';
+const defaultConfig = {
+    id: 'recommend',
+    tag: '',
+    batched: true,
+    realtime: false,
+    globals: {},
+};
+export class RecommendationController extends AbstractController {
+    constructor(config, { client, store, urlManager, eventManager, profiler, logger, tracker }) {
+        super(config, { client, store, urlManager, eventManager, profiler, logger, tracker });
+        this.type = 'recommendation';
+        this.events = {
+            click: null,
+            impression: null,
+            render: null,
+            product: {},
+        };
+        this.track = {
+            product: {
+                click: (e, result) => {
+                    if (!this.store.profile.tag || !result || !this.events.click)
+                        return;
+                    const payload = {
+                        type: BeaconType.PROFILE_PRODUCT_CLICK,
+                        category: BeaconCategory.RECOMMENDATIONS,
+                        context: this.config.globals.siteId ? { website: { trackingCode: this.config.globals.siteId } } : null,
+                        event: {
+                            context: {
+                                action: 'navigate',
+                                placement: this.store.profile.placement,
+                                tag: this.store.profile.tag,
+                                type: 'product-recommendation',
+                            },
+                            product: {
+                                id: result.id,
+                                mappings: {
+                                    core: result.mappings.core,
+                                },
+                                seed: this.config.globals.seed,
+                            },
+                        },
+                        pid: this.events.click.id,
+                    };
+                    const event = this.tracker.track.event(payload);
+                    this.eventManager.fire('track.product.click', { controller: this, event: e, result, trackEvent: event });
+                    return event;
+                },
+                impression: (result) => {
+                    if (!this.store.profile.tag || !result || !this.events.impression || this.events.product[result.id]?.impression)
+                        return;
+                    const payload = {
+                        type: BeaconType.PROFILE_PRODUCT_IMPRESSION,
+                        category: BeaconCategory.RECOMMENDATIONS,
+                        context: this.config.globals.siteId ? { website: { trackingCode: this.config.globals.siteId } } : null,
+                        event: {
+                            context: {
+                                placement: this.store.profile.placement,
+                                tag: this.store.profile.tag,
+                                type: 'product-recommendation',
+                            },
+                            product: {
+                                id: result.id,
+                                mappings: {
+                                    core: result.mappings.core,
+                                },
+                                seed: this.config.globals.seed,
+                            },
+                        },
+                        pid: this.events.impression.id,
+                    };
+                    this.events.product[result.id] = this.events.product[result.id] || {};
+                    const event = (this.events.product[result.id].impression = this.tracker.track.event(payload));
+                    this.eventManager.fire('track.product.impression', { controller: this, result, trackEvent: event });
+                    return event;
+                },
+                render: (result) => {
+                    if (!this.store.profile.tag || !result || !this.events.render || this.events.product[result.id]?.render)
+                        return;
+                    const payload = {
+                        type: BeaconType.PROFILE_PRODUCT_RENDER,
+                        category: BeaconCategory.RECOMMENDATIONS,
+                        context: this.config.globals.siteId ? { website: { trackingCode: this.config.globals.siteId } } : null,
+                        event: {
+                            context: {
+                                placement: this.store.profile.placement,
+                                tag: this.store.profile.tag,
+                                type: 'product-recommendation',
+                            },
+                            product: {
+                                id: result.id,
+                                mappings: {
+                                    core: result.mappings.core,
+                                },
+                                seed: this.config.globals.seed,
+                            },
+                        },
+                        pid: this.events.render.id,
+                    };
+                    this.events.product[result.id] = this.events.product[result.id] || {};
+                    const event = (this.events.product[result.id].render = this.tracker.track.event(payload));
+                    this.eventManager.fire('track.product.render', { controller: this, result, trackEvent: event });
+                    return event;
+                },
+            },
+            click: (e) => {
+                if (!this.store.profile.tag)
+                    return;
+                const event = this.tracker.track.event({
+                    type: BeaconType.PROFILE_CLICK,
+                    category: BeaconCategory.RECOMMENDATIONS,
+                    context: this.config.globals.siteId ? { website: { trackingCode: this.config.globals.siteId } } : null,
+                    event: {
+                        context: {
+                            action: 'navigate',
+                            placement: this.store.profile.placement,
+                            tag: this.store.profile.tag,
+                            type: 'product-recommendation',
+                        },
+                        profile: {
+                            tag: this.store.profile.tag,
+                            placement: this.store.profile.placement,
+                            threshold: this.store.profile.display.threshold,
+                            templateId: this.store.profile.display.template.uuid,
+                        },
+                    },
+                });
+                this.events.click = event;
+                this.eventManager.fire('track.click', { controller: this, event: e, trackEvent: event });
+                return event;
+            },
+            impression: () => {
+                if (!this.store.profile.tag || this.events.impression)
+                    return;
+                const event = this.tracker.track.event({
+                    type: BeaconType.PROFILE_IMPRESSION,
+                    category: BeaconCategory.RECOMMENDATIONS,
+                    context: this.config.globals.siteId ? { website: { trackingCode: this.config.globals.siteId } } : null,
+                    event: {
+                        context: {
+                            placement: this.store.profile.placement,
+                            tag: this.store.profile.tag,
+                            type: 'product-recommendation',
+                        },
+                        profile: {
+                            tag: this.store.profile.tag,
+                            placement: this.store.profile.placement,
+                            threshold: this.store.profile.display.threshold,
+                            templateId: this.store.profile.display.template.uuid,
+                        },
+                    },
+                });
+                this.events.impression = event;
+                this.eventManager.fire('track.impression', { controller: this, trackEvent: event });
+                return event;
+            },
+            render: () => {
+                if (!this.store.profile.tag || this.events.render)
+                    return;
+                const event = this.tracker.track.event({
+                    type: BeaconType.PROFILE_RENDER,
+                    category: BeaconCategory.RECOMMENDATIONS,
+                    context: this.config.globals.siteId ? { website: { trackingCode: this.config.globals.siteId } } : null,
+                    event: {
+                        context: {
+                            placement: this.store.profile.placement,
+                            tag: this.store.profile.tag,
+                            type: 'product-recommendation',
+                        },
+                        profile: {
+                            tag: this.store.profile.tag,
+                            placement: this.store.profile.placement,
+                            threshold: this.store.profile.display.threshold,
+                            templateId: this.store.profile.display.template.uuid,
+                        },
+                    },
+                });
+                this.events.render = event;
+                // track results render
+                this.store.results.forEach((result) => this.track.product.render(result));
+                this.eventManager.fire('track.render', { controller: this, trackEvent: event });
+                return event;
+            },
+        };
+        this.search = async () => {
+            if (!this.initialized) {
+                await this.init();
+            }
+            const params = this.params;
+            try {
+                try {
+                    await this.eventManager.fire('beforeSearch', {
+                        controller: this,
+                        request: params,
+                    });
+                }
+                catch (err) {
+                    if (err?.message == 'cancelled') {
+                        this.log.warn(`'beforeSearch' middleware cancelled`);
+                        return;
+                    }
+                    else {
+                        this.log.error(`error in 'beforeSearch' middleware`);
+                        throw err;
+                    }
+                }
+                const searchProfile = this.profiler.create({ type: 'event', name: 'search', context: params }).start();
+                const response = await this.client.recommend(params);
+                searchProfile.stop();
+                this.log.profile(searchProfile);
+                const afterSearchProfile = this.profiler.create({ type: 'event', name: 'afterSearch', context: params }).start();
+                try {
+                    await this.eventManager.fire('afterSearch', {
+                        controller: this,
+                        request: params,
+                        response,
+                    });
+                }
+                catch (err) {
+                    if (err?.message == 'cancelled') {
+                        this.log.warn(`'afterSearch' middleware cancelled`);
+                        afterSearchProfile.stop();
+                        return;
+                    }
+                    else {
+                        this.log.error(`error in 'afterSearch' middleware`);
+                        throw err;
+                    }
+                }
+                afterSearchProfile.stop();
+                this.log.profile(afterSearchProfile);
+                // update the store
+                this.store.update(response);
+                const afterStoreProfile = this.profiler.create({ type: 'event', name: 'afterStore', context: params }).start();
+                try {
+                    await this.eventManager.fire('afterStore', {
+                        controller: this,
+                        request: params,
+                        response,
+                    });
+                }
+                catch (err) {
+                    if (err?.message == 'cancelled') {
+                        this.log.warn(`'afterStore' middleware cancelled`);
+                        afterStoreProfile.stop();
+                        return;
+                    }
+                    else {
+                        this.log.error(`error in 'afterStore' middleware`);
+                        throw err;
+                    }
+                }
+                afterStoreProfile.stop();
+                this.log.profile(afterStoreProfile);
+            }
+            catch (err) {
+                if (err) {
+                    switch (err) {
+                        case 429:
+                            this.store.error = {
+                                code: 429,
+                                type: ErrorType.WARNING,
+                                message: 'Too many requests try again later',
+                            };
+                            this.log.warn(this.store.error);
+                            break;
+                        case 500:
+                            this.store.error = {
+                                code: 500,
+                                type: ErrorType.ERROR,
+                                message: 'Invalid Search Request or Service Unavailable',
+                            };
+                            this.log.error(this.store.error);
+                            break;
+                        default:
+                            this.log.error(err);
+                            break;
+                    }
+                    this.store.loading = false;
+                }
+            }
+        };
+        if (!config.tag) {
+            throw new Error(`Invalid config passed to RecommendationController. The "tag" attribute is required.`);
+        }
+        // deep merge config with defaults
+        this.config = deepmerge(defaultConfig, this.config);
+        this.store.setConfig(this.config);
+        // add 'beforeSearch' middleware
+        this.eventManager.on('beforeSearch', async (recommend, next) => {
+            recommend.controller.store.loading = true;
+            await next();
+        });
+        // add 'afterStore' middleware
+        this.eventManager.on('afterStore', async (recommend, next) => {
+            await next();
+            recommend.controller.store.loading = false;
+        });
+        // attach config plugins and event middleware
+        this.use(this.config);
+    }
+    get params() {
+        const params = {
+            tag: this.config.tag,
+            batched: this.config.batched,
+            ...this.config.globals,
+            branch: this.config.branch || 'production',
+        };
+        const shopperId = this.tracker.context.shopperId;
+        const cart = this.tracker.cookies.cart.get();
+        const lastViewed = this.tracker.cookies.viewed.get();
+        if (shopperId) {
+            params.shopper = shopperId;
+        }
+        if (cart?.length) {
+            params.cart = cart;
+        }
+        if (lastViewed?.length) {
+            params.lastViewed = lastViewed;
+        }
+        if (this.environment == LogMode.DEVELOPMENT) {
+            params.test = true;
+        }
+        return params;
+    }
+}

package/dist/esm/Search/SearchController.d.ts

@@ -0,0 +1,23 @@
+import { AbstractController } from '../Abstract/AbstractController';
+import { StorageStore } from '@searchspring/snap-store-mobx';
+import type { BeaconEvent } from '@searchspring/snap-tracker';
+import type { SearchStore } from '@searchspring/snap-store-mobx';
+import type { SearchControllerConfig, ControllerServices } from '../types';
+import type { SearchRequestModel } from '@searchspring/snapi-types';
+declare type SearchTrackMethods = {
+    product: {
+        click: (e: any, result: any) => BeaconEvent;
+    };
+};
+export declare class SearchController extends AbstractController {
+    type: string;
+    store: SearchStore;
+    config: SearchControllerConfig;
+    storage: StorageStore;
+    constructor(config: SearchControllerConfig, { client, store, urlManager, eventManager, profiler, logger, tracker }: ControllerServices);
+    track: SearchTrackMethods;
+    get params(): SearchRequestModel;
+    search: () => Promise<void>;
+}
+export {};
+//# sourceMappingURL=SearchController.d.ts.map

package/dist/esm/Search/SearchController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SearchController.d.ts","sourceRoot":"","sources":["../../../src/Search/SearchController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,YAAY,EAA0B,MAAM,+BAA+B,CAAC;AAGrF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EAAE,sBAAsB,EAAkD,kBAAkB,EAAa,MAAM,UAAU,CAAC;AACtI,OAAO,KAAK,EAAE,kBAAkB,EAAgD,MAAM,2BAA2B,CAAC;AAmBlH,aAAK,kBAAkB,GAAG;IACzB,OAAO,EAAE;QACR,KAAK,EAAE,CAAC,CAAC,KAAA,EAAE,MAAM,KAAA,KAAK,WAAW,CAAC;KAClC,CAAC;CACF,CAAC;AAEF,qBAAa,gBAAiB,SAAQ,kBAAkB;IAChD,IAAI,SAAY;IAChB,KAAK,EAAE,WAAW,CAAC;IAC1B,MAAM,EAAE,sBAAsB,CAAC;IAC/B,OAAO,EAAE,YAAY,CAAC;gBAEV,MAAM,EAAE,sBAAsB,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,kBAAkB;IAiFtI,KAAK,EAAE,kBAAkB,CA0BvB;IAEF,IAAI,MAAM,IAAI,kBAAkB,CAsC/B;IAED,MAAM,QAAa,QAAQ,IAAI,CAAC,CAuJ9B;CACF"}

package/dist/esm/Search/SearchController.js

@@ -0,0 +1,282 @@
+import deepmerge from 'deepmerge';
+import { AbstractController } from '../Abstract/AbstractController';
+import { StorageStore, StorageType, ErrorType } from '@searchspring/snap-store-mobx';
+import { getSearchParams } from '../utils/getParams';
+const HEIGHT_CHECK_INTERVAL = 50;
+const defaultConfig = {
+    id: 'search',
+    globals: {},
+    settings: {
+        redirects: {
+            merchandising: true,
+            singleResult: true,
+        },
+        facets: {
+            trim: true,
+            pinFiltered: true,
+        },
+    },
+};
+export class SearchController extends AbstractController {
+    constructor(config, { client, store, urlManager, eventManager, profiler, logger, tracker }) {
+        super(config, { client, store, urlManager, eventManager, profiler, logger, tracker });
+        this.type = 'search';
+        this.track = {
+            product: {
+                click: (e, result) => {
+                    // store scroll position
+                    if (this.config.settings.infinite) {
+                        const stringyParams = this.storage.get('lastStringyParams');
+                        const scrollMap = {};
+                        scrollMap[stringyParams] = window.scrollY;
+                        this.storage.set('scrollMap', scrollMap);
+                    }
+                    // track
+                    const { intellisuggestData, intellisuggestSignature } = result.attributes;
+                    const target = e.target;
+                    const href = target?.href || result.mappings.core?.url || undefined;
+                    const event = this.tracker.track.product.click({
+                        intellisuggestData,
+                        intellisuggestSignature,
+                        href,
+                    });
+                    this.eventManager.fire('track.product.click', { controller: this, event: e, result, trackEvent: event });
+                    return event;
+                },
+            },
+        };
+        this.search = async () => {
+            if (!this.initialized) {
+                await this.init();
+            }
+            const params = this.params;
+            try {
+                const stringyParams = JSON.stringify(params);
+                const prevStringyParams = this.storage.get('lastStringyParams');
+                if (stringyParams == prevStringyParams) {
+                    // no param change - not searching
+                    return;
+                }
+                try {
+                    await this.eventManager.fire('beforeSearch', {
+                        controller: this,
+                        request: params,
+                    });
+                }
+                catch (err) {
+                    if (err?.message == 'cancelled') {
+                        this.log.warn(`'beforeSearch' middleware cancelled`);
+                        return;
+                    }
+                    else {
+                        this.log.error(`error in 'beforeSearch' middleware`);
+                        throw err;
+                    }
+                }
+                if (this.config.settings.infinite) {
+                    // TODO: refactor this
+                    const preventBackfill = this.config.settings.infinite?.backfill && !this.store.results.length && params.pagination?.page > this.config.settings.infinite.backfill;
+                    const dontBackfill = !this.config.settings.infinite?.backfill && !this.store.results.length && params.pagination?.page > 1;
+                    if (preventBackfill || dontBackfill) {
+                        this.storage.set('scrollMap', {});
+                        this.urlManager.set('page', 1).go();
+                        return;
+                    }
+                }
+                const searchProfile = this.profiler.create({ type: 'event', name: 'search', context: params }).start();
+                const [meta, response] = await this.client.search(params);
+                if (!response.meta) {
+                    /**
+                     * MockClient will overwrite the client search() method and use
+                     * SearchData to return mock data which already contains meta data
+                     */
+                    response.meta = meta;
+                }
+                // infinite functionality
+                // if params.page > 1 and infinite setting exists we should append results
+                if (this.config.settings.infinite && params.pagination?.page > 1) {
+                    // if no results fetch results...
+                    let previousResults = this.store.data?.results || [];
+                    if (this.config.settings?.infinite.backfill && !previousResults.length) {
+                        // figure out how many pages of results to backfill and wait on all responses
+                        const backfills = [];
+                        for (let page = 1; page < params.pagination.page; page++) {
+                            const backfillParams = deepmerge({ ...params }, { pagination: { page } });
+                            backfills.push(this.client.search(backfillParams));
+                        }
+                        const backfillResponses = await Promise.all(backfills);
+                        backfillResponses.map(([meta, data]) => {
+                            previousResults = previousResults.concat(data.results);
+                        });
+                    }
+                    response.results = [...previousResults, ...(response.results || [])];
+                }
+                searchProfile.stop();
+                this.log.profile(searchProfile);
+                const afterSearchProfile = this.profiler.create({ type: 'event', name: 'afterSearch', context: params }).start();
+                try {
+                    await this.eventManager.fire('afterSearch', {
+                        controller: this,
+                        request: params,
+                        response,
+                    });
+                }
+                catch (err) {
+                    if (err?.message == 'cancelled') {
+                        this.log.warn(`'afterSearch' middleware cancelled`);
+                        afterSearchProfile.stop();
+                        return;
+                    }
+                    else {
+                        this.log.error(`error in 'afterSearch' middleware`);
+                        throw err;
+                    }
+                }
+                afterSearchProfile.stop();
+                this.log.profile(afterSearchProfile);
+                // update the store
+                this.store.update(response);
+                const afterStoreProfile = this.profiler.create({ type: 'event', name: 'afterStore', context: params }).start();
+                try {
+                    await this.eventManager.fire('afterStore', {
+                        controller: this,
+                        request: params,
+                        response,
+                    });
+                }
+                catch (err) {
+                    if (err?.message == 'cancelled') {
+                        this.log.warn(`'afterStore' middleware cancelled`);
+                        afterStoreProfile.stop();
+                        return;
+                    }
+                    else {
+                        this.log.error(`error in 'afterStore' middleware`);
+                        throw err;
+                    }
+                }
+                afterStoreProfile.stop();
+                this.log.profile(afterStoreProfile);
+            }
+            catch (err) {
+                if (err) {
+                    switch (err) {
+                        case 429:
+                            this.store.error = {
+                                code: 429,
+                                type: ErrorType.WARNING,
+                                message: 'Too many requests try again later',
+                            };
+                            this.log.warn(this.store.error);
+                            break;
+                        case 500:
+                            this.store.error = {
+                                code: 500,
+                                type: ErrorType.ERROR,
+                                message: 'Invalid Search Request or Service Unavailable',
+                            };
+                            this.log.error(this.store.error);
+                            break;
+                        default:
+                            this.log.error(err);
+                            break;
+                    }
+                    this.store.loading = false;
+                }
+            }
+        };
+        // deep merge config with defaults
+        this.config = deepmerge(defaultConfig, this.config);
+        this.store.setConfig(this.config);
+        this.storage = new StorageStore({
+            type: StorageType.SESSION,
+            key: `ss-controller-${this.config.id}`,
+        });
+        // set last params to undefined for compare in search
+        this.storage.set('lastStringyParams', undefined);
+        // add 'beforeSearch' middleware
+        this.eventManager.on('beforeSearch', async (search, next) => {
+            search.controller.store.loading = true;
+            await next();
+        });
+        // add 'afterSearch' middleware
+        this.eventManager.on('afterSearch', async (search, next) => {
+            const config = search.controller.config;
+            const redirectURL = search.response?.merchandising?.redirect;
+            const searchStore = search.controller.store;
+            if (redirectURL && config?.settings?.redirects?.merchandising && !search?.response?.filters?.length && !searchStore.loaded) {
+                window.location.replace(redirectURL);
+                return false;
+            }
+            if (config?.settings?.redirects?.singleResult &&
+                search?.response?.search?.query &&
+                search?.response?.pagination?.totalResults === 1 &&
+                !search?.response?.filters?.length) {
+                window.location.replace(search?.response.results[0].mappings.core.url);
+                return false;
+            }
+            await next();
+        });
+        this.eventManager.on('afterStore', async (search, next) => {
+            await next();
+            search.controller.store.loading = false;
+            // save last params
+            const stringyParams = JSON.stringify(search.request);
+            this.storage.set('lastStringyParams', stringyParams);
+            if (this.config.settings?.infinite && window.scrollY === 0) {
+                // browser didn't jump
+                const scrollMap = this.storage.get('scrollMap') || {};
+                // interval we ony need to keep checking until the page height > than our stored value
+                const scrollToPosition = scrollMap[stringyParams];
+                if (scrollToPosition) {
+                    let checkCount = 0;
+                    const heightCheck = window.setInterval(() => {
+                        if (document.documentElement.scrollHeight >= scrollToPosition) {
+                            window.scrollTo(0, scrollToPosition);
+                            this.log.debug('scrolling to: ', scrollMap[stringyParams]);
+                            window.clearInterval(heightCheck);
+                        }
+                        if (checkCount > 2000 / HEIGHT_CHECK_INTERVAL) {
+                            window.clearInterval(heightCheck);
+                        }
+                        checkCount++;
+                    }, HEIGHT_CHECK_INTERVAL);
+                }
+            }
+        });
+        // attach config plugins and event middleware
+        this.use(this.config);
+    }
+    get params() {
+        const params = deepmerge({ ...getSearchParams(this.urlManager.state) }, this.config.globals);
+        // redirect setting
+        if (!this.config.settings?.redirects?.merchandising || this.store.loaded) {
+            params.search = params.search || {};
+            params.search.redirectResponse = 'full';
+        }
+        params.tracking = params.tracking || {};
+        params.tracking.domain = window.location.href;
+        const userId = this.tracker.getUserId();
+        if (userId) {
+            params.tracking.userId = userId;
+        }
+        if (!this.config.globals?.personalization?.disabled) {
+            const cartItems = this.tracker.cookies.cart.get();
+            if (cartItems.length) {
+                params.personalization = params.personalization || {};
+                params.personalization.cart = cartItems.join(',');
+            }
+            const lastViewedItems = this.tracker.cookies.viewed.get();
+            if (lastViewedItems.length) {
+                params.personalization = params.personalization || {};
+                params.personalization.lastViewed = lastViewedItems.join(',');
+            }
+            const shopperId = this.tracker.getShopperId();
+            if (shopperId) {
+                params.personalization = params.personalization || {};
+                params.personalization.shopper = shopperId;
+            }
+        }
+        return params;
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export { FinderController } from './Finder/FinderController';
+export { SearchController } from './Search/SearchController';
+export { AutocompleteController } from './Autocomplete/AutocompleteController';
+export { RecommendationController } from './Recommendation/RecommendationController';
+export { AbstractController } from './Abstract/AbstractController';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAEnE,cAAc,SAAS,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+export { FinderController } from './Finder/FinderController';
+export { SearchController } from './Search/SearchController';
+export { AutocompleteController } from './Autocomplete/AutocompleteController';
+export { RecommendationController } from './Recommendation/RecommendationController';
+export { AbstractController } from './Abstract/AbstractController';
+export * from './types';