castled-js-sdk 0.0.1 → 0.0.3

package/src/integrations/LaunchDarkly/utils.js

@@ -0,0 +1,24 @@
+const createUser = (message, anonymousUsersSharedKey = undefined) => {
+  const user = {
+    key: message.userId || message.anonymousId,
+  };
+  const { traits } = message.context;
+  if (traits.anonymous !== undefined) {
+    user.anonymous = traits.anonymous;
+    if (anonymousUsersSharedKey) user.key = anonymousUsersSharedKey;
+  }
+  if (traits.avatar !== undefined) user.avatar = traits.avatar;
+  if (traits.country !== undefined) user.country = traits.country;
+  if (traits.custom !== undefined) user.custom = traits.custom;
+  if (traits.email !== undefined) user.email = traits.email;
+  if (traits.firstName !== undefined) user.firstName = traits.firstName;
+  if (traits.ip !== undefined) user.ip = traits.ip;
+  if (traits.lastName !== undefined) user.lastName = traits.lastName;
+  if (traits.name !== undefined) user.name = traits.name;
+  if (traits.privateAttributeNames !== undefined)
+    user.privateAttributeNames = traits.privateAttributeNames;
+  if (traits.secondary !== undefined) user.secondary = traits.secondary;
+  return user;
+};
+
+export default createUser;

package/src/integrations/Lemnisk/browser.js

@@ -0,0 +1,85 @@
+/* eslint-disable class-methods-use-this */
+import Logger from '../../utils/logger';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(NAME);
+class Lemnisk {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.accountId = config.accountId;
+    this.sdkWriteKey = config.sdkWriteKey;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===in init Lemnisk Marketing Automation===');
+    loadNativeSdk(this.accountId, this.sdkWriteKey);
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Lemnisk Marketing Automation===');
+    return !!window.lmSMTObj;
+  }
+
+  isReady() {
+    logger.debug('===In isReady Lemnisk Marketing Automation===');
+    return !!window.lmSMTObj;
+  }
+
+  identify(htElement) {
+    logger.debug('===In Lemnisk Marketing Automation identify===');
+
+    const userId = htElement.message.userId || htElement.message.anonymousId;
+    if (!userId) {
+      logger.debug('[Lemnisk] identify:: user id is required');
+      return;
+    }
+    const { message } = htElement;
+    const context = message?.context || {};
+    const traits = context?.traits || {};
+    traits.isRudderEvents = true;
+    window.lmSMTObj.identify(userId, traits);
+  }
+
+  track(htElement) {
+    logger.debug('===In Lemnisk Marketing Automation track===');
+    const { event, properties } = htElement.message;
+
+    if (!event) {
+      logger.error('[Lemnisk] track:: Event name is missing!');
+      return;
+    }
+    if (properties) {
+      properties.isRudderEvents = true;
+      window.lmSMTObj.track(event, properties);
+    } else {
+      window.lmSMTObj.track(event, { isRudderEvents: true });
+    }
+  }
+
+  page(htElement) {
+    logger.debug('===In Lemnisk Marketing Automation page===');
+    const { name, properties } = htElement.message;
+    if (name && !properties) {
+      window.lmSMTObj.page(name, { isRudderEvents: true });
+    } else if (!name && properties) {
+      properties.isRudderEvents = true;
+      window.lmSMTObj.page(properties);
+    } else if (name && properties) {
+      properties.isRudderEvents = true;
+      window.lmSMTObj.page(name, properties);
+    } else {
+      window.lmSMTObj.page({ isRudderEvents: true });
+    }
+  }
+}
+export default Lemnisk;

package/src/integrations/Lemnisk/constants.js

