iureiure 1.0.0

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

@@ -0,0 +1,134 @@
+/**
+ * @description AMP Linker Parser (works for Rudder, GA or any other linker created by following Google's linker standard.)
+ * @version v1.0.0
+ * @author Parth Mahajan, Ayush Mehra
+ */
+
+import crc32 from './crc32';
+import USER_INTERFACE from './userLib';
+import decode from './base64decoder';
+
+const KEY_VALIDATOR = /^[a-zA-Z0-9\-_.]+$/;
+const CHECKSUM_OFFSET_MAX_MIN = 1;
+const VALID_VERSION = 1;
+const DELIMITER = '*';
+
+/**
+ * Parse the linker param value to version checksum and serializedParams
+ * @param {string} value
+ * @return {?Object}
+ */
+function parseLinkerParamValue(value) {
+  const parts = value.split(DELIMITER);
+  const isEven = parts.length % 2 === 0;
+
+  if (parts.length < 4 || !isEven) {
+    // Format <version>*<checksum>*<key1>*<value1>
+    // Note: linker makes sure there's at least one pair of non empty key value
+    // Make sure there is at least three delimiters.
+    return null;
+  }
+
+  const version = Number(parts.shift());
+  if (version !== VALID_VERSION) {
+    return null;
+  }
+
+  const checksum = parts.shift();
+  const serializedIds = parts.join(DELIMITER);
+  return {
+    checksum,
+    serializedIds,
+  };
+}
+
+/**
+ * Deserialize the serializedIds and return keyValue pairs.
+ * @param {string} serializedIds
+ * @return {!Object<string, string>}
+ */
+function deserialize(serializedIds) {
+  const keyValuePairs = {};
+  const params = serializedIds.split(DELIMITER);
+  for (let i = 0; i < params.length; i += 2) {
+    const key = params[i];
+    const valid = KEY_VALIDATOR.test(key);
+    if (valid) {
+      const value = decode(params[i + 1]);
+      // const value = params[i + 1];
+      keyValuePairs[key] = value;
+    }
+  }
+  return keyValuePairs;
+}
+
+/**
+ * Generates a semi-unique value for page visitor.
+ * @return {string}
+ */
+function getFingerprint(userAgent, language) {
+  const date = new Date();
+  const timezone = date.getTimezoneOffset();
+  return [userAgent, timezone, language].join(DELIMITER);
+}
+
+/**
+ * Rounded time used to check if t2 - t1 is within our time tolerance.
+ * @return {number}
+ */
+function getMinSinceEpoch() {
+  // Timestamp in minutes, floored.
+  return Math.floor(Date.now() / 60000);
+}
+
+/**
+ * Create a unique checksum hashing the fingerprint and a few other values.
+ * @param {string} serializedIds
+ * @param {number=} optOffsetMin
+ * @return {string}
+ */
+function getCheckSum(serializedIds, optOffsetMin, userAgent, language) {
+  const fingerprint = getFingerprint(userAgent, language);
+  const offset = optOffsetMin || 0;
+  const timestamp = getMinSinceEpoch() - offset;
+  const crc = crc32([fingerprint, timestamp, serializedIds].join(DELIMITER));
+  // Encoded to base36 for less bytes.
+  return crc.toString(36);
+}
+
+/**
+ * Check if the checksum is valid with time offset tolerance.
+ * @param {string} serializedIds
+ * @param {string} checksum
+ * @return {boolean}
+ */
+function isCheckSumValid(serializedIds, checksum) {
+  const userAgent = USER_INTERFACE.getUserAgent();
+  const language = USER_INTERFACE.getUserLanguage();
+  for (let i = 0; i <= CHECKSUM_OFFSET_MAX_MIN; i += 1) {
+    const calculateCheckSum = getCheckSum(serializedIds, i, userAgent, language);
+    if (calculateCheckSum === checksum) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Return the key value pairs
+ * @param {string} value
+ * @return {?Object<string, string>}
+ */
+function parseLinker(value) {
+  const linkerObj = parseLinkerParamValue(value);
+  if (!linkerObj) {
+    return null;
+  }
+  const { checksum, serializedIds } = linkerObj;
+  if (!isCheckSumValid(serializedIds, checksum)) {
+    return null;
+  }
+  return deserialize(serializedIds);
+}
+
+export default parseLinker;

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

@@ -0,0 +1,20 @@
+/**
+ * @description An interface to fetch user device details.
+ * @version v1.0.0
+ */
+
+const USER_INTERFACE = {
+  /**
+   * @param {*} req
+   * @returns {string} user language
+   */
+  getUserLanguage: () => navigator && navigator.language,
+
+  /**
+   * @param {*} req
+   * @returns {string} userAgent
+   */
+  getUserAgent: () => navigator && navigator.userAgent,
+};
+
+export default USER_INTERFACE;

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

@@ -0,0 +1,32 @@
+const getUserAgent = () => {
+  if (typeof navigator === 'undefined') {
+    return null;
+  }
+
+  let { userAgent } = navigator;
+  const { brave } = navigator;
+
+  // For supporting Brave browser detection,
+  // add "Brave/<version>" to the user agent with the version value from the Chrome component
+  if (brave && Object.getPrototypeOf(brave).isBrave) {
+    // Example:
+    // Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.114 Safari/537.36
+    const matchedArr = userAgent.match(/(chrome)\/([\w.]+)/i);
+
+    if (matchedArr) {
+      userAgent = `${userAgent} Brave/${matchedArr[2]}`;
+    }
+  }
+
+  return userAgent;
+};
+
+const getLanguage = () => {
+  if (typeof navigator === 'undefined') {
+    return null;
+  }
+
+  return navigator.language || navigator.browserLanguage;
+};
+
+export { getUserAgent, getLanguage };

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

@@ -0,0 +1,74 @@
+/* eslint-disable consistent-return */
+/* eslint-disable camelcase */
+import { Storage } from '@rudderstack/analytics-js-common/v1.1/utils/storage';
+
+function getReferrer() {
+  return document?.referrer || '$direct';
+}
+
+function getReferringDomain(referrer) {
+  const split = referrer.split('/');
+  if (split.length >= 3) {
+    return split[2];
+  }
+  return '';
+}
+
+function getCanonicalUrl() {
+  const tags = document.getElementsByTagName('link');
+  for (let i = 0; tags[i]; i += 1) {
+    const tag = tags[i];
+    if (tag.getAttribute('rel') === 'canonical') {
+      return tag.getAttribute('href');
+    }
+  }
+}
+
+function getUrl(search) {
+  const canonicalUrl = getCanonicalUrl();
+  let url;
+  if (canonicalUrl) {
+    url = canonicalUrl.includes('?') ? canonicalUrl : canonicalUrl + search;
+  } else {
+    url = window.location.href;
+  }
+  const hashIndex = url.indexOf('#');
+  return hashIndex > -1 ? url.slice(0, hashIndex) : url;
+}
+
+function getDefaultPageProperties() {
+  const canonicalUrl = getCanonicalUrl();
+  let path = window.location.pathname;
+
+  if (canonicalUrl) {
+    try {
+      const urlObj = new URL(canonicalUrl);
+      path = urlObj.pathname;
+    } catch (err) {
+      // Do nothing
+    }
+  }
+
+  const { search, href } = window.location;
+  const { title } = document;
+  const url = getUrl(search);
+  const tab_url = href;
+
+  const referrer = getReferrer();
+  const referring_domain = getReferringDomain(referrer);
+  const initial_referrer = Storage.getInitialReferrer() || '';
+  const initial_referring_domain = Storage.getInitialReferringDomain() || '';
+  return {
+    path,
+    referrer,
+    referring_domain,
+    search,
+    title,
+    url,
+    tab_url,
+    initial_referrer,
+    initial_referring_domain,
+  };
+}
+
+export { getReferrer, getReferringDomain, getDefaultPageProperties };

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

@@ -0,0 +1,23 @@
+import { RudderScreenInfo } from './RudderInfo';
+
+const getScreenDetails = () => {
+  const screenDetails = new RudderScreenInfo();
+
+  // Depending on environment within which the code is executing, screen
+  // dimensions can be set
+  // User agent and locale can be retrieved only for browser
+  // When execution is in SSR window will be undefined
+  if (typeof window === 'undefined') {
+    return screenDetails;
+  }
+
+  screenDetails.width = window.screen.width;
+  screenDetails.height = window.screen.height;
+  screenDetails.density = window.devicePixelRatio;
+  screenDetails.innerWidth = window.innerWidth;
+  screenDetails.innerHeight = window.innerHeight;
+
+  return screenDetails;
+};
+
+export { getScreenDetails };

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

@@ -0,0 +1,423 @@
+import { v4 as uuid } from '@lukeed/uuid';
+import { v4 as uuidSecure } from '@lukeed/uuid/secure';
+import { commonNames } from '@rudderstack/analytics-js-common/v1.1/utils/integration_cname';
+import { clientToServerNames } from '@rudderstack/analytics-js-common/v1.1/utils/client_server_name';
+import { logger } from '@rudderstack/analytics-js-common/v1.1/utils/logUtil';
+import { FAILED_REQUEST_ERR_MSG_PREFIX } from '@rudderstack/analytics-js-common/v1.1/utils/constants';
+import { handleError } from '@rudderstack/analytics-js-common/v1.1/utils/errorHandler';
+import { stringifyWithoutCircularV1 } from '@rudderstack/analytics-js-common/v1.1/utils/ObjectUtils';
+import {
+  CONFIG_URL,
+  RESERVED_KEYS,
+  DEFAULT_REGION,
+  RESIDENCY_SERVERS,
+  SUPPORTED_CONSENT_MANAGERS,
+} from './constants';
+
+/**
+ * Utility method to remove '/' at the end of URL
+ * @param {*} inURL
+ */
+function removeTrailingSlashes(inURL) {
+  return inURL && inURL.endsWith('/') ? inURL.replace(/\/+$/, '') : inURL;
+}
+
+/**
+ *
+ * Utility function for UUID generation
+ * @returns
+ */
+function generateUUID() {
+  if (window.crypto && typeof window.crypto.getRandomValues === 'function') {
+    return uuidSecure();
+  }
+
+  return uuid();
+}
+
+/**
+ *
+ * Utility function to get current time (formatted) for including in sent_at field
+ * @returns
+ */
+function getCurrentTimeFormatted() {
+  const curDateTime = new Date().toISOString();
+  return curDateTime;
+}
+
+/**
+ *
+ * Utility function to retrieve configuration JSON from server
+ * @param {*} url
+ * @param {*} wrappers
+ * @param {*} isLoaded
+ * @param {*} callback
+ */
+function getJSON(url, wrappers, isLoaded, callback) {
+  // server-side integration, XHR is node module
+
+  const xhr = new XMLHttpRequest();
+
+  xhr.open('GET', url, false);
+  xhr.onload = function () {
+    const { status, responseText } = xhr;
+    if (status === 200) {
+      // logger.debug("status 200");
+      callback(null, responseText, wrappers, isLoaded);
+    } else {
+      callback(status);
+    }
+  };
+  xhr.send();
+}
+
+/**
+ *
+ * Utility function to retrieve configuration JSON from server
+ * @param {*} context
+ * @param {*} url
+ * @param {*} callback
+ */
+function getJSONTrimmed(context, url, writeKey, callback) {
+  // server-side integration, XHR is node module
+  const cb = callback.bind(context);
+
+  const xhr = new XMLHttpRequest();
+
+  xhr.open('GET', url, true);
+  xhr.setRequestHeader(
+    'Authorization',
+    `Basic ${btoa(`${writeKey}:`)}`,
+    // `Basic ${Buffer.from(`${writeKey}:`).toString("base64")}`
+  );
+
+  // eslint-disable-next-line func-names
+  xhr.onload = function () {
+    const { status, responseText } = xhr;
+    if (status === 200) {
+      // logger.debug("status 200 " + "calling callback");
+      cb(200, responseText);
+    } else {
+      handleError(new Error(`${FAILED_REQUEST_ERR_MSG_PREFIX} ${status} for url: ${url}`));
+      cb(status);
+    }
+  };
+  xhr.send();
+}
+
+function transformNamesCore(integrationObject, namesObj) {
+  Object.keys(integrationObject).forEach(key => {
+    // eslint-disable-next-line no-prototype-builtins
+    if (integrationObject.hasOwnProperty(key)) {
+      if (namesObj[key]) {
+        integrationObject[namesObj[key]] = integrationObject[key];
+      }
+      if (
+        key !== 'All' && // delete user supplied keys except All and if except those where oldkeys are not present or oldkeys are same as transformed keys
+        namesObj[key] !== undefined &&
+        namesObj[key] !== key
+      ) {
+        delete integrationObject[key];
+      }
+    }
+  });
+}
+
+/**
+ *
+ *
+ * @param {*} integrationObject
+ */
+function transformToRudderNames(integrationObject) {
+  transformNamesCore(integrationObject, commonNames);
+}
+
+function transformToServerNames(integrationObject) {
+  transformNamesCore(integrationObject, clientToServerNames);
+}
+
+/**
+ *
+ * @param {*} sdkSuppliedIntegrations
+ * @param {*} configPlaneEnabledIntegrations
+ */
+function findAllEnabledDestinations(sdkSuppliedIntegrations, configPlaneEnabledIntegrations) {
+  const enabledList = [];
+  if (!configPlaneEnabledIntegrations || configPlaneEnabledIntegrations.length === 0) {
+    return enabledList;
+  }
+  let allValue = true;
+  if (sdkSuppliedIntegrations.All !== undefined) {
+    allValue = sdkSuppliedIntegrations.All;
+  }
+  const intgData = [];
+  if (typeof configPlaneEnabledIntegrations[0] === 'string') {
+    configPlaneEnabledIntegrations.forEach(intg => {
+      intgData.push({
+        intgName: intg,
+        intObj: intg,
+      });
+    });
+  } else if (typeof configPlaneEnabledIntegrations[0] === 'object') {
+    configPlaneEnabledIntegrations.forEach(intg => {
+      intgData.push({
+        intgName: intg.name,
+        intObj: intg,
+      });
+    });
+  }
+
+  intgData.forEach(({ intgName, intObj }) => {
+    if (!allValue) {
+      // All false ==> check if intg true supplied
+      if (
+        sdkSuppliedIntegrations[intgName] !== undefined &&
+        Boolean(sdkSuppliedIntegrations[intgName]) === true
+      ) {
+        enabledList.push(intObj);
+      }
+    } else {
+      // All true ==> intg true by default
+      let intgValue = true;
+      // check if intg false supplied
+      if (
+        sdkSuppliedIntegrations[intgName] !== undefined &&
+        Boolean(sdkSuppliedIntegrations[intgName]) === false
+      ) {
+        intgValue = false;
+      }
+      if (intgValue) {
+        enabledList.push(intObj);
+      }
+    }
+  });
+
+  return enabledList;
+}
+
+function getUserProvidedConfigUrl(configUrl, defConfigUrl) {
+  let url = configUrl;
+  if (url.indexOf('sourceConfig') === -1) {
+    url = `${removeTrailingSlashes(url)}/sourceConfig/`;
+  }
+  url = url.slice(-1) === '/' ? url : `${url}/`;
+  const defQueryParams = defConfigUrl.split('?')[1];
+  const urlSplitItems = url.split('?');
+  if (urlSplitItems.length > 1 && urlSplitItems[1] !== defQueryParams) {
+    url = `${urlSplitItems[0]}?${defQueryParams}`;
+  } else {
+    url = `${url}?${defQueryParams}`;
+  }
+  return url;
+}
+/**
+ * Check if a reserved keyword is present in properties/traits
+ * @param {*} message
+ * @param {*} messageType
+ */
+function checkReservedKeywords(message, messageType) {
+  //  properties, traits, contextualTraits are either undefined or object
+  const { properties, traits, context } = message;
+  if (properties) {
+    Object.keys(properties).forEach(property => {
+      if (RESERVED_KEYS.indexOf(property.toLowerCase()) >= 0) {
+        logger.error(
+          `Warning! : Reserved keyword used in properties--> ${property} with ${messageType} call`,
+        );
+      }
+    });
+  }
+  if (traits) {
+    Object.keys(traits).forEach(trait => {
+      if (RESERVED_KEYS.indexOf(trait.toLowerCase()) >= 0) {
+        logger.error(
+          `Warning! : Reserved keyword used in traits--> ${trait} with ${messageType} call`,
+        );
+      }
+    });
+  }
+  const contextualTraits = context.traits;
+  if (contextualTraits) {
+    Object.keys(contextualTraits).forEach(contextTrait => {
+      if (RESERVED_KEYS.indexOf(contextTrait.toLowerCase()) >= 0) {
+        logger.error(
+          `Warning! : Reserved keyword used in traits --> ${contextTrait} with ${messageType} call`,
+        );
+      }
+    });
+  }
+}
+
+const isDefined = x => x !== undefined;
+const isNotNull = x => x !== null;
+const isDefinedAndNotNull = x => isDefined(x) && isNotNull(x);
+
+const getConfigUrl = (writeKey, lockIntegrationsVersion) => {
+  let configUrl = CONFIG_URL;
+  const queryParamStrings = [];
+  if (writeKey) {
+    queryParamStrings.push(`writeKey=${writeKey}`);
+  }
+
+  if (lockIntegrationsVersion) {
+    queryParamStrings.push(`lockIntegrationsVersion=${lockIntegrationsVersion}`);
+  }
+
+  if (queryParamStrings.length > 0) {
+    configUrl = CONFIG_URL.concat(CONFIG_URL.includes('?') ? '&' : '?');
+    configUrl = configUrl.concat(queryParamStrings.join('&'));
+  }
+  return configUrl;
+};
+
+const getSDKUrlInfo = () => {
+  const scripts = document.getElementsByTagName('script');
+  let sdkURL;
+  // eslint-disable-next-line unicorn/no-for-loop
+  for (let i = 0; i < scripts.length; i += 1) {
+    const curScriptSrc = removeTrailingSlashes(scripts[i].getAttribute('src'));
+    if (curScriptSrc) {
+      const urlMatches = curScriptSrc.match(/^.*rudder-analytics?(\.min)?\.js$/);
+      if (urlMatches) {
+        sdkURL = curScriptSrc;
+        break;
+      }
+    }
+  }
+  return { sdkURL };
+};
+
+const countDigits = number => (number ? number.toString().length : 0);
+
+/**
+ * A function to convert non-string IDs to string format
+ * @param {any} id
+ * @returns
+ */
+const getStringId = id =>
+  typeof id === 'string' || typeof id === 'undefined' || id === null
+    ? id
+    : stringifyWithoutCircularV1(id);
+
+/**
+ * A function to validate and return Residency server input
+ * @returns string/undefined
+ */
+const getResidencyServer = options => {
+  const region = options ? options.residencyServer : undefined;
+  if (region) {
+    if (typeof region !== 'string' || !RESIDENCY_SERVERS.includes(region.toUpperCase())) {
+      logger.error('Invalid residencyServer input');
+      return undefined;
+    }
+    return region.toUpperCase();
+  }
+  return undefined;
+};
+
+const isValidServerUrl = serverUrl => typeof serverUrl === 'string' && serverUrl.trim().length > 0;
+
+/**
+ * A function to get url from source config response
+ * @param {array} urls    An array of objects containing urls
+ * @returns
+ */
+const getDefaultUrlofRegion = urls => {
+  let url;
+  if (Array.isArray(urls) && urls.length > 0) {
+    const obj = urls.find(elem => elem.default === true);
+    if (obj && isValidServerUrl(obj.url)) {
+      return obj.url;
+    }
+  }
+  return url;
+};
+
+/**
+ * A function to determine the dataPlaneUrl
+ * @param {Object} dataPlaneUrls An object containing dataPlaneUrl for different region
+ * @returns string
+ */
+const resolveDataPlaneUrl = (response, serverUrl, options) => {
+  try {
+    const dataPlanes = response.source.dataplanes || {};
+    // Check if dataPlanes object is present in source config
+    if (Object.keys(dataPlanes).length > 0) {
+      const inputRegion = getResidencyServer(options);
+      const regionUrlArr = dataPlanes[inputRegion] || dataPlanes[DEFAULT_REGION];
+
+      if (regionUrlArr) {
+        const defaultUrl = getDefaultUrlofRegion(regionUrlArr);
+        if (defaultUrl) {
+          return defaultUrl;
+        }
+      }
+    }
+    // return the dataPlaneUrl provided in load API(if available)
+    if (isValidServerUrl(serverUrl)) {
+      return serverUrl;
+    }
+    // return the default dataPlaneUrl
+    // return DEFAULT_DATAPLANE_URL; // we do not want to divert the events to hosted data plane url
+
+    // Throw error if correct data plane url is not provided
+    throw Error('Unable to load the SDK due to invalid data plane url');
+  } catch (e) {
+    throw Error(e);
+  }
+};
+
+/**
+ * Function to return the state of consent management based on config passed in load options
+ * @param {Object} cookieConsentOptions
+ * @returns
+ */
+const fetchCookieConsentState = cookieConsentOptions => {
+  let isEnabled = false;
+  // eslint-disable-next-line consistent-return
+  Object.keys(cookieConsentOptions).forEach(e => {
+    const isSupportedAndEnabled =
+      SUPPORTED_CONSENT_MANAGERS.includes(e) &&
+      typeof cookieConsentOptions[e].enabled === 'boolean' &&
+      cookieConsentOptions[e].enabled === true;
+
+    if (isSupportedAndEnabled) {
+      isEnabled = true;
+    }
+  });
+  return isEnabled;
+};
+
+const parseQueryString = url => {
+  const result = {};
+  try {
+    const urlObj = new URL(url);
+    urlObj.searchParams.forEach((value, qParam) => {
+      result[qParam] = value;
+    });
+  } catch (error) {
+    // Do nothing
+  }
+  return result;
+};
+
+export {
+  generateUUID,
+  getCurrentTimeFormatted,
+  getJSONTrimmed,
+  getJSON,
+  getUserProvidedConfigUrl,
+  findAllEnabledDestinations,
+  transformToRudderNames,
+  transformToServerNames,
+  checkReservedKeywords,
+  isDefinedAndNotNull,
+  removeTrailingSlashes,
+  getConfigUrl,
+  getSDKUrlInfo,
+  countDigits,
+  getStringId,
+  resolveDataPlaneUrl,
+  fetchCookieConsentState,
+  parseQueryString,
+};