iureiure 1.0.0

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

@@ -0,0 +1,116 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Qualaroo/constants';
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import Logger from '../../utils/logger';
+import { recordQualarooEvents, transformUserTraits } from './utils';
+import { isNotEmpty } from '../../utils/commonUtils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Qualaroo {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.customerId = config.customerId;
+    this.siteToken = config.siteToken;
+    this.recordQualarooEvents = config.recordQualarooEvents;
+    this.eventsToStandard = config.eventsToStandard;
+    this.updateEventNames = config.updateEventNames;
+    this.eventsList = config.eventsList;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    window._kiq = window._kiq || [];
+    ScriptLoader(
+      'qualaroo-integration',
+      `https://cl.qualaroo.com/ki.js/${this.customerId}/${this.siteToken}.js`,
+    );
+  }
+
+  init() {
+    this.loadScript();
+  }
+
+  isLoaded() {
+    return !!window._kiq && typeof window._kiq === 'object';
+  }
+
+  isReady() {
+
+    if (this.recordQualarooEvents) {
+      recordQualarooEvents(
+        this.updateEventNames,
+        this.eventsList,
+        this.eventsToStandard,
+        this.analytics,
+      );
+    }
+    return !!window._kiq && typeof window._kiq === 'object';
+  }
+
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    const { traits } = message.context;
+    const userId = traits?.email || message.userId || traits?.userId || traits?.Id || '';
+
+    if (traits?.email) {
+      delete traits.email;
+    }
+    const transformedTraits = transformUserTraits(traits);
+
+    // If userId is not passed in the request, an empty string will be send for unknown visitors.
+    // ref :- https://help.qualaroo.com/hc/en-us/articles/201956628-Using-the-Identity-API-call#:~:text=echo%20%24current_user%2D%3Eemail%20%3F%3E%27%5D)%3B-,Note,-%3A%20Our%20system
+    window._kiq.push(['identify', userId]);
+
+    if (isNotEmpty(transformedTraits)) {
+      window._kiq.push(['set', transformedTraits]);
+    }
+  }
+
+  track(rudderElement) {
+    const { message } = rudderElement;
+    const { event, context } = message;
+    if (!event) {
+      logger.error('event is required for track call');
+      return;
+    }
+
+    const integrationName = context.integration?.name;
+    if (integrationName && integrationName === 'Qualaroo') {
+      logger.info(`dropping callback event: ${event}`);
+      return;
+    }
+
+    window._kiq.push(['set', { 'Triggered Event': event }]);
+  }
+
+  page(rudderElement) {
+    const { name, category } = rudderElement.message;
+    let pageFullName;
+    if (name && category) {
+      pageFullName = `${category} ${name}`;
+    } else if (name) {
+      pageFullName = name;
+    } else if (category) {
+      pageFullName = category;
+    }
+
+    if (pageFullName) {
+      window._kiq.push(['set', { 'Viewed Page': pageFullName }]);
+    }
+  }
+}
+
+export default Qualaroo;

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

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

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

