iureiure 1.0.0

package/packages/analytics-v1.1/src/utils/PreProcessQueue.js

@@ -0,0 +1,66 @@
+/* eslint-disable consistent-return */
+
+import Queue from '@segment/localstorage-retry';
+import RudderElement from './RudderElement';
+
+/**
+ * Keeping maxAttempts to Infinity to retry cloud mode events and throw an error until processQueueElements flag is not set to true
+ */
+const queueOptions = {
+  maxRetryDelay: 360000,
+  minRetryDelay: 1000,
+  backoffFactor: 2,
+  maxAttempts: Infinity,
+};
+
+class PreProcessQueue {
+  constructor() {
+    this.callback = undefined;
+    this.processQueueElements = false;
+  }
+
+  init(options, callback) {
+    if (options) {
+      // TODO: add checks for value - has to be +ve?
+      Object.assign(queueOptions, options);
+    }
+    if (callback) {
+      this.callback = callback;
+    }
+    this.payloadQueue = new Queue('rs_events', queueOptions, (item, done) => {
+      this.processQueueElement(item.type, item.rudderElement, (err, res) => {
+        if (err) {
+          return done(err);
+        }
+        done(null, res);
+      });
+    });
+    this.payloadQueue.start();
+  }
+
+  activateProcessor() {
+    // An indicator to process elements in queue
+    this.processQueueElements = true;
+  }
+
+  processQueueElement(type, rudderElement, queueFn) {
+    try {
+      if (this.processQueueElements) {
+        Object.setPrototypeOf(rudderElement, RudderElement.prototype);
+        this.callback(type, rudderElement);
+        queueFn(null);
+      } else {
+        queueFn(new Error('The queue elements are not ready to be processed yet'));
+      }
+    } catch (error) {
+      queueFn(error);
+    }
+  }
+
+  enqueue(type, rudderElement) {
+    // add items to the queue
+    this.payloadQueue.addItem({ type, rudderElement });
+  }
+}
+
+export default PreProcessQueue;

package/packages/analytics-v1.1/src/utils/RudderApp.js

@@ -0,0 +1,9 @@
+// Application class
+class RudderApp {
+  constructor() {
+    this.name = 'RudderLabs JavaScript SDK';
+    this.namespace = 'com.rudderlabs.javascript';
+    this.version = '__PACKAGE_VERSION__';
+  }
+}
+export default RudderApp;

package/packages/analytics-v1.1/src/utils/RudderContext.js

@@ -0,0 +1,23 @@
+// Context class
+import { getTimezone } from '@rudderstack/analytics-js-common/utilities/timezone';
+import RudderApp from './RudderApp';
+import { RudderLibraryInfo, RudderOSInfo } from './RudderInfo';
+import { getUserAgent, getLanguage } from './navigator';
+import { getScreenDetails } from './screenDetails';
+
+class RudderContext {
+  constructor() {
+    this.app = new RudderApp();
+    this.traits = null;
+    this.library = new RudderLibraryInfo();
+    this.userAgent = getUserAgent();
+    this.device = null;
+    this.network = null;
+    this.os = new RudderOSInfo();
+    this.locale = getLanguage();
+    this.screen = getScreenDetails();
+    this.timezone = getTimezone();
+  }
+}
+
+export default RudderContext;

package/packages/analytics-v1.1/src/utils/RudderElement.js

@@ -0,0 +1,33 @@
+import RudderMessage from './RudderMessage';
+// Individual element class containing Rudder Message
+class RudderElement {
+  constructor() {
+    this.message = new RudderMessage();
+  }
+
+  // Setters that in turn set the field values for the contained object
+  setType(type) {
+    this.message.type = type;
+  }
+
+  setProperty(rudderProperty) {
+    this.message.properties = rudderProperty;
+  }
+
+  setUserProperty(rudderUserProperty) {
+    this.message.user_properties = rudderUserProperty;
+  }
+
+  setUserId(userId) {
+    this.message.userId = userId;
+  }
+
+  setEventName(eventName) {
+    this.message.event = eventName;
+  }
+
+  getElementContent() {
+    return this.message;
+  }
+}
+export default RudderElement;

package/packages/analytics-v1.1/src/utils/RudderElementBuilder.js

