castled-js-sdk 0.0.1 → 0.0.2

package/src/integrations/Shynet/browser.js

@@ -0,0 +1,97 @@
+/* eslint-disable func-names */
+/* eslint-disable compat/compat */
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { generateUUID } from '../../utils/utils';
+
+class Shynet {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    const { heartBeatFrequencyInMs } = config;
+    const { shynetServiceUrl } = config;
+    this.scriptCheck = false;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+
+    this.shynetScript = {
+      idempotency: null,
+      heartBeatTaskId: null,
+      skipHeartBeat: false,
+      sendHeartBeat(referrerName, url) {
+        try {
+          if (this.skipHeartbeat) {
+            return;
+          }
+
+          this.skipHeartbeat = true;
+          const xhr = new XMLHttpRequest();
+          xhr.open('POST', `${shynetServiceUrl}`, true);
+          xhr.setRequestHeader('Content-Type', 'application/json');
+          xhr.onload = function () {
+            this.skipHeartBeat = false;
+          };
+          xhr.onerror = function () {
+            this.skipHeartBeat = false;
+          };
+          const payloadBody = JSON.stringify({
+            idempotency: this.idempotency,
+            referrer: referrerName,
+            location: url,
+            loadTime: window.performance.now(),
+          });
+          xhr.send(payloadBody);
+        } catch (exp) {
+          logger.info(`Error Sending ${NAME} Event`, exp.message);
+        }
+      },
+      newPageLoad(referrer, url) {
+        if (this.heartBeatTaskId != null) {
+          clearInterval(this.heartBeatTaskId);
+        }
+        this.idempotency = generateUUID();
+        this.skipHeartbeat = false;
+        // taking default as 5 sec as used in shynet doc
+        this.heartBeatTaskId = setInterval(
+          this.sendHeartBeat,
+          parseInt(heartBeatFrequencyInMs || 5000, 10),
+        );
+        this.sendHeartBeat(referrer, url);
+      },
+    };
+    this.scriptCheck = true;
+  }
+
+  init() {
+    logger.debug('=== in init Shynet ===');
+    return this.scriptCheck;
+  }
+
+  isLoaded() {
+    logger.debug('=== in Shynet isLoaded= ==');
+    return this.scriptCheck;
+  }
+
+  isReady() {
+    logger.debug('=== in Shynet is Ready===');
+    return this.scriptCheck;
+  }
+
+  page(htElement) {
+    try {
+      this.shynetScript.newPageLoad(
+        htElement?.message?.properties?.referrer,
+        htElement?.message?.properties?.url,
+      );
+    } catch (exp) {
+      logger.info(exp.message);
+    }
+  }
+}
+export default Shynet;

package/src/integrations/Shynet/constants.js

@@ -0,0 +1,15 @@
+const NAME = 'SHYNET';
+
+const CNameMapping = {
+  [NAME]: NAME,
+  shynet: NAME,
+  ShyNet: NAME,
+  shyNet: NAME,
+  Shynet: NAME,
+  'shy net': NAME,
+  'Shy Net': NAME,
+  'shy Net': NAME,
+  'Shy net': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Shynet/index.js

@@ -0,0 +1 @@
+export { default as Shynet } from './browser';

package/src/integrations/SnapEngage/browser.js

@@ -0,0 +1,75 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+
+import { recordingLiveChatEvents } from './util';
+import { getHashFromArray } from '../../utils/commonUtils';
+import { isObject } from '../../utils/utils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class SnapEngage {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.widgetId = config.widgetId;
+    this.recordLiveChatEvents = config.recordLiveChatEvents;
+    this.eventsToStandard = config.eventsToStandard;
+    this.updateEventNames = config.updateEventNames;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    loadNativeSdk(this.widgetId);
+  }
+
+  init() {
+    logger.debug('===In init SnapEngage===');
+    this.loadScript();
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded SnapEngage===');
+    return !!(window.SnapEngage && isObject(window.SnapEngage));
+  }
+
+  isReady() {
+    logger.debug('===In isReady SnapEngage===');
+
+    // Dashboard Other Settings
+    if (this.recordLiveChatEvents) {
+      const standardEventsMap = getHashFromArray(this.eventsToStandard);
+
+      recordingLiveChatEvents(this.updateEventNames, standardEventsMap, this.analytics);
+    }
+    return !!window.SnapEngage;
+  }
+
+  identify(htElement) {
+    logger.debug('===In SnapEngage Identify===');
+    const { message } = htElement;
+    const email = get(message, 'context.traits.email') || get(message, 'traits.email');
+
+    if (!email) {
+      logger.error('User parameter (email) is required for identify call');
+      return;
+    }
+    window.SnapEngage.setUserEmail(email);
+
+    const name = get(message, 'context.traits.name') || get(message, 'traits.name');
+
+    if (name) {
+      window.SnapEngage.setUserName(name);
+    }
+  }
+}
+
+export default SnapEngage;

