iureiure 1.0.0

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

@@ -0,0 +1,64 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(
+  account_id,
+  settings_tolerance,
+  library_tolerance,
+  use_existing_jquery,
+  isSPA,
+) {
+  window._vwo_code = (function () {
+    let f = false;
+    const d = document;
+    return {
+      use_existing_jquery() {
+        return use_existing_jquery;
+      },
+      library_tolerance() {
+        return library_tolerance;
+      },
+      finish() {
+        if (!f) {
+          f = true;
+          const a = d.getElementById('_vis_opt_path_hides');
+          if (a) a.parentNode.removeChild(a);
+        }
+      },
+      finished() {
+        return f;
+      },
+      load(a) {
+        const b = d.createElement('script');
+        b.src = a;
+        b.type = 'text/javascript';
+        b.setAttribute('data-loader', LOAD_ORIGIN);
+        b.innerText;
+        b.onerror = function () {
+          _vwo_code.finish();
+        };
+        d.getElementsByTagName('head')[0].appendChild(b);
+      },
+      init() {
+        const settings_timer = setTimeout('_vwo_code.finish()', settings_tolerance);
+        const a = d.createElement('style');
+        const b =
+          'body{opacity:0 !important;filter:alpha(opacity=0) !important;background:none !important;}';
+        const h = d.getElementsByTagName('head')[0];
+        a.setAttribute('id', '_vis_opt_path_hides');
+        a.setAttribute('type', 'text/css');
+        if (a.styleSheet) a.styleSheet.cssText = b;
+        else a.appendChild(d.createTextNode(b));
+        h.appendChild(a);
+        this.load(
+          `//dev.visualwebsiteoptimizer.com/j.php?a=${account_id}&u=${encodeURIComponent(
+            d.URL,
+          )}&r=${Math.random()}&f=${+isSPA}`,
+        );
+        return settings_timer;
+      },
+    };
+  })();
+  window._vwo_settings_timer = window._vwo_code.init();
+}
+
+export { loadNativeSdk };

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

@@ -0,0 +1,42 @@
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/VWO/constants';
+
+/**
+ * Get destination specific options from integrations options
+ * By default, it will return options for the destination using its display name
+ * If display name is not present, it will return options for the destination using its name
+ * The fallback is only for backward compatibility with SDK versions < v1.1
+ * @param {object} integrationsOptions Integrations options object
+ * @returns destination specific options
+ */
+const getDestinationOptions = integrationsOptions =>
+  integrationsOptions && (integrationsOptions[DISPLAY_NAME] || integrationsOptions[NAME]);
+
+/**
+ * Sanitizes the given event name by trimming any leading or trailing whitespace and prefixing it with "rudder.".
+ *
+ * @param {string} eventName - The event name to be sanitized.
+ * @return {string} The sanitized event name.
+ */
+const sanitizeName = eventName => {
+  return `rudder.${eventName.trim()}`;
+};
+
+/**
+ * Sanitizes the properties object by formatting the keys and returning a new object with the formatted keys.
+ *
+ * @param {object} properties - The properties object to be sanitized.
+ * @return {object} - The sanitized properties object with formatted keys.
+ */
+const sanitizeAttributes = attributes => {
+  const formattedAttributes = {};
+  for (const key in attributes) {
+    const formattedKey = sanitizeName(key);
+    formattedAttributes[formattedKey] = attributes[key];
+  }
+  return formattedAttributes;
+};
+
+export { getDestinationOptions, sanitizeName, sanitizeAttributes };

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