@@ -0,0 +1,29 @@
+// Class responsible for building up the individual elements in a batch
+// that is transmitted by the SDK
+import RudderElement from './RudderElement';
+
+class RudderElementBuilder {
+  constructor() {
+    this.rudderProperty = null;
+    this.rudderUserProperty = null;
+    this.event = null;
+    this.userId = null;
+    this.type = null;
+  }
+
+  setType(eventType) {
+    this.type = eventType;
+    return this;
+  }
+
+  build() {
+    const element = new RudderElement();
+    element.setUserId(this.userId);
+    element.setType(this.type);
+    element.setEventName(this.event);
+    element.setProperty(this.rudderProperty);
+    element.setUserProperty(this.rudderUserProperty);
+    return element;
+  }
+}
+export default RudderElementBuilder;

package/packages/analytics-v1.1/src/utils/RudderInfo.js

@@ -0,0 +1,41 @@
+/* eslint-disable max-classes-per-file */
+// Library information class
+class RudderLibraryInfo {
+  constructor() {
+    this.name = 'RudderLabs JavaScript SDK';
+    this.version = '__PACKAGE_VERSION__';
+  }
+}
+// Operating System information class
+class RudderOSInfo {
+  constructor() {
+    this.name = '';
+    this.version = '';
+  }
+}
+// Screen information class
+class RudderScreenInfo {
+  constructor() {
+    this.density = 0;
+    this.width = 0;
+    this.height = 0;
+    this.innerWidth = 0;
+    this.innerHeight = 0;
+  }
+}
+// Device information class
+class RudderDeviceInfo {
+  constructor() {
+    this.id = '';
+    this.manufacturer = '';
+    this.model = '';
+    this.name = '';
+  }
+}
+// Carrier information
+class RudderNetwork {
+  constructor() {
+    this.carrier = '';
+  }
+}
+export { RudderLibraryInfo, RudderOSInfo, RudderScreenInfo, RudderDeviceInfo, RudderNetwork };

package/packages/analytics-v1.1/src/utils/RudderMessage.js

@@ -0,0 +1,28 @@
+// Core message class with default values
+import { generateUUID } from './utils';
+import RudderContext from './RudderContext';
+
+class RudderMessage {
+  constructor() {
+    this.channel = 'web';
+    this.context = new RudderContext();
+    this.type = null;
+    this.messageId = generateUUID();
+    this.originalTimestamp = new Date().toISOString();
+    this.anonymousId = null;
+    this.userId = null;
+    this.event = null;
+    this.properties = {};
+  }
+
+  // Get property
+  getProperty(key) {
+    return this.properties[key];
+  }
+
+  // Add property
+  addProperty(key, value) {
+    this.properties[key] = value;
+  }
+}
+export default RudderMessage;

package/packages/analytics-v1.1/src/utils/beaconQueue.js

