castled-js-sdk 0.0.1 → 0.0.2

package/src/integrations/Olark/browser.js

@@ -0,0 +1,94 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import { NAME } from './constants';
+import Logger from '../../utils/logger';
+import { recordingLiveChatEvents } from './utils';
+import { getHashFromArray } from '../../utils/commonUtils';
+import { getDefinedTraits } from '../../utils/utils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(NAME);
+class Olark {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.siteId = config.siteId;
+    this.groupId = config.groupId;
+    this.recordLiveChatEvents = config.recordLiveChatEvents;
+    this.standardToEvent = config.standardToEvent;
+    this.updateEventNames = config.updateEventNames;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    loadNativeSdk();
+    /* custom configuration goes here (www.olark.com/documentation) */
+    window.olark.identify(this.siteId);
+
+    if (this.groupId) {
+      window.olark('api.chat.setOperatorGroup', { group: this.groupId });
+    }
+  }
+
+  init() {
+    logger.debug('===In init Olark===');
+    this.loadScript();
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Olark===');
+    return !!window.olark;
+  }
+
+  isReady() {
+    logger.debug('===In isReady Olark===');
+
+    // Dashboard Other Settings
+    if (this.recordLiveChatEvents) {
+      const standardEventsMap = getHashFromArray(this.standardToEvent, 'from', 'to', false);
+
+      recordingLiveChatEvents(this.updateEventNames, standardEventsMap, this.analytics);
+    }
+    return !!window.olark;
+  }
+
+  identify(htElement) {
+    logger.debug('===In Olark Identify===');
+    const { message } = htElement;
+    const { context } = message;
+
+    const userTraits = getDefinedTraits(message);
+
+    if (context.traits) {
+      const { traits } = context;
+      window.olark('api.visitor.updateCustomFields', traits);
+    }
+
+    if (userTraits?.email) {
+      window.olark('api.visitor.updateEmailAddress', {
+        emailAddress: userTraits.email,
+      });
+    }
+
+    if (userTraits?.name) {
+      window.olark('api.visitor.updateFullName', {
+        fullName: userTraits.name,
+      });
+    }
+
+    if (userTraits?.phone) {
+      window.olark('api.visitor.updatePhoneNumber', {
+        phoneNumber: userTraits.phone,
+      });
+    }
+  }
+}
+
+export default Olark;