@@ -0,0 +1,83 @@
+/* eslint-disable func-names */
+/* eslint-disable no-underscore-dangle */
+import { getHashFromArray } from '../../utils/commonUtils';
+
+const integrationContext = {
+  name: 'Qualaroo',
+  version: '1.0.0',
+};
+
+// supported callback events
+const standardEventsList = ['show', 'close', 'submit', 'noTargetMatch'];
+
+const swapKeyValuePairs = standardEventsMap => {
+  const swappedEventsMap = {};
+  Object.keys(standardEventsMap).forEach(key => {
+    swappedEventsMap[standardEventsMap[key]] = key;
+  });
+  return swappedEventsMap;
+};
+
+/**
+ * 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 rudderanalytics object
+ */
+const triggerCallback = (standardEventsMap, eventName, updateEventNames, analytics) => {
+  const updatedEvent =
+    standardEventsMap[eventName] && updateEventNames ? standardEventsMap[eventName] : eventName;
+  window._kiq.push([
+    'eventHandler',
+    eventName,
+    function () {
+      analytics.track(
+        `${updatedEvent}`,
+        {},
+        {
+          context: { integration: integrationContext },
+        },
+      );
+    },
+  ]);
+};
+
+/**
+ * This function has event listeners for the occurring events and to make a call for the event after collecting the data.
+ * @param {*} updateEventNames boolean variable to change eventName
+ * @param {*} userDefinedEventsList list of requested events by the user
+ * @param {*} userDefinedEventsMapping mapping of events in the webapp by the user
+ * @param {*} analytics rudderanalytics object
+ */
+const recordQualarooEvents = (
+  updateEventNames,
+  userDefinedEventsList,
+  userDefinedEventsMapping,
+  analytics,
+) => {
+  let standardEventsMap = getHashFromArray(userDefinedEventsMapping);
+  standardEventsMap = swapKeyValuePairs(standardEventsMap);
+  standardEventsList.forEach(event => {
+    if (userDefinedEventsList.includes(event)) {
+      triggerCallback(standardEventsMap, event, updateEventNames, analytics);
+    }
+  });
+};
+
+/**
+ * This function is used to replace all dashes(-) from user traits with underscore(_).
+ * ref :- https://help.qualaroo.com/hc/en-us/articles/201541187-Setting-Additional-User-Properties#:~:text=Notes
+ * @param {*} traits {"name":"John Doe","phone-number":"+9199999999"}
+ * @returns {"name":"John Doe","phone_number":"+9199999999"}
+ */
+const transformUserTraits = traits => {
+  const transformedTraits = {};
+  Object.keys(traits).forEach(traitName => {
+    const transformedTrait = traitName.replace(/-/g, '_');
+    transformedTraits[transformedTrait] = traits[traitName];
+  });
+  return transformedTraits;
+};
+
+export { recordQualarooEvents, transformUserTraits };

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

@@ -0,0 +1,92 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-unused-expressions */
+// eslint-disable-next-line no-nested-ternary
+// eslint-disable-next-line class-methods-use-this
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Qualtrics/constants';
+import Logger from '../../utils/logger';
+/* eslint-disable class-methods-use-this */
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Qualtrics {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.projectId = config.projectId;
+    this.brandId = config.brandId;
+    this.enableGenericPageTitle = config.enableGenericPageTitle;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    if (!this.projectId) {
+      logger.error('Project ID missing');
+      return;
+    }
+
+    if (!this.brandId) {
+      logger.error(`${DISPLAY_NAME} :Brand ID missing`);
+      return;
+    }
+
+    loadNativeSdk(this.projectId, this.brandId);
+  }
+
+  isLoaded() {
+    return !!(window._qsie && window.QSI && window.QSI.API);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  page(rudderElement) {
+    const { message } = rudderElement;
+    if (!message) {
+      logger.error('Message field is missing');
+      return;
+    }
+
+    if (this.enableGenericPageTitle) {
+      window._qsie.push('Viewed a Page');
+      return;
+    }
+
+    const { name, category, properties } = message;
+    const categoryField = category || properties?.category || null;
+
+    if (!categoryField && !name) {
+      logger.error('generic title is disabled and no name or category field found');
+      return;
+    }
+    const dynamicTitle =
+      categoryField && name ? `Viewed ${categoryField} ${name} Page` : `Viewed ${name} Page`;
+
+    window._qsie.push(dynamicTitle);
+  }
+
+  track(rudderElement) {
+    const { message } = rudderElement;
+    if (!message) {
+      logger.error('Message field is missing');
+      return;
+    }
+    if (!message.event) {
+      logger.error('Event field is undefined');
+      return;
+    }
+    window._qsie.push(message.event);
+  }
+}
+export default Qualtrics;

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

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

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