@@ -0,0 +1,140 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable class-methods-use-this */
+import { Store } from '@rudderstack/analytics-js-common/v1.1/utils/storage/store';
+import { handleError } from '@rudderstack/analytics-js-common/v1.1/utils/errorHandler';
+import { stringifyWithoutCircularV1 } from '@rudderstack/analytics-js-common/v1.1/utils/ObjectUtils';
+import { logger } from '@rudderstack/analytics-js-common/v1.1/utils/logUtil';
+import { getCurrentTimeFormatted } from './utils';
+
+const defaults = {
+  queue: 'queue',
+  maxPayloadSize: 64 * 1000,
+};
+
+class BeaconQueue {
+  constructor() {
+    this.storage = Store;
+    this.maxItems = 10;
+    this.flushQueueTimeOut = undefined;
+    this.timeOutActive = false;
+    this.flushQueueTimeOutInterval = 1000 * 60 * 10; // 10 mins
+    this.url = '';
+    this.writekey = '';
+    this.queueName = `${defaults.queue}.${Date.now()}`;
+  }
+
+  sendQueueDataForBeacon() {
+    this.sendDataFromQueueAndDestroyQueue();
+  }
+
+  init(writekey, url, options) {
+    this.url = url;
+    this.writekey = writekey;
+    if (options.maxItems) this.maxItems = options.maxItems;
+    if (options.flushQueueInterval) this.flushQueueTimeOutInterval = options.flushQueueInterval;
+
+    this.sendQueueDataForBeacon = this.sendQueueDataForBeacon.bind(this);
+
+    this.attachListeners();
+  }
+
+  attachListeners() {
+    window.addEventListener('visibilitychange', () => {
+      if (document.visibilityState === 'hidden') {
+        this.sendQueueDataForBeacon();
+      }
+    });
+  }
+
+  getQueue() {
+    return this.storage.get(this.queueName);
+  }
+
+  setQueue(value) {
+    this.storage.set(this.queueName, value);
+  }
+
+  enqueue(message) {
+    let queue = this.getQueue() || [];
+    queue = queue.slice(-(this.maxItems - 1));
+    queue.push(message);
+    let batch = queue.slice(0);
+    const data = { batch, sentAt: getCurrentTimeFormatted() };
+    const dataToSend = stringifyWithoutCircularV1(data, true);
+    if (dataToSend && dataToSend.length > defaults.maxPayloadSize) {
+      batch = queue.slice(0, queue.length - 1);
+      this.flushQueue(batch);
+      queue = this.getQueue();
+      queue.push(message);
+    }
+    this.setQueue(queue);
+    this.setTimer();
+
+    if (queue.length === this.maxItems) {
+      this.flushQueue(batch);
+    }
+  }
+
+  sendDataFromQueueAndDestroyQueue() {
+    this.sendDataFromQueue();
+    this.storage.remove(this.queueName);
+  }
+
+  sendDataFromQueue() {
+    const queue = this.getQueue();
+    if (queue && queue.length > 0) {
+      const batch = queue.slice(0, queue.length);
+      this.flushQueue(batch);
+    }
+  }
+
+  flushQueue(batch) {
+    // check batch payload has data before flushing
+    if (batch && batch.length > 0) {
+      const currentTime = getCurrentTimeFormatted();
+      batch.forEach(event => {
+        event.sentAt = currentTime;
+      });
+      const data = { batch, sentAt: currentTime };
+      const payload = stringifyWithoutCircularV1(data, true);
+      if (payload !== null) {
+        const blob = new Blob([payload], { type: 'text/plain' });
+        const targetUrl = `${this.url}?writeKey=${this.writekey}`;
+        try {
+          if (typeof navigator.sendBeacon !== 'function') {
+            handleError(new Error('Beacon API is not supported by browser'));
+          }
+          const isPushed = navigator.sendBeacon(targetUrl, blob);
+          if (!isPushed) {
+            handleError(new Error("Unable to queue data to browser's beacon queue"));
+          }
+        } catch (e) {
+          e.message = `${e.message} - While sending Beacon data to: ${targetUrl}`;
+          handleError(e);
+        }
+      } else {
+        logger.error(`Invalid payload: Event dropped`);
+      }
+    }
+    this.setQueue([]);
+    this.clearTimer();
+  }
+
+  setTimer() {
+    if (!this.timeOutActive) {
+      this.flushQueueTimeOut = setTimeout(
+        this.sendDataFromQueue.bind(this),
+        this.flushQueueTimeOutInterval,
+      );
+      this.timeOutActive = true;
+    }
+  }
+
+  clearTimer() {
+    if (this.timeOutActive) {
+      clearTimeout(this.flushQueueTimeOut);
+      this.timeOutActive = false;
+    }
+  }
+}
+export default BeaconQueue;

package/packages/analytics-v1.1/src/utils/cdnPaths.js

@@ -0,0 +1,43 @@
+import { handleError } from '@rudderstack/analytics-js-common/v1.1/utils/errorHandler';
+import { getSDKUrlInfo, removeTrailingSlashes } from './utils';
+import { CDN_ARCH_VERSION_DIR, CDN_INT_DIR, DEST_SDK_BASE_URL } from './constants';
+
+const getIntegrationsCDNPath = (
+  currentVersion,
+  lockIntegrationsVersion,
+  customIntegrationsCDNPath,
+) => {
+  let integrationsCDNPath = '';
+
+  // Get the CDN base URL from the user provided URL if any
+  if (customIntegrationsCDNPath) {
+    integrationsCDNPath = removeTrailingSlashes(customIntegrationsCDNPath);
+
+    // TODO: add proper url validation
+    if (!integrationsCDNPath) {
+      const errorMsg = 'CDN base URL for integrations is not valid';
+
+      handleError({
+        message: `[Analytics] load:: ${errorMsg}`,
+      });
+      throw Error(`Failed to load Rudder SDK: ${errorMsg}`);
+    }
+
+    return integrationsCDNPath;
+  }
+
+  // Get the base path from the SDK script tag src attribute or use the default path
+  const { sdkURL } = getSDKUrlInfo();
+  integrationsCDNPath = sdkURL
+    ? sdkURL.split('/').slice(0, -1).concat(CDN_INT_DIR).join('/')
+    : DEST_SDK_BASE_URL;
+
+  // If version is not locked it will always get the latest version of the integrations
+  if (lockIntegrationsVersion) {
+    integrationsCDNPath = integrationsCDNPath.replace(CDN_ARCH_VERSION_DIR, currentVersion);
+  }
+
+  return integrationsCDNPath;
+};
+
+export { getIntegrationsCDNPath };

