castled-js-sdk 0.0.1 → 0.0.3

package/src/integrations/AdobeAnalytics/browser.js

@@ -0,0 +1,276 @@
+/* eslint-disable class-methods-use-this */
+import * as utils from './util';
+import * as ecommUtils from './eCommHandle';
+import * as heartbeatUtils from './heartbeatHandle';
+import { getHashFromArray } from '../../utils/commonUtils';
+import ScriptLoader from '../../utils/ScriptLoader';
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+
+class AdobeAnalytics {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.trackingServerUrl = config.trackingServerUrl || '';
+    this.reportSuiteIds = config.reportSuiteIds;
+    this.heartbeatTrackingServerUrl = config.heartbeatTrackingServerUrl || '';
+    this.eventsToTypes = config.eventsToTypes || [];
+    this.marketingCloudOrgId = config.marketingCloudOrgId || '';
+    this.dropVisitorId = config.dropVisitorId;
+    this.trackingServerSecureUrl = config.trackingServerSecureUrl || '';
+    this.timestampOption = config.timestampOption;
+    this.preferVisitorId = config.preferVisitorId;
+    this.rudderEventsToAdobeEvents = config.rudderEventsToAdobeEvents || [];
+    this.proxyNormalUrl = config.proxyNormalUrl;
+    this.proxyHeartbeatUrl = config.proxyHeartbeatUrl;
+    this.pageName = '';
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+    utils.setConfig(config);
+  }
+
+  init() {
+    // check if was already initialised. If yes then use already existing.
+    window.s_account = window.s_account || this.reportSuiteIds;
+    // update playhead value of a session
+    window.rudderHBPlayheads = {};
+    // load separately as heartbeat sdk is large and need not be required if this is off.
+    const heartbeatUrl =
+      this.proxyHeartbeatUrl ||
+      'https://cdn.rudderlabs.com/adobe-analytics-js/adobe-analytics-js-heartbeat.js';
+    const normalUrl =
+      this.proxyNormalUrl || 'https://cdn.rudderlabs.com/adobe-analytics-js/adobe-analytics-js.js';
+    if (this.heartbeatTrackingServerUrl) {
+      ScriptLoader('adobe-analytics-heartbeat', heartbeatUrl);
+      this.setIntervalHandler = setInterval(this.initAdobeAnalyticsClient.bind(this), 1000);
+    } else {
+      ScriptLoader('adobe-analytics-heartbeat', normalUrl);
+      this.setIntervalHandler = setInterval(this.initAdobeAnalyticsClient.bind(this), 1000);
+    }
+  }
+
+  initAdobeAnalyticsClient() {
+    const { s, Visitor } = window;
+    s.trackingServer = s.trackingServer || this.trackingServerUrl;
+    s.trackingServerSecure = s.trackingServerSecure || this.trackingServerSecureUrl;
+    if (this.marketingCloudOrgId && Visitor && typeof Visitor.getInstance === 'function') {
+      s.visitor = Visitor.getInstance(this.marketingCloudOrgId, {
+        trackingServer: s.trackingServer || this.trackingServerUrl,
+        trackingServerSecure: s.trackingServerSecure || this.trackingServerSecureUrl,
+      });
+    }
+  }
+
+  isLoaded() {
+    logger.debug('in AdobeAnalytics isLoaded');
+    return !!(window.s_gi && window.s_gi !== Array.prototype.push);
+  }
+
+  isReady() {
+    logger.debug('in AdobeAnalytics isReady');
+    return !!(window.s_gi && window.s_gi !== Array.prototype.push);
+  }
+
+  page(htElement) {
+    // delete existing keys from widnow.s
+    utils.clearWindowSKeys(utils.getDynamicKeys());
+    // The pageName variable typically stores the name of a given page
+    let name;
+    if (htElement.message.name) {
+      name = htElement.message.name;
+    } else if (htElement.message.properties) {
+      name = htElement.message.properties.name;
+    }
+
+    this.pageName = name ? `Viewed Page ${name}` : 'Viewed Page';
+
+    window.s.pageName = this.pageName;
+
+    // The referrer variable overrides the automatically collected referrer in reports.
+    let referrer;
+    let url;
+    if (htElement.message.context && htElement.message.context.page) {
+      referrer = htElement.message.context.page.referrer;
+      url = htElement.message.context.page.url;
+    } else if (htElement.message.properties) {
+      referrer = htElement.message.properties.referrer;
+      url = htElement.message.properties.url;
+    }
+
+    window.s.referrer = referrer;
+
+    // if dropVisitorId is true visitorID will not be set
+    /** Cross-device visitor identification uses the visitorID variable to associate a user across devices.
+     *  The visitorID variable takes the highest priority when identifying unique visitors.
+     * Visitor deduplication is not retroactive: */
+    if (!this.dropVisitorId) {
+      const { userId } = htElement.message;
+      if (userId) {
+        if (this.timestampOption === 'disabled') {
+          window.s.visitorID = userId;
+        }
+        // If timestamp hybrid option and visitor id preferred is on visitorID is set
+        if (this.timestampOption === 'hybrid' && this.preferVisitorId) {
+          window.s.visitorID = userId;
+        }
+      }
+    }
+    // update values in window.s
+    utils.updateWindowSKeys(this.pageName, 'events');
+    utils.updateWindowSKeys(url, 'pageURL');
+    utils.updateCommonWindowSKeys(htElement, this.pageName);
+
+    utils.calculateTimestamp(htElement);
+
+    utils.handleContextData(htElement);
+    utils.handleEVars(htElement);
+    utils.handleHier(htElement);
+    utils.handleLists(htElement);
+    utils.handleCustomProps(htElement);
+    /** The t() method is an important core component to Adobe Analytics. It takes all Analytics variables defined on the page,
+     *  compiles them into an image request, and sends that data to Adobe data collection servers.
+     * */
+
+    window.s.t();
+  }
+
+  track(htElement) {
+    utils.clearWindowSKeys(utils.getDynamicKeys());
+    const { event } = htElement.message;
+    if (this.heartbeatTrackingServerUrl) {
+      const eventsToTypesHashmap = getHashFromArray(this.eventsToTypes);
+      const heartBeatFunction = eventsToTypesHashmap[event.toLowerCase()];
+      // process mapped video events
+
+      this.processHeartbeatMappedEvents(heartBeatFunction, htElement);
+    }
+    // process unmapped ecomm events
+    const isProcessed = this.checkIfRudderEcommEvent(htElement);
+    // process mapped events
+    if (!isProcessed) {
+      const rudderEventsToAdobeEventsHashmap = getHashFromArray(this.rudderEventsToAdobeEvents);
+      if (rudderEventsToAdobeEventsHashmap[event.toLowerCase()]) {
+        utils.processEvent(
+          htElement,
+          rudderEventsToAdobeEventsHashmap[event.toLowerCase()].trim(),
+          this.pageName,
+        );
+      }
+    }
+  }
+
+  /**
+   * @param  {} htElement
+   * @description Checks if the incoming rudder event is an Ecomm Event. Return true or false accordingly.
+   * DOC: https://docs.rudderstack.com/rudderstack-api-spec/rudderstack-ecommerce-events-specification
+   * @returns ret
+   */
+
+  checkIfRudderEcommEvent(htElement) {
+    const { event } = htElement.message;
+    let ret = true;
+    switch (event.toLowerCase()) {
+      case 'product viewed':
+      case 'product list viewed':
+        ecommUtils.productViewHandle(htElement, this.pageName);
+        break;
+      case 'product added':
+        ecommUtils.productAddedHandle(htElement, this.pageName);
+        break;
+      case 'product removed':
+        ecommUtils.productRemovedHandle(htElement, this.pageName);
+        break;
+      case 'order completed':
+        ecommUtils.orderCompletedHandle(htElement, this.pageName);
+        break;
+      case 'cart viewed':
+        ecommUtils.cartViewedHandle(htElement, this.pageName);
+        break;
+      case 'checkout started':
+        ecommUtils.checkoutStartedHandle(htElement, this.pageName);
+        break;
+      case 'cart opened':
+      case 'opened cart':
+        ecommUtils.cartOpenedHandle(htElement, this.pageName);
+        break;
+      default:
+        ret = false;
+    }
+    return ret;
+  }
+
+  /**
+   * @param  {} heartBeatFunction
+   * @param  {} htElement
+   *
+   * @description Function to process mapped video events in webapp with adobe video events.
+   */
+
+  processHeartbeatMappedEvents(heartBeatFunction, htElement) {
+    if (heartBeatFunction) {
+      switch (heartBeatFunction) {
+        case 'initHeartbeat':
+          heartbeatUtils.initHeartbeat(htElement);
+          break;
+        case 'heartbeatPlaybackStarted':
+        case 'heartbeatPlaybackResumed':
+        case 'heartbeatContentStarted':
+        case 'heartbeatVideoStart':
+          heartbeatUtils.heartbeatVideoStart(htElement);
+          break;
+        case 'heartbeatPlaybackPaused':
+        case 'heartbeatPlaybackInterrupted':
+        case 'heartbeatVideoPaused':
+          heartbeatUtils.heartbeatVideoPaused(htElement);
+          break;
+        case 'heartbeatContentComplete':
+        case 'heartbeatVideoComplete':
+          heartbeatUtils.heartbeatVideoComplete(htElement);
+          break;
+        case 'heartbeatSessionEnd':
+        case 'heartbeatPlaybackCompleted':
+          heartbeatUtils.heartbeatSessionEnd(htElement);
+          break;
+        case 'heartbeatAdStarted':
+        case 'heartbeatAdBreakStarted':
+          heartbeatUtils.heartbeatAdStarted(htElement);
+          break;
+        case 'heartbeatAdCompleted':
+        case 'heartbeatAdBreakCompleted':
+          heartbeatUtils.heartbeatAdCompleted(htElement);
+          break;
+        case 'heartbeatAdSkipped':
+          heartbeatUtils.heartbeatAdSkipped(htElement);
+          break;
+        case 'heartbeatSeekStarted':
+          heartbeatUtils.heartbeatSeekStarted(htElement);
+          break;
+        case 'heartbeatSeekCompleted':
+          heartbeatUtils.heartbeatSeekCompleted(htElement);
+          break;
+        case 'heartbeatBufferStarted':
+          heartbeatUtils.heartbeatBufferStarted(htElement);
+          break;
+        case 'heartbeatBufferCompleted':
+          heartbeatUtils.heartbeatBufferCompleted(htElement);
+          break;
+        case 'heartbeatQualityUpdated':
+          heartbeatUtils.heartbeatQualityUpdated(htElement);
+          break;
+        case 'heartbeatUpdatePlayhead':
+          heartbeatUtils.heartbeatUpdatePlayhead(htElement);
+          break;
+        default:
+          logger.error('No heartbeat function for this event');
+      }
+    }
+  }
+}
+
+export default AdobeAnalytics;