@@ -0,0 +1,79 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(projectId, brandId) {
+  const projectIdFormatted = projectId.replace(/_/g, '').toLowerCase().trim();
+  const requestUrlFormatted = `https://${projectIdFormatted}-${brandId}.siteintercept.qualtrics.com/SIE/?Q_ZID=${projectId}`;
+  const requestIdFormatted = `QSI_S_${projectId}`;
+
+  (function () {
+    var g = function (e, h, f, g) {
+      this.get = function (a) {
+        for (var a = `${a}=`, c = document.cookie.split(';'), b = 0, e = c.length; b < e; b++) {
+          for (var d = c[b]; d.charAt(0) == ' '; ) d = d.substring(1, d.length);
+          if (d.indexOf(a) == 0) return d.substring(a.length, d.length);
+        }
+        return null;
+      };
+      this.set = function (a, c) {
+        var b = '';
+        var b = new Date();
+        b.setTime(b.getTime() + 6048e5);
+        b = `; expires=${b.toGMTString()}`;
+        document.cookie = `${a}=${c}${b}; path=/; `;
+      };
+      this.check = function () {
+        var a = this.get(f);
+        if (a) a = a.split(':');
+        else if (e != 100)
+          h == 'v' && (e = Math.random() >= e / 100 ? 0 : 100),
+            (a = [h, e, 0]),
+            this.set(f, a.join(':'));
+        else return !0;
+        var c = a[1];
+        if (c == 100) return !0;
+        switch (a[0]) {
+          case 'v':
+            return !1;
+          case 'r':
+            return (c = a[2] % Math.floor(100 / c)), a[2]++, this.set(f, a.join(':')), !c;
+        }
+        return !0;
+      };
+      this.go = function () {
+        if (this.check()) {
+          var a = document.createElement('script');
+          a.type = 'text/javascript';
+          a.setAttribute('data-loader', LOAD_ORIGIN);
+          a.src = g;
+          document.body && document.body.appendChild(a);
+        }
+      };
+      this.start = function () {
+        var t = this;
+        document.readyState !== 'complete'
+          ? window.addEventListener
+            ? window.addEventListener(
+                'load',
+                function () {
+                  t.go();
+                },
+                !1,
+              )
+            : window.attachEvent &&
+              window.attachEvent('onload', function () {
+                t.go();
+              })
+          : t.go();
+      };
+    };
+    try {
+      new g(100, 'r', requestIdFormatted, requestUrlFormatted).start();
+    } catch (i) {}
+  })();
+  const div = document.createElement('div');
+  div.setAttribute('id', String(projectId));
+  window._qsie = window._qsie || [];
+  document.getElementsByTagName('head')[0].appendChild(div);
+}
+
+export { loadNativeSdk };

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

@@ -0,0 +1,54 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-underscore-dangle */
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/QuantumMetric/constants';
+import Logger from '../../utils/logger';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class QuantumMetric {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.siteId = config.siteID; // 1549611
+    this.name = NAME;
+    this._ready = false;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    if (window.QuantumMetricAPI) {
+      return;
+    }
+
+    ScriptLoader(
+      'Quantum Metric',
+      `https://cdn.quantummetric.com/qscripts/quantum-${this.siteId}.js`,
+    );
+    if (window.QuantumMetricAPI) {
+      this._ready = true;
+    }
+  }
+
+  isLoaded() {
+    if (!this._ready && window.QuantumMetricAPI) {
+      this._ready = true;
+    }
+    return this._ready;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+}
+
+export default QuantumMetric;

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

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

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