package/src/integrations/SnapEngage/constants.js

@@ -0,0 +1,12 @@
+const NAME = 'SNAPENGAGE';
+const CNameMapping = {
+  [NAME]: NAME,
+  SnapEngage: NAME,
+  Snap_Engage: NAME,
+  snapengage: NAME,
+  'SNAP ENGAGE': NAME,
+  'Snap Engage': NAME,
+  'snap engage': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/SnapEngage/index.js

@@ -0,0 +1 @@
+export { default as SnapEngage } from './browser';

package/src/integrations/SnapEngage/nativeSdkLoader.js

@@ -0,0 +1,24 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(widgetId) {
+  (function (widgetId) {
+    const se = document.createElement('script');
+    se.type = 'text/javascript';
+    se.async = true;
+    se.src = `https://storage.googleapis.com/code.snapengage.com/js/${widgetId}.js`;
+    se.setAttribute('data-loader', LOAD_ORIGIN);
+    let done = false;
+    se.onload = se.onreadystatechange = function () {
+      if (
+        !done &&
+        (!this.readyState || this.readyState === 'loaded' || this.readyState === 'complete')
+      ) {
+        done = true;
+      }
+    };
+    const s = document.getElementsByTagName('script')[0];
+    s.parentNode.insertBefore(se, s);
+  })(widgetId);
+}
+
+export { loadNativeSdk };

package/src/integrations/SnapEngage/util.js

@@ -0,0 +1,63 @@
+const integrationContext = {
+  name: 'snapengage',
+  version: '1.0.0',
+};
+
+/**
+ * Exchanges key with value
+ * @param {*} data
+ * @returns
+ */
+function flip(data) {
+  return Object.fromEntries(Object.entries(data).map(([key, value]) => [value, key]));
+}
+
+function recordingLiveChatEvents(updateEventNames, standardEventsMap, analytics) {
+  const eventNames = flip(standardEventsMap);
+
+  window.SnapEngage.setCallback('StartChat', () => {
+    let eventName = 'Live Chat Conversation Started';
+    if (updateEventNames && eventNames?.startChat) {
+      eventName = eventNames.startChat;
+    }
+    analytics.track(`${eventName}`, {}, { context: { integration: integrationContext } });
+  });
+
+  window.SnapEngage.setCallback('ChatMessageReceived', (agent) => {
+    let eventName = 'Live Chat Message Received';
+    if (updateEventNames && eventNames?.chatMessageReceived) {
+      eventName = eventNames.chatMessageReceived;
+    }
+    analytics.track(
+      `${eventName}`,
+      { agentUsername: agent },
+      { context: { integration: integrationContext } },
+    );
+  });
+
+  window.SnapEngage.setCallback('ChatMessageSent', () => {
+    let eventName = 'Live Chat Message Sent';
+    if (updateEventNames && eventNames?.chatMessageSent) {
+      eventName = eventNames.chatMessageSent;
+    }
+    analytics.track(`${eventName}`, {}, { context: { integration: integrationContext } });
+  });
+
+  window.SnapEngage.setCallback('Close', () => {
+    let eventName = 'Live Chat Conversation Ended';
+    if (updateEventNames && eventNames?.close) {
+      eventName = eventNames.close;
+    }
+    analytics.track(`${eventName}`, {}, { context: { integration: integrationContext } });
+  });
+
+  window.SnapEngage.setCallback('InlineButtonClicked', () => {
+    let eventName = 'Inline Button Clicked';
+    if (updateEventNames && eventNames?.inlineButtonClicked) {
+      eventName = eventNames.inlineButtonClicked;
+    }
+    analytics.track(`${eventName}`, {}, { context: { integration: integrationContext } });
+  });
+}
+
+export { integrationContext, recordingLiveChatEvents };

package/src/integrations/SnapPixel/browser.js

@@ -0,0 +1,232 @@
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import Storage from '../../utils/storage';
+import logger from '../../utils/logUtil';
+
+import {
+  getEventMappingFromConfig,
+  removeUndefinedAndNullValues,
+  getHashFromArrayWithDuplicate,
+} from '../../utils/commonUtils';
+import { ecommEventPayload, eventPayload, getUserEmailAndPhone, sendEvent } from './util';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class SnapPixel {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.pixelId = config.pixelId;
+    this.hashMethod = config.hashMethod;
+    this.name = NAME;
+    this.deduplicationKey = config.deduplicationKey;
+    this.enableDeduplication = config.enableDeduplication;
+    this.eventMappingFromConfig = config.eventMappingFromConfig;
+    this.trackEvents = [
+      'SIGN_UP',
+      'OPEN_APP',
+      'SAVE',
+      'SUBSCRIBE',
+      'COMPLETE_TUTORIAL',
+      'INVITE',
+      'LOGIN',
+      'SHARE',
+      'RESERVE',
+      'ACHIEVEMENT_UNLOCKED',
+      'SPENT_CREDITS',
+      'RATE',
+      'START_TRIAL',
+      'LIST_VIEW',
+    ];
+
+    this.ecomEvents = {
+      PURCHASE: 'PURCHASE',
+      START_CHECKOUT: 'START_CHECKOUT',
+      ADD_CART: 'ADD_CART',
+      ADD_BILLING: 'ADD_BILLING',
+      AD_CLICK: 'AD_CLICK',
+      AD_VIEW: 'AD_VIEW',
+      ADD_TO_WISHLIST: 'ADD_TO_WISHLIST',
+      VIEW_CONTENT: 'VIEW_CONTENT',
+      SEARCH: 'SEARCH',
+    };
+
+    this.customEvents = [
+      'custom_event_1',
+      'custom_event_2',
+      'custom_event_3',
+      'custom_event_4',
+      'custom_event_5',
+    ];
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===In init SnapPixel===');
+
+    loadNativeSdk();
+
+    const userTraits = Storage.getUserTraits();
+
+    const userEmail = userTraits?.email;
+    const userPhoneNumber = userTraits?.phone;
+
+    let payload = getUserEmailAndPhone(this.hashMethod, userEmail, userPhoneNumber);
+
+    payload = removeUndefinedAndNullValues(payload);
+    window.snaptr('init', this.pixelId, payload);
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded SnapPixel===');
+    return !!window.snaptr;
+  }
+
+  isReady() {
+    logger.debug('===In isReady SnapPixel===');
+    return !!window.snaptr;
+  }
+
+  identify(htElement) {
+    logger.debug('===In SnapPixel identify');
+
+    const { message } = htElement;
+
+    const userEmail = get(message, 'context.traits.email');
+    const userPhoneNumber = get(message, 'context.traits.phone');
+    const ipAddress = get(message, 'context.ip') || get(message, 'request_ip');
+    let payload = {};
+
+    if (!userEmail && !userPhoneNumber && !ipAddress) {
+      logger.error(
+        'User parameter (email or phone number or ip address) is required for Identify call.',
+      );
+      return;
+    }
+
+    payload = getUserEmailAndPhone(this.hashMethod, userEmail, userPhoneNumber);
+    payload = { ...payload, ip_address: ipAddress };
+
+    payload = removeUndefinedAndNullValues(payload);
+    window.snaptr('init', this.pixelId, payload);
+  }
+
+  track(htElement) {
+    logger.debug('===In SnapPixel track===');
+
+    const { message } = htElement;
+    const { event } = message;
+    const eventMappingFromConfigMap = getHashFromArrayWithDuplicate(
+      this.eventMappingFromConfig,
+      'from',
+      'to',
+      false,
+    );
+
+    if (!event) {
+      logger.error('Event name not present');
+      return;
+    }
+
+    try {
+      if (eventMappingFromConfigMap[event]) {
+        // mapping event from UI
+        const events = getEventMappingFromConfig(event, eventMappingFromConfigMap);
+        events.forEach((ev) => {
+          sendEvent(
+            ev,
+            ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+          );
+        });
+      } else {
+        switch (event.toLowerCase().trim()) {
+          case 'order completed':
+            sendEvent(
+              this.ecomEvents.PURCHASE,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          case 'checkout started':
+            sendEvent(
+              this.ecomEvents.START_CHECKOUT,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          case 'product added':
+            sendEvent(
+              this.ecomEvents.ADD_CART,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          case 'payment info entered':
+            sendEvent(
+              this.ecomEvents.ADD_BILLING,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          case 'promotion clicked':
+            sendEvent(
+              this.ecomEvents.AD_CLICK,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          case 'promotion viewed':
+            sendEvent(
+              this.ecomEvents.AD_VIEW,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          case 'product added to wishlist':
+            sendEvent(
+              this.ecomEvents.ADD_TO_WISHLIST,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          case 'product viewed':
+          case 'product list viewed':
+            sendEvent(
+              this.ecomEvents.VIEW_CONTENT,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          case 'products searched':
+            sendEvent(
+              this.ecomEvents.SEARCH,
+              ecommEventPayload(event, message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+          default:
+            if (
+              !this.trackEvents.includes(event.trim().toUpperCase()) &&
+              !this.customEvents.includes(event.trim().toLowerCase())
+            ) {
+              logger.error("Event doesn't match with Snap Pixel Events!");
+              return;
+            }
+            sendEvent(
+              event,
+              eventPayload(message, this.deduplicationKey, this.enableDeduplication),
+            );
+            break;
+        }
+      }
+    } catch (err) {
+      logger.error('[Snap Pixel] track failed with following error', err);
+    }
+  }
+
+  page(htElement) {
+    logger.debug('===In SnapPixel page===');
+
+    const { message } = htElement;
+    sendEvent('PAGE_VIEW', eventPayload(message, this.deduplicationKey, this.enableDeduplication));
+  }
+}
+
+export default SnapPixel;

package/src/integrations/SnapPixel/constants.js

@@ -0,0 +1,13 @@
+const NAME = 'SNAP_PIXEL';
+const CNameMapping = {
+  [NAME]: NAME,
+  Snap_Pixel: NAME,
+  SnapPixel: NAME,
+  SNAPPIXEL: NAME,
+  snappixel: NAME,
+  'Snap Pixel': NAME,
+  'SNAP PIXEL': NAME,
+  'snap pixel': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/SnapPixel/index.js

@@ -0,0 +1 @@
+export { default as SnapPixel } from './browser';

package/src/integrations/SnapPixel/nativeSdkLoader.js

@@ -0,0 +1,20 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk() {
+  (function (e, t, n) {
+    if (e.snaptr) return;
+    var a = (e.snaptr = function () {
+      a.handleRequest ? a.handleRequest.apply(a, arguments) : a.queue.push(arguments);
+    });
+    a.queue = [];
+    const s = 'script';
+    const r = t.createElement(s);
+    r.async = !0;
+    r.src = n;
+    r.setAttribute('data-loader', LOAD_ORIGIN);
+    const u = t.getElementsByTagName(s)[0];
+    u.parentNode.insertBefore(r, u);
+  })(window, document, 'https://sc-static.net/scevent.min.js');
+}
+
+export { loadNativeSdk };