iureiure 1.0.0

package/packages/analytics-js/src/components/userSessionManager/utils.ts

@@ -0,0 +1,109 @@
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { SessionInfo } from '@rudderstack/analytics-js-common/types/Session';
+import { USER_SESSION_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import type { StorageType } from '@rudderstack/analytics-js-common/types/Storage';
+import {
+  COOKIE_STORAGE,
+  LOCAL_STORAGE,
+  MEMORY_STORAGE,
+  SESSION_STORAGE,
+} from '@rudderstack/analytics-js-common/constants/storages';
+import { generateUUID } from '@rudderstack/analytics-js-common/utilities/uuId';
+import { DEFAULT_SESSION_TIMEOUT_MS } from '../../constants/timeouts';
+import { INVALID_SESSION_ID_WARNING } from '../../constants/logMessages';
+import { hasMinLength, isPositiveInteger } from '../utilities/number';
+
+const MIN_SESSION_ID_LENGTH = 10;
+
+/**
+ * A function to validate current session and return true/false depending on that
+ * @returns boolean
+ */
+const hasSessionExpired = (expiresAt?: number): boolean => {
+  const timestamp = Date.now();
+  return Boolean(!expiresAt || timestamp > expiresAt);
+};
+
+/**
+ * A function to generate session id
+ * @returns number
+ */
+const generateSessionId = (): number => Date.now();
+
+/**
+ * Function to validate user provided sessionId
+ * @param {number} sessionId
+ * @param logger logger
+ * @returns
+ */
+const isManualSessionIdValid = (sessionId?: number, logger?: ILogger): boolean => {
+  if (
+    !sessionId ||
+    !isPositiveInteger(sessionId) ||
+    !hasMinLength(MIN_SESSION_ID_LENGTH, sessionId)
+  ) {
+    logger?.warn(
+      INVALID_SESSION_ID_WARNING(USER_SESSION_MANAGER, sessionId, MIN_SESSION_ID_LENGTH),
+    );
+    return false;
+  }
+  return true;
+};
+
+/**
+ * A function to generate new auto tracking session
+ * @param sessionTimeout current timestamp
+ * @returns SessionInfo
+ */
+const generateAutoTrackingSession = (sessionTimeout?: number): SessionInfo => {
+  const timestamp = Date.now();
+  const timeout: number = sessionTimeout || DEFAULT_SESSION_TIMEOUT_MS;
+  return {
+    id: timestamp, // set the current timestamp
+    expiresAt: timestamp + timeout, // set the expiry time of the session
+    timeout,
+    sessionStart: undefined,
+    autoTrack: true,
+  };
+};
+
+/**
+ * A function to generate new manual tracking session
+ * @param id Provided sessionId
+ * @param logger Logger module
+ * @returns SessionInfo
+ */
+const generateManualTrackingSession = (id?: number, logger?: ILogger): SessionInfo => {
+  const sessionId: number = isManualSessionIdValid(id, logger)
+    ? (id as number)
+    : generateSessionId();
+  return {
+    id: sessionId,
+    sessionStart: undefined,
+    manualTrack: true,
+  };
+};
+
+const isStorageTypeValidForStoringData = (storageType: StorageType): boolean =>
+  Boolean(
+    storageType === COOKIE_STORAGE ||
+      storageType === LOCAL_STORAGE ||
+      storageType === SESSION_STORAGE ||
+      storageType === MEMORY_STORAGE,
+  );
+
+/**
+ * Generate a new anonymousId
+ * @returns string anonymousID
+ */
+const generateAnonymousId = (): string => generateUUID();
+
+export {
+  hasSessionExpired,
+  generateSessionId,
+  generateAutoTrackingSession,
+  generateManualTrackingSession,
+  MIN_SESSION_ID_LENGTH,
+  isStorageTypeValidForStoringData,
+  generateAnonymousId,
+};

package/packages/analytics-js/src/components/utilities/consent.ts

@@ -0,0 +1,163 @@
+import { CONFIG_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import type {
+  ConsentManagementOptions,
+  ConsentManagementProvider,
+  Consents,
+  CookieConsentOptions,
+} from '@rudderstack/analytics-js-common/types/Consent';
+import type { ConsentOptions } from '@rudderstack/analytics-js-common/types/LoadOptions';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+import {
+  isNonEmptyObject,
+  isObjectLiteralAndNotNull,
+  mergeDeepRight,
+} from '@rudderstack/analytics-js-common/utilities/object';
+import { UNSUPPORTED_CONSENT_MANAGER_ERROR } from '@rudderstack/analytics-js/constants/logMessages';
+import { clone } from 'ramda';
+import { state } from '@rudderstack/analytics-js/state';
+import { DEFAULT_INTEGRATIONS_CONFIG } from '@rudderstack/analytics-js-common/constants/integrationsConfig';
+import { isDefined } from '@rudderstack/analytics-js-common/utilities/checks';
+import { ConsentManagersToPluginNameMap } from '../configManager/constants';
+
+/**
+ * A function to get the name of the consent manager with enabled true set in the load options
+ * @param cookieConsentOptions Input provided as load option
+ * @returns string|undefined
+ *
+ * Example input: {
+ *   oneTrust:{
+ *     enabled: true
+ *   }
+ * }
+ *
+ * Output: 'oneTrust'
+ */
+const getUserSelectedConsentManager = (
+  cookieConsentOptions?: CookieConsentOptions,
+): string | undefined => {
+  if (!isNonEmptyObject(cookieConsentOptions)) {
+    return undefined;
+  }
+
+  const validCookieConsentOptions = cookieConsentOptions as CookieConsentOptions;
+  return Object.keys(validCookieConsentOptions).find(
+    e =>
+      e && validCookieConsentOptions[e] && (validCookieConsentOptions[e] as any).enabled === true,
+  );
+};
+
+/**
+ * Validates and normalizes the consent options provided by the user
+ * @param options Consent options provided by the user
+ * @returns Validated and normalized consent options
+ */
+const getValidPostConsentOptions = (options?: ConsentOptions) => {
+  const validOptions: ConsentOptions = {
+    sendPageEvent: false,
+    trackConsent: false,
+    discardPreConsentEvents: false,
+  };
+  if (isObjectLiteralAndNotNull(options)) {
+    const clonedOptions = clone(options);
+
+    validOptions.storage = clonedOptions.storage;
+    if (isDefined(clonedOptions.integrations)) {
+      validOptions.integrations = isObjectLiteralAndNotNull(clonedOptions.integrations)
+        ? clonedOptions.integrations
+        : DEFAULT_INTEGRATIONS_CONFIG;
+    }
+    validOptions.discardPreConsentEvents = clonedOptions.discardPreConsentEvents === true;
+    validOptions.sendPageEvent = clonedOptions.sendPageEvent === true;
+    validOptions.trackConsent = clonedOptions.trackConsent === true;
+    if (isNonEmptyObject(clonedOptions.consentManagement)) {
+      // Override enabled value with the current state value
+      validOptions.consentManagement = mergeDeepRight(clonedOptions.consentManagement, {
+        enabled: state.consents.enabled.value,
+      });
+    }
+  }
+  return validOptions;
+};
+
+/**
+ * Validates if the input is a valid consents data
+ * @param value Input consents data
+ * @returns true if the input is a valid consents data else false
+ */
+const isValidConsentsData = (value: Consents | undefined): value is Consents =>
+  isNonEmptyObject(value) || Array.isArray(value);
+
+/**
+ * Retrieves the corresponding provider and plugin name of the selected consent manager from the supported consent managers
+ * @param consentManagementOpts consent management options
+ * @param logger logger instance
+ * @returns Corresponding provider and plugin name of the selected consent manager from the supported consent managers
+ */
+const getConsentManagerInfo = (
+  consentManagementOpts: ConsentManagementOptions,
+  logger?: ILogger,
+) => {
+  let { provider }: { provider: ConsentManagementProvider | undefined } = consentManagementOpts;
+  const consentManagerPluginName = ConsentManagersToPluginNameMap[provider];
+  if (provider && !consentManagerPluginName) {
+    logger?.error(
+      UNSUPPORTED_CONSENT_MANAGER_ERROR(CONFIG_MANAGER, provider, ConsentManagersToPluginNameMap),
+    );
+
+    // Reset the provider value
+    provider = undefined;
+  }
+  return { provider, consentManagerPluginName };
+};
+
+/**
+ * Validates and converts the consent management options into a normalized format
+ * @param consentManagementOpts Consent management options provided by the user
+ * @param logger logger instance
+ * @returns An object containing the consent manager plugin name, initialized, enabled and consents data
+ */
+const getConsentManagementData = (
+  consentManagementOpts: ConsentManagementOptions | undefined,
+  logger?: ILogger,
+) => {
+  let consentManagerPluginName: PluginName | undefined;
+  let allowedConsentIds: Consents = [];
+  let deniedConsentIds: Consents = [];
+  let initialized = false;
+  let provider: ConsentManagementProvider | undefined;
+
+  let enabled = consentManagementOpts?.enabled === true;
+  if (isNonEmptyObject<ConsentManagementOptions>(consentManagementOpts) && enabled) {
+    // Get the corresponding plugin name of the selected consent manager from the supported consent managers
+    ({ provider, consentManagerPluginName } = getConsentManagerInfo(consentManagementOpts, logger));
+
+    if (isValidConsentsData(consentManagementOpts.allowedConsentIds)) {
+      allowedConsentIds = consentManagementOpts.allowedConsentIds;
+      initialized = true;
+    }
+
+    if (isValidConsentsData(consentManagementOpts.deniedConsentIds)) {
+      deniedConsentIds = consentManagementOpts.deniedConsentIds;
+      initialized = true;
+    }
+  }
+
+  const consentsData = {
+    allowedConsentIds,
+    deniedConsentIds,
+  };
+
+  // Enable consent management only if consent manager is supported
+  enabled = enabled && Boolean(consentManagerPluginName);
+
+  return {
+    provider,
+    consentManagerPluginName,
+    initialized,
+    enabled,
+    consentsData,
+  };
+};
+
+export { getUserSelectedConsentManager, getValidPostConsentOptions, getConsentManagementData };

package/packages/analytics-js/src/components/utilities/destinations.ts

@@ -0,0 +1,31 @@
+import type { Destination } from '@rudderstack/analytics-js-common/types/Destination';
+import type { ConfigResponseDestinationItem } from '../configManager/types';
+
+/**
+ * A function to filter enabled destinations and map to required properties only
+ * @param destinations
+ *
+ * @returns Destination[]
+ */
+const filterEnabledDestination = (destinations: ConfigResponseDestinationItem[]): Destination[] => {
+  const nativeDestinations: Destination[] = [];
+  destinations.forEach((destination: ConfigResponseDestinationItem) => {
+    if (destination.enabled && !destination.deleted) {
+      nativeDestinations.push({
+        id: destination.id,
+        displayName: destination.destinationDefinition.displayName,
+        config: destination.config,
+        shouldApplyDeviceModeTransformation:
+          destination.shouldApplyDeviceModeTransformation || false,
+        propagateEventsUntransformedOnError:
+          destination.propagateEventsUntransformedOnError || false,
+        userFriendlyId: `${destination.destinationDefinition.displayName.replaceAll(' ', '-')}___${
+          destination.id
+        }`,
+      });
+    }
+  });
+  return nativeDestinations;
+};
+
+export { filterEnabledDestination };

package/packages/analytics-js/src/components/utilities/event.ts

@@ -0,0 +1,3 @@
+const isEvent = (error: unknown): boolean => error instanceof Event;
+
+export { isEvent };

package/packages/analytics-js/src/components/utilities/globals.ts

@@ -0,0 +1,54 @@
+import type { DebouncedFunction } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import { DEBOUNCED_TIMEOUT_MS } from '../../constants/timeouts';
+import type { ExposedGlobals, IRudderStackGlobals } from '../../app/IRudderStackGlobals';
+
+/**
+ * Create globally accessible RudderStackGlobals object
+ */
+const createExposedGlobals = (analyticsInstanceId = 'app') => {
+  if (!(globalThis as typeof window).RudderStackGlobals) {
+    (globalThis as typeof window).RudderStackGlobals = {} as IRudderStackGlobals;
+  }
+
+  if (!(globalThis as typeof window).RudderStackGlobals[analyticsInstanceId]) {
+    (globalThis as typeof window).RudderStackGlobals[analyticsInstanceId] =
+      {} as IRudderStackGlobals;
+  }
+};
+
+/**
+ * Add move values to globally accessible RudderStackGlobals object per analytics instance
+ */
+const setExposedGlobal = (keyName: string, value?: any, analyticsInstanceId = 'app') => {
+  createExposedGlobals(analyticsInstanceId);
+  ((globalThis as typeof window).RudderStackGlobals[analyticsInstanceId] as ExposedGlobals)[
+    keyName
+  ] = value;
+};
+
+/**
+ * Get values from globally accessible RudderStackGlobals object by analytics instance
+ */
+const getExposedGlobal = (
+  keyName: string,
+  analyticsInstanceId = 'app',
+): Partial<ExposedGlobals> => {
+  createExposedGlobals(analyticsInstanceId);
+  return ((globalThis as typeof window).RudderStackGlobals[analyticsInstanceId] as ExposedGlobals)[
+    keyName
+  ];
+};
+
+function debounce(func: DebouncedFunction, thisArg: any, delay: number = DEBOUNCED_TIMEOUT_MS) {
+  let timeoutId: number;
+
+  return (...args: any[]) => {
+    (globalThis as typeof window).clearTimeout(timeoutId);
+
+    timeoutId = (globalThis as typeof window).setTimeout(() => {
+      func.apply(thisArg, args);
+    }, delay);
+  };
+}
+
+export { createExposedGlobals, setExposedGlobal, getExposedGlobal, debounce };

package/packages/analytics-js/src/components/utilities/loadOptions.ts

@@ -0,0 +1,176 @@
+import { clone } from 'ramda';
+import {
+  isObjectLiteralAndNotNull,
+  mergeDeepRight,
+  removeUndefinedAndNullValues,
+} from '@rudderstack/analytics-js-common/utilities/object';
+import { removeDuplicateSlashes } from '@rudderstack/analytics-js-common/utilities/url';
+import type {
+  LoadOptions,
+  UaChTrackLevel,
+} from '@rudderstack/analytics-js-common/types/LoadOptions';
+import type { StorageOpts, CookieSameSite } from '@rudderstack/analytics-js-common/types/Storage';
+import { isDefined, isString } from '@rudderstack/analytics-js-common/utilities/checks';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { CONFIG_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import { INVALID_CONFIG_URL_WARNING } from '../../constants/logMessages';
+import { APP_VERSION, MODULE_TYPE } from '../../constants/app';
+import { defaultOptionalPluginsList } from '../pluginsManager/defaultPluginsList';
+import { BUILD_TYPE, DEFAULT_CONFIG_BE_URL } from '../../constants/urls';
+import { isNumber } from './number';
+import { removeTrailingSlashes } from './url';
+
+const normalizeLoadOptions = (
+  loadOptionsFromState: LoadOptions,
+  loadOptions: Partial<LoadOptions>,
+): LoadOptions => {
+  // TODO: Maybe add warnings for invalid values
+  const normalizedLoadOpts = clone(loadOptions);
+
+  if (!isString(normalizedLoadOpts.setCookieDomain)) {
+    delete normalizedLoadOpts.setCookieDomain;
+  }
+
+  const cookieSameSiteValues = ['Strict', 'Lax', 'None'];
+  if (!cookieSameSiteValues.includes(normalizedLoadOpts.sameSiteCookie as CookieSameSite)) {
+    delete normalizedLoadOpts.sameSiteCookie;
+  }
+
+  normalizedLoadOpts.secureCookie = normalizedLoadOpts.secureCookie === true;
+
+  const uaChTrackLevels = ['none', 'default', 'full'];
+  if (!uaChTrackLevels.includes(normalizedLoadOpts.uaChTrackLevel as UaChTrackLevel)) {
+    delete normalizedLoadOpts.uaChTrackLevel;
+  }
+
+  if (!isObjectLiteralAndNotNull(normalizedLoadOpts.integrations)) {
+    delete normalizedLoadOpts.integrations;
+  }
+
+  normalizedLoadOpts.plugins = normalizedLoadOpts.plugins ?? defaultOptionalPluginsList;
+
+  normalizedLoadOpts.useGlobalIntegrationsConfigInEvents =
+    normalizedLoadOpts.useGlobalIntegrationsConfigInEvents === true;
+
+  normalizedLoadOpts.bufferDataPlaneEventsUntilReady =
+    normalizedLoadOpts.bufferDataPlaneEventsUntilReady === true;
+
+  normalizedLoadOpts.sendAdblockPage = normalizedLoadOpts.sendAdblockPage === true;
+
+  if (!isObjectLiteralAndNotNull(normalizedLoadOpts.sendAdblockPageOptions)) {
+    delete normalizedLoadOpts.sendAdblockPageOptions;
+  }
+
+  if (!isDefined(normalizedLoadOpts.loadIntegration)) {
+    delete normalizedLoadOpts.loadIntegration;
+  } else {
+    normalizedLoadOpts.loadIntegration = normalizedLoadOpts.loadIntegration === true;
+  }
+
+  if (!isObjectLiteralAndNotNull(normalizedLoadOpts.storage)) {
+    delete normalizedLoadOpts.storage;
+  } else {
+    normalizedLoadOpts.storage = removeUndefinedAndNullValues(normalizedLoadOpts.storage);
+    (normalizedLoadOpts.storage as StorageOpts).migrate =
+      normalizedLoadOpts.storage?.migrate === true;
+  }
+
+  if (!isObjectLiteralAndNotNull(normalizedLoadOpts.beaconQueueOptions)) {
+    delete normalizedLoadOpts.beaconQueueOptions;
+  } else {
+    normalizedLoadOpts.beaconQueueOptions = removeUndefinedAndNullValues(
+      normalizedLoadOpts.beaconQueueOptions,
+    );
+  }
+
+  if (!isObjectLiteralAndNotNull(normalizedLoadOpts.destinationsQueueOptions)) {
+    delete normalizedLoadOpts.destinationsQueueOptions;
+  } else {
+    normalizedLoadOpts.destinationsQueueOptions = removeUndefinedAndNullValues(
+      normalizedLoadOpts.destinationsQueueOptions,
+    );
+  }
+
+  if (!isObjectLiteralAndNotNull(normalizedLoadOpts.queueOptions)) {
+    delete normalizedLoadOpts.queueOptions;
+  } else {
+    normalizedLoadOpts.queueOptions = removeUndefinedAndNullValues(normalizedLoadOpts.queueOptions);
+  }
+
+  normalizedLoadOpts.lockIntegrationsVersion = normalizedLoadOpts.lockIntegrationsVersion === true;
+
+  if (!isNumber(normalizedLoadOpts.dataPlaneEventsBufferTimeout)) {
+    delete normalizedLoadOpts.dataPlaneEventsBufferTimeout;
+  }
+
+  if (!isObjectLiteralAndNotNull(normalizedLoadOpts.storage?.cookie)) {
+    delete normalizedLoadOpts.storage?.cookie;
+  } else {
+    (normalizedLoadOpts.storage as StorageOpts).cookie = removeUndefinedAndNullValues(
+      normalizedLoadOpts.storage?.cookie,
+    );
+  }
+
+  if (!isObjectLiteralAndNotNull(normalizedLoadOpts.preConsent)) {
+    delete normalizedLoadOpts.preConsent;
+  } else {
+    normalizedLoadOpts.preConsent = removeUndefinedAndNullValues(normalizedLoadOpts.preConsent);
+  }
+
+  const mergedLoadOptions: LoadOptions = mergeDeepRight(loadOptionsFromState, normalizedLoadOpts);
+
+  return mergedLoadOptions;
+};
+
+const getSourceConfigURL = (
+  configUrl: string | undefined,
+  writeKey: string,
+  lockIntegrationsVersion: boolean,
+  logger?: ILogger,
+): string => {
+  const defSearchParams = new URLSearchParams({
+    p: MODULE_TYPE,
+    v: APP_VERSION,
+    build: BUILD_TYPE,
+    writeKey,
+    lockIntegrationsVersion: lockIntegrationsVersion.toString(),
+  });
+
+  let origin = DEFAULT_CONFIG_BE_URL;
+  let searchParams = defSearchParams;
+  let pathname = '/sourceConfig/';
+  let hash = '';
+  // Ideally, this check is not required but URL polyfill
+  // doesn't seem to throw errors for empty URLs
+  // TODO: Need to improve this check to find out if the URL is valid or not
+  if (configUrl) {
+    try {
+      const configUrlInstance = new URL(configUrl);
+      if (
+        !(removeTrailingSlashes(configUrlInstance.pathname) as string).endsWith('/sourceConfig')
+      ) {
+        configUrlInstance.pathname = `${
+          removeTrailingSlashes(configUrlInstance.pathname) as string
+        }/sourceConfig/`;
+      }
+      configUrlInstance.pathname = removeDuplicateSlashes(configUrlInstance.pathname);
+
+      defSearchParams.forEach((value, key) => {
+        if (configUrlInstance.searchParams.get(key) === null) {
+          configUrlInstance.searchParams.set(key, value);
+        }
+      });
+
+      origin = configUrlInstance.origin;
+      pathname = configUrlInstance.pathname;
+      searchParams = configUrlInstance.searchParams;
+      hash = configUrlInstance.hash;
+    } catch (err) {
+      logger?.warn(INVALID_CONFIG_URL_WARNING(CONFIG_MANAGER, configUrl));
+    }
+  }
+
+  return `${origin}${pathname}?${searchParams}${hash}`;
+};
+
+export { normalizeLoadOptions, getSourceConfigURL };

package/packages/analytics-js/src/components/utilities/number.ts

@@ -0,0 +1,23 @@
+/**
+ * A function to check given value is a number or not
+ * @param num input value
+ * @returns boolean
+ */
+const isNumber = (num: any): boolean => typeof num === 'number' && !Number.isNaN(num);
+
+/**
+ * A function to check given number has minimum length or not
+ * @param minimumLength     minimum length
+ * @param num               input number
+ * @returns boolean
+ */
+const hasMinLength = (minimumLength: number, num: number) => num.toString().length >= minimumLength;
+
+/**
+ * A function to check given value is a positive integer or not
+ * @param num input value
+ * @returns boolean
+ */
+const isPositiveInteger = (num: any) => isNumber(num) && num >= 0 && Number.isInteger(num);
+
+export { isNumber, hasMinLength, isPositiveInteger };

package/packages/analytics-js/src/components/utilities/page.ts

@@ -0,0 +1,103 @@
+import { isUndefined } from '@rudderstack/analytics-js-common/utilities/checks';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import { getReferringDomain, getUrlWithoutHash } from './url';
+
+/**
+ * Get the referrer URL
+ * @returns The referrer URL
+ */
+const getReferrer = (): string => document?.referrer || '$direct';
+
+/**
+ * To get the canonical URL of the page
+ * @returns canonical URL
+ */
+const getCanonicalUrl = (): string => {
+  const tags = document.getElementsByTagName('link');
+  let canonicalUrl = '';
+
+  for (let i = 0; tags[i]; i += 1) {
+    const tag = tags[i] as HTMLLinkElement;
+    if (tag.getAttribute('rel') === 'canonical' && !canonicalUrl) {
+      canonicalUrl = tag.getAttribute('href') ?? '';
+      break;
+    }
+  }
+
+  return canonicalUrl;
+};
+
+const getUserAgent = (): Nullable<string> => {
+  if (isUndefined(globalThis.navigator)) {
+    return null;
+  }
+
+  let { userAgent } = globalThis.navigator;
+  const { brave } = globalThis.navigator as any;
+
+  // 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 = (): Nullable<string> => {
+  if (isUndefined(globalThis.navigator)) {
+    return null;
+  }
+
+  return globalThis.navigator.language ?? (globalThis.navigator as any).browserLanguage;
+};
+
+/**
+ * Default page properties
+ * @returns Default page properties
+ */
+const getDefaultPageProperties = (): Record<string, any> => {
+  const canonicalUrl = getCanonicalUrl();
+  let path = globalThis.location.pathname;
+  const { href: tabUrl } = globalThis.location;
+  let pageUrl = tabUrl;
+  const { search } = globalThis.location;
+
+  // If valid canonical url is provided use this as page url.
+  if (canonicalUrl) {
+    try {
+      const urlObj = new URL(canonicalUrl);
+      // If existing, query params of canonical url will be used instead of the location.search ones
+      if (urlObj.search === '') {
+        pageUrl = canonicalUrl + search;
+      } else {
+        pageUrl = canonicalUrl;
+      }
+
+      path = urlObj.pathname;
+    } catch (err) {
+      // Do nothing
+    }
+  }
+
+  const url = getUrlWithoutHash(pageUrl);
+  const { title } = document;
+  const referrer = getReferrer();
+  return {
+    path,
+    referrer,
+    referring_domain: getReferringDomain(referrer),
+    search,
+    title,
+    url,
+    tab_url: tabUrl,
+  };
+};
+
+export { getCanonicalUrl, getReferrer, getUserAgent, getLanguage, getDefaultPageProperties };

package/packages/analytics-js/src/components/utilities/sort.ts

@@ -0,0 +1,15 @@
+import { prop, sortBy } from 'ramda';
+
+// A helper method to sort an array according to sortProp property of the array element.
+const sortObjectArrayByProp = (arr: unknown[], sortProp: string): unknown[] => {
+  const sortMethod = sortBy(prop(sortProp));
+  return sortMethod(arr);
+};
+
+// arr.sort((a, b) => {
+//   var order1 = a.hasOwnProperty(sortProp) ? a[sortProp] : 1000000;
+//   var order2 = b.hasOwnProperty(sortProp) ? b[sortProp] : 1000000;
+//   return order1 - order2;
+// });
+
+export { sortObjectArrayByProp };