@@ -0,0 +1,13 @@
+const NAME = 'LEMNISK';
+const CNameMapping = {
+  [NAME]: NAME,
+  'LEMNISK_MARKETING_AUTOMATION': NAME,
+  'Lemnisk Marketing Automation': NAME,
+  'LemniskMarketingAutomation': NAME,
+  'lemniskmarketingautomation': NAME,
+  'lemniskMarketingAutomation': NAME,
+  'lemnisk': NAME,
+  'Lemnisk': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Lemnisk/index.js

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

package/src/integrations/Lemnisk/nativeSdkLoader.js

@@ -0,0 +1,34 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(accountId, sdkWriteKey) {
+  (function (window, tag, o, a, r) {
+    var methods = ['init', 'page', 'track', 'identify'];
+    window.lmSMTObj = window.lmSMTObj || [];
+
+    for (var i = 0; i < methods.length; i++) {
+      lmSMTObj[methods[i]] = (function (methodName) {
+        return function () {
+          lmSMTObj.push([methodName].concat(Array.prototype.slice.call(arguments)));
+        };
+      })(methods[i]);
+    }
+    // eslint-disable-next-line no-param-reassign
+    a = o.getElementsByTagName('head')[0];
+    // eslint-disable-next-line no-param-reassign
+    r = o.createElement('script');
+    r.setAttribute('data-loader', LOAD_ORIGIN);
+    r.type = 'text/javascript';
+    r.async = 1;
+    r.src = tag;
+    a.appendChild(r);
+  })(
+    window,
+    document.location.protocol === 'https:'
+      ? `https://cdn25.lemnisk.co/ssp/st/${accountId}.js`
+      : `http://cdn25.lemnisk.co/ssp/st/${accountId}.js`,
+    document,
+  );
+  window.lmSMTObj.init(sdkWriteKey);
+}
+
+export { loadNativeSdk };

package/src/integrations/LinkedInInsightTag/browser.js

@@ -0,0 +1,71 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import ScriptLoader from '../../utils/ScriptLoader';
+import { getHashFromArrayWithDuplicate } from '../../utils/commonUtils';
+import { NAME } from './constants';
+
+class LinkedInInsightTag {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.partnerId = config.partnerId;
+    this.eventToConversionIdMap = config.eventToConversionIdMap;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===in init LinkedIn Insight Tag===');
+    ScriptLoader('LinkedIn Insight Tag', 'https://snap.licdn.com/li.lms-analytics/insight.min.js');
+    if (!this.partnerId) {
+      return;
+    }
+    window._linkedin_data_partner_id = this.partnerId;
+  }
+
+  isLoaded() {
+    logger.debug('=== in isLoaded LinkedIn Insight Tag===');
+    return !!window._linkedin_data_partner_id;
+  }
+
+  isReady() {
+    logger.debug('=== in isReady LinkedIn Insight Tag===');
+    return !!window._linkedin_data_partner_id;
+  }
+
+  track(htElement) {
+    logger.debug('===In LinkedIn Insight Tag Track===');
+    const { message } = htElement;
+    const { event } = message;
+    if (!event) {
+      logger.error('[LinkedIn Insight Tag]: Event name is missing for track call.');
+      return;
+    }
+    const trimmedEvent = event.trim();
+    const eventMapping = getHashFromArrayWithDuplicate(
+      this.eventToConversionIdMap,
+      'from',
+      'to',
+      false,
+    );
+    if (!eventMapping[trimmedEvent]) {
+      logger.debug(
+        `The "${event}" event is not mapped in the destination dashboard. It'll be skipped.`,
+      );
+      return;
+    }
+    const eventArray = eventMapping[trimmedEvent] || [];
+    eventArray.forEach((eventValue) => {
+      window.lintrk('track', { conversion_id: eventValue });
+    });
+  }
+}
+
+export default LinkedInInsightTag;

package/src/integrations/LinkedInInsightTag/constants.js

