@searchspring/snap-preact 0.27.8 → 0.30.0

package/dist/esm/Snap.js

@@ -3,14 +3,14 @@ import deepmerge from 'deepmerge';
 import { isPlainObject } from 'is-plain-object';
 import { render } from 'preact';
 import { Client } from '@searchspring/snap-client';
-import { Logger, LogMode } from '@searchspring/snap-logger';
+import { Logger } from '@searchspring/snap-logger';
 import { Tracker } from '@searchspring/snap-tracker';
-import { version, DomTargeter, url, cookies, featureFlags } from '@searchspring/snap-toolbox';
-import { getContext } from '@searchspring/snap-toolbox';
+import { AppMode, version, getContext, DomTargeter, url, cookies, featureFlags } from '@searchspring/snap-toolbox';
 import { ControllerTypes } from '@searchspring/snap-controller';
 import { default as createSearchController } from './create/createSearchController';
 export const BRANCH_COOKIE = 'ssBranch';
-export const SS_DEV_COOKIE = 'ssDev';
+export const DEV_COOKIE = 'ssDev';
+const SESSION_ATTRIBUTION = 'ssAttribution';
 const COMPONENT_ERROR = `Uncaught Error - Invalid value passed as the component.
 This usually happens when you pass a JSX Element, and not a function that returns the component, in the snap config. 
 		
@@ -47,6 +47,10 @@ This usually happens when you pass a JSX Element, and not a function that return
 The error above happened in the following targeter in the Snap Config`;
 export class Snap {
     constructor(config, services) {
+        this.mode = AppMode.production;
+        this._instantiatorPromises = {};
+        this._controllerPromises = {};
+        this.controllers = {};
         this.getInstantiator = (id) => {
             return this._instantiatorPromises[id] || Promise.reject(`getInstantiator could not find instantiator with id: ${id}`);
         };
@@ -58,12 +62,22 @@ export class Snap {
             controllerIds.forEach((id) => getControllerPromises.push(this.getController(id)));
             return Promise.all(getControllerPromises);
         };
+        // exposed method used for creating controllers dynamically - calls _createController()
         this.createController = async (type, config, services, urlConfig, context, callback) => {
+            if (typeof this._controllerPromises[config.id] != 'undefined') {
+                throw new Error(`Controller with id '${config.id}' is already defined`);
+            }
+            this._controllerPromises[config.id] = new Promise((resolve) => this._createController(type, config, services, urlConfig, context, async (cntrlr) => {
+                if (typeof callback == 'function')
+                    await callback(cntrlr);
+                resolve(cntrlr);
+            }));
+            return this._controllerPromises[config.id];
+        };
+        // internal use method that creates controllers without verifying if id is in use first
+        this._createController = async (type, config, services, urlConfig, context, callback) => {
             let importPromise;
             switch (type) {
-                case ControllerTypes.search:
-                    importPromise = import('./create/createSearchController');
-                    break;
                 case ControllerTypes.autocomplete:
                     importPromise = import('./create/createAutocompleteController');
                     break;
@@ -73,10 +87,17 @@ export class Snap {
                 case ControllerTypes.recommendation:
                     importPromise = import('./create/createRecommendationController');
                     break;
+                case ControllerTypes.search:
+                default:
+                    importPromise = import('./create/createSearchController');
+                    break;
             }
+            // @ts-ignore - we know the config is correct, but complicated typing
             const creationFunc = (await importPromise).default;
             if (!this.controllers[config.id]) {
-                this.controllers[config.id] = creationFunc({
+                window.searchspring.controller = window.searchspring.controller || {};
+                window.searchspring.controller[config.id] = this.controllers[config.id] = creationFunc({
+                    mode: this.mode,
                     url: deepmerge(this.config.url || {}, urlConfig || {}),
                     controller: config,
                     context: deepmerge(this.context || {}, context || {}),
@@ -95,15 +116,42 @@ export class Snap {
             }
             return this.controllers[config.id];
         };
+        this.handlers = {
+            error: (event) => {
+                try {
+                    const { filename } = event;
+                    if (filename.includes('snapui.searchspring.io') && this.tracker.track.error) {
+                        const { colno, lineno, error: { stack }, message, timeStamp, } = event;
+                        const userAgent = navigator.userAgent;
+                        const href = window.location.href;
+                        const beaconPayload = {
+                            userAgent,
+                            href,
+                            filename,
+                            stack,
+                            message,
+                            colno,
+                            lineno,
+                            timeStamp,
+                        };
+                        this.tracker.track.error(beaconPayload);
+                    }
+                }
+                catch (e) {
+                    // prevent error metrics from breaking the app
+                }
+            },
+        };
+        window.removeEventListener('error', this.handlers.error);
+        window.addEventListener('error', this.handlers.error);
         this.config = config;
-        this.logger = services?.logger || new Logger('Snap Preact ');
         let globalContext = {};
         try {
             // get global context
             globalContext = getContext(['shopper', 'config', 'merchandising']);
         }
         catch (err) {
-            this.logger.error('failed to find global context');
+            console.error('Snap failed to find global context');
         }
         // merge configs - but only merge plain objects
         this.config = deepmerge(this.config || {}, globalContext.config || {}, {
@@ -115,8 +163,9 @@ export class Snap {
         if ((!services?.client || !services?.tracker) && !this.config?.client?.globals?.siteId) {
             throw new Error(`Snap: config provided must contain a valid config.client.globals.siteId value`);
         }
-        if (this.context.merchandising?.segments) {
-            if (this.config.client.globals.merchandising) {
+        // segmented merchandising context -> client globals
+        if (this.config.client?.globals && this.context.merchandising?.segments) {
+            if (this.config.client.globals?.merchandising) {
                 this.config.client.globals.merchandising.segments = deepmerge(this.config.client.globals.merchandising.segments, this.context.merchandising.segments);
             }
             else {
@@ -125,33 +174,73 @@ export class Snap {
                 };
             }
         }
-        this.client = services?.client || new Client(this.config.client.globals, this.config.client.config);
-        this.tracker = services?.tracker || new Tracker(this.config.client.globals);
-        this._controllerPromises = {};
-        this._instantiatorPromises = {};
-        this.controllers = {};
-        // TODO environment switch using URL?
-        this.logger.setMode(process.env.NODE_ENV);
-        // log version
-        this.logger.imageText({
-            url: 'https://snapui.searchspring.io/favicon.svg',
-            text: `[${version}]`,
-            style: `color: ${this.logger.colors.indigo}; font-weight: bold;`,
-        });
         try {
             const urlParams = url(window.location.href);
-            const branchParam = urlParams.params?.query?.branch || cookies.get(BRANCH_COOKIE);
-            if (branchParam && !document.querySelector(`script[${BRANCH_COOKIE}]`)) {
-                // set a cookie or localstorage with branch
+            const branchOverride = urlParams?.params?.query?.branch || cookies.get(BRANCH_COOKIE);
+            /* app mode priority:
+                1. node env
+                2. config
+                3. override via query param / cookie
+            */
+            // node env
+            if (process.env.NODE_ENV && Object.values(AppMode).includes(process.env.NODE_ENV)) {
+                this.mode = process.env.NODE_ENV;
+            }
+            // config
+            if (this.config.mode && Object.values(AppMode).includes(this.config.mode)) {
+                this.mode = this.config.mode;
+            }
+            // query param / cookiev override
+            if ((urlParams?.params?.query && 'dev' in urlParams.params.query) || !!cookies.get(DEV_COOKIE)) {
+                if (urlParams?.params.query?.dev == 'false' || urlParams?.params.query?.dev == '0') {
+                    cookies.unset(DEV_COOKIE);
+                    this.mode = AppMode.production;
+                }
+                else {
+                    cookies.set(DEV_COOKIE, '1', 'Lax', 0);
+                    this.mode = AppMode.development;
+                }
+            }
+            // client mode uses client config over snap config
+            if (this.config.client) {
+                this.config.client.config = this.config.client.config || {};
+                this.config.client.config.mode = this.config.client.config.mode || this.mode;
+            }
+            this.client = services?.client || new Client(this.config.client.globals, this.config.client.config);
+            this.tracker = services?.tracker || new Tracker(this.config.client.globals, { framework: 'preact' });
+            this.logger = services?.logger || new Logger({ prefix: 'Snap Preact ', mode: this.mode });
+            // check for tracking attribution in URL ?ss_attribution=type:id
+            const sessionAttribution = window.sessionStorage?.getItem(SESSION_ATTRIBUTION);
+            if (urlParams?.params?.query?.ss_attribution) {
+                const attribution = urlParams.params.query.ss_attribution.split(':');
+                const [type, id] = attribution;
+                if (type && id) {
+                    this.tracker.updateContext('attribution', { type, id });
+                }
+                // save to session storage
+                window.sessionStorage?.setItem(SESSION_ATTRIBUTION, urlParams.params.query.ss_attribution);
+            }
+            else if (sessionAttribution) {
+                const [type, id] = sessionAttribution.split(':');
+                if (type && id) {
+                    this.tracker.updateContext('attribution', { type, id });
+                }
+            }
+            // log version
+            this.logger.imageText({
+                url: 'https://snapui.searchspring.io/favicon.svg',
+                text: `[${version}]`,
+                style: `color: ${this.logger.colors.indigo}; font-weight: bold;`,
+            });
+            if (branchOverride && !document.querySelector(`script[${BRANCH_COOKIE}]`)) {
+                this.logger.warn(`...loading build... '${branchOverride}'`);
+                // set a cookie with branch
                 if (featureFlags.cookies) {
-                    cookies.set(BRANCH_COOKIE, branchParam, 'Lax', 3600000); // 1 hour
-                    cookies.set(SS_DEV_COOKIE, '1', 'Lax', 0);
+                    cookies.set(BRANCH_COOKIE, branchOverride, 'Lax', 3600000); // 1 hour
                 }
                 else {
                     this.logger.warn('Cookies are not supported/enabled by this browser, branch overrides will not persist!');
                 }
-                this.logger.setMode(LogMode.DEVELOPMENT);
-                this.logger.warn(`...loading build... '${branchParam}'`);
                 // get the path and siteId from the current bundle script in case its not the same as the client config
                 let path = `https://snapui.searchspring.io/${this.config.client.globals.siteId}/`;
                 const script = document.querySelector('script[src*="//snapui.searchspring.io"]');
@@ -163,10 +252,9 @@ export class Snap {
                 }
                 // append script with new branch in path
                 const branchScript = document.createElement('script');
-                const src = `${path}${branchParam}/bundle.js`;
+                const src = `${path}${branchOverride}/bundle.js`;
                 branchScript.src = src;
-                branchScript.setAttribute(BRANCH_COOKIE, branchParam);
-                document.head.appendChild(branchScript);
+                branchScript.setAttribute(BRANCH_COOKIE, branchOverride);
                 new DomTargeter([
                     {
                         selector: 'body',
@@ -180,32 +268,43 @@ export class Snap {
                         },
                     },
                 ], async (target, elem) => {
-                    let bundleDetails, error;
+                    const props = {};
                     try {
                         const getBundleDetails = (await import('./getBundleDetails/getBundleDetails')).getBundleDetails;
-                        bundleDetails = await getBundleDetails(src);
+                        props.details = await getBundleDetails(src);
                     }
                     catch (err) {
-                        error = err;
+                        props.error = err;
                     }
                     const BranchOverride = (await import('./components/BranchOverride')).BranchOverride;
-                    render(_jsx(BranchOverride, { name: branchParam, details: bundleDetails, error: error, onRemoveClick: () => {
+                    render(_jsx(BranchOverride, { ...props, name: branchOverride, onRemoveClick: () => {
                             cookies.unset(BRANCH_COOKIE);
                             const urlState = url(window.location.href);
-                            delete urlState.params.query['branch'];
-                            window.location.href = urlState.url();
+                            delete urlState?.params.query['branch'];
+                            const newUrl = urlState?.url();
+                            if (newUrl && newUrl != window.location.href) {
+                                window.location.href = newUrl;
+                            }
+                            else {
+                                window.location.reload();
+                            }
                         } }), elem);
+                    // reset the global searchspring object
+                    delete window.searchspring;
+                    document.head.appendChild(branchScript);
                 });
                 // prevent further instantiation of config
                 return;
             }
         }
-        catch (e) { }
-        if (window.searchspring) {
-            window.searchspring.context = this.context;
-            if (this.client)
-                window.searchspring.client = this.client;
+        catch (e) {
+            this.logger.error(e);
         }
+        // bind to window global
+        window.searchspring = window.searchspring || {};
+        window.searchspring.context = this.context;
+        if (this.client)
+            window.searchspring.client = this.client;
         // autotrack shopper id from the context
         if (this.context?.shopper?.id) {
             this.tracker.track.shopper.login({
@@ -216,7 +315,7 @@ export class Snap {
         if (this.context?.shopper?.cart) {
             const cart = this.context.shopper.cart;
             if (Array.isArray(cart)) {
-                const cartItems = cart.filter((item) => item?.sku || item?.childSku).map((item) => (item?.sku || item?.childSku).trim());
+                const cartItems = cart.filter((item) => item?.sku || item?.childSku).map((item) => (item?.sku || item?.childSku || '').trim());
                 this.tracker.cookies.cart.set(cartItems);
             }
         }
@@ -225,7 +324,12 @@ export class Snap {
                 case 'search': {
                     this.config.controllers[type].forEach((controller, index) => {
                         try {
+                            if (typeof this._controllerPromises[controller.config.id] != 'undefined') {
+                                this.logger.error(`Controller with id '${controller.config.id}' is already defined`);
+                                return;
+                            }
                             const cntrlr = createSearchController({
+                                mode: this.mode,
                                 url: deepmerge(this.config.url || {}, controller.url || {}),
                                 controller: controller.config,
                                 context: deepmerge(this.context || {}, controller.context || {}),
@@ -238,7 +342,8 @@ export class Snap {
                                 logger: controller.services?.logger,
                                 tracker: controller.services?.tracker || this.tracker,
                             });
-                            this.controllers[cntrlr.config.id] = cntrlr;
+                            window.searchspring.controller = window.searchspring.controller || {};
+                            window.searchspring.controller[cntrlr.config.id] = this.controllers[cntrlr.config.id] = cntrlr;
                             this._controllerPromises[cntrlr.config.id] = new Promise((resolve) => resolve(cntrlr));
                             let searched = false;
                             const runSearch = () => {
@@ -272,7 +377,7 @@ export class Snap {
                                     runSearch();
                                 }
                                 cntrlr.createTargeter({ controller: cntrlr, ...target }, async (target, elem, originalElem) => {
-                                    if (target.skeleton) {
+                                    if (target && target.skeleton && elem) {
                                         const Skeleton = await target.skeleton();
                                         setTimeout(() => {
                                             render(_jsx(Skeleton, {}), elem);
@@ -290,6 +395,10 @@ export class Snap {
                 }
                 case 'autocomplete': {
                     this.config.controllers[type].forEach((controller, index) => {
+                        if (typeof this._controllerPromises[controller.config.id] != 'undefined') {
+                            this.logger.error(`Controller with id '${controller.config.id}' is already defined`);
+                            return;
+                        }
                         this._controllerPromises[controller.config.id] = new Promise((resolve) => {
                             try {
                                 let bound = false;
@@ -315,8 +424,9 @@ export class Snap {
                                     }
                                 };
                                 if (!controller?.targeters || controller?.targeters.length === 0) {
-                                    this.createController(ControllerTypes.autocomplete, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
-                                        resolve(cntrlr);
+                                    this._createController(ControllerTypes.autocomplete, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
+                                        if (cntrlr)
+                                            resolve(cntrlr);
                                     });
                                 }
                                 controller?.targeters?.forEach((target, target_index) => {
@@ -342,8 +452,9 @@ export class Snap {
                                             ...target,
                                         },
                                     ], async (target, elem, originalElem) => {
-                                        const cntrlr = await this.createController(ControllerTypes.autocomplete, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
-                                            resolve(cntrlr);
+                                        const cntrlr = await this._createController(ControllerTypes.autocomplete, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
+                                            if (cntrlr)
+                                                resolve(cntrlr);
                                         });
                                         runBind();
                                         targetFunction({ controller: cntrlr, ...target }, elem, originalElem);
@@ -360,6 +471,10 @@ export class Snap {
                 }
                 case 'finder': {
                     this.config.controllers[type].forEach((controller, index) => {
+                        if (typeof this._controllerPromises[controller.config.id] != 'undefined') {
+                            this.logger.error(`Controller with id '${controller.config.id}' is already defined`);
+                            return;
+                        }
                         this._controllerPromises[controller.config.id] = new Promise((resolve) => {
                             try {
                                 let searched = false;
@@ -383,8 +498,9 @@ export class Snap {
                                     }
                                 };
                                 if (!controller?.targeters || controller?.targeters.length === 0) {
-                                    this.createController(ControllerTypes.finder, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
-                                        resolve(cntrlr);
+                                    this._createController(ControllerTypes.finder, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
+                                        if (cntrlr)
+                                            resolve(cntrlr);
                                     });
                                 }
                                 controller?.targeters?.forEach((target, target_index) => {
@@ -395,8 +511,9 @@ export class Snap {
                                         throw new Error(`Targets at index ${target_index} missing component value (Component).`);
                                     }
                                     const targeter = new DomTargeter([{ ...target }], async (target, elem, originalElem) => {
-                                        const cntrlr = await this.createController(ControllerTypes.finder, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
-                                            resolve(cntrlr);
+                                        const cntrlr = await this._createController(ControllerTypes.finder, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
+                                            if (cntrlr)
+                                                resolve(cntrlr);
                                         });
                                         runSearch();
                                         targetFunction({ controller: cntrlr, ...target }, elem, originalElem);
@@ -413,6 +530,10 @@ export class Snap {
                 }
                 case 'recommendation': {
                     this.config.controllers[type].forEach((controller, index) => {
+                        if (typeof this._controllerPromises[controller.config.id] != 'undefined') {
+                            this.logger.error(`Controller with id '${controller.config.id}' is already defined`);
+                            return;
+                        }
                         this._controllerPromises[controller.config.id] = new Promise((resolve) => {
                             try {
                                 let searched = false;
@@ -436,8 +557,9 @@ export class Snap {
                                     }
                                 };
                                 if (!controller?.targeters || controller?.targeters.length === 0) {
-                                    this.createController(ControllerTypes.recommendation, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
-                                        resolve(cntrlr);
+                                    this._createController(ControllerTypes.recommendation, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
+                                        if (cntrlr)
+                                            resolve(cntrlr);
                                     });
                                 }
                                 controller?.targeters?.forEach((target, target_index) => {
@@ -448,8 +570,9 @@ export class Snap {
                                         throw new Error(`Targets at index ${target_index} missing component value (Component).`);
                                     }
                                     const targeter = new DomTargeter([{ ...target }], async (target, elem, originalElem) => {
-                                        const cntrlr = await this.createController(ControllerTypes.recommendation, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
-                                            resolve(cntrlr);
+                                        const cntrlr = await this._createController(ControllerTypes.recommendation, controller.config, controller.services, controller.url, controller.context, (cntrlr) => {
+                                            if (cntrlr)
+                                                resolve(cntrlr);
                                         });
                                         runSearch();
                                         targetFunction({ controller: cntrlr, ...target }, elem, originalElem);
@@ -469,6 +592,7 @@ export class Snap {
         if (this.config?.instantiators?.recommendation) {
             try {
                 this._instantiatorPromises.recommendation = import('./Instantiators/RecommendationInstantiator').then(({ RecommendationInstantiator }) => {
+                    this.config.instantiators.recommendation.mode = this.config.instantiators.recommendation.mode || this.mode;
                     return new RecommendationInstantiator(this.config.instantiators.recommendation, {
                         client: this.client,
                         tracker: this.tracker,

package/dist/esm/create/createAutocompleteController.d.ts

@@ -1,5 +1,5 @@
 import { AutocompleteController } from '@searchspring/snap-controller';
 import type { SnapControllerServices, SnapAutocompleteControllerConfig } from '../types';
-declare const _default: (config: SnapAutocompleteControllerConfig, services?: SnapControllerServices) => AutocompleteController;
+declare const _default: (config: SnapAutocompleteControllerConfig, services?: SnapControllerServices | undefined) => AutocompleteController;
 export default _default;
 //# sourceMappingURL=createAutocompleteController.d.ts.map

package/dist/esm/create/createAutocompleteController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createAutocompleteController.d.ts","sourceRoot":"","sources":["../../../src/create/createAutocompleteController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AASvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,gCAAgC,EAAE,MAAM,UAAU,CAAC;iCAIjE,gCAAgC,aAAa,sBAAsB,KAAG,sBAAsB;AAApH,wBAkBE"}
+{"version":3,"file":"createAutocompleteController.d.ts","sourceRoot":"","sources":["../../../src/create/createAutocompleteController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AASvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,gCAAgC,EAAE,MAAM,UAAU,CAAC;iCAIjE,gCAAgC,oDAAsC,sBAAsB;AAApH,wBAwBE"}

package/dist/esm/create/createAutocompleteController.js

@@ -10,13 +10,18 @@ import { Tracker } from '@searchspring/snap-tracker';
 configureMobx({ useProxies: 'never' });
 export default (config, services) => {
     const urlManager = (services?.urlManager || new UrlManager(new UrlTranslator(config.url), reactLinker)).detach();
+    // set client mode
+    if (config.mode && config.client) {
+        config.client.config = config.client.config || {};
+        config.client.config.mode = config.mode;
+    }
     const cntrlr = new AutocompleteController(config.controller, {
         client: services?.client || new Client(config.client.globals, config.client.config),
         store: services?.store || new AutocompleteStore(config.controller, { urlManager }),
         urlManager,
         eventManager: services?.eventManager || new EventManager(),
         profiler: services?.profiler || new Profiler(),
-        logger: services?.logger || new Logger(),
+        logger: services?.logger || new Logger({ mode: config.mode }),
         tracker: services?.tracker || new Tracker(config.client.globals),
     }, config.context);
     return cntrlr;

package/dist/esm/create/createFinderController.d.ts

@@ -1,5 +1,5 @@
 import { FinderController } from '@searchspring/snap-controller';
 import type { SnapControllerServices, SnapFinderControllerConfig } from '../types';
-declare const _default: (config: SnapFinderControllerConfig, services?: SnapControllerServices) => FinderController;
+declare const _default: (config: SnapFinderControllerConfig, services?: SnapControllerServices | undefined) => FinderController;
 export default _default;
 //# sourceMappingURL=createFinderController.d.ts.map

package/dist/esm/create/createFinderController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createFinderController.d.ts","sourceRoot":"","sources":["../../../src/create/createFinderController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AASjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;iCAI3D,0BAA0B,aAAa,sBAAsB,KAAG,gBAAgB;AAAxG,wBAkBE"}
+{"version":3,"file":"createFinderController.d.ts","sourceRoot":"","sources":["../../../src/create/createFinderController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AASjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;iCAI3D,0BAA0B,oDAAsC,gBAAgB;AAAxG,wBAwBE"}

package/dist/esm/create/createFinderController.js

@@ -10,13 +10,18 @@ import { Tracker } from '@searchspring/snap-tracker';
 configureMobx({ useProxies: 'never' });
 export default (config, services) => {
     const urlManager = (services?.urlManager || new UrlManager(new UrlTranslator(config.url), reactLinker)).detach(true);
+    // set client mode
+    if (config.mode && config.client) {
+        config.client.config = config.client.config || {};
+        config.client.config.mode = config.mode;
+    }
     const cntrlr = new FinderController(config.controller, {
         client: services?.client || new Client(config.client.globals, config.client.config),
         store: services?.store || new FinderStore(config.controller, { urlManager }),
         urlManager,
         eventManager: services?.eventManager || new EventManager(),
         profiler: services?.profiler || new Profiler(),
-        logger: services?.logger || new Logger(),
+        logger: services?.logger || new Logger({ mode: config.mode }),
         tracker: services?.tracker || new Tracker(config.client.globals),
     }, config.context);
     return cntrlr;

package/dist/esm/create/createRecommendationController.d.ts

@@ -1,5 +1,5 @@
 import { RecommendationController } from '@searchspring/snap-controller';
 import type { SnapControllerServices, SnapRecommendationControllerConfig } from '../types';
-declare const _default: (config: SnapRecommendationControllerConfig, services?: SnapControllerServices) => RecommendationController;
+declare const _default: (config: SnapRecommendationControllerConfig, services?: SnapControllerServices | undefined) => RecommendationController;
 export default _default;
 //# sourceMappingURL=createRecommendationController.d.ts.map

package/dist/esm/create/createRecommendationController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createRecommendationController.d.ts","sourceRoot":"","sources":["../../../src/create/createRecommendationController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AASzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,kCAAkC,EAAE,MAAM,UAAU,CAAC;iCAInE,kCAAkC,aAAa,sBAAsB,KAAG,wBAAwB;AAAxH,wBAiBE"}
+{"version":3,"file":"createRecommendationController.d.ts","sourceRoot":"","sources":["../../../src/create/createRecommendationController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AASzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,kCAAkC,EAAE,MAAM,UAAU,CAAC;iCAInE,kCAAkC,oDAAsC,wBAAwB;AAAxH,wBAwBE"}

package/dist/esm/create/createRecommendationController.js

@@ -10,13 +10,18 @@ import { Tracker } from '@searchspring/snap-tracker';
 configureMobx({ useProxies: 'never' });
 export default (config, services) => {
     const urlManager = (services?.urlManager || new UrlManager(new UrlTranslator(config.url), reactLinker)).detach(true);
+    // set client mode
+    if (config.mode && config.client) {
+        config.client.config = config.client.config || {};
+        config.client.config.mode = config.mode;
+    }
     const cntrlr = new RecommendationController(config.controller, {
         client: services?.client || new Client(config.client.globals, config.client.config),
         store: services?.store || new RecommendationStore(config.controller, { urlManager }),
         urlManager,
         eventManager: services?.eventManager || new EventManager(),
         profiler: services?.profiler || new Profiler(),
-        logger: services?.logger || new Logger(),
+        logger: services?.logger || new Logger({ mode: config.mode }),
         tracker: services?.tracker || new Tracker(config.client.globals),
     }, config.context);
     return cntrlr;

package/dist/esm/create/createSearchController.d.ts

@@ -1,5 +1,5 @@
 import { SearchController } from '@searchspring/snap-controller';
 import type { SnapControllerServices, SnapSearchControllerConfig } from '../types';
-declare const _default: (config: SnapSearchControllerConfig, services?: SnapControllerServices) => SearchController;
+declare const _default: (config: SnapSearchControllerConfig, services?: SnapControllerServices | undefined) => SearchController;
 export default _default;
 //# sourceMappingURL=createSearchController.d.ts.map

package/dist/esm/create/createSearchController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createSearchController.d.ts","sourceRoot":"","sources":["../../../src/create/createSearchController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAQjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;iCAI3D,0BAA0B,aAAa,sBAAsB,KAAG,gBAAgB;AAAxG,wBAkBE"}
+{"version":3,"file":"createSearchController.d.ts","sourceRoot":"","sources":["../../../src/create/createSearchController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAQjE,OAAO,KAAK,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;iCAI3D,0BAA0B,oDAAsC,gBAAgB;AAAxG,wBAwBE"}

package/dist/esm/create/createSearchController.js

@@ -10,13 +10,18 @@ import { Tracker } from '@searchspring/snap-tracker';
 configureMobx({ useProxies: 'never' });
 export default (config, services) => {
     const urlManager = services?.urlManager || new UrlManager(new UrlTranslator(config.url), reactLinker);
+    // set client mode
+    if (config.mode && config.client) {
+        config.client.config = config.client.config || {};
+        config.client.config.mode = config.mode;
+    }
     const cntrlr = new SearchController(config.controller, {
         client: services?.client || new Client(config.client.globals, config.client.config),
         store: services?.store || new SearchStore(config.controller, { urlManager }),
         urlManager,
         eventManager: services?.eventManager || new EventManager(),
         profiler: services?.profiler || new Profiler(),
-        logger: services?.logger || new Logger(),
+        logger: services?.logger || new Logger({ mode: config.mode }),
         tracker: services?.tracker || new Tracker(config.client.globals),
     }, config.context);
     return cntrlr;

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

@@ -1 +1 @@
-{"version":3,"file":"getBundleDetails.d.ts","sourceRoot":"","sources":["../../../src/getBundleDetails/getBundleDetails.ts"],"names":[],"mappings":"AAAA,aAAK,aAAa,GAAG;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAe,MAAM,KAAG,QAAQ,aAAa,CAuBzE,CAAC"}
+{"version":3,"file":"getBundleDetails.d.ts","sourceRoot":"","sources":["../../../src/getBundleDetails/getBundleDetails.ts"],"names":[],"mappings":"AAAA,aAAK,aAAa,GAAG;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAe,MAAM,KAAG,QAAQ,aAAa,CAyBzE,CAAC"}

package/dist/esm/getBundleDetails/getBundleDetails.js

@@ -5,10 +5,11 @@ export const getBundleDetails = async (url) => {
         request.onreadystatechange = () => {
             if (request.readyState === request.DONE) {
                 const status = request.status;
-                if (status === 0 || (status >= 200 && status < 400)) {
+                const lastModified = request.getResponseHeader('Last-Modified');
+                if ((lastModified && status === 0) || (status >= 200 && status < 400)) {
                     resolve({
                         url,
-                        lastModified: request.getResponseHeader('Last-Modified').split(',')[1].trim(),
+                        lastModified: lastModified.split(',')[1].trim(),
                     });
                 }
                 else {