package/packages/analytics-v1.1/src/utils/clientHint.js

@@ -0,0 +1,28 @@
+const getUserAgentClientHint = (callback, level = 'none') => {
+  if (level === 'none') {
+    callback(undefined);
+  }
+  if (level === 'default') {
+    callback(navigator.userAgentData);
+  }
+  if (level === 'full') {
+    navigator.userAgentData
+      .getHighEntropyValues([
+        'architecture',
+        'bitness',
+        'brands',
+        'mobile',
+        'model',
+        'platform',
+        'platformVersion',
+        'uaFullVersion',
+        'fullVersionList',
+        'wow64',
+      ])
+      .then(ua => {
+        callback(ua);
+      });
+  }
+};
+
+export { getUserAgentClientHint };

package/packages/analytics-v1.1/src/utils/constants.js

@@ -0,0 +1,70 @@
+// Reserved Keywords for properties/traits
+const RESERVED_KEYS = [
+  'anonymous_id',
+  'id',
+  'sent_at',
+  'received_at',
+  'timestamp',
+  'original_timestamp',
+  'event_text',
+  'event',
+];
+
+const CONFIG_URL =
+  'https://api.rudderstack.com/sourceConfig/?p=__MODULE_TYPE__&v=__PACKAGE_VERSION__';
+const SDK_CDN_BASE_URL = 'https://cdn.rudderlabs.com';
+const CDN_ARCH_VERSION_DIR = 'v1.1';
+const CDN_INT_DIR = 'js-integrations';
+const DEST_SDK_BASE_URL = `${SDK_CDN_BASE_URL}/${CDN_ARCH_VERSION_DIR}/${CDN_INT_DIR}`;
+
+const DEFAULT_DATA_PLANE_EVENTS_BUFFER_TIMEOUT_MS = 10000;
+const INTG_SUFFIX = '_RS';
+// eslint-disable-next-line no-constant-condition
+const POLYFILL_URL = '__RS_POLYFILLIO_SDK_URL__'
+  ? '__RS_POLYFILLIO_SDK_URL__?version=3.111.0&features=Number.isNaN%2CURL%2CArray.prototype.find%2CArray.prototype.includes%2CPromise%2CString.prototype.endsWith%2CString.prototype.includes%2CString.prototype.startsWith%2CObject.entries%2CObject.values%2CElement.prototype.dataset%2CString.prototype.replaceAll%2CTextEncoder%2Cnavigator.sendBeacon'
+  : '';
+
+const SAMESITE_COOKIE_OPTS = ['Lax', 'None', 'Strict'];
+
+const DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1000; // 30 min in milliseconds
+const MIN_SESSION_TIMEOUT = 10 * 1000; // 10 sec in milliseconds
+const MIN_SESSION_ID_LENGTH = 10;
+
+const DEFAULT_REGION = 'US';
+const DEFAULT_DATAPLANE_URL = 'https://hosted.rudderlabs.com';
+
+const RESIDENCY_SERVERS = [DEFAULT_REGION, 'EU'];
+
+const SUPPORTED_CONSENT_MANAGERS = ['oneTrust', 'ketch'];
+
+const SYSTEM_KEYWORDS = ['library', 'consentManagement'];
+const UA_CH_LEVELS = ['none', 'default', 'full'];
+
+const DEFAULT_INTEGRATIONS_CONFIG = { All: true };
+
+// xhr request timeout
+const REQUEST_TIMEOUT_MS = 30 * 1000;
+
+export {
+  RESERVED_KEYS,
+  CONFIG_URL,
+  SDK_CDN_BASE_URL,
+  CDN_ARCH_VERSION_DIR,
+  CDN_INT_DIR,
+  DEST_SDK_BASE_URL,
+  INTG_SUFFIX,
+  POLYFILL_URL,
+  SAMESITE_COOKIE_OPTS,
+  DEFAULT_SESSION_TIMEOUT,
+  MIN_SESSION_TIMEOUT,
+  MIN_SESSION_ID_LENGTH,
+  DEFAULT_REGION,
+  DEFAULT_DATAPLANE_URL,
+  RESIDENCY_SERVERS,
+  SUPPORTED_CONSENT_MANAGERS,
+  SYSTEM_KEYWORDS,
+  UA_CH_LEVELS,
+  DEFAULT_INTEGRATIONS_CONFIG,
+  DEFAULT_DATA_PLANE_EVENTS_BUFFER_TIMEOUT_MS,
+  REQUEST_TIMEOUT_MS,
+};

