@croct/sdk 0.17.7 → 0.17.8

package/tracker.js

@@ -1,338 +1,338 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tracker = void 0;
-const logging_1 = require("./logging");
-const error_1 = require("./error");
-const trackingEvents_1 = require("./trackingEvents");
+import { NullLogger } from "./logging";
+import { formatCause } from "./error";
+import {
+  isCartPartialEvent,
+  isIdentifiedUserEvent
+} from "./trackingEvents";
 const trackedEvents = {};
 class Tracker {
-    constructor(config) {
-        var _a;
-        this.listeners = [];
-        this.pending = [];
-        this.state = {
-            enabled: false,
-            initialized: false,
-            suspended: false,
-        };
-        this.inactivityTimer = {
-            since: 0,
-        };
-        const { tab, tokenProvider, channel, logger, inactivityRetryPolicy, ...options } = config;
-        this.tab = tab;
-        this.tokenProvider = tokenProvider;
-        this.inactivityRetryPolicy = inactivityRetryPolicy;
-        this.channel = channel;
-        this.logger = logger !== null && logger !== void 0 ? logger : new logging_1.NullLogger();
-        this.processor = config.processor;
-        this.options = {
-            ...options,
-            eventMetadata: (_a = options.eventMetadata) !== null && _a !== void 0 ? _a : {},
-        };
-        this.enable = this.enable.bind(this);
-        this.disable = this.disable.bind(this);
-        this.suspend = this.suspend.bind(this);
-        this.unsuspend = this.unsuspend.bind(this);
-        this.trackPageLoad = this.trackPageLoad.bind(this);
-        this.trackTabVisibilityChange = this.trackTabVisibilityChange.bind(this);
-        this.trackTabUrlChange = this.trackTabUrlChange.bind(this);
-        this.trackInactivity = this.trackInactivity.bind(this);
+  constructor(config) {
+    this.listeners = [];
+    this.pending = [];
+    this.state = {
+      enabled: false,
+      initialized: false,
+      suspended: false
+    };
+    this.inactivityTimer = {
+      since: 0
+    };
+    const { tab, tokenProvider, channel, logger, inactivityRetryPolicy, ...options } = config;
+    this.tab = tab;
+    this.tokenProvider = tokenProvider;
+    this.inactivityRetryPolicy = inactivityRetryPolicy;
+    this.channel = channel;
+    this.logger = logger ?? new NullLogger();
+    this.processor = config.processor;
+    this.options = {
+      ...options,
+      eventMetadata: options.eventMetadata ?? {}
+    };
+    this.enable = this.enable.bind(this);
+    this.disable = this.disable.bind(this);
+    this.suspend = this.suspend.bind(this);
+    this.unsuspend = this.unsuspend.bind(this);
+    this.trackPageLoad = this.trackPageLoad.bind(this);
+    this.trackTabVisibilityChange = this.trackTabVisibilityChange.bind(this);
+    this.trackTabUrlChange = this.trackTabUrlChange.bind(this);
+    this.trackInactivity = this.trackInactivity.bind(this);
+  }
+  addListener(listener) {
+    this.listeners.push(listener);
+  }
+  removeListener(listener) {
+    let index = this.listeners.indexOf(listener);
+    while (index >= 0) {
+      this.listeners.splice(index, 1);
+      index = this.listeners.indexOf(listener);
     }
-    addListener(listener) {
-        this.listeners.push(listener);
+  }
+  get flushed() {
+    const suppress = () => {
+    };
+    return Promise.all(this.pending).then(suppress, suppress);
+  }
+  isEnabled() {
+    return this.state.enabled;
+  }
+  isSuspended() {
+    return this.state.suspended;
+  }
+  enable() {
+    if (this.state.enabled) {
+      return;
     }
-    removeListener(listener) {
-        let index = this.listeners.indexOf(listener);
-        while (index >= 0) {
-            this.listeners.splice(index, 1);
-            index = this.listeners.indexOf(listener);
-        }
+    this.logger.info("Tracker enabled");
+    this.state.enabled = true;
+    if (this.state.suspended) {
+      return;
     }
-    get flushed() {
-        const suppress = () => {
-            // suppress errors
-        };
-        return Promise.all(this.pending).then(suppress, suppress);
+    this.startInactivityTimer();
+    if (!this.state.initialized) {
+      this.state.initialized = true;
+      this.initialize();
     }
-    isEnabled() {
-        return this.state.enabled;
+    this.tab.addListener("load", this.trackPageLoad);
+    this.tab.addListener("urlChange", this.trackTabUrlChange);
+    this.tab.addListener("visibilityChange", this.trackTabVisibilityChange);
+  }
+  disable() {
+    if (!this.state.enabled) {
+      return;
     }
-    isSuspended() {
-        return this.state.suspended;
+    this.logger.info("Tracker disabled");
+    this.state.enabled = false;
+    if (this.state.suspended) {
+      return;
     }
-    enable() {
-        if (this.state.enabled) {
-            return;
-        }
-        this.logger.info('Tracker enabled');
-        this.state.enabled = true;
-        if (this.state.suspended) {
-            return;
-        }
-        this.startInactivityTimer();
-        if (!this.state.initialized) {
-            this.state.initialized = true;
-            this.initialize();
-        }
-        this.tab.addListener('load', this.trackPageLoad);
-        this.tab.addListener('urlChange', this.trackTabUrlChange);
-        this.tab.addListener('visibilityChange', this.trackTabVisibilityChange);
-    }
-    disable() {
-        if (!this.state.enabled) {
-            return;
-        }
-        this.logger.info('Tracker disabled');
-        this.state.enabled = false;
-        if (this.state.suspended) {
-            return;
-        }
-        this.tab.removeListener('load', this.trackPageLoad);
-        this.tab.removeListener('urlChange', this.trackTabUrlChange);
-        this.tab.removeListener('visibilityChange', this.trackTabVisibilityChange);
-        this.stopInactivityTimer();
+    this.tab.removeListener("load", this.trackPageLoad);
+    this.tab.removeListener("urlChange", this.trackTabUrlChange);
+    this.tab.removeListener("visibilityChange", this.trackTabVisibilityChange);
+    this.stopInactivityTimer();
+  }
+  suspend() {
+    if (this.state.suspended) {
+      return;
     }
-    suspend() {
-        if (this.state.suspended) {
-            return;
-        }
-        this.logger.info('Tracker suspended');
-        if (this.state.enabled) {
-            this.disable();
-            this.state.enabled = true;
-        }
-        this.state.suspended = true;
+    this.logger.info("Tracker suspended");
+    if (this.state.enabled) {
+      this.disable();
+      this.state.enabled = true;
     }
-    unsuspend() {
-        if (!this.state.suspended) {
-            return;
-        }
-        this.logger.info('Tracker unsuspended');
-        this.state.suspended = false;
-        if (this.state.enabled) {
-            this.state.enabled = false;
-            this.enable();
-        }
+    this.state.suspended = true;
+  }
+  unsuspend() {
+    if (!this.state.suspended) {
+      return;
     }
-    initialize() {
-        if (trackedEvents[this.tab.id] === undefined) {
-            trackedEvents[this.tab.id] = {};
-        }
-        const initEvents = trackedEvents[this.tab.id];
-        if (this.tab.isNew && !initEvents.tabOpened) {
-            initEvents.tabOpened = true;
-            this.trackTabOpen({ tabId: this.tab.id });
-        }
-        if (!initEvents.pageOpened) {
-            initEvents.pageOpened = true;
-            this.trackPageOpen({
-                url: this.tab.url,
-                referrer: this.tab.referrer,
-            });
-        }
+    this.logger.info("Tracker unsuspended");
+    this.state.suspended = false;
+    if (this.state.enabled) {
+      this.state.enabled = false;
+      this.enable();
     }
-    stopInactivityTimer() {
-        if (this.inactivityTimer.id !== undefined) {
-            window.clearTimeout(this.inactivityTimer.id);
-            delete this.inactivityTimer.id;
-        }
+  }
+  initialize() {
+    if (trackedEvents[this.tab.id] === void 0) {
+      trackedEvents[this.tab.id] = {};
     }
-    startInactivityTimer() {
-        this.stopInactivityTimer();
-        this.inactivityTimer.since = Date.now();
-        let iteration = -1;
-        const startTimer = () => {
-            if (!this.inactivityRetryPolicy.shouldRetry(iteration + 1, this.inactivityTimer.since)) {
-                window.clearTimeout(this.inactivityTimer.id);
-                return;
-            }
-            iteration += 1;
-            this.inactivityTimer.id = window.setTimeout(() => {
-                this.trackInactivity();
-                startTimer();
-            }, this.inactivityRetryPolicy.getDelay(iteration));
-        };
-        startTimer();
+    const initEvents = trackedEvents[this.tab.id];
+    if (this.tab.isNew && !initEvents.tabOpened) {
+      initEvents.tabOpened = true;
+      this.trackTabOpen({ tabId: this.tab.id });
     }
-    track(event, timestamp = Date.now()) {
-        return this.dispatch(this.enrichEvent(event, timestamp), timestamp).then(() => event);
+    if (!initEvents.pageOpened) {
+      initEvents.pageOpened = true;
+      this.trackPageOpen({
+        url: this.tab.url,
+        referrer: this.tab.referrer
+      });
     }
-    trackPageOpen({ referrer, ...payload }) {
-        this.enqueue({
-            type: 'pageOpened',
-            ...payload,
-            ...(referrer.length > 0 ? { referrer: referrer } : {}),
-        });
+  }
+  stopInactivityTimer() {
+    if (this.inactivityTimer.id !== void 0) {
+      window.clearTimeout(this.inactivityTimer.id);
+      delete this.inactivityTimer.id;
     }
-    trackPageLoad({ detail: { tab } }) {
-        this.enqueue({
-            type: 'pageLoaded',
-            url: tab.url,
-            title: tab.title,
-            lastModifiedTime: Date.parse(tab.document.lastModified),
-        });
+  }
+  startInactivityTimer() {
+    this.stopInactivityTimer();
+    this.inactivityTimer.since = Date.now();
+    let iteration = -1;
+    const startTimer = () => {
+      if (!this.inactivityRetryPolicy.shouldRetry(iteration + 1, this.inactivityTimer.since)) {
+        window.clearTimeout(this.inactivityTimer.id);
+        return;
+      }
+      iteration += 1;
+      this.inactivityTimer.id = window.setTimeout(
+        () => {
+          this.trackInactivity();
+          startTimer();
+        },
+        this.inactivityRetryPolicy.getDelay(iteration)
+      );
+    };
+    startTimer();
+  }
+  track(event, timestamp = Date.now()) {
+    return this.dispatch(this.enrichEvent(event, timestamp), timestamp).then(() => event);
+  }
+  trackPageOpen({ referrer, ...payload }) {
+    this.enqueue({
+      type: "pageOpened",
+      ...payload,
+      ...referrer.length > 0 ? { referrer } : {}
+    });
+  }
+  trackPageLoad({ detail: { tab } }) {
+    this.enqueue({
+      type: "pageLoaded",
+      url: tab.url,
+      title: tab.title,
+      lastModifiedTime: Date.parse(tab.document.lastModified)
+    });
+  }
+  trackTabOpen(payload) {
+    this.enqueue({
+      type: "tabOpened",
+      ...payload
+    });
+  }
+  trackTabUrlChange({ detail }) {
+    this.enqueue({
+      type: "tabUrlChanged",
+      tabId: detail.tab.id,
+      url: detail.url
+    });
+  }
+  trackTabVisibilityChange({ detail }) {
+    this.enqueue({
+      type: "tabVisibilityChanged",
+      tabId: detail.tab.id,
+      visibility: detail.visible ? "visible" : "hidden"
+    });
+  }
+  trackInactivity() {
+    this.enqueue({
+      type: "nothingChanged",
+      sinceTime: this.inactivityTimer.since
+    });
+  }
+  enqueue(event, timestamp = Date.now()) {
+    this.dispatch(event, timestamp).catch(() => {
+    });
+  }
+  notifyEvent(event) {
+    this.listeners.map((listener) => listener(event));
+  }
+  dispatch(event, timestamp) {
+    const userToken = this.tokenProvider.getToken();
+    const metadata = this.options.eventMetadata;
+    const context = {
+      tabId: this.tab.id,
+      url: this.tab.url,
+      ...Object.keys(metadata).length > 0 ? { metadata } : {}
+    };
+    const queuedEvent = {
+      ...userToken !== null ? { userToken } : {},
+      event,
+      timestamp,
+      context
+    };
+    const processedEvents = this.processor !== void 0 ? this.processor.process(queuedEvent) : [queuedEvent];
+    processedEvents.sort((left, right) => left.timestamp - right.timestamp);
+    let result = null;
+    for (const processedEvent of processedEvents) {
+      if (processedEvent === queuedEvent) {
+        result = this.publish(queuedEvent);
+        continue;
+      }
+      this.publish(processedEvent);
     }
-    trackTabOpen(payload) {
-        this.enqueue({
-            type: 'tabOpened',
-            ...payload,
-        });
+    if (result === null) {
+      return Promise.reject(new Error("Event suppressed."));
     }
-    trackTabUrlChange({ detail }) {
-        this.enqueue({
-            type: 'tabUrlChanged',
-            tabId: detail.tab.id,
-            url: detail.url,
-        });
+    return result;
+  }
+  publish(queuedEvent) {
+    const { event } = queuedEvent;
+    if (event.type !== "nothingChanged") {
+      this.stopInactivityTimer();
     }
-    trackTabVisibilityChange({ detail }) {
-        this.enqueue({
-            type: 'tabVisibilityChanged',
-            tabId: detail.tab.id,
-            visibility: detail.visible ? 'visible' : 'hidden',
-        });
+    const eventInfo = {
+      ...queuedEvent,
+      status: "pending"
+    };
+    if (this.state.suspended) {
+      this.logger.warn(`Tracker is suspended, ignoring event "${event.type}"`);
+      this.notifyEvent({ ...eventInfo, status: "ignored" });
+      return Promise.reject(new Error("The tracker is suspended."));
     }
-    trackInactivity() {
-        this.enqueue({
-            type: 'nothingChanged',
-            sinceTime: this.inactivityTimer.since,
-        });
-    }
-    enqueue(event, timestamp = Date.now()) {
-        this.dispatch(event, timestamp).catch(() => {
-            // suppress error
-        });
-    }
-    notifyEvent(event) {
-        this.listeners.map(listener => listener(event));
-    }
-    dispatch(event, timestamp) {
-        const userToken = this.tokenProvider.getToken();
-        const metadata = this.options.eventMetadata;
-        const context = {
-            tabId: this.tab.id,
-            url: this.tab.url,
-            ...(Object.keys(metadata).length > 0 ? { metadata: metadata } : {}),
-        };
-        const queuedEvent = {
-            ...(userToken !== null ? { userToken: userToken } : {}),
-            event: event,
-            timestamp: timestamp,
-            context: context,
-        };
-        const processedEvents = this.processor !== undefined
-            ? this.processor.process(queuedEvent)
-            : [queuedEvent];
-        // sort events by timestamp in ascending order
-        processedEvents.sort((left, right) => left.timestamp - right.timestamp);
-        let result = null;
-        for (const processedEvent of processedEvents) {
-            if (processedEvent === queuedEvent) {
-                result = this.publish(queuedEvent);
-                continue;
-            }
-            this.publish(processedEvent);
+    this.logger.info(`Tracked event "${event.type}"`);
+    this.notifyEvent(eventInfo);
+    return new Promise((resolve, reject) => {
+      const promise = this.channel.publish(this.createBeacon(queuedEvent)).then(
+        () => {
+          this.logger.debug(`Successfully published event "${event.type}"`);
+          this.notifyEvent({ ...eventInfo, status: "confirmed" });
+          resolve(event);
+        },
+        (cause) => {
+          this.logger.error(`Failed to publish event "${event.type}", reason: ${formatCause(cause)}`);
+          this.notifyEvent({ ...eventInfo, status: "failed" });
+          reject(cause);
         }
-        if (result === null) {
-            return Promise.reject(new Error('Event suppressed.'));
+      );
+      this.pending.push(promise);
+      promise.finally(() => {
+        this.pending.splice(this.pending.indexOf(promise), 1);
+      });
+      if (this.state.enabled && event.type !== "nothingChanged") {
+        this.startInactivityTimer();
+      }
+    });
+  }
+  enrichEvent(event, timestamp) {
+    if (isCartPartialEvent(event)) {
+      const { cart: { lastUpdateTime = timestamp, ...cart }, ...payload } = event;
+      return {
+        ...payload,
+        cart: {
+          ...cart,
+          lastUpdateTime
         }
-        return result;
+      };
     }
-    publish(queuedEvent) {
-        const { event } = queuedEvent;
-        if (event.type !== 'nothingChanged') {
-            this.stopInactivityTimer();
-        }
-        const eventInfo = {
-            ...queuedEvent,
-            status: 'pending',
-        };
-        if (this.state.suspended) {
-            this.logger.warn(`Tracker is suspended, ignoring event "${event.type}"`);
-            this.notifyEvent({ ...eventInfo, status: 'ignored' });
-            return Promise.reject(new Error('The tracker is suspended.'));
-        }
-        this.logger.info(`Tracked event "${event.type}"`);
-        this.notifyEvent(eventInfo);
-        return new Promise((resolve, reject) => {
-            const promise = this.channel
-                .publish(this.createBeacon(queuedEvent))
-                .then(() => {
-                this.logger.debug(`Successfully published event "${event.type}"`);
-                this.notifyEvent({ ...eventInfo, status: 'confirmed' });
-                resolve(event);
-            }, cause => {
-                this.logger.error(`Failed to publish event "${event.type}", reason: ${(0, error_1.formatCause)(cause)}`);
-                this.notifyEvent({ ...eventInfo, status: 'failed' });
-                reject(cause);
-            });
-            this.pending.push(promise);
-            promise.finally(() => {
-                this.pending.splice(this.pending.indexOf(promise), 1);
-            });
-            if (this.state.enabled && event.type !== 'nothingChanged') {
-                this.startInactivityTimer();
-            }
-        });
+    return event;
+  }
+  createBeacon({ event, timestamp, context, userToken }) {
+    return {
+      timestamp,
+      ...userToken !== void 0 ? { token: userToken.toString() } : {},
+      context,
+      payload: this.enrichBeaconPayload(this.createBeaconPayload(event))
+    };
+  }
+  createBeaconPayload(event) {
+    if (!isIdentifiedUserEvent(event)) {
+      return event;
     }
-    enrichEvent(event, timestamp) {
-        if ((0, trackingEvents_1.isCartPartialEvent)(event)) {
-            const { cart: { lastUpdateTime = timestamp, ...cart }, ...payload } = event;
-            return {
-                ...payload,
-                cart: {
-                    ...cart,
-                    lastUpdateTime: lastUpdateTime,
-                },
-            };
+    if (event.type === "userSignedUp" && event.profile !== void 0) {
+      const { userId: userId2, profile, ...payload2 } = event;
+      return {
+        ...payload2,
+        externalUserId: userId2,
+        patch: {
+          operations: [
+            {
+              type: "merge",
+              path: ".",
+              value: profile
+            }
+          ]
         }
-        return event;
-    }
-    createBeacon({ event, timestamp, context, userToken }) {
-        return {
-            timestamp: timestamp,
-            ...(userToken !== undefined ? { token: userToken.toString() } : {}),
-            context: context,
-            payload: this.enrichBeaconPayload(this.createBeaconPayload(event)),
-        };
+      };
     }
-    createBeaconPayload(event) {
-        if (!(0, trackingEvents_1.isIdentifiedUserEvent)(event)) {
-            return event;
-        }
-        if (event.type === 'userSignedUp' && event.profile !== undefined) {
-            const { userId, profile, ...payload } = event;
-            return {
-                ...payload,
-                externalUserId: userId,
-                patch: {
-                    operations: [
-                        {
-                            type: 'merge',
-                            path: '.',
-                            value: profile,
-                        },
-                    ],
-                },
-            };
-        }
-        const { userId, ...payload } = event;
+    const { userId, ...payload } = event;
+    return {
+      ...payload,
+      externalUserId: userId
+    };
+  }
+  enrichBeaconPayload(event) {
+    switch (event.type) {
+      case "linkOpened":
         return {
-            ...payload,
-            externalUserId: userId,
+          ...event,
+          link: new URL(event.link, this.tab.url).toString()
         };
+      default:
+        return event;
     }
-    enrichBeaconPayload(event) {
-        switch (event.type) {
-            case 'linkOpened':
-                return {
-                    ...event,
-                    link: new URL(event.link, this.tab.url).toString(),
-                };
-            default:
-                return event;
-        }
-    }
+  }
 }
-exports.Tracker = Tracker;
+export {
+  Tracker
+};
 //# sourceMappingURL=tracker.js.map