@@ -0,0 +1,77 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/QuoraPixel/constants';
+import { isDefinedAndNotNull } from '@rudderstack/analytics-js-common/utilities/checks';
+import Logger from '../../utils/logger';
+import { getHashFromArrayWithDuplicate } from '../../utils/commonUtils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class QuoraPixel {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.pixelId = config.pixelId;
+    this.eventsToQPEvents = config.eventsToQPEvents;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    loadNativeSdk(this.pixelId);
+  }
+
+  init() {
+    this.loadScript();
+  }
+
+  isLoaded() {
+    return !!(window.qp && window.qp.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  track(rudderElement) {
+    const { event } = rudderElement.message;
+    const eventsMapping = getHashFromArrayWithDuplicate(this.eventsToQPEvents);
+
+    if (!isDefinedAndNotNull(event)) {
+      logger.error('Event name is either null or undefined');
+      return;
+    }
+
+    if (typeof event !== 'string') {
+      logger.error('Event name should be a string');
+      return;
+    }
+
+    const trimmedEvent = event.toLowerCase().trim();
+    const events = eventsMapping[trimmedEvent] || [];
+
+    if (events.length === 0) {
+      logger.warn('No Quora Pixel mapped event found. Sending Generic as the default event');
+      window.qp('track', 'Generic');
+    }
+
+    events.forEach(qpEvent => {
+      if (!qpEvent) {
+        window.qp('track', 'Generic');
+      } else if (qpEvent !== 'Custom') {
+        window.qp('track', qpEvent);
+      }
+    });
+  }
+}
+
+export default QuoraPixel;

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

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

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

@@ -0,0 +1,21 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(pixelId) {
+  !(function (q, e, v, n, t, s) {
+    if (q.qp) return;
+    n = q.qp = function () {
+      n.qp ? n.qp.apply(n, arguments) : n.queue.push(arguments);
+    };
+    n.queue = [];
+    t = document.createElement(e);
+    t.async = !0;
+    t.src = v;
+    t.setAttribute('data-loader', LOAD_ORIGIN);
+    s = document.getElementsByTagName(e)[0];
+    s.parentNode.insertBefore(t, s);
+  })(window, 'script', 'https://a.quora.com/qevents.js');
+  window.qp('init', pixelId);
+  window.qp('track', 'ViewContent');
+}
+
+export { loadNativeSdk };

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

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-unused-vars */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable prefer-rest-params */
+/* eslint-disable prefer-spread */
+/* eslint-disable no-multi-assign */
+/* eslint-disable func-names */
+/* eslint-disable no-var */
+/* eslint-disable vars-on-top */
+/* eslint-disable no-unused-expressions */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/RedditPixel/constants';
+import Logger from '../../utils/logger';
+import { getHashFromArrayWithDuplicate, getEventMappingFromConfig } from '../../utils/commonUtils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class RedditPixel {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.pixelId = config.advertiserId;
+    this.name = NAME;
+    this.eventMappingFromConfig = config.eventMappingFromConfig;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadNativeSdk(this.pixelId);
+  }
+
+  isLoaded() {
+    return !!(window.rdt && window.rdt.pixelId === this.pixelId);
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+
+  identify(rudderElement) {
+    window.rdt('track', 'SignUp');
+  }
+
+  track(rudderElement) {
+    const { event } = rudderElement.message;
+    if (!event) {
+      logger.error('Event name is required');
+      return;
+    }
+    const eventMappingFromConfigMap = getHashFromArrayWithDuplicate(
+      this.eventMappingFromConfig,
+      'from',
+      'to',
+      false,
+    );
+    if (eventMappingFromConfigMap[event]) {
+      // mapping event from UI
+      const events = getEventMappingFromConfig(event, eventMappingFromConfigMap);
+      events.forEach(ev => {
+        window.rdt('track', ev);
+      });
+    } else {
+      switch (event.toLowerCase()) {
+        case 'product added':
+          window.rdt('track', 'AddToCart');
+          break;
+        case 'product added to wishlist':
+          window.rdt('track', 'AddToWishlist');
+          break;
+        case 'order completed':
+          window.rdt('track', 'Purchase');
+          break;
+        case 'lead':
+          window.rdt('track', 'Lead');
+          break;
+        case 'view content':
+          window.rdt('track', 'ViewContent');
+          break;
+        case 'search':
+          window.rdt('track', 'Search');
+          break;
+        default:
+          logger.error(`Invalid event ${event}. Track call not supported`);
+          break;
+      }
+    }
+  }
+
+  page(rudderElement) {
+    window.rdt('track', 'PageVisit');
+  }
+}
+
+export default RedditPixel;

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

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

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

@@ -0,0 +1,21 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(pixelId) {
+  !(function (w, d) {
+    if (!w.rdt) {
+      var p = (w.rdt = function () {
+        p.sendEvent ? p.sendEvent.apply(p, arguments) : p.callQueue.push(arguments);
+      });
+      p.callQueue = [];
+      var t = d.createElement('script');
+      (t.src = 'https://www.redditstatic.com/ads/pixel.js'), (t.async = !0);
+      t.setAttribute('data-loader', LOAD_ORIGIN);
+      var s = d.getElementsByTagName('script')[0];
+      s.parentNode.insertBefore(t, s);
+    }
+  })(window, document);
+
+  window.rdt('init', pixelId);
+}
+
+export { loadNativeSdk };