castled-js-sdk 0.0.1 → 0.0.2

package/src/integrations/Heap/nativeSdkLoader.js

@@ -0,0 +1,40 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(appId) {
+  (window.heap = window.heap || []),
+    (window.heap.load = function (e, t) {
+      (window.heap.appid = e), (window.heap.config = t = t || {});
+      const r = document.createElement('script');
+      (r.type = 'text/javascript'),
+        (r.async = !0),
+        r.setAttribute('data-loader', LOAD_ORIGIN),
+        (r.src = `https://cdn.heapanalytics.com/js/heap-${e}.js`);
+      const a = document.getElementsByTagName('script')[0];
+      a.parentNode.insertBefore(r, a);
+      for (
+        let n = function (e) {
+            return function () {
+              window.heap.push([e].concat(Array.prototype.slice.call(arguments, 0)));
+            };
+          },
+          p = [
+            'addEventProperties',
+            'addUserProperties',
+            'clearEventProperties',
+            'identify',
+            'resetIdentity',
+            'removeEventProperty',
+            'setEventProperties',
+            'track',
+            'unsetEventProperty',
+          ],
+          o = 0;
+        o < p.length;
+        o++
+      )
+        heap[p[o]] = n(p[o]);
+    });
+  window.heap.load(appId);
+}
+
+export { loadNativeSdk };

package/src/integrations/Heap/util.js

@@ -0,0 +1,23 @@
+import is from 'is';
+import { toIso, isDefinedAndNotNull, flattenJson } from '../../utils/commonUtils';
+
+// Heap accepts only string, boolean and number
+
+const processHeapProperties = (propertiesJson) => {
+  // flatten the json
+  const propertiesJsonFlattened = flattenJson(propertiesJson);
+  const processedProperties = {};
+  Object.keys(propertiesJsonFlattened).forEach((key) => {
+    const value = propertiesJsonFlattened[key];
+    if (isDefinedAndNotNull(value)) {
+      // check if date. Then convert to iso.
+      if (is.date(value)) {
+        processedProperties[key] = toIso(value);
+      } else {
+        processedProperties[key] = value;
+      }
+    }
+  });
+  return processedProperties;
+};
+export default processHeapProperties;

package/src/integrations/Hotjar/browser.js

@@ -0,0 +1,86 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class Hotjar {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.siteId = config.siteID;
+    this.name = NAME;
+    this._ready = false;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===In init Hotjar===');
+    loadNativeSdk(this.siteId);
+    this._ready = true;
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Hotjar===');
+    return this._ready;
+  }
+
+  isReady() {
+    logger.debug('===In isReady Hotjar===');
+    return this._ready;
+  }
+
+  identify(htElement) {
+    logger.debug('===In Hotjar identify===');
+
+    const userId = htElement.message.userId || htElement.message.anonymousId;
+    if (!userId) {
+      logger.debug('[Hotjar] identify:: user id is required');
+      return;
+    }
+
+    const { traits } = htElement.message.context;
+
+    window.hj('identify', htElement.message.userId, traits);
+  }
+
+  track(htElement) {
+    logger.debug('===In Hotjar track===');
+
+    let { event } = htElement.message;
+
+    if (!event) {
+      logger.error('Event name is not present');
+      return;
+    }
+
+    if (typeof event !== 'string') {
+      logger.error('Event name should be string');
+      return;
+    }
+
+    // event name must not exceed 750 characters and can only contain alphanumeric, underscores, and dashes.
+    // Ref - https://help.hotjar.com/hc/en-us/articles/4405109971095#the-events-api-call
+    if (event.length > 750) {
+      event = event.substring(0, 750);
+    }
+    event = event.replace(/ /g, '_');
+
+    if (event) {
+      window.hj('event', event);
+    }
+  }
+
+  page() {
+    logger.debug('===In Hotjar page===');
+    logger.debug('[Hotjar] page:: method not supported');
+  }
+}
+
+export { Hotjar };

package/src/integrations/Hotjar/constants.js