@@ -0,0 +1,166 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Vero/constants';
+import { ScriptLoader } from '@rudderstack/analytics-js-common/v1.1/utils/ScriptLoader';
+import Logger from '../../utils/logger';
+import { isDefinedAndNotNull } from '../../utils/commonUtils';
+import { getDestinationOptions } from './utils';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Vero {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.apiKey = config.apiKey;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    window._veroq = window._veroq || [];
+    ScriptLoader('vero-integration', 'https://d3qxef4rp70elm.cloudfront.net/m.js');
+    window._veroq.push(['init', { api_key: this.apiKey }]);
+  }
+
+  isLoaded() {
+    return !!window._veroq && typeof window._veroq === 'object';
+  }
+
+  isReady() {
+    return !!window._veroq && !!window._veroq.ready;
+  }
+
+  /**
+   * AddOrRemoveTags.
+   * This block handles any tag addition or removal requests.
+   * Ref - http://developers.getvero.com/?javascript#tags
+   *
+   * @param {Object} tags
+   */
+  addOrRemoveTags(message) {
+    const { integrations, anonymousId, userId } = message;
+    const veroIntgConfig = getDestinationOptions(integrations);
+    if (veroIntgConfig) {
+      const { tags } = veroIntgConfig;
+      if (isDefinedAndNotNull(tags)) {
+        const id = userId || anonymousId;
+        const addTags = Array.isArray(tags.add) ? tags.add : [];
+        const removeTags = Array.isArray(tags.remove) ? tags.remove : [];
+        window._veroq.push([
+          'tags',
+          {
+            id,
+            add: addTags,
+            remove: removeTags,
+          },
+        ]);
+      }
+    }
+  }
+
+  /**
+   * Identify.
+   * Ref - https://developers.getvero.com/?javascript#users-identify
+   *
+   * @param {Identify} identify
+   */
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    const { traits } = message.context || message;
+    const userId = message.userId || message.anonymousId;
+    let payload = traits;
+    if (userId) {
+      payload = { id: userId, ...payload };
+    }
+    window._veroq.push(['user', payload]);
+    this.addOrRemoveTags(message);
+  }
+
+  /**
+   * Track - tracks an event for a specific user
+   * for event `unsubscribe`
+   * Ref - https://developers.getvero.com/?javascript#users-unsubscribe
+   * for event `resubscribe`
+   * Ref - https://developers.getvero.com/?javascript#users-resubscribe
+   * else
+   * Ref - https://developers.getvero.com/?javascript#events-track
+   *
+   * @param {Track} track
+   */
+  track(rudderElement) {
+    const { message } = rudderElement;
+    const { event, properties, anonymousId, userId } = message;
+    if (!event) {
+      logger.error('Event name from track call is missing');
+      return;
+    }
+    const id = userId || anonymousId;
+    switch (event.toLowerCase()) {
+      case 'unsubscribe':
+        window._veroq.push(['unsubscribe', id]);
+        break;
+      case 'resubscribe':
+        window._veroq.push(['resubscribe', id]);
+        break;
+      default:
+        window._veroq.push(['track', event, properties]);
+    }
+    this.addOrRemoveTags(message);
+  }
+
+  /**
+   * Page.
+   *
+   * @param {Page} page
+   */
+  page(rudderElement) {
+    const { name, category } = rudderElement.message;
+    let eventName;
+    if (!name && !category) {
+      eventName = `Viewed Page`;
+    } else if (!name && category) {
+      eventName = `Viewed ${category} Page`;
+    } else if (name && !category) {
+      eventName = `Viewed ${name} Page`;
+    } else {
+      eventName = `Viewed ${category} ${name} Page`;
+    }
+    const elemClone = { ...rudderElement };
+    elemClone.message = { ...rudderElement.message };
+    elemClone.message.event = eventName;
+    this.track(elemClone);
+  }
+
+  /**
+   * Alias.
+   * Ref - https://www.getvero.com/api/http/#users
+   *
+   * @param {Alias} alias
+   */
+  alias(rudderElement) {
+    const { message } = rudderElement;
+    const { userId, previousId } = message;
+    if (!previousId) {
+      logger.error('previousId is required for alias call');
+      return;
+    }
+    if (!userId) {
+      logger.error('userId is required for alias call');
+      return;
+    }
+    window._veroq.push(['reidentify', userId, previousId]);
+    this.addOrRemoveTags(message);
+  }
+}
+
+export default Vero;

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

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

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

@@ -0,0 +1,17 @@
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Vero/constants';
+
+/**
+ * Get destination specific options from integrations options
+ * By default, it will return options for the destination using its display name
+ * If display name is not present, it will return options for the destination using its name
+ * The fallback is only for backward compatibility with SDK versions < v1.1
+ * @param {object} integrationsOptions Integrations options object
+ * @returns destination specific options
+ */
+const getDestinationOptions = integrationsOptions =>
+  integrationsOptions && (integrationsOptions[DISPLAY_NAME] || integrationsOptions[NAME]);
+
+export { getDestinationOptions };

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

