@searchspring/snap-tracker 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,474 @@
+# Snap Tracker
+
+<a href="https://www.npmjs.com/package/@searchspring/snap-tracker"><img alt="NPM Status" src="https://img.shields.io/npm/v/@searchspring/snap-tracker.svg?style=flat"></a>
+
+The Snap Tracker service is responsible for sending beacon events. 
+
+## Dependencies
+
+Snap Tracker is a dependency of [@searchspring/snap-controller](https://github.com/searchspring/snap/tree/main/packages/snap-controller) <a href="https://www.npmjs.com/package/@searchspring/snap-controller"><img alt="NPM Status" src="https://img.shields.io/npm/v/@searchspring/snap-controller.svg?style=flat"></a>
+
+## Installation
+
+```bash
+npm install --save @searchspring/snap-tracker
+```
+
+## Import
+```typescript
+import { Tracker } from '@searchspring/snap-tracker';
+```
+## Controller usage
+Snap Tracker is a dependency of Snap Controller and Tracker events can be invoked via the `tracker` reference of any Snap Controller. 
+
+```typescript
+const globals = { siteId: 'abc123' };
+const tracker = new Tracker(globals);
+const controller = new SearchController(config, {
+    ...
+    tracker,
+    ...
+});
+
+console.log(tracker.track.product.click === controller.tracker.track.product.click) // true
+console.log(tracker.track.product.click === window.searchspring.tracker.track.product.click) // true
+```
+
+## Standalone usage
+Snap Tracker can also be used without a Snap Controller. Typically used to send events before an integration has gone live. 
+
+```typescript
+const tracker = new Tracker();
+const payload = {
+    type: BeaconType.CLICK,
+    category: BeaconCategory.INTERACTION, 
+    event: {
+        intellisuggestData: '37d5578e1d1646ac97701a063ba84777',
+        intellisuggestSignature: '5739a2596d3b4161b041ce1764ffa04d',
+        href: '/product123'
+    }
+};
+tracker.track.event(payload)
+```
+
+## Tracking Events with DomTargeter
+As an alternative method for tracking events, the Tracker utilizes the `DomTargeter` to look for script tags on the current page. These script tags must have a specific `type` attribute and data contents for the tracking to be used. These tracking script blocks ensure tracking events are sent when using asynchronous script execution and must be on the page prior to the `DOMContentLoaded` event to be picked up by initial targeting. If the script blocks are added after this event, the `retarget` method must be invoked.
+
+### `retarget` method
+This method will call the `retarget` method on all `DomTargeters` set in the Tracker. Typically this would be used when new tracking script blocks have been added to the page after initial targeting.
+
+### Shopper Login Script Block
+
+```html
+<script type="searchspring/track/shopper/login">
+    id = 'snapdev';
+</script>
+```
+
+### Product View Script Block
+
+```html
+<script type="searchspring/track/product/view">
+    item = {
+        sku: 'product123',
+        childSku: 'product123_a',
+    };
+</script>
+```
+
+### Cart View Script Block
+
+```html
+<script type="searchspring/track/cart/view">
+    items = [
+        {
+            sku: 'product123',
+            childSku: 'product123_a',
+            qty: '1',
+            price: '9.99',
+        },
+        {
+            sku: 'product456',
+            childSku: 'product456_a',
+            qty: '2',
+            price: '10.99',
+        },
+    ];
+</script>
+```
+
+### Order Transaction Script Block
+
+```html
+<script type="searchspring/track/order/transaction">
+    order = {
+        id: '123456',
+        total: '31.97',
+        city: 'Los Angeles',
+        state: 'CA',
+        country: 'US',
+    };
+    items = [
+        {
+            sku: 'product123',
+            childSku: 'product123_a',
+            qty: '1',
+            price: '9.99'
+        },
+        {
+            sku: 'product456',
+            childSku: 'product456_a',
+            qty: '2',
+            price: '10.99'
+        },
+    ];
+</script>
+```
+
+## `track` methods
+The Tracker object is exposed to the browser's `window` via the first Snap Controller that has been instantiated. This will use the `siteId` that has been provided to the Snap Tracker instance of the respective Controller Services. The Tracker contains various tracking methods available on the `track` object within it. 
+
+```typescript
+window.searchspring.tracker.track
+```
+
+Each tracking method expects a data object which contains different attributes depending on the method.
+
+```typescript
+tracker.track.product.view({
+    sku: 'product123',
+    childSku: 'product123_a',
+});
+```
+
+If a bundle is using multiple Snap Controllers with different `siteId`, an optional `siteId` parameter can be specified to overwrite any event `siteId`
+
+```typescript
+tracker.track.product.view({
+    sku: 'product123',
+    childSku: 'product123_a',
+}, 'abc123');
+```
+
+### Generic Event `track.event`
+Creates and sends a generic beacon event. Parameter expects an Event Payload object. 
+If a `type` or `category` is not provided, a value of `'custom'` will be used. 
+
+```typescript
+const payload = {
+    type: BeaconType.CLICK,
+    category: BeaconCategory.INTERACTION, 
+    event: {
+        intellisuggestData: '37d5578e1d1646ac97701a063ba84777',
+        intellisuggestSignature: '5739a2596d3b4161b041ce1764ffa04d',
+        href: '/product123'
+    }
+};
+tracker.track.event(payload)
+```
+
+#### Event Payload
+
+A beacon event payload object provided to the `track.event` method may contain the following:
+
+`type` -  BeaconType enum value or custom event type value. If not specified, `'custom'` will be used.
+
+`category` - BeaconCategory enum value or custom event type value. If not specified, `'custom'` will be used.
+
+`event` - object containing event data
+
+`context.website.trackingCode` - optional `context` object that will be merged with constructed context object. Can be used to specify a different `siteId` value.
+
+```typescript
+const payload = {
+    type: BeaconType.CLICK,
+    category: BeaconCategory.INTERACTION,
+    event: {
+        intellisuggestData: '37d5578e1d1646ac97701a063ba84777',
+        intellisuggestSignature: '5739a2596d3b4161b041ce1764ffa04d',
+        href: '/product123',
+    },
+    context: {
+        website: {
+            trackingCode: 'abc123',
+        },
+    },
+};
+
+```
+
+### Product Click `track.product.click`
+Tracks product click events. It is reccomended to invoke on each product `onmousedown` event via the `result.track.click()` method. Various Snap controllers will expose these tracking events differently, see the controller documentation for details. 
+
+```jsx
+searchController.store.results.map(result)=>{(
+    <a href={core.url} onMouseDown={(e)=>{result.track.click(e)}}>
+)}
+```
+
+If invoking directly, the `intellisuggestData` and `intellisuggestSignature` values are returned from SearchSpring's Search API on each `result.attributes` object. An optional `href` value can also be provided. 
+
+```typescript
+import { SearchController } from '@searchspring/snap-controller';
+import { Tracker } from '@searchspring/snap-tracker';
+const searchController = new SearchController({
+    ...
+    tracker: new Tracker(),
+    ...
+}):
+
+tracker.track.product.click({
+    intellisuggestData: '37d5578e1d1646ac97701a063ba84777',
+    intellisuggestSignature: '5739a2596d3b4161b041ce1764ffa04d',
+    href: '/product123',
+});
+```
+
+### Product View `track.product.view`
+Tracks product page views. Should be invoked from a product detail page. A `sku` and/or `childSku` are required.
+
+```typescript
+tracker.track.product.view({
+    sku: 'product123',
+    childSku: 'product123_a',
+});
+```
+
+### Shopper Login `track.shopper.login`
+Tracks user login and sets `context.shopperId` value. Should be invoked when a user has logged into their account.
+
+```typescript
+const shopperId = "snapdev"
+tracker.track.shopper.login({
+    id: shopperId
+});
+```
+
+### Cart View `track.cart.view`
+Tracks cart contents. Should be invoked from a cart page. Each item object must contain a `qty`, `price`, (`sku` and/or `childSku`)
+
+```typescript
+tracker.track.cart.view({
+    items: [
+        {
+            sku: 'product123',
+            childSku: 'product123_a',
+            qty: '1',
+            price: '9.99',
+        },
+        {
+            sku: 'product456',
+            childSku: 'product456_a',
+            qty: '2',
+            price: '10.99',
+        },
+    ]
+});
+```
+
+### Order Transaction `track.order.transaction`
+Tracks order transaction. Should be invoked from an order confirmation page. Expects an object with the following:
+
+`order` - (optional) object containing the following
+
+`order.id` - (optional) order id
+
+`order.otal` - (optional) sub total of all items
+
+`order.city` - (optional) city name
+
+`order.state` - (optional) 2 digit state abbreviation (US only)
+
+`order.country` - (optional) 2 digit country abbreviation	(ie. 'US', 'CA', 'MX', 'PL', 'JP')
+
+`order.items` - required array of items - same object provided to `track.cart.view` event
+
+```typescript
+tracker.track.order.transaction({
+    order: {
+        id: '123456',
+        total: '31.97',
+        city: 'Los Angeles',
+        state: 'CA',
+        country: 'US',
+    },
+    items: [
+        {
+            sku: 'product123',
+            childSku: 'product123_a',
+            qty: '1',
+            price: '9.99'
+        },
+        {
+            sku: 'product456',
+            childSku: 'product456_a',
+            qty: '2',
+            price: '10.99'
+        },
+    ]
+});
+```
+
+## Tracker properties
+
+### `globals` property
+When constructing an instance of `Tracker`, a globals object is required to be constructed. This object contains a `siteId` key and value. 
+
+```typescript
+const globals = { siteId: 'abc123' };
+const tracker = new Tracker(globals);
+console.log(tracker.globals === globals) // true
+```
+
+### `localStorage` property
+A reference to the StorageStore object for accessing Tracker local storage.
+
+```typescript
+const tracker = new Tracker();
+tracker.localStorage.set('key', 'value')
+tracker.localStorage.get('key') // 'value'
+```
+
+
+### `context` property
+The `context` property is generated at the time of instantiating Tracker. It is part of each event payload and provides context of the event.
+
+`userId` - unique ID to identify the user, persisted in a cookie/local storage fallback
+
+`pageLoadId` - unique ID generated at the time of instantiating Tracker
+
+`sessionId` - unique ID generated at the start of a new browser session, persisted in session storage/cookie fallback
+
+`shopperId` - unique ID provided set via the SearchController `SearchController.tracker.track.shopper.login` event and then persisted in a cookie
+
+`website.trackingCode` - the `siteId` specified in the globals object
+
+```typescript
+context: {
+    userId: '0560d7e7-148a-4b1d-b12c-924f164d3d00',
+    pageLoadId: 'cfb75606-c15b-4f25-a711-9de2c5d22660',
+    sessionId: 'f4b25c96-9ca1-4ac6-ad04-f5ce933f8b61',
+    shopperId: 'shopper0001',
+    website: {
+        trackingCode: 'abc123',
+    },
+}
+```
+
+### `isSending` property
+The `isSending` property contains the return value from `setTimeout` and when defined, signifys that an event is being sent to the beacon endpoint. If subsequent events are invoked and `isSending` is still defined, the incoming event will be added to the event queue to be sent at a later time. 
+
+### `namespace` property
+The `namespace` property contains the Tracker namespace. Invoking this method is only required if a bundle contains multiple Tracker instances. 
+
+### `track` property
+The `track` property contains various tracking events. See `track` methods section above.
+
+### `getUserId` method
+Returns an object containing the `userId` stored in the `ssUserId` cookie (with a fallback to localstorage.) If key doesn't exist, a new ID will be generated, saved to cookie/localstorage, and returned. 
+
+```typescript
+const tracker = new Tracker();
+
+console.log(tracker.getUserId()) 
+// { userId: '0560d7e7-148a-4b1d-b12c-924f164d3d00' }
+```
+
+### `getSessionId` method
+Returns an object containing the `sessionId` stored in the `ssSessionIdNamespace` session storage (with a fallback to cookies.) If key doesn't exist, a new ID will be generated, saved to session storage/cookie, and returned. 
+
+```typescript
+const tracker = new Tracker();
+
+console.log(tracker.getSessionId()) 
+// { sessionId: 'f4b25c96-9ca1-4ac6-ad04-f5ce933f8b61' }
+```
+
+### `getShopperId` method
+Returns an object containing the `shopperId` stored in the `ssShopperId` cookie. This value is set via the SearchController `SearchController.tracker.track.shopper.login` event
+
+```typescript
+const tracker = new Tracker();
+
+console.log(tracker.getShopperId()) 
+// { shopperId: 'shopper0001' }
+```
+
+### `cookies` property
+The `cookies` property provides access to the `cart` and `viewed` tracking cookies.
+
+#### `cookies.cart.get` method
+Returns an array of strings containing the `sku` of each item last registered as being in the shopping cart. This value is stored in the `ssCartProducts` cookie and is set via the calls to the `tracker.track.cart.view` event.
+
+```typescript
+const tracker = new Tracker();
+
+console.log(tracker.cookies.cart.get()) 
+// ['sku1', 'sku2']
+```
+
+#### `cookies.cart.add` method
+Provides a means of adding cart products to the `ssCartProducts` cookie.
+
+```typescript
+const tracker = new Tracker();
+
+console.log(tracker.cookies.cart.get());
+// ['sku1', 'sku2']
+
+console.log(tracker.cookies.cart.add(['sku3']));
+// ['sku1', 'sku2', 'sku3']
+```
+
+#### `cookies.cart.remove` method
+Provides a means for removing `skus` from the `ssCartProducts` cookie.
+
+```typescript
+const tracker = new Tracker();
+
+console.log(tracker.cookies.cart.get());
+// ['sku1', 'sku2']
+
+tracker.cookies.cart.remove(['sku1']);
+// ['sku2']
+```
+
+#### `cookies.cart.set` method
+Provides a means of setting the `ssCartProducts` cookie via an array of product `skus`.
+
+```typescript
+const tracker = new Tracker();
+
+tracker.cookies.cart.set(['sku1', 'sku2']);
+// ['sku1', 'sku2']
+```
+
+#### `cookies.cart.clear` method
+Empties the `ssCartProducts` cookie.
+
+```typescript
+const tracker = new Tracker();
+
+tracker.cookies.cart.clear();
+```
+
+#### `cookies.viewed.get` method
+Returns an array of strings containing the `sku` of items which have been viewed. This value is stored in the `ssViewedProducts` cookie and is set via the calls to the `tracker.track.product.view` event.
+
+```typescript
+const tracker = new Tracker();
+
+console.log(tracker.cookies.viewed.get());
+// ['sku1', 'sku2']
+```
+
+### `sendEvents` method
+Sends event(s) to beacon (and various legacy) endpoint(s). 
+
+```typescript
+const tracker = new Tracker();
+const event1 = new BeaconEvent();
+const event2 = new BeaconEvent();
+tracker.sendEvents([event1, event2])
+```
+

package/dist/cjs/BeaconEvent.d.ts

@@ -0,0 +1,12 @@
+import { BeaconPayload } from './types';
+export declare class BeaconEvent implements BeaconPayload {
+    type: any;
+    category: any;
+    context: any;
+    event: any;
+    meta: any;
+    id: any;
+    pid?: any;
+    constructor(payload: BeaconPayload);
+}
+//# sourceMappingURL=BeaconEvent.d.ts.map

package/dist/cjs/BeaconEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BeaconEvent.d.ts","sourceRoot":"","sources":["../../src/BeaconEvent.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,qBAAa,WAAY,YAAW,aAAa;IAChD,IAAI,MAAC;IACL,QAAQ,MAAC;IACT,OAAO,MAAC;IACR,KAAK,MAAC;IACN,IAAI,MAAC;IACL,EAAE,MAAC;IACH,GAAG,CAAC,MAAC;gBAEO,OAAO,EAAE,aAAa;CAYlC"}

package/dist/cjs/BeaconEvent.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeaconEvent = void 0;
+var uuid_1 = require("uuid");
+var snap_toolbox_1 = require("@searchspring/snap-toolbox");
+var BeaconEvent = /** @class */ (function () {
+    function BeaconEvent(payload) {
+        var _this = this;
+        Object.keys(payload).forEach(function (key) {
+            _this[key] = payload[key];
+        });
+        this.meta = {
+            initiator: {
+                lib: 'searchspring/snap',
+                'lib.version': snap_toolbox_1.version,
+            },
+        };
+        this.id = (0, uuid_1.v4)();
+    }
+    return BeaconEvent;
+}());
+exports.BeaconEvent = BeaconEvent;

package/dist/cjs/PixelEvent.d.ts

@@ -0,0 +1,9 @@
+import { ProductViewEvent, OrderTransactionEvent, BeaconPayload, CartViewEvent } from './types';
+export declare class PixelEvent {
+    endpoint: string;
+    src: string;
+    img: HTMLImageElement;
+    event: ProductViewEvent | CartViewEvent | OrderTransactionEvent;
+    constructor(payload: BeaconPayload);
+}
+//# sourceMappingURL=PixelEvent.d.ts.map

package/dist/cjs/PixelEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PixelEvent.d.ts","sourceRoot":"","sources":["../../src/PixelEvent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,aAAa,EAAE,aAAa,EAAkB,MAAM,SAAS,CAAC;AAEhH,qBAAa,UAAU;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,gBAAgB,CAAC;IACtB,KAAK,EAAE,gBAAgB,GAAG,aAAa,GAAG,qBAAqB,CAAC;gBAEpD,OAAO,EAAE,aAAa;CAkDlC"}

package/dist/cjs/PixelEvent.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelEvent = void 0;
+var snap_toolbox_1 = require("@searchspring/snap-toolbox");
+var types_1 = require("./types");
+var PixelEvent = /** @class */ (function () {
+    function PixelEvent(payload) {
+        var _this = this;
+        this.endpoint = "https://d3cgm8py10hi0z.cloudfront.net/is.gif";
+        this.src =
+            this.endpoint +
+                "?s=".concat(encodeURIComponent(payload.context.website.trackingCode)) +
+                "&u=".concat(encodeURIComponent(payload.context.userId)) +
+                "&ce=".concat(snap_toolbox_1.featureFlags.cookies ? '1' : '0') +
+                "&pt=".concat(encodeURIComponent(document.title)) +
+                "&v=1" + // version always '1'? or set to snap package version?
+                "&x=".concat(Math.floor(Math.random() * 2147483647)) +
+                "".concat(window.document.referrer ? "&r=".concat(encodeURIComponent(window.document.referrer)) : '');
+        switch (payload.category) {
+            case types_1.BeaconCategory.PAGEVIEW:
+                this.event = payload.event;
+                this.src += '&a=viewItem';
+                if (this.event.sku) {
+                    this.src += "&sku=".concat(encodeURIComponent(this.event.sku));
+                }
+                break;
+            case types_1.BeaconCategory.CARTVIEW:
+                this.event = payload.event;
+                this.src += '&a=basket';
+                this.event.items.forEach(function (item) {
+                    if (item.sku) {
+                        _this.src += "&item=".concat(encodeURIComponent(item.sku), ";").concat(encodeURIComponent((item === null || item === void 0 ? void 0 : item.qty) || ''), ";").concat(encodeURIComponent((item === null || item === void 0 ? void 0 : item.price) || ''), ";");
+                    }
+                });
+                break;
+            case types_1.BeaconCategory.ORDERVIEW:
+                var _a = (this.event = payload.event), orderId = _a.orderId, total = _a.total, city = _a.city, state = _a.state, country = _a.country, items = _a.items;
+                this.src += "&a=sale";
+                if (orderId)
+                    this.src += "&orderId=".concat(encodeURIComponent(orderId));
+                if (total)
+                    this.src += "&total=".concat(encodeURIComponent(total));
+                if (city)
+                    this.src += "&city=".concat(encodeURIComponent(city));
+                if (state)
+                    this.src += "&state=".concat(encodeURIComponent(state));
+                if (country)
+                    this.src += "&country=".concat(encodeURIComponent(country));
+                items.forEach(function (item) {
+                    if (item.sku) {
+                        _this.src += "&item=".concat(encodeURIComponent(item.sku), ";").concat(encodeURIComponent((item === null || item === void 0 ? void 0 : item.qty) || ''), ";").concat(encodeURIComponent((item === null || item === void 0 ? void 0 : item.price) || ''), ";");
+                    }
+                });
+                break;
+        }
+        if (this.src.includes('&a=')) {
+            this.img = new Image(1, 1);
+            this.img.src = this.src; // setting src immediately invokes a request
+        }
+    }
+    return PixelEvent;
+}());
+exports.PixelEvent = PixelEvent;

package/dist/cjs/TrackEvent.d.ts

@@ -0,0 +1,11 @@
+import { BeaconPayload } from './types';
+export declare class TrackEvent {
+    intellisuggestData: string;
+    intellisuggestSignature: string;
+    href?: string;
+    endpoint: string;
+    src: string;
+    img: HTMLImageElement;
+    constructor(payload: BeaconPayload);
+}
+//# sourceMappingURL=TrackEvent.d.ts.map

package/dist/cjs/TrackEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrackEvent.d.ts","sourceRoot":"","sources":["../../src/TrackEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,aAAa,EAAE,MAAM,SAAS,CAAC;AAE3D,qBAAa,UAAU;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,uBAAuB,EAAE,MAAM,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,gBAAgB,CAAC;gBAEV,OAAO,EAAE,aAAa;CA6BlC"}

package/dist/cjs/TrackEvent.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackEvent = void 0;
+var TrackEvent = /** @class */ (function () {
+    function TrackEvent(payload) {
+        var _a, _b, _c;
+        payload.event = payload.event;
+        if (!payload.context || !payload.event) {
+            throw 'TrackEvent: object parameter required a valid `context` BeaconContext and `event` ProductClickEvent objects';
+        }
+        if (!((_a = payload.event) === null || _a === void 0 ? void 0 : _a.intellisuggestData) || !((_b = payload.event) === null || _b === void 0 ? void 0 : _b.intellisuggestSignature)) {
+            throw 'TrackEvent: object parameter `event` ProductClickEvent object requires valid intellisuggestData and intellisuggestSignature values. These are the corresponding attributes in the Searchspring API response.';
+        }
+        this.intellisuggestData = payload.event.intellisuggestData;
+        this.intellisuggestSignature = payload.event.intellisuggestSignature;
+        this.href = ((_c = payload.event) === null || _c === void 0 ? void 0 : _c.href) || '';
+        this.endpoint = "https://".concat(payload.context.website.trackingCode, ".a.searchspring.io/api/track/track.json");
+        this.src =
+            this.endpoint +
+                "?d=".concat(encodeURIComponent(this.intellisuggestData)) +
+                "&s=".concat(encodeURIComponent(this.intellisuggestSignature)) +
+                "&u=".concat(encodeURIComponent(this.href));
+        if (window.document.referrer) {
+            this.src += "&r=".concat(encodeURIComponent(window.document.referrer));
+        }
+        this.img = new Image(1, 1);
+        this.img.src = this.src; // setting src immediately invokes a request
+    }
+    return TrackEvent;
+}());
+exports.TrackEvent = TrackEvent;