@@ -0,0 +1,10 @@
+const NAME = 'HOTJAR';
+const CNameMapping = {
+  [NAME]: NAME,
+  Hotjar: NAME,
+  hotjar: NAME,
+  'Hot Jar': NAME,
+  'hot jar': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Hotjar/index.js

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

package/src/integrations/Hotjar/nativeSdkLoader.js

@@ -0,0 +1,21 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(siteId) {
+  window.hotjarSiteId = siteId;
+  (function (h, o, t, j, a, r) {
+    h.hj =
+      h.hj ||
+      function () {
+        (h.hj.q = h.hj.q || []).push(arguments);
+      };
+    h._hjSettings = { hjid: h.hotjarSiteId, hjsv: 6 };
+    a = o.getElementsByTagName('head')[0];
+    r = o.createElement('script');
+    r.setAttribute('data-loader', LOAD_ORIGIN);
+    r.async = 1;
+    r.src = t + h._hjSettings.hjid + j + h._hjSettings.hjsv;
+    a.appendChild(r);
+  })(window, document, 'https://static.hotjar.com/c/hotjar-', '.js?sv=');
+}
+
+export { loadNativeSdk };

package/src/integrations/HubSpot/browser.js

@@ -0,0 +1,96 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import ScriptLoader from '../../utils/ScriptLoader';
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { getDefinedTraits } from '../../utils/utils';
+
+class HubSpot {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.hubId = config.hubID; // 6405167
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    const hubSpotJs = `https://js.hs-scripts.com/${this.hubId}.js`;
+    ScriptLoader('hubspot-integration', hubSpotJs);
+    logger.debug('===in init HS===');
+  }
+
+  isLoaded() {
+    logger.debug('in HubSpotAnalyticsManager isLoaded');
+    return !!(window._hsq && window._hsq.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return !!(window._hsq && window._hsq.push !== Array.prototype.push);
+  }
+
+  identify(htElement) {
+    logger.debug('in HubSpotAnalyticsManager identify');
+
+    const { message } = htElement;
+    const { traits } = message.context;
+
+    const { userId, email } = getDefinedTraits(message);
+
+    if (!email) {
+      logger.error('Email is required');
+      return;
+    }
+
+    const traitsValue = {};
+    if (userId) {
+      traitsValue.id = userId;
+    }
+
+    if (traits) {
+      Object.keys(traits).forEach((key) => {
+        if (Object.prototype.hasOwnProperty.call(traits, key)) {
+          const value = traits[key];
+          traitsValue[key] = value instanceof Date ? value.getTime() : value;
+        }
+      });
+    }
+
+    logger.debug(traitsValue);
+
+    if (typeof window !== 'undefined') {
+      window._hsq.push(['identify', traitsValue]);
+    }
+  }
+
+  track(htElement) {
+    logger.debug('in HubSpotAnalyticsManager track');
+
+    const { properties, event } = htElement.message;
+    const eventValue = {
+      name: event,
+      properties: properties || {},
+    };
+
+    window._hsq.push(['trackCustomBehavioralEvent', eventValue]);
+  }
+
+  page(htElement) {
+    logger.debug('in HubSpotAnalyticsManager page');
+
+    const { properties } = htElement.message;
+    const { path } = properties;
+    if (path) {
+      window._hsq.push(['setPath', path]);
+    }
+    window._hsq.push(['trackPageView']);
+  }
+}
+
+export { HubSpot };

package/src/integrations/HubSpot/constants.js

@@ -0,0 +1,11 @@
+const NAME = 'HS';
+const CNameMapping = {
+  [NAME]: NAME,
+  Hubspot: NAME,
+  HUBSPOT: NAME,
+  'hub spot': NAME,
+  'Hub Spot': NAME,
+  'Hub spot': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/HubSpot/index.js

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

package/src/integrations/INTERCOM/browser.js

@@ -0,0 +1,107 @@
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+import { flattenJsonPayload } from '../../utils/utils';
+import { processNameField, processCompanyField, processIdentityVerificationProps } from './utils';
+
+class INTERCOM {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.appId = config.appId;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadNativeSdk(this.appId);
+  }
+
+  isLoaded() {
+    return !!window.intercom_code;
+  }
+
+  isReady() {
+    return !!window.intercom_code;
+  }
+
+  identify(htElement) {
+    const { context, userId } = htElement.message;
+    const { traits, Intercom } = context;
+
+    const identityVerificationProps = Intercom || null;
+    const rawPayload = processIdentityVerificationProps(identityVerificationProps);
+    traits.name = processNameField(traits);
+
+    // map rudderPayload to desired
+    Object.keys(traits).forEach((field) => {
+      if (Object.prototype.hasOwnProperty.call(traits, field)) {
+        const value = traits[field];
+        switch (field) {
+          case 'createdAt':
+            rawPayload.created_at = value;
+            rawPayload[field] = value;
+            break;
+          case 'anonymousId':
+            rawPayload.user_id = value;
+            rawPayload[field] = value;
+            break;
+          case 'company':
+            rawPayload.companies = [processCompanyField(value)];
+            break;
+          case 'avatar':
+            rawPayload.avatar = {
+              type: 'avatar',
+              image_url: value,
+            };
+            break;
+          default:
+            rawPayload[field] = value;
+            break;
+        }
+      }
+    });
+    rawPayload.user_id = userId;
+    window.Intercom('update', rawPayload);
+  }
+
+  track(htElement) {
+    const rawPayload = {};
+    const { message } = htElement;
+    const { event, userId, anonymousId, originalTimestamp } = message;
+    const properties = message?.properties || {};
+
+    if (event) {
+      rawPayload.event_name = event;
+    }
+
+    rawPayload.user_id = userId || anonymousId;
+
+    Object.keys(properties).forEach((property) => {
+      const value = properties[property];
+      if (value && typeof value !== 'object' && !Array.isArray(value)) {
+        rawPayload[property] = value;
+      } else if (value && typeof value === 'object') {
+        Object.assign(rawPayload, flattenJsonPayload(value, property));
+      }
+    });
+
+    rawPayload.created_at = Math.floor(new Date(originalTimestamp).getTime() / 1000);
+
+    window.Intercom('trackEvent', rawPayload.event_name, rawPayload);
+  }
+
+  page() {
+    // Get new messages of the current user
+    window.Intercom('update');
+  }
+}
+
+export { INTERCOM };

package/src/integrations/INTERCOM/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'INTERCOM';
+const CNameMapping = {
+  [NAME]: NAME,
+  Intercom: NAME,
+  intercom: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/INTERCOM/index.js

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

package/src/integrations/INTERCOM/nativeSdkLoader.js

@@ -0,0 +1,46 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(appId) {
+  window.intercomSettings = {
+    app_id: appId,
+  };
+  (function () {
+    const w = window;
+    const ic = w.Intercom;
+    if (typeof ic === 'function') {
+      ic('reattach_activator');
+      ic('update', w.intercomSettings);
+    } else {
+      const d = document;
+      var i = function () {
+        i.c(arguments);
+      };
+      i.q = [];
+      i.c = function (args) {
+        i.q.push(args);
+      };
+      w.Intercom = i;
+      const l = function () {
+        const s = d.createElement('script');
+        s.setAttribute('data-loader', LOAD_ORIGIN);
+        s.type = 'text/javascript';
+        s.async = true;
+        s.src = `https://widget.intercom.io/widget/${window.intercomSettings.app_id}`;
+        const x = d.getElementsByTagName('script')[0];
+        x.parentNode.insertBefore(s, x);
+      };
+      if (document.readyState === 'complete') {
+        l();
+        window.intercom_code = true;
+      } else if (w.attachEvent) {
+        w.attachEvent('onload', l);
+        window.intercom_code = true;
+      } else {
+        w.addEventListener('load', l, false);
+        window.intercom_code = true;
+      }
+    }
+  })();
+}
+
+export { loadNativeSdk };

package/src/integrations/INTERCOM/utils.js

@@ -0,0 +1,68 @@
+import md5 from 'md5';
+/**
+ * Returns payload
+ * @param {*} props
+ * @returns
+ */
+const processIdentityVerificationProps = (props) => {
+  const payload = {};
+  if (props) {
+    const userHash = props.user_hash || null;
+    if (userHash) {
+      payload.user_hash = userHash;
+    }
+
+    const hideDefaultLauncher = props.hideDefaultLauncher || null;
+    if (hideDefaultLauncher) {
+      payload.hide_default_launcher = hideDefaultLauncher;
+    }
+  }
+
+  return payload;
+};
+
+/**
+ * Returns company payload
+ * @param {*} companyField
+ * @returns
+ */
+const processCompanyField = (companyField) => {
+  const company = {};
+  if (typeof companyField === 'string') {
+    company.company_id = md5(companyField);
+  }
+
+  const companyFields = typeof companyField === 'object' ? Object.keys(companyField) : [];
+  companyFields.forEach((key) => {
+    if (key !== 'id') {
+      company[key] = companyField[key];
+    } else {
+      company.company_id = companyField[key];
+    }
+  });
+
+  if (typeof companyField === 'object' && !companyFields.includes('id')) {
+    company.company_id = md5(company.name);
+  }
+
+  return company;
+};
+
+/**
+ * Returns name parameter
+ * @param {*} traits
+ * @returns
+ */
+const processNameField = (traits) => {
+  const { firstName, lastName, name } = traits;
+  /**
+   * populate name if firstName and lastName is populated
+   * if name is not set
+   */
+  if (!name && (firstName || lastName)) {
+    return `${firstName} ${lastName}`.trim();
+  }
+  return name;
+};
+
+export { processNameField, processCompanyField, processIdentityVerificationProps };