iureiure 1.0.0

package/packages/analytics-js-integrations/src/integrations/GoogleAds/utils.js

@@ -0,0 +1,135 @@
+import { isDefinedAndNotNull } from '../../utils/utils';
+
+/**
+ * if trackEvents are not enabled then do not send events (return false)
+ * if trackEvents are enabled but event filtering is not enabled then send all events
+ * if trackEvents are enabled and event filtering is also enabled then check if event is configured to event list or not
+ * if non of above is true then do not send event at all (return false)
+ * @param {*} eventName
+ * @param {*} trackEvents
+ * @param {*} enableFiltering
+ * @param {*} events
+ * @returns
+ */
+function shouldSendEvent(eventName, trackEvents, enableFiltering, events) {
+  if(!eventName || eventName.trim() === ''){
+    return false;
+  }
+  
+  if (!trackEvents) {
+    return false;
+  }
+
+  if (trackEvents && !enableFiltering) {
+    return true;
+  }
+
+  if (trackEvents && enableFiltering) {
+    const eventNames = [];
+    events.forEach(event => {
+      if (event.eventName !== '') {
+        eventNames.push(event.eventName);
+      }
+    });
+    return eventNames.includes(eventName.trim());
+  }
+
+  return false;
+}
+
+/**
+ * Returns weather to send conversion event or not
+ * @param {*} eventName - event name
+ * @param {*} trackConversions - decides weather to send conversion event or not
+ * @param {*} enableConversionEventsFiltering - decides weather to apply filtering on event or not
+ * @param {*} eventsToTrackConversions - allowed list of events to send google ads
+ * @param {*} dynamicRemarketing - Depreciating : old config flag to check weather to send event as conversion or dynamic remarketing
+ * @returns
+ */
+function shouldSendConversionEvent(
+  eventName,
+  trackConversions,
+  enableConversionEventsFiltering,
+  eventsToTrackConversions,
+  dynamicRemarketing,
+) {
+  if (isDefinedAndNotNull(trackConversions)) {
+    return shouldSendEvent(
+      eventName,
+      trackConversions,
+      enableConversionEventsFiltering,
+      eventsToTrackConversions,
+    );
+  }
+  return !dynamicRemarketing;
+}
+
+/**
+ * Returns weather to send dynamic remarketing event or not
+ * @param {*} eventName
+ * @param {*} trackDynamicRemarketing - decides weather to send dynamic remarketing event or not
+ * @param {*} enableDynamicRemarketingEventsFiltering - decides weather to apply filtering on event or not
+ * @param {*} eventsToTrackDynamicRemarketing - allowed list of events to send google ads
+ * @param {*} dynamicRemarketing - Depreciating : old config flag to check weather to send event as conversion or dynamic remarketing
+ * @returns
+ */
+function shouldSendDynamicRemarketingEvent(
+  eventName,
+  trackDynamicRemarketing,
+  enableDynamicRemarketingEventsFiltering,
+  eventsToTrackDynamicRemarketing,
+  dynamicRemarketing,
+) {
+  if (isDefinedAndNotNull(trackDynamicRemarketing)) {
+    return shouldSendEvent(
+      eventName,
+      trackDynamicRemarketing,
+      enableDynamicRemarketingEventsFiltering,
+      eventsToTrackDynamicRemarketing,
+    );
+  }
+  return dynamicRemarketing;
+}
+
+/**
+ * returns conversionData object (conversionLabel and eventName)
+ * if eventName is not present but defaultPageConversion is configured then keeping default eventName as Viewed a Page
+ * @param {*} eventTypeConversions
+ * @param {*} eventName
+ * @param {*} defaultPageConversion
+ * @returns
+ */
+function getConversionData(eventTypeConversions, eventName, defaultPageConversion) {
+  const conversionData = {};
+  if (eventTypeConversions) {
+    if (eventName) {
+      eventTypeConversions.forEach(eventTypeConversion => {
+        if (eventTypeConversion.name.toLowerCase() === eventName.toLowerCase()) {
+          // rudderElement["message"]["name"]
+          conversionData.conversionLabel = eventTypeConversion.conversionLabel;
+          conversionData.eventName = eventTypeConversion.name;
+        }
+      });
+    } else if (defaultPageConversion) {
+      conversionData.conversionLabel = defaultPageConversion;
+      conversionData.eventName = 'Viewed a Page';
+    }
+  }
+  return conversionData;
+}
+
+function newCustomerAcquisitionReporting(properties) {
+  const updatedProperties = { ...properties }; // create a copy of properties object
+  if (updatedProperties && updatedProperties.newCustomer) {
+    updatedProperties.new_customer = updatedProperties.newCustomer;
+    delete updatedProperties.newCustomer;
+  }
+  return updatedProperties;
+}
+
+export {
+  shouldSendConversionEvent,
+  shouldSendDynamicRemarketingEvent,
+  getConversionData,
+  newCustomerAcquisitionReporting,
+};