package/packages/analytics-v1.1/src/utils/eventProcessorUtils.js

@@ -0,0 +1,53 @@
+import { logger } from '@rudderstack/analytics-js-common/v1.1/utils/logUtil';
+import { mergeDeepRight } from '@rudderstack/analytics-js-common/utilities/object';
+import { SYSTEM_KEYWORDS } from './constants';
+
+const defaultTopLevelElements = ['integrations', 'anonymousId', 'originalTimestamp'];
+
+const mergeTopLevelElementsMutator = (rudderElementMessage, options = {}) => {
+  if (typeof options !== 'object' || options === null) {
+    return;
+  }
+
+  Object.keys(options).forEach(key => {
+    if (defaultTopLevelElements.includes(key)) {
+      // eslint-disable-next-line no-param-reassign
+      rudderElementMessage[key] = options[key];
+    }
+  });
+};
+
+const mergeContext = (rudderElementMessage, options = {}) => {
+  let { context } = rudderElementMessage;
+
+  if (typeof options !== 'object' || options === null) {
+    return context;
+  }
+
+  Object.keys(options).forEach(key => {
+    if (!defaultTopLevelElements.includes(key) && !SYSTEM_KEYWORDS.includes(key)) {
+      if (key !== 'context') {
+        context = mergeDeepRight(context, {
+          [key]: options[key],
+        });
+      } else if (typeof options[key] === 'object' && options[key] !== null) {
+        const tempContext = {};
+        Object.keys(options[key]).forEach(e => {
+          if (!SYSTEM_KEYWORDS.includes(e)) {
+            tempContext[e] = options[key][e];
+          }
+        });
+        context = mergeDeepRight(context, {
+          ...tempContext,
+        });
+      } else {
+        logger.error(
+          `[Analytics: processOptionsParam] context passed in options ${key} is not object.`,
+        );
+      }
+    }
+  });
+  return context;
+};
+
+export { mergeContext, mergeTopLevelElementsMutator };

package/packages/analytics-v1.1/src/utils/linker/base64decoder.js

@@ -0,0 +1,29 @@
+/**
+ * @description This is utility function for decoding from base 64 to utf8
+ * @version v1.0.0
+ */
+
+/**
+ * @param {string} str base64
+ * @returns {string} utf8
+ */
+function b64DecodeUnicode(str) {
+  // Going backwards: from bytestream, to percent-encoding, to original string.
+  return decodeURIComponent(
+    atob(str)
+      .split('')
+      .map(c => `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`)
+      .join(''),
+  );
+}
+
+/**
+ * @param {string} data
+ * @return {string}
+ */
+function decode(data = '') {
+  data = data.endsWith('..') ? data.substr(0, data.length - 2) : data;
+  return b64DecodeUnicode(data);
+}
+
+export default decode;

package/packages/analytics-v1.1/src/utils/linker/crc32.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-bitwise */
+/**
+ * @description This is utility function for crc32 algorithm
+ * @version v1.0.0
+ */
+
+/**
+ * @description generate crc table
+ * @params none
+ * @returns array of CRC table
+ */
+
+const makeCRCTable = function () {
+  const crcTable = [];
+  let c;
+  for (let n = 0; n < 256; n++) {
+    c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    crcTable[n] = c;
+  }
+  return crcTable;
+};
+
+/**
+ *
+ * @param {string} str
+ * @returns {Bytestream} crc32
+ */
+const crc32 = function (str) {
+  const crcTable = makeCRCTable();
+  let crc = 0 ^ -1;
+
+  for (let i = 0; i < str.length; i++) {
+    crc = (crc >>> 8) ^ crcTable[(crc ^ str.charCodeAt(i)) & 0xff];
+  }
+
+  return (crc ^ -1) >>> 0;
+};
+
+export default crc32;