castled-js-sdk 0.0.1 → 0.0.2

package/src/integrations/Qualtrics/browser.js

@@ -0,0 +1,89 @@
+/* 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 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() {
+    logger.debug('===in init Qualtrics===');
+    if (!this.projectId) {
+      logger.debug('Project ID missing');
+      return;
+    }
+
+    if (!this.brandId) {
+      logger.debug('Brand ID missing');
+      return;
+    }
+
+    loadNativeSdk(this.projectId, this.brandId);
+  }
+
+  isLoaded() {
+    logger.debug('===in Qualtrics isLoaded===');
+    return !!(window._qsie && window.QSI && window.QSI.API);
+  }
+
+  isReady() {
+    logger.debug('===in Qualtrics isReady===');
+    return !!(window._qsie && window.QSI && window.QSI.API);
+  }
+
+  page(htElement) {
+    logger.debug('===in Qualtrics page===');
+    const { message } = htElement;
+    if (!message) {
+      logger.debug('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.debug('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(htElement) {
+    logger.debug('===in Qualtrics track===');
+    const { message } = htElement;
+    if (!message) {
+      logger.debug('Message field is missing');
+      return;
+    }
+    if (!message.event) {
+      logger.debug('Event field is undefined');
+      return;
+    }
+    window._qsie.push(message.event);
+  }
+}
+export default Qualtrics;

package/src/integrations/Qualtrics/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'QUALTRICS';
+const CNameMapping = {
+  [NAME]: NAME,
+  Qualtrics: NAME,
+  qualtrics: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Qualtrics/index.js

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

package/src/integrations/Qualtrics/nativeSdkLoader.js

@@ -0,0 +1,79 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+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/src/integrations/QuantumMetric/browser.js

@@ -0,0 +1,63 @@
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-underscore-dangle */
+import logger from '../../utils/logUtil';
+import ScriptLoader from '../../utils/ScriptLoader';
+import { NAME } from './constants';
+
+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;
+    }
+
+    logger.debug('===in init Quantum Metric===');
+  }
+
+  identify() {
+    logger.debug('[QuantumMetric] track:: method not supported');
+  }
+
+  track() {
+    logger.debug('[QuantumMetric] track:: method not supported');
+  }
+
+  page() {
+    logger.debug('[QuantumMetric] page:: method not supported');
+  }
+
+  isLoaded() {
+    if (!this._ready && window.QuantumMetricAPI) {
+      this._ready = true;
+    }
+    return this._ready;
+  }
+
+  isReady() {
+    return this.isLoaded();
+  }
+}
+
+export default QuantumMetric;

package/src/integrations/QuantumMetric/constants.js