package/packages/analytics-js-integrations/src/integrations/GoogleOptimize/browser.js

@@ -0,0 +1,81 @@
+/* eslint-disable prefer-rest-params */
+/* eslint-disable no-inner-declarations */
+/* eslint-disable class-methods-use-this */
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/GoogleOptimize/constants';
+import Logger from '../../utils/logger';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class GoogleOptimize {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.ga = config.ga;
+    this.trackingId = config.trackingId;
+    this.containerId = config.containerId;
+    this.async = config.async;
+    this.aflicker = config.aflicker;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    if (!this.containerId) {
+      return;
+    }
+    // load optimize script first
+    ScriptLoader(
+      'Google Optimize',
+      `https://www.googleoptimize.com/optimize.js?id=${this.containerId}`,
+      { async: this.async },
+    );
+    if (this.ga) {
+      if (!this.trackingId) {
+        return;
+      }
+      ScriptLoader(
+        'Google Tag Manager',
+        `https://www.googletagmanager.com/gtag/js?id=${this.trackingId}`,
+      );
+      window.dataLayer = window.dataLayer || [];
+      function gtag() {
+        window.dataLayer.push(arguments);
+      }
+      gtag('js', new Date());
+      gtag('config', `${this.trackingId}`);
+    }
+
+    // anti flicker snippet contains insertBefore since it needs to be executed before any other script
+    // link -> https://support.google.com/optimize/answer/7100284?hl=en&ref_topic=6197443
+    if (this.aflicker) {
+      const flick = document.createElement('style');
+      flick.innerHTML = '.async-hide { opacity: 0 !important}';
+      const js = document.createElement('script');
+      js.setAttribute('data-loader', LOAD_ORIGIN);
+      js.innerHTML = `(function(a,s,y,n,c,h,i,d,e){s.className+=' '+y;h.start=1*new Date;h.end=i=function(){s.className=s.className.replace(RegExp(' ?'+y),'')};(a[n]=a[n]||[]).hide=h;setTimeout(function(){i();h.end=null},c);h.timeout=c;})(window,document.documentElement,'async-hide','dataLayer',4000,{'${this.containerId}':true});`;
+      const e = document.getElementsByTagName('script')[0];
+      e.parentNode.insertBefore(flick, e); // style tag in anti flicker snippet should be before the a-flicker script as per docs
+      e.parentNode.insertBefore(js, e);
+    }
+  }
+
+  isLoaded() {
+    return !!window.dataLayer;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+}
+export default GoogleOptimize;

package/packages/analytics-js-integrations/src/integrations/GoogleOptimize/index.js

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

package/packages/analytics-js-integrations/src/integrations/GoogleTagManager/browser.js

@@ -0,0 +1,96 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/GoogleTagManager/constants';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class GoogleTagManager {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.containerID = config.containerID;
+    this.name = NAME;
+    this.serverUrl = config.serverUrl;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadNativeSdk(this.containerID, this.serverUrl);
+  }
+
+  isLoaded() {
+    return !!(window.dataLayer && Array.prototype.push !== window.dataLayer.push);
+  }
+
+  sendToGTMDatalayer(props) {
+    window.dataLayer.push(props);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    // set the traits to the datalayer and put everything under the key traits
+    // keeping it under the traits key as destructing might conflict with `message.properties`
+    const rudderMessage = rudderElement.message;
+    const props = { traits: rudderMessage.context.traits };
+    this.sendToGTMDatalayer(props);
+  }
+
+  track(rudderElement) {
+    const rudderMessage = rudderElement.message;
+    const props = {
+      event: rudderMessage.event,
+      userId: rudderMessage.userId,
+      anonymousId: rudderMessage.anonymousId,
+      // set the traits as well if there is any
+      // it'll be null/undefined before identify call is made
+      traits: rudderMessage.context.traits,
+      ...rudderMessage.properties,
+    };
+    this.sendToGTMDatalayer(props);
+  }
+
+  page(rudderElement) {
+    const rudderMessage = rudderElement.message;
+    const pageName = rudderMessage.name;
+    const pageCategory = rudderMessage.properties ? rudderMessage.properties.category : undefined;
+
+    let eventName;
+
+    if (pageName) {
+      eventName = `Viewed ${pageName} page`;
+    }
+
+    if (pageCategory && pageName) {
+      eventName = `Viewed ${pageCategory} ${pageName} page`;
+    }
+    if (!eventName) {
+      eventName = 'Viewed a Page';
+    }
+    const props = {
+      event: eventName,
+      userId: rudderMessage.userId,
+      anonymousId: rudderMessage.anonymousId,
+      // set the traits as well if there is any
+      // it'll be null/undefined before identify call is made
+      traits: rudderMessage.context.traits,
+      ...rudderMessage.properties,
+    };
+
+    this.sendToGTMDatalayer(props);
+  }
+}
+
+export default GoogleTagManager;