@@ -0,0 +1,16 @@
+const NAME = 'LINKEDIN_INSIGHT_TAG';
+const CNameMapping = {
+  [NAME]: NAME,
+  'LinkedIn Insight Tag': NAME,
+  'LinkedIn insight tag': NAME,
+  'linkedIn insight tag': NAME,
+  Linkedin_insight_tag: NAME,
+  LinkedinInsighttag: NAME,
+  LinkedinInsightTag: NAME,
+  LinkedInInsightTag: NAME,
+  Linkedininsighttag: NAME,
+  LINKEDININSIGHTTAG: NAME,
+  linkedininsighttag: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/LinkedInInsightTag/index.js

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

package/src/integrations/LiveChat/browser.js

@@ -0,0 +1,82 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+
+import { recordingLiveChatEvents } from './util';
+import { isObject } from '../../utils/utils';
+import { flattenJson } from '../../utils/commonUtils';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class LiveChat {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.licenseId = config.licenseId;
+    this.recordLiveChatEvents = config.recordLiveChatEvents;
+    this.eventsToStandard = config.eventsToStandard;
+    this.updateEventNames = config.updateEventNames;
+    this.eventsList = config.eventsList;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===in init Livechat===');
+    loadNativeSdk(this.licenseId);
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded LiveChat===');
+    return !!(window.LiveChatWidget && isObject(window.LiveChatWidget));
+  }
+
+  isReady() {
+    logger.debug('===In isReady LiveChat===');
+
+    // Dashboard Other Settings
+    if (this.recordLiveChatEvents) {
+      recordingLiveChatEvents(
+        this.updateEventNames,
+        this.eventsList,
+        this.eventsToStandard,
+        this.analytics,
+      );
+    }
+    return !!window.LiveChatWidget;
+  }
+
+  identify(htElement) {
+    logger.debug('===In LiveChat Identify===');
+    const { message } = htElement;
+    const { userId, context } = message;
+    const { traits } = context;
+    const email = get(message, 'context.traits.email');
+
+    if (email) {
+      window.LiveChatWidget.call('set_customer_email', email);
+    } else {
+      logger.error('User parameter (email) ,required for identify call, not found.');
+    }
+
+    const name = get(message, 'context.traits.name');
+
+    if (name) {
+      window.LiveChatWidget.call('set_customer_name', name);
+    }
+    if (traits) {
+      const flattenTraits = flattenJson(traits);
+      if (userId) flattenTraits.userId = userId;
+      window.LiveChatWidget.call('set_session_variables', flattenTraits);
+    }
+  }
+}
+
+export default LiveChat;

package/src/integrations/LiveChat/constants.js