package/src/integrations/AdobeAnalytics/constants.js

@@ -0,0 +1,14 @@
+const NAME = 'ADOBE_ANALYTICS';
+const CNameMapping = {
+  'Adobe Analytics': NAME,
+  ADOBEANALYTICS: NAME,
+  'ADOBE ANALYTICS': NAME,
+  [NAME]: NAME,
+  AdobeAnalytics: NAME,
+  adobeanalytics: NAME,
+  'adobe analytics': NAME,
+  'Adobe analytics': NAME,
+  'adobe Analytics': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/AdobeAnalytics/eCommHandle.js

@@ -0,0 +1,56 @@
+import * as utils from './util';
+
+const productViewHandle = (htElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(htElement, 'prodView', pageName);
+};
+
+const productAddedHandle = (htElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(htElement, 'scAdd', pageName);
+};
+
+const productRemovedHandle = (htElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(htElement, 'scRemove', pageName);
+};
+
+const orderCompletedHandle = (htElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  const { properties } = htElement.message;
+  const { purchaseId, transactionId, order_id: orderId } = properties;
+  utils.updateWindowSKeys(purchaseId || orderId, 'purchaseID');
+  utils.updateWindowSKeys(transactionId || orderId, 'transactionID');
+
+  utils.processEvent(htElement, 'purchase', pageName);
+};
+
+const checkoutStartedHandle = (htElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  const { properties } = htElement.message;
+  const { purchaseId, transactionId, order_id: orderId } = properties;
+  utils.updateWindowSKeys(purchaseId || orderId, 'purchaseID');
+  utils.updateWindowSKeys(transactionId || orderId, 'transactionID');
+
+  utils.processEvent(htElement, 'scCheckout', pageName);
+};
+
+const cartViewedHandle = (htElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(htElement, 'scView', pageName);
+};
+
+const cartOpenedHandle = (htElement, pageName) => {
+  utils.clearWindowSKeys(utils.getDynamicKeys());
+  utils.processEvent(htElement, 'scOpen', pageName);
+};
+
+export {
+  productViewHandle,
+  productAddedHandle,
+  productRemovedHandle,
+  orderCompletedHandle,
+  checkoutStartedHandle,
+  cartViewedHandle,
+  cartOpenedHandle,
+};

package/src/integrations/AdobeAnalytics/heartbeatHandle.js

@@ -0,0 +1,266 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable camelcase */
+import * as utils from './util';
+
+let qosData = {};
+const mediaHeartbeats = {};
+let playhead = 0;
+const adBreakCounts = {};
+let adBreakProgress = false;
+// Begin heartbeat implementation
+
+// Handling Video Type Events
+// DOC: https://experienceleague.adobe.com/docs/media-analytics/using/sdk-implement/setup/setup-javascript/set-up-js-2.html?lang=en
+// DOC: https://experienceleague.adobe.com/docs/media-analytics/using/sdk-implement/track-av-playback/track-core-overview.html?lang=en
+
+const heartbeatSessionStart = (htElement) => {
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  const { livestream, title, asset_id, total_length, session_id } = properties;
+  const streamType = livestream
+    ? va.MediaHeartbeat.StreamType.LIVE
+    : va.MediaHeartbeat.StreamType.VOD;
+  const mediaObj = va.MediaHeartbeat.createMediaObject(
+    title || '',
+    asset_id || 'unknown video id',
+    total_length || 0,
+    streamType,
+  );
+  const contextData = utils.handleVideoContextData(htElement);
+  utils.standardVideoMetadata(htElement, mediaObj);
+
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackSessionStart(mediaObj, contextData);
+};
+
+const initHeartbeat = (htElement) => {
+  const config = utils.getConfig();
+  const { va } = window.ADB;
+  const { message } = htElement;
+  const { properties, context } = message;
+  const { channel, video_player, session_id, ovp } = properties;
+
+  const mediaHeartbeatConfig = new va.MediaHeartbeatConfig();
+  const mediaHeartbeatDelegate = new va.MediaHeartbeatDelegate();
+
+  mediaHeartbeatConfig.trackingServer = config.heartbeatTrackingServerUrl;
+  mediaHeartbeatConfig.channel = channel || '';
+  mediaHeartbeatConfig.ovp = ovp || 'unknown';
+  mediaHeartbeatConfig.appVersion = context.app.version || 'unknown';
+  mediaHeartbeatConfig.playerName = video_player || 'unknown';
+  mediaHeartbeatConfig.ssl = config.sslHeartbeat;
+  mediaHeartbeatConfig.debugLogging = !!window._enableHeartbeatDebugLogging;
+
+  mediaHeartbeatDelegate.getCurrentPlaybackTime = () => {
+    playhead = playhead || 0;
+    const sessions = window.rudderHBPlayheads || {};
+    playhead = sessions[session_id] ? sessions[session_id] : playhead;
+    return playhead;
+  };
+
+  mediaHeartbeatDelegate.getQoSObject = () => qosData;
+
+  mediaHeartbeats[session_id || 'default'] = {
+    heartbeat: new va.MediaHeartbeat(mediaHeartbeatDelegate, mediaHeartbeatConfig, window.s),
+    delegate: mediaHeartbeatDelegate,
+    config: mediaHeartbeatConfig,
+  };
+  qosData = utils.createQos(htElement);
+  heartbeatSessionStart(htElement);
+};
+
+const populateHeartbeat = (htElement) => {
+  const { properties } = htElement.message;
+  const { session_id, channel, video_player } = properties;
+  const mediaHeartbeat = mediaHeartbeats[session_id || 'default'];
+  if (!mediaHeartbeat) {
+    initHeartbeat(htElement);
+  } else {
+    const mediaHeartbeatConfig = mediaHeartbeat.config;
+    mediaHeartbeatConfig.channel = channel || mediaHeartbeatConfig.channel;
+    mediaHeartbeatConfig.playerName = video_player || mediaHeartbeatConfig.playerName;
+  }
+};
+
+const heartbeatVideoStart = (htElement) => {
+  populateHeartbeat(htElement);
+  const { properties } = htElement.message;
+  const { va } = window.ADB;
+  const { session_id, chapter_name, position, length, start_time } = properties;
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackPlay();
+  const contextData = utils.handleVideoContextData(htElement);
+  if (!mediaHeartbeats[session_id || 'default'].chapterInProgress) {
+    const chapterObj = va.MediaHeartbeat.createChapterObject(
+      chapter_name || 'no chapter name',
+      position || 1,
+      length || 6000,
+      start_time || 0,
+    );
+    mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(
+      va.MediaHeartbeat.Event.ChapterStart,
+      chapterObj,
+      contextData,
+    );
+    mediaHeartbeats[session_id || 'default'].chapterInProgress = true;
+  }
+};
+
+const heartbeatVideoPaused = (htElement) => {
+  populateHeartbeat(htElement);
+  const { properties } = htElement.message;
+  mediaHeartbeats[properties.session_id || 'default'].heartbeat.trackPause();
+};
+
+const heartbeatVideoComplete = (htElement) => {
+  populateHeartbeat(htElement);
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  mediaHeartbeats[properties.session_id || 'defualt'].heartbeat.trackEvent(
+    va.MediaHeartbeat.Event.ChapterComplete,
+  );
+  mediaHeartbeats[properties.session_id || 'default'].chapterInProgress = false;
+};
+
+const heartbeatSessionEnd = (htElement) => {
+  populateHeartbeat(htElement);
+  const { properties } = htElement.message;
+  const { session_id } = properties;
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackComplete();
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackSessionEnd();
+
+  delete mediaHeartbeats[session_id || 'default'];
+  delete adBreakCounts[session_id || 'default'];
+};
+
+const heartbeatAdStarted = (htElement) => {
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  const { session_id, type, position, title, asset_id, total_length, content } = properties;
+  let adSessionCount = adBreakCounts[session_id || 'deafult'];
+  adSessionCount = adSessionCount
+    ? adBreakCounts[session_id || 'default'] + 1
+    : (adBreakCounts[session_id || 'default'] = 1);
+  const adBreakObj = va.MediaHeartbeat.createAdBreakObject(
+    type || 'unknown',
+    adSessionCount,
+    position || 1,
+  );
+
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(
+    va.MediaHeartbeat.Event.AdBreakStart,
+    adBreakObj,
+  );
+  adBreakProgress = true;
+
+  const adObject = va.MediaHeartbeat.createAdObject(
+    title || 'no title',
+    asset_id.toString() || 'default ad',
+    position || 1,
+    total_length || 0,
+  );
+  utils.standardAdMetadata(htElement, adObject);
+
+  mediaHeartbeats[session_id || 'deafult'].heartbeat.trackEvent(
+    va.MediaHeartbeat.Event.AdStart,
+    adObject,
+    content || {},
+  );
+};
+
+const heartbeatAdCompleted = (htElement) => {
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  const { session_id } = properties;
+  if (!adBreakProgress) {
+    heartbeatAdStarted(htElement);
+  }
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(va.MediaHeartbeat.Event.AdComplete);
+
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(
+    va.MediaHeartbeat.Event.AdBreakComplete,
+  );
+  adBreakProgress = false;
+};
+
+const heartbeatAdSkipped = (htElement) => {
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  const { session_id } = properties;
+  if (!adBreakProgress) {
+    heartbeatAdStarted(htElement);
+  }
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(va.MediaHeartbeat.Event.AdSkip);
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(
+    va.MediaHeartbeat.Event.AdBreakComplete,
+  );
+  adBreakProgress = false;
+};
+
+const heartbeatSeekStarted = (htElement) => {
+  populateHeartbeat(htElement);
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  const { session_id } = properties;
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(va.MediaHeartbeat.Event.SeekStart);
+};
+
+const heartbeatSeekCompleted = (htElement) => {
+  populateHeartbeat(htElement);
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  const { session_id } = properties;
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(
+    va.MediaHeartbeat.Event.SeekComplete,
+  );
+};
+
+const heartbeatBufferStarted = (htElement) => {
+  populateHeartbeat(htElement);
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  const { session_id } = properties;
+
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(
+    va.MediaHeartbeat.Event.BufferStart,
+  );
+};
+
+const heartbeatQualityUpdated = (htElement) => {
+  qosData = utils.createQos(htElement);
+};
+
+const heartbeatUpdatePlayhead = (htElement) => {
+  if (htElement.message.properties) {
+    playhead =
+      htElement.message.properties.position || htElement.message.properties.playhead || null;
+  }
+};
+
+const heartbeatBufferCompleted = (htElement) => {
+  populateHeartbeat(htElement);
+  const { va } = window.ADB;
+  const { properties } = htElement.message;
+  const { session_id } = properties;
+
+  mediaHeartbeats[session_id || 'default'].heartbeat.trackEvent(
+    va.MediaHeartbeat.Event.BufferComplete,
+  );
+};
+
+export {
+  populateHeartbeat,
+  initHeartbeat,
+  heartbeatSessionStart,
+  heartbeatVideoStart,
+  heartbeatVideoPaused,
+  heartbeatVideoComplete,
+  heartbeatSessionEnd,
+  heartbeatAdStarted,
+  heartbeatAdCompleted,
+  heartbeatAdSkipped,
+  heartbeatSeekStarted,
+  heartbeatSeekCompleted,
+  heartbeatBufferStarted,
+  heartbeatQualityUpdated,
+  heartbeatUpdatePlayhead,
+  heartbeatBufferCompleted,
+};

package/src/integrations/AdobeAnalytics/index.js

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