package/packages/analytics-js-integrations/src/integrations/GoogleTagManager/index.js

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

package/packages/analytics-js-integrations/src/integrations/GoogleTagManager/nativeSdkLoader.js

@@ -0,0 +1,21 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(containerID, serverUrl) {
+  const defaultUrl = `https://www.googletagmanager.com`;
+  // ref: https://developers.google.com/tag-platform/tag-manager/server-side/send-data#update_the_gtmjs_source_domain
+
+  window.finalUrl = serverUrl ? serverUrl : defaultUrl;
+  (function (w, d, s, l, i) {
+    w[l] = w[l] || [];
+    w[l].push({ 'gtm.start': new Date().getTime(), event: 'gtm.js' });
+    const f = d.getElementsByTagName(s)[0];
+    const j = d.createElement(s);
+    const dl = l !== 'dataLayer' ? `&l=${l}` : '';
+    j.setAttribute('data-loader', LOAD_ORIGIN);
+    j.async = true;
+    j.src = `${window.finalUrl}/gtm.js?id=${i}${dl}`;
+    f.parentNode.insertBefore(j, f);
+  })(window, document, 'script', 'dataLayer', containerID);
+}
+
+export { loadNativeSdk };

package/packages/analytics-js-integrations/src/integrations/Heap/browser.js

@@ -0,0 +1,64 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Heap/constants';
+import Logger from '../../utils/logger';
+import processHeapProperties from './util';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Heap {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.appId = config.appId;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  /**
+   * Initialize Heap
+   * DOC: https://developers.heap.io/docs/web
+   */
+
+  init() {
+    loadNativeSdk(this.appId);
+  }
+
+  isLoaded() {
+    return !!(window.heap && window.heap.appid);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  // DOC: https://developers.heap.io/reference#identify
+
+  identify(rudderElement) {
+    const { userId, context } = rudderElement.message;
+    if (userId) {
+      window.heap.identify(userId);
+    }
+    const { traits } = context;
+    // DOC: https://developers.heap.io/reference#adduserproperties
+    window.heap.addUserProperties(processHeapProperties(traits));
+  }
+
+  // DOC: https://developers.heap.io/reference#track
+
+  track(rudderElement) {
+    const { event, properties } = rudderElement.message;
+    window.heap.track(event, processHeapProperties(properties));
+  }
+}
+
+export default Heap;

package/packages/analytics-js-integrations/src/integrations/Heap/index.js

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

package/packages/analytics-js-integrations/src/integrations/Heap/nativeSdkLoader.js

@@ -0,0 +1,40 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+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/packages/analytics-js-integrations/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/packages/analytics-js-integrations/src/integrations/Hotjar/browser.js

@@ -0,0 +1,79 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Hotjar/constants';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+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() {
+    loadNativeSdk(this.siteId);
+    this._ready = true;
+  }
+
+  isLoaded() {
+    return this._ready;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const userId = rudderElement.message.userId || rudderElement.message.anonymousId;
+    if (!userId) {
+      logger.error('user id is required for an identify call');
+      return;
+    }
+
+    const { traits } = rudderElement.message.context;
+
+    window.hj('identify', rudderElement.message.userId, traits);
+  }
+
+  track(rudderElement) {
+    let { event } = rudderElement.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);
+    }
+  }
+}
+
+export default Hotjar;

package/packages/analytics-js-integrations/src/integrations/Hotjar/index.js

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

package/packages/analytics-js-integrations/src/integrations/Hotjar/nativeSdkLoader.js

@@ -0,0 +1,21 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+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/packages/analytics-js-integrations/src/integrations/HubSpot/browser.js

@@ -0,0 +1,91 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/HubSpot/constants';
+import Logger from '../../utils/logger';
+import { getDefinedTraits } from '../../utils/utils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+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);
+  }
+
+  isLoaded() {
+    return !!(window._hsq && window._hsq.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    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;
+        }
+      });
+    }
+
+    if (typeof window !== 'undefined') {
+      window._hsq.push(['identify', traitsValue]);
+    }
+  }
+
+  track(rudderElement) {
+    const { properties, event } = rudderElement.message;
+    const eventValue = {
+      name: event,
+      properties: properties || {},
+    };
+
+    window._hsq.push(['trackCustomBehavioralEvent', eventValue]);
+  }
+
+  page(rudderElement) {
+    const { properties } = rudderElement.message;
+    const { path } = properties;
+    if (path) {
+      window._hsq.push(['setPath', path]);
+    }
+    window._hsq.push(['trackPageView']);
+  }
+}
+
+export default HubSpot;

package/packages/analytics-js-integrations/src/integrations/HubSpot/index.js

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