@athoscommerce/snap-controller 1.0.0

package/dist/esm/Search/SearchController.js

@@ -0,0 +1,795 @@
+import deepmerge from 'deepmerge';
+import cssEscape from 'css.escape';
+import { AbstractController } from '../Abstract/AbstractController';
+import { StorageStore, ErrorType } from '@athoscommerce/snap-store-mobx';
+import { getSearchParams } from '../utils/getParams';
+import { ControllerTypes } from '../types';
+import { CLICK_DUPLICATION_TIMEOUT, isClickWithinProductLink } from '../utils/isClickWithinProductLink';
+import { isClickWithinBannerLink } from '../utils/isClickWithinBannerLink';
+const BACKGROUND_FILTER_FIELD_MATCHES = ['collection', 'category', 'categories', 'hierarchy', 'brand', 'manufacturer'];
+const BACKGROUND_FILTERS_VALUE_FLAGS = [1, 0, '1', '0', 'true', 'false', true, false];
+const defaultConfig = {
+    id: 'search',
+    globals: {},
+    beacon: {
+        enabled: true,
+    },
+    settings: {
+        redirects: {
+            merchandising: true,
+            singleResult: true,
+        },
+        facets: {
+            trim: true,
+            pinFiltered: true,
+            storeRange: true,
+            autoOpenActive: true,
+        },
+    },
+};
+export class SearchController extends AbstractController {
+    constructor(config, { client, store, urlManager, eventManager, profiler, logger, tracker }, context) {
+        super(config, { client, store, urlManager, eventManager, profiler, logger, tracker }, context);
+        this.type = ControllerTypes.search;
+        this.previousResults = [];
+        this.page = {
+            type: 'search',
+        };
+        this.events = {};
+        this.track = {
+            banner: {
+                impression: ({ uid, responseId }) => {
+                    if (!uid) {
+                        this.log.warn('No banner provided to track.banner.impression');
+                        return;
+                    }
+                    if (!this.events[responseId]) {
+                        this.log.warn('No responseId found in controller, ensure correct controller is used');
+                        return;
+                    }
+                    else if (this.events[responseId]?.banner[uid]?.impression) {
+                        return;
+                    }
+                    const banner = { uid };
+                    const data = {
+                        responseId,
+                        banners: [banner],
+                        results: [],
+                    };
+                    this.eventManager.fire('track.banner.impression', { controller: this, product: { uid }, trackEvent: data });
+                    this.config.beacon?.enabled && this.tracker.events[this.page.type].impression({ data, siteId: this.config.globals?.siteId });
+                    this.events[responseId].banner[uid] = this.events[responseId].banner[uid] || {};
+                    this.events[responseId].banner[uid].impression = true;
+                },
+                click: (e, banner) => {
+                    if (!banner) {
+                        this.log.warn('No banner provided to track.banner.click');
+                        return;
+                    }
+                    const { responseId, uid } = banner;
+                    if (!this.events[responseId]) {
+                        this.log.warn('No responseId found in controller, ensure correct controller is used');
+                        return;
+                    }
+                    if (isClickWithinBannerLink(e)) {
+                        if (this.events?.[responseId]?.banner[uid]?.clickThrough) {
+                            return;
+                        }
+                        this.track.banner.clickThrough(e, banner);
+                        this.events[responseId].banner[uid] = this.events[responseId].banner[uid] || {};
+                        this.events[responseId].banner[uid].clickThrough = true;
+                        setTimeout(() => {
+                            this.events[responseId].banner[uid].clickThrough = false;
+                        }, CLICK_DUPLICATION_TIMEOUT);
+                    }
+                },
+                clickThrough: (e, { uid, responseId }) => {
+                    if (!uid) {
+                        this.log.warn('No banner provided to track.banner.clickThrough');
+                        return;
+                    }
+                    if (!this.events[responseId]) {
+                        this.log.warn('No responseId found in controller, ensure correct controller is used');
+                        return;
+                    }
+                    const banner = { uid };
+                    const data = {
+                        responseId,
+                        banners: [banner],
+                    };
+                    this.eventManager.fire('track.banner.clickThrough', { controller: this, event: e, product: { uid }, trackEvent: data });
+                    this.config.beacon?.enabled && this.tracker.events[this.page.type].clickThrough({ data, siteId: this.config.globals?.siteId });
+                    this.events[responseId].banner[uid] = this.events[responseId].banner[uid] || {};
+                    this.events[responseId].banner[uid].clickThrough = true;
+                    setTimeout(() => {
+                        this.events[responseId].banner[uid].clickThrough = false;
+                    }, CLICK_DUPLICATION_TIMEOUT);
+                },
+            },
+            product: {
+                clickThrough: (e, result) => {
+                    if (!result) {
+                        this.log.warn('No result provided to track.product.clickThrough');
+                        return;
+                    }
+                    const responseId = result.responseId;
+                    if (!this.events[responseId]) {
+                        this.log.warn('No responseId found in controller, ensure correct controller is used');
+                        return;
+                    }
+                    const target = e.target;
+                    const resultHref = result.display?.mappings.core?.url || result.mappings.core?.url || '';
+                    const elemHref = target?.getAttribute('href');
+                    // the href that should be used for restoration - if the elemHref contains the resultHref - use resultHref
+                    const storedHref = elemHref?.indexOf(resultHref) != -1 ? resultHref : elemHref || resultHref;
+                    const scrollMap = {};
+                    // generate the selector using element class and parent classes
+                    const selector = generateHrefSelector(target, storedHref);
+                    const domRect = selector ? document?.querySelector(selector)?.getBoundingClientRect() : undefined;
+                    // store element position data to scrollMap
+                    if (selector || storedHref || domRect) {
+                        try {
+                            const lastRequest = this.storage.get('lastStringyParams');
+                            if (lastRequest) {
+                                const storableRequestParams = getStorableRequestParams(JSON.parse(lastRequest));
+                                const storableStringyParams = JSON.stringify(storableRequestParams);
+                                scrollMap[storableStringyParams] = { domRect, href: storedHref, selector };
+                            }
+                        }
+                        catch (err) {
+                            // failed to get lastStringParams
+                            this.log.warn('Failed to save srcollMap!', err);
+                        }
+                    }
+                    // store position data or empty object
+                    this.storage.set('scrollMap', scrollMap);
+                    const type = (['product', 'banner'].includes(result.type) ? result.type : 'product');
+                    const item = {
+                        type,
+                        uid: result.id ? '' + result.id : '',
+                        ...(type === 'product'
+                            ? {
+                                parentId: result.mappings.core?.parentId ? '' + result.mappings.core?.parentId : '',
+                                sku: result.mappings.core?.sku ? '' + result.mappings.core?.sku : undefined,
+                            }
+                            : {}),
+                    };
+                    const data = {
+                        responseId,
+                        results: [item],
+                    };
+                    this.eventManager.fire('track.product.clickThrough', { controller: this, event: e, product: result, trackEvent: data });
+                    this.config.beacon?.enabled && this.tracker.events[this.page.type].clickThrough({ data, siteId: this.config.globals?.siteId });
+                },
+                click: (e, result) => {
+                    if (!result) {
+                        this.log.warn('No result provided to track.product.click');
+                        return;
+                    }
+                    const responseId = result.responseId;
+                    if (!this.events[responseId]) {
+                        this.log.warn('No responseId found in controller, ensure correct controller is used');
+                        return;
+                    }
+                    if (result.type === 'banner' && isClickWithinBannerLink(e)) {
+                        if (this.events?.[responseId]?.product[result.id]?.inlineBannerClickThrough) {
+                            return;
+                        }
+                        this.track.product.clickThrough(e, result);
+                        this.events[responseId].product[result.id] = this.events[responseId].product[result.id] || {};
+                        this.events[responseId].product[result.id].inlineBannerClickThrough = true;
+                        setTimeout(() => {
+                            this.events[responseId].product[result.id].inlineBannerClickThrough = false;
+                        }, CLICK_DUPLICATION_TIMEOUT);
+                    }
+                    else if (isClickWithinProductLink(e, result)) {
+                        if (this.events?.[responseId]?.product[result.id]?.productClickThrough) {
+                            return;
+                        }
+                        this.track.product.clickThrough(e, result);
+                        this.events[responseId].product[result.id] = this.events[responseId].product[result.id] || {};
+                        this.events[responseId].product[result.id].productClickThrough = true;
+                        setTimeout(() => {
+                            this.events[responseId].product[result.id].productClickThrough = false;
+                        }, CLICK_DUPLICATION_TIMEOUT);
+                    }
+                },
+                impression: (result) => {
+                    if (!result) {
+                        this.log.warn('No result provided to track.product.impression');
+                        return;
+                    }
+                    const responseId = result.responseId;
+                    if (!this.events[responseId]) {
+                        this.log.warn('No responseId found in controller, ensure correct controller is used');
+                        return;
+                    }
+                    else if (this.events[responseId]?.product[result.id]?.impression) {
+                        return;
+                    }
+                    const type = (['product', 'banner'].includes(result.type) ? result.type : 'product');
+                    const item = {
+                        type,
+                        uid: result.id ? '' + result.id : '',
+                        ...(type === 'product'
+                            ? {
+                                parentId: result.mappings.core?.parentId ? '' + result.mappings.core?.parentId : '',
+                                sku: result.mappings.core?.sku ? '' + result.mappings.core?.sku : undefined,
+                            }
+                            : {}),
+                    };
+                    const data = {
+                        responseId,
+                        results: [item],
+                        banners: [],
+                    };
+                    this.eventManager.fire('track.product.impression', { controller: this, product: result, trackEvent: data });
+                    this.config.beacon?.enabled && this.tracker.events[this.page.type].impression({ data, siteId: this.config.globals?.siteId });
+                    this.events[responseId].product[result.id] = this.events[responseId].product[result.id] || {};
+                    this.events[responseId].product[result.id].impression = true;
+                },
+                addToCart: (result) => {
+                    if (!result) {
+                        this.log.warn('No result provided to track.product.addToCart');
+                        return;
+                    }
+                    const responseId = result.responseId;
+                    if (!this.events[responseId]) {
+                        this.log.warn('No responseId found in controller, ensure correct controller is used');
+                        return;
+                    }
+                    const product = {
+                        parentId: result.mappings.core?.parentId ? '' + result.mappings.core?.parentId : '',
+                        uid: result.id,
+                        sku: result.mappings.core?.sku,
+                        qty: result.quantity || 1,
+                        price: Number(result.mappings.core?.price),
+                    };
+                    const data = {
+                        responseId,
+                        results: [product],
+                    };
+                    this.eventManager.fire('track.product.addToCart', { controller: this, product: result, trackEvent: data });
+                    this.config.beacon?.enabled && this.tracker.events[this.page.type].addToCart({ data, siteId: this.config.globals?.siteId });
+                },
+            },
+            redirect: ({ redirectURL, responseId }) => {
+                if (!redirectURL) {
+                    this.log.warn('No redirectURL provided to track.redirect');
+                    return;
+                }
+                const data = {
+                    responseId,
+                    redirect: redirectURL,
+                };
+                this.eventManager.fire('track.redirect', { controller: this, redirectURL, trackEvent: data });
+                this.config.beacon?.enabled && this.tracker.events.search.redirect({ data, siteId: this.config.globals?.siteId });
+            },
+        };
+        this.search = async () => {
+            try {
+                if (!this.initialized) {
+                    await this.init();
+                }
+                const params = this.params;
+                if (params.search?.query?.string && params.search?.query?.string.length) {
+                    // save it to the history store
+                    this.store.history.save(params.search.query.string);
+                }
+                this.store.loading = true;
+                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 stringyParams = JSON.stringify(getStorableRequestParams(params));
+                const prevStringyParams = this.storage.get('lastStringyParams');
+                if (this.store.loaded && stringyParams === prevStringyParams) {
+                    // no param change - not searching
+                    return;
+                }
+                const searchProfile = this.profiler.create({ type: 'event', name: 'search', context: params }).start();
+                let meta = {};
+                let search;
+                // infinite scroll functionality (after page 1)
+                if (this.config.settings?.infinite?.enabled && params.pagination?.page && params.pagination.page > 1) {
+                    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;
+                    // if the page is higher than the backfill setting redirect back to page 1
+                    if (preventBackfill || dontBackfill) {
+                        this.storage.set('scrollMap', {});
+                        this.urlManager.set('page', 1).go();
+                        return;
+                    }
+                    // infinite backfill is enabled AND we have not yet fetched any results
+                    if (this.config.settings?.infinite.backfill && !this.store.loaded) {
+                        // create requests for all missing pages (using Arrray(page).fill() to populate an array to map)
+                        const backfillRequestsParams = [];
+                        const backfillRequests = Array(params.pagination.page)
+                            .fill('backfill')
+                            .map((v, i) => {
+                            const backfillParams = deepmerge({ ...params }, { pagination: { page: i + 1 }, search: { redirectResponse: 'full' } });
+                            // don't include page parameter if on page 1
+                            if (i + 1 == 1) {
+                                delete backfillParams?.pagination?.page;
+                                if (this.config.settings?.redirects?.merchandising) {
+                                    // redirect setting
+                                    // DUPLICATED LOGIC can be found in params getter
+                                    delete backfillParams?.search?.redirectResponse;
+                                }
+                            }
+                            backfillRequestsParams.push(backfillParams);
+                            return this.client[this.page.type](backfillParams);
+                        });
+                        const backfillResponses = await Promise.all(backfillRequests);
+                        // backfillResponses are [{ meta: MetaResponseModel, search: SearchResponseModel }]
+                        // set the meta and response to the first page of backfillResponses
+                        meta = backfillResponses[0].meta;
+                        search = backfillResponses[0].search;
+                        // accumulate results from all backfill responses
+                        const backfillResults = backfillResponses.reduce((results, response) => {
+                            const responseId = response.search.tracking.responseId;
+                            this.events[responseId] = this.events[responseId] || { product: {}, banner: {} };
+                            return results.concat(...response.search.results);
+                        }, []);
+                        // overwrite pagination params to expected state
+                        search.pagination.totalPages = Math.ceil(search.pagination.totalResults / search.pagination.pageSize);
+                        search.pagination.page = params.pagination?.page;
+                        // set the response results with results from backfill responses
+                        search.results = backfillResults;
+                    }
+                    else {
+                        // infinite with no backfills.
+                        const infiniteResponse = await this.client[this.page.type](params);
+                        meta = infiniteResponse.meta;
+                        search = infiniteResponse.search;
+                        const responseId = search.tracking.responseId;
+                        this.events[responseId] = this.events[responseId] || { product: {}, banner: {} };
+                        // append new results to previous results
+                        search.results = [...this.previousResults, ...(search.results || [])];
+                    }
+                }
+                else {
+                    // normal request
+                    // clear previousResults to prevent infinite scroll from using them
+                    this.previousResults = [];
+                    const searchResponse = await this.client[this.page.type](params);
+                    meta = searchResponse.meta;
+                    search = searchResponse.search;
+                    const responseId = search.tracking.responseId;
+                    this.events[responseId] = { product: {}, banner: {} };
+                }
+                // need to reconsolidate in order for references to be preserved
+                const response = { meta, search };
+                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);
+                // store previous results for infinite usage (need to alsways store in case switch to infinite after pagination)
+                this.previousResults = JSON.parse(JSON.stringify(response.search.results));
+                // update the store
+                this.store.update(response);
+                const data = { responseId: response.search.tracking.responseId };
+                this.config.beacon?.enabled && this.tracker.events[this.page.type].render({ data, siteId: this.config.globals?.siteId });
+                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) {
+                    if (err.err && err.fetchDetails) {
+                        switch (err.fetchDetails.status) {
+                            case 429: {
+                                this.store.error = {
+                                    code: 429,
+                                    type: ErrorType.WARNING,
+                                    message: 'Too many requests try again later',
+                                };
+                                break;
+                            }
+                            case 500: {
+                                this.store.error = {
+                                    code: 500,
+                                    type: ErrorType.ERROR,
+                                    message: 'Invalid Search Request or Service Unavailable',
+                                };
+                                break;
+                            }
+                            default: {
+                                this.store.error = {
+                                    type: ErrorType.ERROR,
+                                    message: err.err.message,
+                                };
+                                break;
+                            }
+                        }
+                        this.log.error(this.store.error);
+                        this.handleError(err.err, err.fetchDetails);
+                    }
+                    else {
+                        this.store.error = {
+                            type: ErrorType.ERROR,
+                            message: `Something went wrong... - ${err}`,
+                        };
+                        this.log.error(err);
+                        this.handleError(err);
+                    }
+                }
+            }
+            finally {
+                this.store.loading = false;
+            }
+        };
+        this.addToCart = async (_products) => {
+            const products = typeof _products?.slice == 'function' ? _products.slice() : [_products];
+            if (!_products || products.length === 0) {
+                this.log.warn('No products provided to search controller.addToCart');
+                return;
+            }
+            products.forEach((product) => {
+                this.track.product.addToCart(product);
+            });
+            if (products.length > 0) {
+                this.eventManager.fire('addToCart', { controller: this, products });
+            }
+        };
+        // deep merge config with defaults
+        this.config = deepmerge(defaultConfig, this.config);
+        if (this.config.settings?.infinite &&
+            typeof this.config.settings?.infinite == 'object' &&
+            (Object.keys(this.config.settings?.infinite).length == 0 || typeof this.config.settings?.infinite?.backfill != 'undefined')) {
+            // infinite is enabled by setting config.infinite={} (old method)
+            // set config.infinite.enabled=true
+            this.config.settings = {
+                ...this.config.settings,
+                infinite: {
+                    enabled: true,
+                    ...this.config.settings.infinite,
+                },
+            };
+        }
+        // set restorePosition to be enabled by default when using infinite (if not provided)
+        if (this.config.settings?.infinite?.enabled && typeof this.config.settings.restorePosition == 'undefined') {
+            this.config.settings.restorePosition = { enabled: true };
+        }
+        this.store.setConfig(this.config);
+        this.storage = new StorageStore({
+            type: 'session',
+            key: `athos-controller-${this.config.id}`,
+        });
+        if (typeof this.context?.page === 'object' && ['search', 'category'].includes(this.context.page.type)) {
+            this.page = deepmerge(this.page, this.context.page);
+        }
+        this.eventManager.on('beforeSearch', async ({ request }, next) => {
+            // wait for other middleware to resolve
+            await next();
+            const req = request;
+            const query = req.search?.query;
+            if (!query) {
+                const hasCategoryBackgroundFilters = req.filters
+                    ?.filter((filter) => filter.background)
+                    .filter((filter) => {
+                    return BACKGROUND_FILTER_FIELD_MATCHES.find((bgFilter) => {
+                        return filter.field?.toLowerCase().includes(bgFilter);
+                    });
+                })
+                    .filter((filter) => {
+                    return BACKGROUND_FILTERS_VALUE_FLAGS.every((flag) => {
+                        switch (filter.type) {
+                            case 'range':
+                                const rangeFilter = filter;
+                                return rangeFilter.value !== flag;
+                            case 'value':
+                            default:
+                                const valueFilter = filter;
+                                return valueFilter.value !== flag;
+                        }
+                    });
+                });
+                if (hasCategoryBackgroundFilters?.length) {
+                    this.page = deepmerge(this.page, { type: 'category' });
+                }
+            }
+        });
+        // add 'afterSearch' middleware
+        this.eventManager.on('afterSearch', async (search, next) => {
+            const config = search.controller.config;
+            const redirectURL = search.response?.search?.merchandising?.redirect;
+            const searchStore = search.controller.store;
+            if (redirectURL && config?.settings?.redirects?.merchandising && !search?.response?.search?.filters?.length && !searchStore.loaded) {
+                // set loaded to true to prevent infinite search/reloading from happening
+                searchStore.loaded = true;
+                this.track.redirect({ redirectURL, responseId: search.response.search.tracking.responseId });
+                window.location.replace(redirectURL);
+                return false;
+            }
+            await next();
+        });
+        this.eventManager.on('afterStore', async (search, next) => {
+            await next();
+            // get scrollTo positioning and send it to 'restorePosition' event
+            const storableRequestParams = getStorableRequestParams(search.request);
+            const stringyParams = JSON.stringify(storableRequestParams);
+            this.storage.set('lastStringyParams', stringyParams);
+            const scrollMap = this.storage.get('scrollMap') || {};
+            const elementPosition = scrollMap[stringyParams];
+            if (!elementPosition) {
+                // search params have changed - empty the scrollMap
+                this.storage.set('scrollMap', {});
+            }
+            // not awaiting this event as it relies on render, and render is blocked by afterStore event
+            this.eventManager.fire('restorePosition', { controller: this, element: elementPosition });
+        });
+        this.eventManager.on('afterSearch', async (search, next) => {
+            await next();
+            // add hierarchy filter to filter summary
+            const facets = search.response.search.facets;
+            if (facets) {
+                facets.forEach((facet) => {
+                    if (search.response.meta?.facets && facet.field) {
+                        const field = facet.field || '';
+                        const metaFacet = search.response.meta.facets[field];
+                        const dataDelimiter = metaFacet?.hierarchyDelimiter || ' / ';
+                        const filterSettings = this.config?.settings?.filters?.fields
+                            ? this.config?.settings?.filters?.fields[field]
+                            : this.config?.settings?.filters;
+                        const displayDelimiter = filterSettings?.hierarchy?.displayDelimiter ?? ' / '; // choose delimiter for label
+                        const showFullPath = filterSettings?.hierarchy?.showFullPath ?? false; // display full hierarchy path or just the current level
+                        if (filterSettings?.hierarchy?.enabled &&
+                            metaFacet &&
+                            metaFacet.display === 'hierarchy' &&
+                            facet.filtered &&
+                            facet.values?.length > 0) {
+                            const filteredValues = facet.values?.filter((val) => val?.filtered === true);
+                            if (filteredValues && filteredValues.length) {
+                                const filterToAdd = {
+                                    field: facet.field,
+                                    //escape special charactors used in regex
+                                    label: showFullPath
+                                        ? (filteredValues[0].value ?? filteredValues[0].label ?? '').replace(new RegExp(dataDelimiter.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), displayDelimiter)
+                                        : filteredValues[0].label,
+                                    type: 'value',
+                                };
+                                if (search.response.search.filters) {
+                                    search.response.search.filters.push(filterToAdd);
+                                }
+                                else {
+                                    search.response.search.filters = [filterToAdd];
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+        });
+        this.eventManager.on('afterStore', async (search, next) => {
+            await next();
+            const controller = search.controller;
+            const response = search.response.search;
+            if (controller.store.loaded && !controller.store.error) {
+                const config = search.controller.config;
+                const nonBackgroundFilters = search?.request?.filters?.filter((filter) => !filter.background);
+                const singleResultUrl = response?.results?.length && response?.results[0].mappings?.core?.url;
+                if (config?.settings?.redirects?.singleResult &&
+                    response.search?.query &&
+                    response.pagination?.totalResults === 1 &&
+                    !nonBackgroundFilters?.length &&
+                    singleResultUrl) {
+                    window.location.replace(singleResultUrl);
+                    return false;
+                }
+            }
+        });
+        // restore position
+        if (this.config.settings?.restorePosition?.enabled) {
+            this.eventManager.on('restorePosition', async ({ controller, element }, next) => {
+                // attempt to grab the element from storage if it is not provided
+                if (!element?.selector) {
+                    const lastRequest = this.storage.get('lastStringyParams');
+                    if (lastRequest) {
+                        const storableRequestParams = getStorableRequestParams(JSON.parse(lastRequest));
+                        const stringyParams = JSON.stringify(storableRequestParams);
+                        const scrollMap = this.storage.get('scrollMap') || {};
+                        element = scrollMap[stringyParams];
+                    }
+                }
+                const scrollToPosition = () => {
+                    return new Promise(async (resolve) => {
+                        const maxCheckTime = 600;
+                        const checkTime = 60;
+                        const maxScrolls = Math.ceil(maxCheckTime / checkTime);
+                        const maxCheckCount = maxScrolls + 2;
+                        let scrollBackCount = 0;
+                        let checkCount = 0;
+                        let scrolledElem = undefined;
+                        const checkAndScroll = () => {
+                            let offset = element?.domRect?.top || 0;
+                            let elem = document.querySelector(element?.selector);
+                            // for case where the element clicked on has no height
+                            while (elem && !elem.getBoundingClientRect().height) {
+                                elem = elem.parentElement;
+                                // original offset no longer applies since using different element
+                                offset = 0;
+                            }
+                            if (elem) {
+                                const { y } = elem.getBoundingClientRect();
+                                scrollBackCount++;
+                                // if the offset is off, we need to scroll into position (can be caused by lazy loaded images)
+                                if (y > offset + 1 || y < offset - 1) {
+                                    window.scrollBy(0, y - offset);
+                                }
+                                else {
+                                    // don't need to scroll - it is right where we want it
+                                    scrolledElem = elem;
+                                }
+                            }
+                            else {
+                                checkCount++;
+                            }
+                            return true;
+                        };
+                        while (checkAndScroll() && scrollBackCount <= maxScrolls && checkCount <= maxCheckCount) {
+                            await new Promise((resolve) => setTimeout(resolve, checkTime));
+                        }
+                        if (scrolledElem) {
+                            controller.log.debug('restored position to: ', scrolledElem);
+                        }
+                        else {
+                            controller.log.debug('attempted to scroll back to element with selector: ', element?.selector);
+                        }
+                        resolve();
+                    });
+                };
+                if (element)
+                    await scrollToPosition();
+                await next();
+            });
+            // fire restorePosition event on 'pageshow' when setting is enabled
+            if (this.config.settings?.restorePosition?.onPageShow) {
+                window.addEventListener('pageshow', (e) => {
+                    if (e.persisted && this.store.loaded) {
+                        this.eventManager.fire('restorePosition', { controller: this, element: {} });
+                    }
+                });
+            }
+        }
+        // attach config plugins and event middleware
+        this.use(this.config);
+    }
+    get params() {
+        const params = deepmerge({ ...getSearchParams(this.urlManager.state) }, this.config.globals || {});
+        // redirect setting
+        // DUPLICATED LOGIC can be found in infinite backfill (change both if updating)
+        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, sessionId, pageLoadId, shopperId } = this.tracker.getContext();
+        if (userId) {
+            params.tracking.userId = userId;
+        }
+        if (sessionId) {
+            params.tracking.sessionId = sessionId;
+        }
+        if (pageLoadId) {
+            params.tracking.pageLoadId = pageLoadId;
+        }
+        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(',');
+            }
+            if (shopperId) {
+                params.personalization = params.personalization || {};
+                params.personalization.shopper = shopperId;
+            }
+        }
+        return params;
+    }
+}
+export function getStorableRequestParams(request) {
+    return {
+        siteId: request.siteId,
+        sorts: request.sorts,
+        search: {
+            query: {
+                string: request?.search?.query?.string || '',
+            },
+            subQuery: request?.search?.subQuery || '',
+        },
+        filters: request.filters,
+        pagination: request.pagination,
+        facets: request.facets,
+        merchandising: {
+            landingPage: request.merchandising?.landingPage || '',
+        },
+    };
+}
+export function generateHrefSelector(element, href, levels = 7) {
+    let level = 0;
+    let elem = element;
+    while (elem && level <= levels) {
+        let innerHrefElem = null;
+        try {
+            innerHrefElem = elem.querySelector(`[href*="${href}"]`);
+        }
+        catch (e) {
+            try {
+                innerHrefElem = elem.querySelector(cssEscape(`[href*="${href}"]`));
+            }
+            catch { }
+        }
+        if (innerHrefElem) {
+            // innerHrefElem was found! now get selectors up to elem that contained it
+            let selector = '';
+            let parentElem = innerHrefElem;
+            while (parentElem && parentElem != elem.parentElement) {
+                const classNames = parentElem.classList.value.trim().split(' ');
+                // document.querySelector does not appreciate special characters - must escape them
+                const escapedClassSelector = classNames.reduce((classes, classname) => (classname.trim() ? `${classes}.${cssEscape(classname.trim())}` : classes), '');
+                selector = `${parentElem.tagName}${escapedClassSelector}${selector ? ` ${selector}` : ''}`;
+                parentElem = parentElem.parentElement;
+            }
+            return `${selector}[href*="${href}"]`;
+        }
+        elem = elem.parentElement;
+        level++;
+    }
+    return;
+}