@@ -0,0 +1,12 @@
+const NAME = 'LIVECHAT';
+const CNameMapping = {
+  [NAME]: NAME,
+  LiveChat: NAME,
+  Live_Chat: NAME,
+  livechat: NAME,
+  'LIVE CHAT': NAME,
+  'Live Chat': NAME,
+  'live chat': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/LiveChat/index.js

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

package/src/integrations/LiveChat/nativeSdkLoader.js

@@ -0,0 +1,40 @@
+function loadNativeSdk(licenseId) {
+  window.__lc = window.__lc || {};
+  window.__lc.license = licenseId;
+  (function (n, t, c) {
+    function i(n) {
+      return e._h ? e._h.apply(null, n) : e._q.push(n);
+    }
+    var e = {
+      _q: [],
+      _h: null,
+      _v: '2.0',
+      on: function () {
+        i(['on', c.call(arguments)]);
+      },
+      once: function () {
+        i(['once', c.call(arguments)]);
+      },
+      off: function () {
+        i(['off', c.call(arguments)]);
+      },
+      get: function () {
+        if (!e._h) throw new Error("[LiveChatWidget] You can't use getters before load.");
+        return i(['get', c.call(arguments)]);
+      },
+      call: function () {
+        i(['call', c.call(arguments)]);
+      },
+      init: function () {
+        var n = t.createElement('script');
+        (n.async = !0),
+          (n.type = 'text/javascript'),
+          (n.src = 'https://cdn.livechatinc.com/tracking.js'),
+          t.head.appendChild(n);
+      },
+    };
+    !n.__lc.asyncInit && e.init(), (n.LiveChatWidget = n.LiveChatWidget || e);
+  })(window, document, [].slice);
+}
+
+export { loadNativeSdk };

package/src/integrations/LiveChat/util.js

@@ -0,0 +1,71 @@
+/* eslint-disable func-names */
+import { getHashFromArray } from '../../utils/commonUtils';
+
+const integrationContext = {
+  name: 'LiveChat',
+  version: '1.0.0',
+};
+
+/**
+ * This function is used to trigger a callback.
+ * @param {*} standardEventsMap mapping of events done by the user
+ * @param {*} eventName standard event name
+ * @param {*} updateEventNames boolean variable to change eventName.
+ * @param {*} analytics hightouchevents object
+ */
+const makeACall = (standardEventsMap, eventName, updateEventNames, analytics) => {
+  // Updating the event name with any mapping from the webapp if available else
+  // storing default event name in the updatedEvent
+  const updatedEvent =
+    standardEventsMap[eventName] && updateEventNames ? standardEventsMap[eventName] : eventName;
+
+  analytics.track(`${updatedEvent}`, {}, { context: { integration: integrationContext } });
+};
+
+const swapKeyValuePairs = (standardEventsMap) => {
+  const swappedEventsMap = {};
+  Object.keys(standardEventsMap).forEach((key) => {
+    swappedEventsMap[standardEventsMap[key]] = key;
+  });
+  return swappedEventsMap;
+};
+
+/**
+ * This function has event listeners for the occurring events and to make a call for the event after
+ * collecting the data.
+ * @param {*} updateEventNames variable to Update event name .
+ * @param {*} userDefinedEventsList List of requested events by the user.
+ * @param {*} userDefinedEventsMapping Mapping of events in the webapp by the user
+ * @param {*} analytics hightouchevents object
+ */
+function recordingLiveChatEvents(
+  updateEventNames,
+  userDefinedEventsList,
+  userDefinedEventsMapping,
+  analytics,
+) {
+  let standardEventsMap = getHashFromArray(userDefinedEventsMapping);
+  standardEventsMap = swapKeyValuePairs(standardEventsMap);
+  (function (api) {
+    [
+      'ready',
+      'new_event',
+      'form_submitted',
+      'greeting_hidden',
+      'rating_submitted',
+      'visibility_changed',
+      'greeting_displayed',
+      'availability_changed',
+      'customer_status_changed',
+      'rich_message_button_clicked',
+    ].forEach((eventName) => {
+      if (userDefinedEventsList.includes(eventName)) {
+        api.on(eventName, () => {
+          makeACall(standardEventsMap, eventName, updateEventNames, analytics);
+        });
+      }
+    });
+  })(window.LiveChatWidget);
+}
+
+export { integrationContext, recordingLiveChatEvents };

package/src/integrations/Lotame/LotameStorage.js

@@ -0,0 +1,21 @@
+import Storage from '../../utils/storage';
+
+const defaults = {
+  lotame_synch_time_key: 'lt_synch_timestamp',
+};
+
+class LotameStorage {
+  constructor() {
+    this.storage = Storage;
+  }
+
+  setLotameSynchTime(value) {
+    this.storage.setItem(defaults.lotame_synch_time_key, value);
+  }
+
+  getLotameSynchTime() {
+    return this.storage.getItem(defaults.lotame_synch_time_key);
+  }
+}
+const lotameStorage = new LotameStorage();
+export { lotameStorage as LotameStorage };

package/src/integrations/Lotame/browser.js

@@ -0,0 +1,172 @@
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import { LotameStorage } from './LotameStorage';
+import { NAME } from './constants';
+
+class Lotame {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.name = NAME;
+    this.analytics = analytics;
+    this.storage = LotameStorage;
+    this.bcpUrlSettingsPixel = config.bcpUrlSettingsPixel;
+    this.bcpUrlSettingsIframe = config.bcpUrlSettingsIframe;
+    this.dspUrlSettingsPixel = config.dspUrlSettingsPixel;
+    this.dspUrlSettingsIframe = config.dspUrlSettingsIframe;
+    this.mappings = {};
+    config?.mappings?.forEach((mapping) => {
+      const { key } = mapping;
+      const { value } = mapping;
+      this.mappings[key] = value;
+    });
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===in init Lotame===');
+    window.LOTAME_SYNCH_CALLBACK = () => {};
+  }
+
+  isLoaded() {
+    logger.debug('in Lotame isLoaded');
+    return true;
+  }
+
+  isReady() {
+    return true;
+  }
+
+  addPixel(source, width, height) {
+    logger.debug(`Adding pixel for :: ${source}`);
+
+    const image = document.createElement('img');
+    image.src = source;
+    image.setAttribute('width', width);
+    image.setAttribute('height', height);
+
+    logger.debug(`Image Pixel :: ${image}`);
+    document.getElementsByTagName('body')[0].appendChild(image);
+  }
+
+  addIFrame(source) {
+    logger.debug(`Adding iframe for :: ${source}`);
+
+    const iframe = document.createElement('iframe');
+    iframe.src = source;
+    iframe.title = 'empty';
+    iframe.setAttribute('id', 'LOTCCFrame');
+    iframe.setAttribute('tabindex', '-1');
+    iframe.setAttribute('role', 'presentation');
+    iframe.setAttribute('aria-hidden', 'true');
+    iframe.setAttribute('style', 'border: 0px; width: 0px; height: 0px; display: block;');
+
+    logger.debug(`IFrame :: ${iframe}`);
+    document.getElementsByTagName('body')[0].appendChild(iframe);
+  }
+
+  syncPixel(userId) {
+    logger.debug('===== in syncPixel ======');
+
+    logger.debug('Firing DSP Pixel URLs');
+    if (this.dspUrlSettingsPixel && this.dspUrlSettingsPixel.length > 0) {
+      const currentTime = Date.now();
+      this.dspUrlSettingsPixel.forEach((urlSettings) => {
+        const dspUrl = this.compileUrl(
+          { ...this.mappings, userId, random: currentTime },
+          urlSettings.dspUrlTemplate,
+        );
+        this.addPixel(dspUrl, '1', '1');
+      });
+    }
+
+    logger.debug('Firing DSP IFrame URLs');
+    if (this.dspUrlSettingsIframe && this.dspUrlSettingsIframe.length > 0) {
+      const currentTime = Date.now();
+      this.dspUrlSettingsIframe.forEach((urlSettings) => {
+        const dspUrl = this.compileUrl(
+          { ...this.mappings, userId, random: currentTime },
+          urlSettings.dspUrlTemplate,
+        );
+        this.addIFrame(dspUrl);
+      });
+    }
+
+    this.storage.setLotameSynchTime(Date.now());
+    // emit on syncPixel
+    if (this.analytics.methodToCallbackMapping.syncPixel) {
+      this.analytics.emit('syncPixel', {
+        destination: this.name,
+      });
+    }
+  }
+
+  compileUrl(map, url) {
+    let compiledUrl = url;
+    Object.keys(map).forEach((key) => {
+      if (Object.prototype.hasOwnProperty.call(map, key)) {
+        const value = map[key];
+        const replaceKey = `{{${key}}}`;
+        const regex = new RegExp(replaceKey, 'gi');
+        compiledUrl = compiledUrl.replace(regex, value);
+      }
+    });
+    return compiledUrl;
+  }
+
+  identify(htElement) {
+    logger.debug('in Lotame identify');
+    const { userId } = htElement.message;
+    this.syncPixel(userId);
+  }
+
+  page(htElement) {
+    logger.debug('in Lotame page');
+
+    logger.debug('Firing BCP Pixel URLs');
+    if (this.bcpUrlSettingsPixel && this.bcpUrlSettingsPixel.length > 0) {
+      const currentTime = Date.now();
+      this.bcpUrlSettingsPixel.forEach((urlSettings) => {
+        const bcpUrl = this.compileUrl(
+          { ...this.mappings, random: currentTime },
+          urlSettings.bcpUrlTemplate,
+        );
+        this.addPixel(bcpUrl, '1', '1');
+      });
+    }
+
+    logger.debug('Firing BCP IFrame URLs');
+    if (this.bcpUrlSettingsIframe && this.bcpUrlSettingsIframe.length > 0) {
+      const currentTime = Date.now();
+      this.bcpUrlSettingsIframe.forEach((urlSettings) => {
+        const bcpUrl = this.compileUrl(
+          { ...this.mappings, random: currentTime },
+          urlSettings.bcpUrlTemplate,
+        );
+        this.addIFrame(bcpUrl);
+      });
+    }
+
+    if (htElement.message.userId && this.isPixelToBeSynched()) {
+      this.syncPixel(htElement.message.userId);
+    }
+  }
+
+  isPixelToBeSynched() {
+    const lastSynchedTime = this.storage.getLotameSynchTime();
+    const currentTime = Date.now();
+    if (!lastSynchedTime) {
+      return true;
+    }
+
+    const difference = Math.floor((currentTime - lastSynchedTime) / (1000 * 3600 * 24));
+    return difference >= 7;
+  }
+}
+
+export { Lotame };

package/src/integrations/Lotame/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'LOTAME';
+const CNameMapping = {
+  [NAME]: NAME,
+  Lotame: NAME,
+  lotame: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Lotame/index.js

@@ -0,0 +1 @@
+export { Lotame } from './browser';