@searchspring/snap-preact 0.20.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Searchspring
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,293 @@
+# Snap Preact
+
+<a href="https://www.npmjs.com/package/@searchspring/snap-preact"><img alt="NPM Status" src="https://img.shields.io/npm/v/@searchspring/snap-preact.svg?style=flat"></a>
+
+Snap Preact is an abstraction layer that provides a config based interface for creating a Searchspring integration quickly.
+
+
+## Installation
+
+To install the `snap-preact` package and it's dependencies:
+
+```bash
+npm install --save @searchspring/snap-preact
+```
+
+## Instantiation
+
+```typescript
+import { Snap } from '@searchspring/snap-preact';
+
+const snap = new Snap(config);
+```
+
+## Configuration
+A configuration object provided to Snap will determin the services that will be created. 
+
+Full example:
+
+```typescript
+const config = {
+	url: {
+		parameters: {
+			core: {
+				query: { name: 'search' },
+			},
+		},
+	},
+	client: {
+		globals: {
+			siteId: 'xxxxxx',
+		},
+	},
+	controllers: {
+		search: [
+			{
+				config: {
+					id: 'search',
+					settings: {
+						redirects: {
+							merchandising: false,
+						},
+					},
+				},
+				targets: [
+					{
+						selector: '#searchspring-content',
+						component: () => Content,
+						hideTarget: true,
+					},
+					{
+						selector: '#searchspring-sidebar',
+						component: () => Sidebar,
+						hideTarget: true,
+					},
+				],
+			},
+		],
+		autocomplete: [
+			{
+				config: {
+					id: 'autocomplete',
+					selector: 'input.searchspring-ac',
+					settings: {
+						trending: {
+							limit: 5,
+						},
+					},
+				},
+				targets: [
+					{
+						selector: 'input.searchspring-ac',
+						component: () => Autocomplete,
+						hideTarget: true,
+					},
+				],
+			},
+		],
+	},
+};
+```
+
+### config.client
+A single client instance will be created and shared across all services using the provided config. 
+
+See [@searchspring/snap-client](https://github.com/searchspring/snap/tree/main/packages/snap-client) documentation for full client config options.
+
+```typescript
+const config = {
+	client: {
+		globals: {
+			siteId: 'xxxxxx'
+		}
+	}
+}
+```
+
+### config.instantiators
+The `instantiators` object must be defined if any Recommendation controllers have also been defined via `config.controllers.recommendation`
+
+```typescript
+const config = {
+	instantiators: {
+		recommendation: {
+			components: {
+				Standard: () => Standard
+			},
+			config: {
+				branch: BRANCHNAME,
+				batched: true
+			},
+			selector: '',
+			services: {}
+		}
+	},
+	controllers: {
+		recommendation: []
+	}
+}
+```
+
+`recommendation.components` - required mapping of recommendation components.
+
+`recommendation.config.branch` - required current git branch name. Defined via webpack during bundle build:
+
+```typescript
+const webpack = require('webpack');
+const childProcess = require('child_process');
+const branchName = childProcess.execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+
+module.exports = {
+	plugins: [
+		new webpack.DefinePlugin({
+			BRANCHNAME: `"${branchName}"`,
+		}),
+	],
+}
+```
+
+`recommendation.config.batched` - optional boolean (default: `true`) to batch multiple recommendations into a single network request
+
+`recommendation.selector` - optional selector to target recommendation instances if using a non-standard installation. Default selector: `script[type="searchspring/recommend"]`
+
+`recommendation.services` - optional object of `ControllerServices` 
+
+
+
+### config.url
+The `url` object contains the config provided to each [`UrlTranslator`](https://github.com/searchspring/snap/tree/main/packages/snap-url-manager/src/Translators/Url) created by Snap Preact.
+
+```typescript
+const config = {
+	url: {
+		parameters: {
+			core: {
+				query: { name: 'search' },
+				page: { name: 'p' }
+			},
+		},
+	},
+}
+```
+
+### config.controllers
+The `controllers` object contains a list of controllers to create for each controller type. 
+
+Available controllers:
+
+- [SearchController](https://github.com/searchspring/snap/tree/main/packages/snap-controller/src/Search) 
+- [AutocompleteController](https://github.com/searchspring/snap/tree/main/packages/snap-controller/src/Autocomplete)
+- [FinderController](https://github.com/searchspring/snap/tree/main/packages/snap-controller/src/Finder)
+- [RecommendationController](https://github.com/searchspring/snap/tree/main/packages/snap-controller/src/Recommendation)
+
+```typescript
+const config = {
+	controllers: {
+		search: [],
+		autocomplete: [],
+		finder: [],
+		recommendation: [],
+	}
+}
+```
+
+Each array entry contains an object with the following properties:
+
+`config` - required controller config for the corresponding controller. See Controller specific documentation for all available configuration options.
+
+`targets` - optional array of Target objects. Targets thats have been found will have the corresponding controller provided to the target component `controller` prop and the controller's `search` method invoked.
+
+```typescript
+type ExtendedTarget = {
+	selector: string;
+	inject?: {
+		action: 'before' | 'after' | 'append' | 'prepend' | 'replace';
+		element: Element | ((target: Target, element: Element) => Element);
+	};
+	hideTarget?: boolean;
+	emptyTarget?: boolean;
+	name?: string;
+	component?: () => Promise<RootComponent> | RootComponent;
+	props?: unknown;  // additional props to pass to the component
+	onTarget?: OnTarget;  // additional scripts to execute when target is found
+	prefetch?: boolean;  // run controller search before finding targets
+}
+```
+
+`services` - optional object of `ControllerServices` to be used for this controller in place of the default services
+
+`url` - optional `UrlTranslator` config object to be used with the `UrlManager` for this controller
+
+
+An example creating a SearchController:
+
+```typescript
+const config = {
+	controllers: {
+		search: [
+			{
+				config: {
+					id: 'search',
+				},
+				targets: [
+					{
+						selector: '#searchspring-content',
+						component: () => Content,
+						hideTarget: true,
+					},
+					{
+						selector: '#searchspring-sidebar',
+						component: () => Sidebar,
+						hideTarget: true,
+					},
+				],
+				services: {}
+			}
+		]
+	}
+}
+```
+The controller config `id` will be the name of the controller that you will then interface from the return of creating the `new Snap()` instance via the `controllers` object. 
+
+For example, if using the `config` example above:
+
+```typescript
+const snap = new Snap(config);
+const { search } = snap.controllers;
+```
+
+## properties
+
+After instantiating an instance of Snap, the following properties can be accessed. 
+
+### config
+A reference to the config that was provided.
+
+### logger
+A reference to the shared [@searchspring/snap-logger](https://github.com/searchspring/snap/tree/main/packages/snap-logger) instance used by each controller.
+
+### client
+A reference to the shared [@searchspring/snap-client](https://github.com/searchspring/snap/tree/main/packages/snap-client) instance used by each controller.
+
+### tracker
+A reference to the shared [@searchspring/snap-tracker](https://github.com/searchspring/snap/tree/main/packages/snap-tracker) instance used by each controller.
+
+### controllers
+An object containing all controllers that have been created. 
+
+
+### recommendations
+A reference to `RecommendationInstantiator` instance if creating recommendation instances.
+
+
+## polyfills
+
+Snap Preact provides various polyfills to ensure legacy browser support.
+
+```typescript
+import { polyfills } from '@searchspring/snap-preact';
+
+polyfills.then(() => {
+	import('./index');
+})
+```

package/dist/cjs/Instantiators/RecommendationInstantiator.d.ts

@@ -0,0 +1,49 @@
+import { DomTargeter } from '@searchspring/snap-toolbox';
+import type { Logger } from '@searchspring/snap-logger';
+import type { UrlTranslatorConfig } from '@searchspring/snap-url-manager';
+import type { Client } from '@searchspring/snap-client';
+import type { Tracker } from '@searchspring/snap-tracker';
+import type { AbstractController, RecommendationController, Attachments } from '@searchspring/snap-controller';
+import type { Middleware } from '@searchspring/snap-event-manager';
+import type { SnapControllerServices, RootComponent } from '../types';
+export declare type RecommendationInstantiatorConfig = {
+    components: {
+        [name: string]: () => Promise<RootComponent> | RootComponent;
+    };
+    config: {
+        branch: string;
+        realtime?: boolean;
+        batched?: boolean;
+    } & Attachments;
+    selector?: string;
+    services?: SnapControllerServices;
+    url?: UrlTranslatorConfig;
+};
+export declare type RecommendationInstantiatorServices = {
+    client: Client;
+    logger: Logger;
+    tracker: Tracker;
+};
+export declare class RecommendationInstantiator {
+    controllers: {
+        [key: string]: RecommendationController;
+    };
+    client: Client;
+    tracker: Tracker;
+    logger: Logger;
+    config: RecommendationInstantiatorConfig;
+    uses: Attachments[];
+    plugins: {
+        (cntrlr: AbstractController): Promise<void>;
+    }[];
+    middleware: {
+        event: string;
+        func: Middleware<unknown>[];
+    }[];
+    targeter: DomTargeter;
+    constructor(config: RecommendationInstantiatorConfig, { client, logger, tracker }: RecommendationInstantiatorServices);
+    plugin(func: (cntrlr: AbstractController) => Promise<void>): void;
+    on<T>(event: string, ...func: Middleware<T>[]): void;
+    use(attachments: Attachments): void;
+}
+//# sourceMappingURL=RecommendationInstantiator.d.ts.map

package/dist/cjs/Instantiators/RecommendationInstantiator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecommendationInstantiator.d.ts","sourceRoot":"","sources":["../../../src/Instantiators/RecommendationInstantiator.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAc,MAAM,4BAA4B,CAAC;AAErE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC/G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEtE,oBAAY,gCAAgC,GAAG;IAC9C,UAAU,EAAE;QACX,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,OAAO,CAAC,aAAa,CAAC,GAAG,aAAa,CAAC;KAC7D,CAAC;IACF,MAAM,EAAE;QACP,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,OAAO,CAAC,EAAE,OAAO,CAAC;KAClB,GAAG,WAAW,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAClC,GAAG,CAAC,EAAE,mBAAmB,CAAC;CAC1B,CAAC;AAEF,oBAAY,kCAAkC,GAAG;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,qBAAa,0BAA0B;IACtC,WAAW,EAAE;QACZ,CAAC,GAAG,EAAE,MAAM,GAAG,wBAAwB,CAAC;KACxC,CAAM;IACP,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,gCAAgC,CAAC;IACzC,IAAI,EAAE,WAAW,EAAE,CAAM;IACzB,OAAO,EAAE;QAAE,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,EAAE,CAAM;IAChE,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,CAAA;KAAE,EAAE,CAAM;IAC3D,QAAQ,EAAE,WAAW,CAAC;gBAEjB,MAAM,EAAE,gCAAgC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,kCAAkC;IA8I9G,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAIjE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI;IAIpD,GAAG,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;CAG1C"}

package/dist/cjs/Instantiators/RecommendationInstantiator.js

@@ -0,0 +1,226 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecommendationInstantiator = void 0;
+var jsx_runtime_1 = require("preact/jsx-runtime");
+var preact_1 = require("preact");
+var snap_toolbox_1 = require("@searchspring/snap-toolbox");
+var RecommendationInstantiator = /** @class */ (function () {
+    function RecommendationInstantiator(config, _a) {
+        var _this = this;
+        var client = _a.client, logger = _a.logger, tracker = _a.tracker;
+        var _b;
+        this.controllers = {};
+        this.uses = [];
+        this.plugins = [];
+        this.middleware = [];
+        this.config = config;
+        if (!this.config) {
+            throw new Error("Recommendation Instantiator config is required");
+        }
+        if (!((_b = this.config.config) === null || _b === void 0 ? void 0 : _b.branch)) {
+            throw new Error("Recommendation Instantiator config must contain 'branch' property");
+        }
+        if (!this.config.components || typeof this.config.components != 'object') {
+            throw new Error("Recommendation Instantiator config must contain 'components' mapping property");
+        }
+        this.client = client;
+        this.tracker = tracker;
+        this.logger = logger;
+        var profileCount = {};
+        this.targeter = new snap_toolbox_1.DomTargeter([
+            {
+                selector: "script[type=\"searchspring/recommend\"], script[type=\"searchspring/personalized-recommendations\"]".concat(this.config.selector ? " , ".concat(this.config.selector) : ''),
+                inject: {
+                    action: 'before',
+                    element: function (target, origElement) {
+                        var profile = origElement.getAttribute('profile');
+                        if (profile) {
+                            var recsContainer = document.createElement('div');
+                            recsContainer.setAttribute('searchspring-recommend', profile);
+                            return recsContainer;
+                        }
+                        else {
+                            _this.logger.warn("'profile' attribute is missing from <script> tag, skipping this profile", origElement);
+                        }
+                    },
+                },
+            },
+        ], function (target, injectedElem, elem) { return __awaiter(_this, void 0, void 0, function () {
+            var globals, _a, shopper, shopperId, product, seed, options, tag, controllerConfig, createRecommendationController, client, tracker, recs, profileVars, component, RecommendationsComponent, _b;
+            var _c, _d, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        globals = {};
+                        _a = (0, snap_toolbox_1.getContext)(['shopperId', 'shopper', 'product', 'seed', 'options'], elem), shopper = _a.shopper, shopperId = _a.shopperId, product = _a.product, seed = _a.seed, options = _a.options;
+                        /*
+                            type instantiatorContext = {
+                                shopper?: string;
+                                shopperId?: string;
+                                product?: string;
+                                seed?: string;
+                                options?: {
+                                    siteId?: string;
+                                    branch?: string;
+                                    batched?: boolean;
+                                    realtime?: boolean;
+                                    categories?: any;
+                                }
+                            }
+                        */
+                        if (shopper || shopperId) {
+                            globals.shopper = shopper || shopperId;
+                        }
+                        if (product || seed) {
+                            globals.product = product || seed;
+                        }
+                        if (options === null || options === void 0 ? void 0 : options.branch) {
+                            globals.branch = options.branch;
+                        }
+                        if (options === null || options === void 0 ? void 0 : options.siteId) {
+                            globals.siteId = options.siteId;
+                        }
+                        if (options === null || options === void 0 ? void 0 : options.categories) {
+                            globals.categories = options.categories;
+                        }
+                        tag = injectedElem.getAttribute('searchspring-recommend');
+                        profileCount[tag] = profileCount[tag] + 1 || 1;
+                        controllerConfig = __assign({ id: "recommend_".concat(tag + (profileCount[tag] - 1)), tag: tag, batched: (_c = options === null || options === void 0 ? void 0 : options.batched) !== null && _c !== void 0 ? _c : true, realtime: Boolean(options === null || options === void 0 ? void 0 : options.realtime), globals: globals }, this.config.config);
+                        return [4 /*yield*/, Promise.resolve().then(function () { return __importStar(require('../create/createRecommendationController')); })];
+                    case 1:
+                        createRecommendationController = (_g.sent()).default;
+                        client = ((_d = this.config.services) === null || _d === void 0 ? void 0 : _d.client) || this.client;
+                        tracker = ((_e = this.config.services) === null || _e === void 0 ? void 0 : _e.tracker) || this.tracker;
+                        recs = createRecommendationController({
+                            url: this.config.url || {},
+                            controller: controllerConfig,
+                        }, { client: client, tracker: tracker });
+                        this.uses.forEach(function (attachements) { return recs.use(attachements); });
+                        this.plugins.forEach(function (plugin) { return recs.plugin(plugin); });
+                        this.middleware.forEach(function (middleware) { return recs.on.apply(recs, __spreadArray([middleware.event], middleware.func, false)); });
+                        return [4 /*yield*/, recs.search()];
+                    case 2:
+                        _g.sent();
+                        recs.addTargeter(this.targeter);
+                        this.controllers[recs.config.id] = recs;
+                        profileVars = recs.store.profile.display.templateParameters;
+                        component = (_f = recs.store.profile.display.template) === null || _f === void 0 ? void 0 : _f.component;
+                        if (!profileVars) {
+                            recs.log.error("profile failed to load!");
+                            return [2 /*return*/];
+                        }
+                        if (!component) {
+                            recs.log.error("template does not support components!");
+                            return [2 /*return*/];
+                        }
+                        _b = this.config.components;
+                        if (!_b) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.config.components[component]()];
+                    case 3:
+                        _b = (_g.sent());
+                        _g.label = 4;
+                    case 4:
+                        RecommendationsComponent = _b;
+                        if (!RecommendationsComponent) {
+                            recs.log.error("component '".concat(profileVars.component, "' not found!"));
+                            return [2 /*return*/];
+                        }
+                        setTimeout(function () {
+                            (0, preact_1.render)((0, jsx_runtime_1.jsx)(RecommendationsComponent, { controller: recs }, void 0), injectedElem);
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    }
+    RecommendationInstantiator.prototype.plugin = function (func) {
+        this.plugins.push(func);
+    };
+    RecommendationInstantiator.prototype.on = function (event) {
+        var func = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            func[_i - 1] = arguments[_i];
+        }
+        this.middleware.push({ event: event, func: func });
+    };
+    RecommendationInstantiator.prototype.use = function (attachments) {
+        this.uses.push(attachments);
+    };
+    return RecommendationInstantiator;
+}());
+exports.RecommendationInstantiator = RecommendationInstantiator;

package/dist/cjs/Snap.d.ts

@@ -0,0 +1,93 @@
+import { Client } from '@searchspring/snap-client';
+import { Logger } from '@searchspring/snap-logger';
+import { Tracker } from '@searchspring/snap-tracker';
+import type { ClientConfig, ClientGlobals } from '@searchspring/snap-client';
+import type { AbstractController, SearchController, AutocompleteController, FinderController, RecommendationController, SearchControllerConfig, AutocompleteControllerConfig, FinderControllerConfig, RecommendationControllerConfig, ControllerConfigs } from '@searchspring/snap-controller';
+import type { Product } from '@searchspring/snap-tracker';
+import type { Target, OnTarget } from '@searchspring/snap-toolbox';
+import type { UrlTranslatorConfig } from '@searchspring/snap-url-manager';
+import { RecommendationInstantiator, RecommendationInstantiatorConfig } from './Instantiators/RecommendationInstantiator';
+import type { SnapControllerServices, RootComponent } from './types';
+declare type ExtendedTarget = Target & {
+    name?: string;
+    controller?: AbstractController;
+    component?: () => Promise<RootComponent> | RootComponent;
+    skeleton?: () => Promise<any>;
+    props?: unknown;
+    onTarget?: OnTarget;
+    prefetch?: boolean;
+};
+declare type ContextVariables = {
+    shopper?: {
+        id: string;
+        cart?: Product[];
+        [variable: string]: any;
+    };
+    [variable: string]: any;
+};
+export declare type SnapConfig = {
+    context?: ContextVariables;
+    url?: UrlTranslatorConfig;
+    client: {
+        globals: ClientGlobals;
+        config?: ClientConfig;
+    };
+    instantiators?: {
+        recommendation?: RecommendationInstantiatorConfig;
+    };
+    controllers?: {
+        search?: {
+            config: SearchControllerConfig;
+            targeters?: ExtendedTarget[];
+            services?: SnapControllerServices;
+            url?: UrlTranslatorConfig;
+        }[];
+        autocomplete?: {
+            config: AutocompleteControllerConfig;
+            targeters: ExtendedTarget[];
+            services?: SnapControllerServices;
+            url?: UrlTranslatorConfig;
+        }[];
+        finder?: {
+            config: FinderControllerConfig;
+            targeters?: ExtendedTarget[];
+            services?: SnapControllerServices;
+            url?: UrlTranslatorConfig;
+        }[];
+        recommendation?: {
+            config: RecommendationControllerConfig;
+            targeters?: ExtendedTarget[];
+            services?: SnapControllerServices;
+            url?: UrlTranslatorConfig;
+        }[];
+    };
+};
+declare type ControllerTypes = SearchController | AutocompleteController | FinderController | RecommendationController;
+declare enum DynamicImportNames {
+    SEARCH = "searchController",
+    AUTOCOMPLETE = "autocompleteController",
+    FINDER = "finderController",
+    RECOMMENDATION = "recommendationController"
+}
+export declare class Snap {
+    config: SnapConfig;
+    logger: Logger;
+    client: Client;
+    tracker: Tracker;
+    _controllerPromises: {
+        [controllerConfigId: string]: Promise<ControllerTypes>;
+    };
+    controllers: {
+        [controllerConfigId: string]: ControllerTypes;
+    };
+    _instantiatorPromises: {
+        [instantiatorId: string]: Promise<RecommendationInstantiator>;
+    };
+    getInstantiator: (id: string) => Promise<RecommendationInstantiator>;
+    getController: (id: string) => Promise<ControllerTypes>;
+    getControllers: (...controllerIds: string[]) => Promise<ControllerTypes[]>;
+    createController: (type: DynamicImportNames, config: ControllerConfigs, services: SnapControllerServices, urlConfig: UrlTranslatorConfig, resolve: (value?: ControllerTypes | PromiseLike<ControllerTypes>) => void) => Promise<ControllerTypes>;
+    constructor(config: SnapConfig);
+}
+export {};
+//# sourceMappingURL=Snap.d.ts.map