package/src/integrations/Olark/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'OLARK';
+const CNameMapping = {
+  [NAME]: NAME,
+  Olark: NAME,
+  olark: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Olark/index.js

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

package/src/integrations/Olark/nativeSdkLoader.js

@@ -0,0 +1,31 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk() {
+  (function (o, l, a, r, k, y) {
+    if (o.olark) return;
+    r = 'script';
+    y = l.createElement(r);
+    r = l.getElementsByTagName(r)[0];
+    y.async = 1;
+    y.src = '//' + a;
+    y.setAttribute('data-loader', LOAD_ORIGIN);
+    r.parentNode.insertBefore(y, r);
+    y = o.olark = function () {
+      k.s.push(arguments);
+      k.t.push(+new Date());
+    };
+    y.extend = function (i, j) {
+      y('extend', i, j);
+    };
+    y.identify = function (i) {
+      y('identify', (k.i = i));
+    };
+    y.configure = function (i, j) {
+      y('configure', i, j);
+      k.c[i] = j;
+    };
+    k = y._ = { s: [], t: [+new Date()], c: {}, l: a };
+  })(window, document, 'static.olark.com/jsclient/loader.js');
+}
+
+export { loadNativeSdk };

package/src/integrations/Olark/utils.js

@@ -0,0 +1,51 @@
+const integrationContext = {
+  name: 'olark',
+  version: '1.0.0',
+};
+
+function recordingLiveChatEvents(updateEventNames, standardEventsMap, analytics) {
+  const eventNames = standardEventsMap;
+  window.olark('api.chat.onBeginConversation', () => {
+    let eventName = 'Live Chat Conversation Started';
+    if (updateEventNames && eventNames?.startChat) {
+      eventName = eventNames.startChat;
+    }
+    analytics.track(
+      `${eventName}`,
+      {},
+      {
+        context: { integration: integrationContext },
+      },
+    );
+  });
+
+  window.olark('api.chat.onMessageToOperator', () => {
+    let eventName = 'Live Chat Message Sent';
+    if (updateEventNames && eventNames?.chatMessageSent) {
+      eventName = eventNames.chatMessageSent;
+    }
+    analytics.track(
+      `${eventName}`,
+      {},
+      {
+        context: { integration: integrationContext },
+      },
+    );
+  });
+
+  window.olark('api.chat.onMessageToVisitor', () => {
+    let eventName = 'Live Chat Message Received';
+    if (updateEventNames && eventNames?.chatMessageReceived) {
+      eventName = eventNames.chatMessageReceived;
+    }
+    analytics.track(
+      `${eventName}`,
+      {},
+      {
+        context: { integration: integrationContext },
+      },
+    );
+  });
+}
+
+export { integrationContext, recordingLiveChatEvents };

package/src/integrations/Optimizely/browser.js

@@ -0,0 +1,230 @@
+/* eslint-disable class-methods-use-this */
+import { mapRudderPropsToOptimizelyProps } from './utils';
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+
+class Optimizely {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.sendExperimentTrack = config.sendExperimentTrack;
+    this.sendExperimentIdentify = config.sendExperimentIdentify;
+    this.sendExperimentTrackAsNonInteractive = config.sendExperimentTrackAsNonInteractive;
+    this.revenueOnlyOnOrderCompleted = config.revenueOnlyOnOrderCompleted;
+    this.trackCategorizedPages = config.trackCategorizedPages;
+    this.trackNamedPages = config.trackNamedPages;
+    this.customCampaignProperties = config.customCampaignProperties
+      ? config.customCampaignProperties
+      : [];
+    this.customExperimentProperties = config.customExperimentProperties
+      ? config.customExperimentProperties
+      : [];
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('=== in optimizely init ===');
+    this.initOptimizelyIntegration(this.referrerOverride, this.sendDataToRudder);
+  }
+
+  isLoaded() {
+    return !!(window.optimizely && window.optimizely.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return !!(window.optimizely && window.optimizely.push !== Array.prototype.push);
+  }
+
+  referrerOverride = (referrer) => {
+    if (referrer) {
+      window.optimizelyEffectiveReferrer = referrer;
+      return referrer;
+    }
+    return undefined;
+  };
+
+  sendDataToRudder = (campaignState) => {
+    logger.debug(campaignState);
+    const { experiment, variation } = campaignState;
+    const context = { integrations: { All: true } };
+    const { audiences, campaignName, id, isInCampaignHoldback } = campaignState;
+
+    // Reformatting this data structure into hash map so concatenating variation ids and names is easier later
+    const audiencesMap = {};
+    audiences.forEach((audience) => {
+      audiencesMap[audience.id] = audience.name;
+    });
+
+    const audienceIds = Object.keys(audiencesMap)
+      .sort((a, b) => a.localeCompare(b))
+      .join();
+    const audienceNames = Object.values(audiencesMap)
+      .sort((a, b) => a.localeCompare(b))
+      .join(', ');
+
+    if (this.sendExperimentTrack) {
+      let props = {
+        campaignName,
+        campaignId: id,
+        experimentId: experiment.id,
+        experimentName: experiment.name,
+        variationName: variation.name,
+        variationId: variation.id,
+        audienceId: audienceIds, // eg. '7527562222,7527111138'
+        audienceName: audienceNames, // eg. 'Peaky Blinders, Trust Tree'
+        isInCampaignHoldback,
+      };
+
+      // If this was a redirect experiment and the effective referrer is different from document.referrer,
+      // this value is made available. So if a customer came in via google.com/ad -> tb12.com -> redirect experiment -> Belichickgoat.com
+      // `experiment.referrer` would be google.com/ad here NOT `tb12.com`.
+      if (experiment.referrer) {
+        props.referrer = experiment.referrer;
+        context.page = { referrer: experiment.referrer };
+      }
+
+      // For Google's nonInteraction flag
+      if (this.sendExperimentTrackAsNonInteractive) props.nonInteraction = 1;
+
+      // If customCampaignProperties is provided override the props with it.
+      // If valid customCampaignProperties present it will override existing props.
+      // const data = window.optimizely && window.optimizely.get("data");
+      props = mapRudderPropsToOptimizelyProps(props, campaignState, this.customCampaignProperties);
+
+      // Send to Rudder
+      this.analytics.track('Experiment Viewed', props, context);
+    }
+    if (this.sendExperimentIdentify) {
+      const traits = {};
+      traits[`Experiment: ${experiment.name}`] = variation.name;
+
+      // Send to Rudder
+      this.analytics.identify(traits);
+    }
+  };
+
+  initOptimizelyIntegration(referrerOverride, sendCampaignData) {
+    const newActiveCampaign = (id, referrer) => {
+      const state = window?.optimizely?.get('state');
+      if (state) {
+        const activeCampaigns = state.getCampaignStates({
+          isActive: true,
+        });
+        const campaignState = activeCampaigns[id];
+        if (referrer) campaignState.experiment.referrer = referrer;
+        sendCampaignData(campaignState);
+      }
+    };
+
+    const checkReferrer = () => {
+      const state = window?.optimizely?.get('state');
+      if (state) {
+        const referrer = state.getRedirectInfo() && state.getRedirectInfo().referrer;
+
+        if (referrer) {
+          referrerOverride(referrer);
+          return referrer;
+        }
+      }
+      return undefined;
+    };
+
+    const registerFutureActiveCampaigns = () => {
+      window.optimizely = window.optimizely || [];
+      window.optimizely.push({
+        type: 'addListener',
+        filter: {
+          type: 'lifecycle',
+          name: 'campaignDecided',
+        },
+        handler(event) {
+          const { id } = event.data.campaign;
+          newActiveCampaign(id);
+        },
+      });
+    };
+
+    const registerCurrentlyActiveCampaigns = () => {
+      window.optimizely = window.optimizely || [];
+      const state = window?.optimizely?.get('state');
+      if (state) {
+        const referrer = checkReferrer();
+        const activeCampaigns = state.getCampaignStates({
+          isActive: true,
+        });
+        Object.keys(activeCampaigns).forEach((id) => {
+          if (referrer) {
+            newActiveCampaign(id, referrer);
+          } else {
+            newActiveCampaign(id);
+          }
+        });
+      } else {
+        window.optimizely.push({
+          type: 'addListener',
+          filter: {
+            type: 'lifecycle',
+            name: 'initialized',
+          },
+          handler() {
+            checkReferrer();
+          },
+        });
+      }
+    };
+    registerCurrentlyActiveCampaigns();
+    registerFutureActiveCampaigns();
+  }
+
+  track(htElement) {
+    logger.debug('in Optimizely web track');
+    const eventProperties = htElement.message.properties;
+    const { event } = htElement.message;
+    if (eventProperties.revenue && this.revenueOnlyOnOrderCompleted) {
+      if (event === 'Order Completed') {
+        eventProperties.revenue = Math.round(eventProperties.revenue * 100);
+      } else if (event !== 'Order Completed') {
+        delete eventProperties.revenue;
+      }
+    }
+    const eventName = event.replace(/:/g, '_'); // can't have colons so replacing with underscores
+    const payload = {
+      type: 'event',
+      eventName,
+      tags: eventProperties,
+    };
+
+    window.optimizely.push(payload);
+  }
+
+  page(htElement) {
+    logger.debug('in Optimizely web page');
+
+    const clonedHtElement = htElement;
+    const { category } = clonedHtElement.message.properties;
+    const { name } = clonedHtElement.message;
+
+    // categorized pages
+    if (category && this.trackCategorizedPages) {
+      clonedHtElement.message.event = `Viewed ${category} page`;
+      clonedHtElement.message.type = 'track';
+      this.track(clonedHtElement);
+    }
+
+    // named pages
+    if (name && this.trackNamedPages) {
+      clonedHtElement.message.event = `Viewed ${name} page`;
+      clonedHtElement.message.type = 'track';
+      this.track(clonedHtElement);
+    }
+  }
+}
+
+export default Optimizely;

package/src/integrations/Optimizely/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'OPTIMIZELY';
+const CNameMapping = {
+  [NAME]: NAME,
+  Optimizely: NAME,
+  optimizely: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Optimizely/index.js

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

package/src/integrations/Optimizely/utils.js

@@ -0,0 +1,23 @@
+/**
+ * Returns updated mapped properties
+ * @param {*} props
+ * @param {*} campaignState
+ * @param {*} customCampaignProperties
+ * @returns
+ */
+const mapRudderPropsToOptimizelyProps = (props, campaignState, customCampaignProperties) => {
+  const properties = props;
+  if (campaignState && customCampaignProperties.length > 0) {
+    customCampaignProperties.forEach((customCampaignProperty) => {
+      const rudderProp = customCampaignProperties[customCampaignProperty].from;
+      const optimizelyProp = customCampaignProperties[customCampaignProperty].to;
+      if (typeof properties[optimizelyProp] !== 'undefined') {
+        properties[rudderProp] = properties[optimizelyProp];
+        delete properties[optimizelyProp];
+      }
+    });
+  }
+  return properties;
+};
+
+export { mapRudderPropsToOptimizelyProps };

package/src/integrations/Pendo/browser.js

@@ -0,0 +1,119 @@
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class Pendo {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.apiKey = !config.apiKey ? '' : config.apiKey;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+    logger.debug('Config ', config);
+  }
+
+  init() {
+    loadNativeSdk(this.apiKey);
+    this.initializeMe();
+    logger.debug('===in init Pendo===');
+  }
+
+  initializeMe() {
+    const userId =
+      this.analytics.getUserId() || this.constructPendoAnonymousId(this.analytics.getAnonymousId());
+
+    const accountObj = {
+      id: this.analytics.getGroupId(),
+      ...this.analytics.getGroupTraits(),
+    };
+    const visitorObj = { id: userId, ...this.analytics.getUserTraits() };
+
+    window.pendo.initialize({ account: accountObj, visitor: visitorObj });
+  }
+
+  /* utility functions ---Start here ---  */
+  isLoaded() {
+    return !!(window.pendo && window.pendo.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return !!(window.pendo && window.pendo.push !== Array.prototype.push);
+  }
+
+  constructPendoAnonymousId(id) {
+    return `_PENDO_T_${id}`;
+  }
+  /* utility functions --- Ends here ---  */
+
+  /*
+   * PENDO MAPPED FUNCTIONS :: identify, track, group
+   */
+
+  /* Pendo's identify call works intelligently, once u have identified a visitor/user,
+   *or associated a visitor to a group/account then Pendo save this data in local storage and
+   *any further upcoming calls are done taking user info from local.
+   * To track user pendo maps user to Visitor in Pendo.
+   */
+  identify(htElement) {
+    let visitorObj = {};
+    let accountObj = {};
+    const { groupId } = this.analytics;
+    const { userId, anonymousId } = htElement.message;
+    const id = userId || this.constructPendoAnonymousId(anonymousId);
+    visitorObj = {
+      id,
+      ...this.analytics.getUserTraits(),
+    };
+
+    if (groupId) {
+      accountObj = { id: groupId, ...this.analytics.getGroupTraits() };
+    }
+
+    window.pendo.identify({ visitor: visitorObj, account: accountObj });
+  }
+
+  /*
+   *Group call maps to an account for which visitor belongs.
+   *It is same as identify call but here we send account object.
+   */
+  group(htElement) {
+    let accountObj = {};
+    let visitorObj = {};
+    const { userId, traits, context } = htElement.message;
+    accountObj.id = this.analytics.getGroupId() || this.analytics.getAnonymousId();
+    accountObj = {
+      ...accountObj,
+      ...traits,
+    };
+
+    if (userId) {
+      visitorObj = {
+        id: userId,
+        ...context?.traits,
+      };
+    }
+
+    window.pendo.identify({ account: accountObj, visitor: visitorObj });
+  }
+
+  /* Once user is identified Pendo makes Track call to track user activity.
+   */
+  track(htElement) {
+    const { event, properties } = htElement.message;
+    if (!event) {
+      logger.error('Cannot call un-named track event');
+      return;
+    }
+    const props = properties;
+    window.pendo.track(event, props);
+  }
+}
+
+export { Pendo };

package/src/integrations/Pendo/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'PENDO';
+const CNameMapping = {
+  [NAME]: NAME,
+  Pendo: NAME,
+  pendo: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Pendo/index.js

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

package/src/integrations/Pendo/nativeSdkLoader.js

@@ -0,0 +1,32 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(apiKey) {
+  (function (apiKey) {
+    (function (p, e, n, d, o) {
+      let v;
+      let w;
+      let x;
+      let y;
+      let z;
+      o = p[d] = p[d] || {};
+      o._q = [];
+      v = ['initialize', 'identify', 'updateOptions', 'pageLoad', 'track'];
+      for (w = 0, x = v.length; w < x; ++w)
+        (function (m) {
+          o[m] =
+            o[m] ||
+            function () {
+              o._q[m === v[0] ? 'unshift' : 'push']([m].concat([].slice.call(arguments, 0)));
+            };
+        })(v[w]);
+      y = e.createElement(n);
+      y.setAttribute('data-loader', LOAD_ORIGIN);
+      y.async = !0;
+      y.src = `https://cdn.pendo.io/agent/static/${apiKey}/pendo.js`;
+      z = e.getElementsByTagName(n)[0];
+      z.parentNode.insertBefore(y, z);
+    })(window, document, 'script', 'pendo');
+  })(apiKey);
+}
+
+export { loadNativeSdk };