@@ -0,0 +1,82 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/Woopra/constants';
+import Logger from '../../utils/logger';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class Woopra {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.projectName = config.projectName;
+    this.name = NAME;
+    this.cookieName = config.cookieName;
+    this.cookiePath = config.cookiePath;
+    this.cookieDomain = config.cookieDomain;
+    this.clickTracking = config.clickTracking;
+    this.downloadTracking = config.downloadTracking;
+    this.hideCampaign = config.hideCampaign;
+    this.idleTimeout = config.idleTimeout;
+    this.ignoreQueryUrl = config.ignoreQueryUrl;
+    this.outgoingIgnoreSubdomain = config.outgoingIgnoreSubdomain;
+    this.outgoingTracking = config.outgoingTracking;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    loadNativeSdk();
+    window.Woopra.config({
+      domain: this.projectName,
+      cookie_name: this.cookieName,
+      cookie_path: this.cookiePath,
+      cookie_domain: this.cookieDomain,
+      click_tracking: this.clickTracking,
+      download_tracking: this.downloadTracking,
+      hide_campaign: this.hideCampaign,
+      idle_timeout: this.idleTimeout,
+      ignore_query_url: this.ignoreQueryUrl,
+      outgoing_ignore_subdomain: this.outgoingIgnoreSubdomain,
+      outgoing_tracking: this.outgoingTracking,
+    });
+  }
+
+  isLoaded() {
+    return !!window?.Woopra?.loaded;
+  }
+
+  isReady() {
+    return !!window.Woopra;
+  }
+
+  identify(rudderElement) {
+    const { traits } = rudderElement.message.context;
+    if (traits) {
+      window.Woopra.identify(traits).push();
+    }
+  }
+
+  track(rudderElement) {
+    const { event, properties } = rudderElement.message;
+    window.Woopra.track(event, properties);
+  }
+
+  page(rudderElement) {
+    const { name, properties, category } = rudderElement.message;
+    const pageCat = category ? `${category} ` : '';
+    const pageName = name ? `${name} ` : '';
+    const eventName = `Viewed ${pageCat}${pageName}Page`;
+    window.Woopra.track(eventName, properties);
+  }
+}
+
+export default Woopra;

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

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

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

@@ -0,0 +1,43 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk() {
+  !(function () {
+    var t,
+      o,
+      c,
+      e = window,
+      n = document,
+      r = arguments,
+      a = 'script',
+      i = [
+        'call',
+        'cancelAction',
+        'config',
+        'identify',
+        'push',
+        'track',
+        'trackClick',
+        'trackForm',
+        'update',
+        'visit',
+      ],
+      s = function () {
+        var t,
+          o = this,
+          c = function (t) {
+            o[t] = function () {
+              return o._e.push([t].concat(Array.prototype.slice.call(arguments, 0))), o;
+            };
+          };
+        for (o._e = [], t = 0; t < i.length; t++) c(i[t]);
+      };
+    for (e.__woo = e.__woo || {}, t = 0; t < r.length; t++)
+      e.__woo[r[t]] = e[r[t]] = e[r[t]] || new s();
+    ((o = n.createElement(a)).async = 1),
+      (o.src = 'https://static.woopra.com/w.js'),
+      o.setAttribute('data-loader', LOAD_ORIGIN),
+      (c = n.getElementsByTagName(a)[0]).parentNode.insertBefore(o, c);
+  })('Woopra');
+}
+
+export { loadNativeSdk };

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