@@ -0,0 +1,13 @@
+const NAME = 'QUANTUMMETRIC';
+const CNameMapping = {
+  [NAME]: NAME,
+  'Quantum Metric': NAME,
+  'quantum Metric': NAME,
+  'quantum metric': NAME,
+  QuantumMetric: NAME,
+  quantumMetric: NAME,
+  quantummetric: NAME,
+  Quantum_Metric: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/QuantumMetric/index.js

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

package/src/integrations/QuoraPixel/browser.js

@@ -0,0 +1,64 @@
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { getHashFromArrayWithDuplicate } from '../../utils/commonUtils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+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() {
+    logger.debug('===In init Quora Pixel===');
+    this.loadScript();
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Quora Pixel===');
+    return !!(window.qp && window.qp.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    logger.debug('===In isReady Quora Pixel===');
+    return !!(window.qp && window.qp.push !== Array.prototype.push);
+  }
+
+  track(htElement) {
+    logger.debug('===In Quora Pixel track===');
+    const { event } = htElement.message;
+    const eventsMapping = getHashFromArrayWithDuplicate(this.eventsToQPEvents);
+    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/src/integrations/QuoraPixel/constants.js

@@ -0,0 +1,15 @@
+const NAME = 'QUORA_PIXEL';
+const CNameMapping = {
+  [NAME]: NAME,
+  'Quora Pixel': NAME,
+  'Quora pixel': NAME,
+  'QUORA PIXEL': NAME,
+  QuoraPixel: NAME,
+  Quorapixel: NAME,
+  QUORAPIXEL: NAME,
+  Quora_Pixel: NAME,
+  quora_pixel: NAME,
+  Quora: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/QuoraPixel/index.js

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

package/src/integrations/QuoraPixel/nativeSdkLoader.js

@@ -0,0 +1,21 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+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/src/integrations/RedditPixel/browser.js

@@ -0,0 +1,98 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { getHashFromArrayWithDuplicate, getEventMappingFromConfig } from '../../utils/commonUtils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+class RedditPixel {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.advertiserId = config.advertiserId;
+    this.name = NAME;
+    this.eventMappingFromConfig = config.eventMappingFromConfig;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===In init RedditPixel===');
+
+    loadNativeSdk(this.advertiserId);
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded RedditPixel===');
+    return !!(window.rdt && window.rdt.advertiserId === this.advertiserId);
+  }
+
+  isReady() {
+    logger.debug('===In isReady RedditPixel===');
+    return !!(window.rdt && window.rdt.advertiserId === this.advertiserId);
+  }
+
+  identify(htElement) {
+    logger.debug('===In RedditPixel identify===');
+    window.rdt('track', 'SignUp');
+  }
+
+  track(htElement) {
+    logger.debug('===In RedditPixel track===');
+
+    const { event } = htElement.message;
+    if (!event) {
+      logger.error('Event name is not present');
+      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(htElement) {
+    logger.debug('===In RedditPixel page===');
+    window.rdt('track', 'PageVisit');
+  }
+}
+
+export default RedditPixel;

package/src/integrations/RedditPixel/constants.js

@@ -0,0 +1,13 @@
+const NAME = 'REDDIT_PIXEL';
+const CNameMapping = {
+  [NAME]: NAME,
+  Reddit_Pixel: NAME,
+  RedditPixel: NAME,
+  REDDITPIXEL: NAME,
+  redditpixel: NAME,
+  'Reddit Pixel': NAME,
+  'REDDIT PIXEL': NAME,
+  'reddit pixel': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/RedditPixel/index.js

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

package/src/integrations/RedditPixel/nativeSdkLoader.js

@@ -0,0 +1,21 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(advertiserId) {
+  !(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', advertiserId);
+}
+
+export { loadNativeSdk };

package/src/integrations/Refiner/browser.js

@@ -0,0 +1,119 @@
+/* eslint-disable no-underscore-dangle */
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+import { loadNativeSdk } from './nativeSdkLoader';
+import { replaceUserTraits, replaceAccountTraits } from './utils';
+
+class Refiner {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.name = NAME;
+    this.apiKey = config.webClientApiKey;
+    this.userAttributesMapping = config.userAttributesMapping;
+    this.accountAttributesMapping = config.accountAttributesMapping;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    loadNativeSdk(this.apiKey);
+  }
+
+  init() {
+    logger.debug('===In init Refiner===');
+    this.loadScript();
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Refiner===');
+    return !!this._refiner;
+  }
+
+  isReady() {
+    logger.debug('===In isReady Refiner===');
+    return !!this._refiner;
+  }
+
+  identify(htElement) {
+    logger.debug('===In Refiner Identify===');
+    const { message } = htElement;
+    const { userId, traits, context } = message;
+    const email = traits?.email || context?.traits?.email;
+    if (!userId && !email) {
+      logger.error('either one userId or email is required');
+      return;
+    }
+    let userTraits = {
+      ...traits,
+      ...context.traits,
+      email,
+    };
+    userTraits = replaceUserTraits(userTraits, this.userAttributesMapping);
+    this._refiner('identifyUser', {
+      id: userId,
+      ...userTraits,
+    });
+  }
+
+  track(htElement) {
+    logger.debug('===In Refiner track===');
+    const { event } = htElement.message;
+
+    if (!event) {
+      logger.error('Event name not present');
+      return;
+    }
+
+    if (typeof event !== 'string') {
+      logger.error('Event name should be string');
+      return;
+    }
+
+    this._refiner('trackEvent', event);
+  }
+
+  group(htElement) {
+    logger.debug('===In Refiner Group===');
+    const { message } = htElement;
+    const { userId, groupId, traits, context } = message;
+    const userEmail = context?.traits?.email;
+    if (!userId && !userEmail) {
+      logger.error('either one userId or email is required');
+      return;
+    }
+    let accountTraits = { ...traits };
+    accountTraits = replaceAccountTraits(accountTraits, this.accountAttributesMapping);
+    this._refiner('identifyUser', {
+      id: userId,
+      email: userEmail,
+      account: {
+        id: groupId,
+        ...accountTraits,
+      },
+    });
+  }
+
+  page(htElement) {
+    logger.debug('===In Refiner page===');
+    const { message } = htElement;
+    let pageFullName;
+    if (!message.name && !message.category) {
+      pageFullName = `pageView`;
+    } else if (!message.name && message.category) {
+      pageFullName = `Viewed ${message.category} Page`;
+    } else if (message.name && !message.category) {
+      pageFullName = `Viewed ${message.name} Page`;
+    } else {
+      pageFullName = `Viewed ${message.category} ${message.name} Page`;
+    }
+    this._refiner('trackEvent', pageFullName);
+  }
+}
+
+export default Refiner;

package/src/integrations/Refiner/constants.js

@@ -0,0 +1,8 @@
+const NAME = 'REFINER';
+const CNameMapping = {
+  [NAME]: NAME,
+  Refiner: NAME,
+  refiner: NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/Refiner/index.js

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

package/src/integrations/Refiner/nativeSdkLoader.js

@@ -0,0 +1,20 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(apiKey) {
+  window._refinerQueue = window._refinerQueue || [];
+  window._refiner = function () {
+    window._refinerQueue.push(arguments);
+  };
+  window._refiner('setProject', apiKey);
+  (function () {
+    var a = document.createElement('script');
+    a.setAttribute('data-loader', LOAD_ORIGIN);
+    a.type = 'text/javascript';
+    a.async = !0;
+    a.src = 'https://js.refiner.io/v001/client.js';
+    var b = document.getElementsByTagName('script')[0];
+    b.parentNode.insertBefore(a, b);
+  })();
+}
+
+export { loadNativeSdk };