@@ -0,0 +1,139 @@
+/* eslint-disable class-methods-use-this */
+import {
+  NAME,
+  DISPLAY_NAME,
+} from '@rudderstack/analytics-js-common/constants/integrations/YandexMetrica/constants';
+import Logger from '../../utils/logger';
+import { ecommEventPayload, sendEvent, ecommerceEventMapping } from './utils';
+import {
+  removeUndefinedAndNullValues,
+  getHashFromArrayWithDuplicate,
+} from '../../utils/commonUtils';
+import { getDefinedTraits } from '../../utils/utils';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+const logger = new Logger(DISPLAY_NAME);
+
+class YandexMetrica {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.tagId = config.tagId;
+    this.clickMap = config.clickMap;
+    this.trackLinks = config.trackLinks;
+    this.trackBounce = config.trackBounce;
+    this.webvisor = config.webvisor;
+    this.containerName = config.containerName || 'dataLayer';
+    this.goalId = config.goalId;
+    this.eventNameToYandexEvent = config.eventNameToYandexEvent;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  loadScript() {
+    loadNativeSdk(
+      this.tagId,
+      this.clickMap,
+      this.trackLinks,
+      this.accurateTrackBounce,
+      this.webvisor,
+      this.containerName,
+    );
+  }
+
+  init() {
+    this.loadScript();
+  }
+
+  isLoaded() {
+    return !!window.ym && typeof window.ym === 'function';
+  }
+
+  isReady() {
+    return !!window.ym;
+  }
+
+  // identify call to yandex.metrica
+  identify(rudderElement) {
+    const { message } = rudderElement;
+    const { userId } = getDefinedTraits(message);
+    let payload = { UserID: userId };
+    if (!message?.context?.traits) {
+      logger.info('user traits not present');
+    } else {
+      const { traits } = message.context;
+      payload = { ...payload, ...traits };
+    }
+    window.ym(this.tagId, 'setUserID', userId);
+    window.ym(this.tagId, 'userParams', payload);
+  }
+
+  // track call
+  track(rudderElement) {
+    const { message } = rudderElement;
+    const { event, properties } = message;
+    const eventMappingFromConfigMap = getHashFromArrayWithDuplicate(
+      this.eventNameToYandexEvent,
+      'from',
+      'to',
+      false,
+    );
+
+    if (!event) {
+      logger.error('Event name not present');
+      return;
+    }
+    const ecomEvents = Object.keys(ecommerceEventMapping);
+
+    const trimmedEvent = event.trim().replace(/\s+/g, '_');
+    if (!properties) {
+      logger.error('Properties is not present in the payload');
+      return;
+    }
+
+    if (eventMappingFromConfigMap[event]) {
+      eventMappingFromConfigMap[event].forEach(eventType => {
+        sendEvent(this.containerName, ecommEventPayload(eventType, properties, this.goalId));
+      });
+    } else if (ecomEvents.includes(trimmedEvent)) {
+      sendEvent(
+        this.containerName,
+        ecommEventPayload(ecommerceEventMapping[trimmedEvent], properties, this.goalId),
+      );
+    } else {
+      logger.error(
+        'Event is neither mapped in UI nor it belongs to the supported ecommerce events',
+      );
+    }
+  }
+
+  // page call
+  page(rudderElement) {
+    const { message } = rudderElement;
+    if (!message?.context?.page) {
+      logger.error('page object containing page properties are not present in the payload');
+      return;
+    }
+    const { page } = message.context;
+    if (!page.url) {
+      logger.error('url from page call is missing');
+      return;
+    }
+    let payload = {};
+    payload = {
+      ...payload,
+      title: page.title,
+      referer: page.referrer,
+    };
+    payload = removeUndefinedAndNullValues(payload);
+    window.ym(this.tagId, 'hit', page.url, payload);
+  }
+}
+
+export default YandexMetrica;

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

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

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

@@ -0,0 +1,35 @@
+import { LOAD_ORIGIN } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+
+function loadNativeSdk(tagId, clickmap, trackLinks, accurateTrackBounce, webvisor, ecommerce) {
+  (function (m, e, t, r, i, k, a) {
+    m[i] =
+      m[i] ||
+      function () {
+        (m[i].a = m[i].a || []).push(arguments);
+      };
+    m[i].l = 1 * new Date();
+    for (var j = 0; j < document.scripts.length; j++) {
+      if (document.scripts[j].src === r) {
+        return;
+      }
+    }
+    (k = e.createElement(t)),
+      (a = e.getElementsByTagName(t)[0]),
+      (k.async = 1),
+      (k.src = r),
+      k.setAttribute('data-loader', LOAD_ORIGIN),
+      a.parentNode.insertBefore(k, a);
+  })(window, document, 'script', 'https://mc.yandex.ru/metrika/tag.js', 'ym');
+
+  ym(tagId, 'init', {
+    clickmap,
+    trackLinks,
+    accurateTrackBounce,
+    webvisor,
+    ecommerce,
+  });
+  window[`${ecommerce}`] = window[`${ecommerce}`] || [];
+  window[`${ecommerce}`].push({});
+}
+
+export { loadNativeSdk };