iureiure 1.0.0

package/packages/analytics-js-common/src/utilities/json.ts

@@ -0,0 +1,69 @@
+import type { ILogger } from '../types/Logger';
+import type { Nullable } from '../types/Nullable';
+import { isNull, isNullOrUndefined } from './checks';
+import { CIRCULAR_REFERENCE_WARNING, JSON_STRINGIFY_WARNING } from '../constants/logMessages';
+
+const JSON_STRINGIFY = 'JSONStringify';
+
+const getCircularReplacer = (
+  excludeNull?: boolean,
+  excludeKeys?: string[],
+  logger?: ILogger,
+): ((key: string, value: any) => any) => {
+  const ancestors: any[] = [];
+
+  // Here we do not want to use arrow function to use "this" in function context
+  // eslint-disable-next-line func-names
+  return function (key, value): any {
+    if (excludeKeys?.includes(key)) {
+      return undefined;
+    }
+
+    if (excludeNull && isNullOrUndefined(value)) {
+      return undefined;
+    }
+
+    if (typeof value !== 'object' || isNull(value)) {
+      return value;
+    }
+
+    // `this` is the object that value is contained in, i.e., its direct parent.
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore-next-line
+    while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+      ancestors.pop();
+    }
+
+    if (ancestors.includes(value)) {
+      logger?.warn(CIRCULAR_REFERENCE_WARNING(JSON_STRINGIFY, key));
+      return '[Circular Reference]';
+    }
+
+    ancestors.push(value);
+    return value;
+  };
+};
+
+/**
+ * Utility method for JSON stringify object excluding null values & circular references
+ *
+ * @param {*} value input
+ * @param {boolean} excludeNull if it should exclude nul or not
+ * @param {function} logger optional logger methods for warning
+ * @returns string
+ */
+const stringifyWithoutCircular = <T = Record<string, any> | any[] | number | string>(
+  value?: Nullable<T>,
+  excludeNull?: boolean,
+  excludeKeys?: string[],
+  logger?: ILogger,
+): Nullable<string> => {
+  try {
+    return JSON.stringify(value, getCircularReplacer(excludeNull, excludeKeys, logger));
+  } catch (err) {
+    logger?.warn(JSON_STRINGIFY_WARNING, err);
+    return null;
+  }
+};
+
+export { stringifyWithoutCircular };

package/packages/analytics-js-common/src/utilities/object.ts

@@ -0,0 +1,119 @@
+import { clone, mergeDeepWith, path, pickBy } from 'ramda';
+import { isDefined, isDefinedAndNotNull, isNull } from './checks';
+
+const getValueByPath = (obj: Record<string, any>, keyPath: string): any => {
+  const pathParts = keyPath.split('.');
+  return path(pathParts, obj);
+};
+
+const hasValueByPath = (obj: Record<string, any>, path: string): boolean =>
+  Boolean(getValueByPath(obj, path));
+
+/**
+ * Checks if the input is an object literal or built-in object type and not null
+ * @param value Input value
+ * @returns true if the input is an object and not null
+ */
+const isObjectAndNotNull = (value: any): value is object =>
+  !isNull(value) && typeof value === 'object' && !Array.isArray(value);
+
+/**
+ * Checks if the input is an object literal and not null
+ * @param value Input value
+ * @returns true if the input is an object and not null
+ */
+const isObjectLiteralAndNotNull = <T>(value?: T): value is T =>
+  !isNull(value) && Object.prototype.toString.call(value) === '[object Object]';
+
+const mergeDeepRightObjectArrays = (
+  leftValue: any | any[],
+  rightValue: any | any[],
+): any | any[] => {
+  if (!Array.isArray(leftValue) || !Array.isArray(rightValue)) {
+    return clone(rightValue);
+  }
+
+  const mergedArray = clone(leftValue);
+  rightValue.forEach((value, index) => {
+    mergedArray[index] =
+      Array.isArray(value) || isObjectAndNotNull(value)
+        ? // eslint-disable-next-line @typescript-eslint/no-use-before-define
+          mergeDeepRight(mergedArray[index], value)
+        : value;
+  });
+  return mergedArray;
+};
+
+const mergeDeepRight = <T = Record<string, any>>(
+  leftObject: Record<string, any>,
+  rightObject: Record<string, any>,
+): T => mergeDeepWith(mergeDeepRightObjectArrays, leftObject, rightObject);
+
+/**
+ Checks if the input is a non-empty object literal type and not undefined or null
+ * @param value input any
+ * @returns boolean
+ */
+const isNonEmptyObject = <T>(value?: T): value is T =>
+  isObjectLiteralAndNotNull(value) && Object.keys(value as any).length > 0;
+
+/**
+ * A utility to recursively remove undefined values from an object
+ * @param obj input object
+ * @returns a new object
+ */
+const removeUndefinedValues = <T = Record<string, any>>(obj: T): T => {
+  const result = pickBy(isDefined, obj) as Record<string, any>;
+  Object.keys(result).forEach(key => {
+    const value = result[key];
+    if (isObjectLiteralAndNotNull(value)) {
+      result[key] = removeUndefinedValues(value);
+    }
+  });
+
+  return result as T;
+};
+
+/**
+ * A utility to recursively remove undefined and null values from an object
+ * @param obj input object
+ * @returns a new object
+ */
+const removeUndefinedAndNullValues = <T = Record<string, any>>(obj: T): T => {
+  const result = pickBy(isDefinedAndNotNull, obj) as Record<string, any>;
+  Object.keys(result).forEach(key => {
+    const value = result[key];
+    if (isObjectLiteralAndNotNull(value)) {
+      result[key] = removeUndefinedAndNullValues(value);
+    }
+  });
+
+  return result as T;
+};
+
+/**
+ * A utility to get all the values from an object
+ * @param obj Input object
+ * @returns an array of values from the input object
+ */
+const getObjectValues = <T = Record<string, any>>(obj: T): any[] => {
+  const result: any[] = [];
+  Object.keys(obj as Record<string, any>).forEach(key => {
+    result.push((obj as Record<string, any>)[key]);
+  });
+
+  return result;
+};
+
+export {
+  getValueByPath,
+  hasValueByPath,
+  mergeDeepRightObjectArrays,
+  mergeDeepRight,
+  isObjectAndNotNull,
+  isNonEmptyObject,
+  isObjectLiteralAndNotNull,
+  removeUndefinedValues,
+  removeUndefinedAndNullValues,
+  getObjectValues,
+};

package/packages/analytics-js-common/src/utilities/string.ts

@@ -0,0 +1,64 @@
+import type { Nullable } from '../types/Nullable';
+import { isNullOrUndefined, isString } from './checks';
+
+// TODO: see if bundle size is bumped up if we use ramda trim instead of custom
+const trim = (value: string): string => value.replace(/^\s+|\s+$/gm, '');
+
+const removeDoubleSpaces = (value: string): string => value.replace(/ {2,}/g, ' ');
+
+/**
+ * A function to convert values to string
+ * @param val input value
+ * @returns stringified value
+ */
+const tryStringify = (val?: any): Nullable<string> | undefined => {
+  let retVal = val;
+  if (!isString(val) && !isNullOrUndefined(val)) {
+    try {
+      retVal = JSON.stringify(val);
+    } catch (e) {
+      retVal = null;
+    }
+  }
+  return retVal;
+};
+
+// The following text encoding and decoding is done before base64 encoding to prevent
+// https://developer.mozilla.org/en-US/docs/Glossary/Base64#the_unicode_problem
+
+/**
+ * Converts a base64 encoded string to bytes array
+ * @param base64Str base64 encoded string
+ * @returns bytes array
+ */
+const base64ToBytes = (base64Str: string): Uint8Array => {
+  const binString = (globalThis as typeof window).atob(base64Str);
+  const bytes = binString.split('').map(char => char.charCodeAt(0));
+  return new Uint8Array(bytes);
+};
+
+/**
+ * Converts a bytes array to base64 encoded string
+ * @param bytes bytes array to be converted to base64
+ * @returns base64 encoded string
+ */
+const bytesToBase64 = (bytes: Uint8Array): string => {
+  const binString = Array.from(bytes, x => String.fromCodePoint(x)).join('');
+  return (globalThis as typeof window).btoa(binString);
+};
+
+/**
+ * Encodes a string to base64 even with unicode characters
+ * @param value input string
+ * @returns base64 encoded string
+ */
+const toBase64 = (value: string): string => bytesToBase64(new TextEncoder().encode(value));
+
+/**
+ * Decodes a base64 encoded string
+ * @param value base64 encoded string
+ * @returns decoded string
+ */
+const fromBase64 = (value: string): string => new TextDecoder().decode(base64ToBytes(value));
+
+export { trim, removeDoubleSpaces, tryStringify, toBase64, fromBase64 };

package/packages/analytics-js-common/src/utilities/timestamp.ts

@@ -0,0 +1,10 @@
+/**
+ * To get the current timestamp in ISO string format
+ * @returns ISO formatted timestamp string
+ */
+const getCurrentTimeFormatted = (): string => {
+  const curDateTime = new Date().toISOString();
+  return curDateTime;
+};
+
+export { getCurrentTimeFormatted };

package/packages/analytics-js-common/src/utilities/timezone.ts

@@ -0,0 +1,11 @@
+/**
+ * To get the timezone of the user
+ *
+ * @returns string
+ */
+const getTimezone = (): string => {
+  const timezone = new Date().toString().match(/([A-Z]+[+-]\d+)/);
+  return timezone && timezone[1] ? timezone[1] : 'NA';
+};
+
+export { getTimezone };

package/packages/analytics-js-common/src/utilities/url.ts

@@ -0,0 +1,3 @@
+const removeDuplicateSlashes = (str: string): string => str.replace(/\/{2,}/g, '/');
+
+export { removeDuplicateSlashes };

package/packages/analytics-js-common/src/utilities/uuId.ts

@@ -0,0 +1,13 @@
+import { v4 as uuidSecure } from '@lukeed/uuid/secure';
+import { v4 as uuid } from '@lukeed/uuid';
+import { hasCrypto } from './crypto';
+
+const generateUUID = (): string => {
+  if (hasCrypto()) {
+    return uuidSecure();
+  }
+
+  return uuid();
+};
+
+export { generateUUID };

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

@@ -0,0 +1,54 @@
+import { logger } from './logUtil';
+
+const getCircularReplacer = excludeNull => {
+  const ancestors = [];
+
+  return function (key, value) {
+    if (excludeNull && (value === null || value === undefined)) {
+      return undefined;
+    }
+
+    if (typeof value !== 'object' || value === null) {
+      return value;
+    }
+
+    // `this` is the object that value is contained in, i.e., its direct parent.
+    while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+      ancestors.pop();
+    }
+
+    if (ancestors.includes(value)) {
+      logger.debug(`Circular Reference detected for key: ${key}`);
+      return '[Circular Reference]';
+    }
+
+    ancestors.push(value);
+    return value;
+  };
+};
+
+const stringifyWithoutCircularV1 = (obj, excludeNull) => {
+  try {
+    return JSON.stringify(obj, getCircularReplacer(excludeNull));
+  } catch (err) {
+    logger.warn(`Failed to convert the value to a JSON string.`);
+    return null;
+  }
+};
+
+const isInstanceOfEvent = value => typeof value === 'object' && value !== null && 'target' in value;
+
+/**
+ * Returns true for empty object {}
+ * @param {*} obj
+ * @returns
+ */
+const isEmptyObject = obj => {
+  if (!obj) {
+    logger.warn('input is undefined or null');
+    return true;
+  }
+  return Object.keys(obj).length === 0;
+};
+
+export { getCircularReplacer, stringifyWithoutCircularV1, isInstanceOfEvent, isEmptyObject };

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

@@ -0,0 +1,51 @@
+/* eslint-disable no-use-before-define */
+import { handleError } from './errorHandler';
+import { LOAD_ORIGIN } from './constants';
+
+const defaultAsyncState = true;
+
+/**
+ * Script loader
+ * @param {String} id                               Id of the script
+ * @param {String} src                              URL of the script
+ * @param {Object} options                          Object containing different configuration
+ * @param {Boolean} options.async                   Determines script will be loaded asynchronously or not
+ * @param {Boolean} options.isNonNativeSDK          Determines whether the script that will be loaded is one of RS's own
+ * @param {Boolean} options.skipDatasetAttributes   Determines whether to add or skip dataset attribute
+ */
+const ScriptLoader = (id, src, options = {}) => {
+  try {
+    const exists = document.getElementById(id);
+    if (exists) {
+      // logger.debug("script already loaded");
+      return;
+    }
+
+    const js = document.createElement('script');
+    js.src = src;
+    js.async = options.async === undefined ? defaultAsyncState : options.async;
+    js.type = 'text/javascript';
+    js.id = id;
+    // This checking is in place to skip the dataset attribute for some cases(while loading polyfill)
+    if (options.skipDatasetAttributes !== true) {
+      js.setAttribute('data-loader', LOAD_ORIGIN);
+      if (options.isNonNativeSDK !== undefined) {
+        js.setAttribute('data-isNonNativeSDK', options.isNonNativeSDK);
+      }
+    }
+    const headElmColl = document.getElementsByTagName('head');
+    if (headElmColl.length > 0) {
+      // logger.debug("==adding script==", js);
+      headElmColl[0].insertBefore(js, headElmColl[0].firstChild);
+    } else {
+      const e = document.getElementsByTagName('script')[0];
+      // logger.debug("==parent script==", e);
+      // logger.debug("==adding script==", js);
+      e.parentNode.insertBefore(js, e);
+    }
+  } catch (e) {
+    handleError(e);
+  }
+};
+
+export { ScriptLoader };

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

@@ -0,0 +1,82 @@
+// from client native integration name to server identified display name
+// add a mapping from Rudder identified key names to Rudder server recognizable names
+const clientToServerNames = {
+  All: 'All',
+  GA: 'Google Analytics',
+  GOOGLEADS: 'Google Ads',
+  BRAZE: 'Braze',
+  CHARTBEAT: 'Chartbeat',
+  COMSCORE: 'Comscore',
+  CUSTOMERIO: 'Customer IO',
+  DCM_Floodlight: 'DCM Floodlight',
+  FACEBOOK_PIXEL: 'Facebook Pixel',
+  GTM: 'Google Tag Manager',
+  HOTJAR: 'Hotjar',
+  HS: 'HubSpot',
+  INTERCOM: 'Intercom',
+  KEEN: 'Keen',
+  KISSMETRICS: 'Kiss Metrics',
+  LOTAME: 'Lotame',
+  VWO: 'VWO',
+  OPTIMIZELY: 'Optimizely Web',
+  FULLSTORY: 'Fullstory',
+  TVSQUARED: 'TVSquared',
+  GA4: 'Google Analytics 4 (GA4)',
+  MOENGAGE: 'MoEngage',
+  AM: 'Amplitude',
+  PENDO: 'Pendo',
+  LYTICS: 'Lytics',
+  APPCUES: 'Appcues',
+  POSTHOG: 'PostHog',
+  PROFITWELL: 'ProfitWell',
+  KLAVIYO: 'Klaviyo',
+  CLEVERTAP: 'CleverTap',
+  BINGADS: 'Bing Ads',
+  PINTEREST_TAG: 'Pinterest Tag',
+  SNAP_PIXEL: 'Snap Pixel',
+  LINKEDIN_INSIGHT_TAG: 'Linkedin Insight Tag',
+  REDDIT_PIXEL: 'Reddit Pixel',
+  DRIP: 'Drip',
+  HEAP: 'Heap.io',
+  CRITEO: 'Criteo',
+  MP: 'Mixpanel',
+  QUALTRICS: 'Qualtrics',
+  SENTRY: 'Sentry',
+  GOOGLE_OPTIMIZE: 'Google Optimize',
+  POST_AFFILIATE_PRO: 'Post Affiliate Pro',
+  LAUNCHDARKLY: 'LaunchDarkly',
+  GA360: 'Google Analytics 360',
+  ADROLL: 'Adroll',
+  VERO: 'Vero',
+  MATOMO: 'Matomo',
+  MOUSEFLOW: 'Mouseflow',
+  ROCKERBOX: 'Rockerbox',
+  CONVERTFLOW: 'ConvertFlow',
+  SNAPENGAGE: 'SnapEngage',
+  LIVECHAT: 'LiveChat',
+  SHYNET: 'Shynet',
+  WOOPRA: 'Woopra',
+  ROLLBAR: 'RollBar',
+  QUORA_PIXEL: 'Quora Pixel',
+  JUNE: 'June',
+  ENGAGE: 'Engage',
+  ITERABLE: 'Iterable',
+  YANDEX_METRICA: 'Yandex.Metrica',
+  REFINER: 'Refiner',
+  QUALAROO: 'Qualaroo',
+  PODSIGHTS: 'Podsights',
+  AXEPTIO: 'Axeptio',
+  SATISMETER: 'Satismeter',
+  MICROSOFT_CLARITY: 'Microsoft Clarity',
+  SENDINBLUE: 'Sendinblue',
+  OLARK: 'Olark',
+  LEMNISK: 'Lemnisk',
+  TIKTOK_ADS: 'TikTok Ads',
+  ACTIVE_CAMPAIGN: 'ActiveCampaign',
+  SPRIG: 'Sprig',
+  SPOTIFYPIXEL: 'Spotify Pixel',
+  COMMANDBAR: 'CommandBar',
+  NINETAILED: 'Ninetailed',
+};
+
+export { clientToServerNames };

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

@@ -0,0 +1,83 @@
+// map b/w the names of integrations comming from config plane to integration module names
+const configToIntNames = {
+  HS: 'HubSpot',
+  GA: 'GA',
+  HOTJAR: 'Hotjar',
+  GOOGLEADS: 'GoogleAds',
+  VWO: 'VWO',
+  GTM: 'GoogleTagManager',
+  BRAZE: 'Braze',
+  INTERCOM: 'INTERCOM',
+  KEEN: 'Keen',
+  KISSMETRICS: 'Kissmetrics',
+  CUSTOMERIO: 'CustomerIO',
+  CHARTBEAT: 'Chartbeat',
+  COMSCORE: 'Comscore',
+  FACEBOOK_PIXEL: 'FacebookPixel',
+  LOTAME: 'Lotame',
+  OPTIMIZELY: 'Optimizely',
+  BUGSNAG: 'Bugsnag',
+  FULLSTORY: 'Fullstory',
+  TVSQUARED: 'TVSquared',
+  GA4: 'GA4',
+  MOENGAGE: 'MoEngage',
+  AM: 'Amplitude',
+  PENDO: 'Pendo',
+  LYTICS: 'Lytics',
+  APPCUES: 'Appcues',
+  POSTHOG: 'Posthog',
+  KLAVIYO: 'Klaviyo',
+  CLEVERTAP: 'Clevertap',
+  BINGADS: 'BingAds',
+  PINTEREST_TAG: 'PinterestTag',
+  ADOBE_ANALYTICS: 'AdobeAnalytics',
+  LINKEDIN_INSIGHT_TAG: 'LinkedInInsightTag',
+  REDDIT_PIXEL: 'RedditPixel',
+  DRIP: 'Drip',
+  HEAP: 'Heap',
+  CRITEO: 'Criteo',
+  MP: 'Mixpanel',
+  QUALTRICS: 'Qualtrics',
+  PROFITWELL: 'ProfitWell',
+  SENTRY: 'Sentry',
+  QUANTUMMETRIC: 'QuantumMetric',
+  SNAP_PIXEL: 'SnapPixel',
+  POST_AFFILIATE_PRO: 'PostAffiliatePro',
+  GOOGLE_OPTIMIZE: 'GoogleOptimize',
+  LAUNCHDARKLY: 'LaunchDarkly',
+  GA360: 'GA360',
+  ADROLL: 'Adroll',
+  DCM_FLOODLIGHT: 'DCMFloodlight',
+  MATOMO: 'Matomo',
+  VERO: 'Vero',
+  MOUSEFLOW: 'Mouseflow',
+  ROCKERBOX: 'Rockerbox',
+  CONVERTFLOW: 'ConvertFlow',
+  SNAPENGAGE: 'SnapEngage',
+  LIVECHAT: 'LiveChat',
+  SHYNET: 'Shynet',
+  WOOPRA: 'Woopra',
+  ROLLBAR: 'RollBar',
+  QUORA_PIXEL: 'QuoraPixel',
+  JUNE: 'June',
+  ENGAGE: 'Engage',
+  ITERABLE: 'Iterable',
+  YANDEX_METRICA: 'YandexMetrica',
+  REFINER: 'Refiner',
+  QUALAROO: 'Qualaroo',
+  PODSIGHTS: 'Podsights',
+  AXEPTIO: 'Axeptio',
+  SATISMETER: 'Satismeter',
+  MICROSOFT_CLARITY: 'MicrosoftClarity',
+  SENDINBLUE: 'Sendinblue',
+  OLARK: 'Olark',
+  LEMNISK: 'Lemnisk',
+  TIKTOK_ADS: 'TiktokAds',
+  ACTIVE_CAMPAIGN: 'ActiveCampaign',
+  SPRIG: 'Sprig',
+  SPOTIFYPIXEL: 'SpotifyPixel',
+  COMMANDBAR: 'CommandBar',
+  NINETAILED: 'Ninetailed',
+};
+
+export { configToIntNames };

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

@@ -0,0 +1,15 @@
+const MAX_WAIT_FOR_INTEGRATION_LOAD = 10000;
+const INTEGRATION_LOAD_CHECK_INTERVAL = 1000;
+const LOAD_ORIGIN = 'RS_JS_SDK';
+const FAILED_REQUEST_ERR_MSG_PREFIX = 'Request failed with status:';
+const ERROR_MESSAGES_TO_BE_FILTERED = [FAILED_REQUEST_ERR_MSG_PREFIX];
+const ERROR_REPORTING_SERVICE_GLOBAL_KEY_NAME = 'errorReporting';
+
+export {
+  MAX_WAIT_FOR_INTEGRATION_LOAD,
+  INTEGRATION_LOAD_CHECK_INTERVAL,
+  LOAD_ORIGIN,
+  FAILED_REQUEST_ERR_MSG_PREFIX,
+  ERROR_MESSAGES_TO_BE_FILTERED,
+  ERROR_REPORTING_SERVICE_GLOBAL_KEY_NAME,
+};

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

@@ -0,0 +1,88 @@
+import { logger } from './logUtil';
+import { notifyError } from './notifyError';
+import { isInstanceOfEvent, stringifyWithoutCircularV1 } from './ObjectUtils';
+import { ERROR_MESSAGES_TO_BE_FILTERED, LOAD_ORIGIN } from './constants';
+
+const normalizeError = (error, customMessage, analyticsInstance) => {
+  let errorMessage;
+  try {
+    if (typeof error === 'string') {
+      errorMessage = error;
+    } else if (error instanceof Error) {
+      errorMessage = error.message;
+    } else {
+      errorMessage = error.message ? error.message : stringifyWithoutCircularV1(error);
+    }
+  } catch (e) {
+    errorMessage = '';
+  }
+
+  if (isInstanceOfEvent(error)) {
+    // Discard all the non-script loading errors
+    if (error.target && error.target.localName !== 'script') {
+      return '';
+    }
+
+    // Discard script errors that are not originated at SDK or from native SDKs
+    if (
+      error.target.dataset &&
+      (error.target.dataset.loader !== LOAD_ORIGIN ||
+        error.target.dataset.isnonnativesdk !== 'true')
+    ) {
+      return '';
+    }
+
+    errorMessage = `error in script loading:: src::  ${error.target.src} id:: ${error.target.id}`;
+
+    // SDK triggered ad-blocker script
+    if (error.target.id === 'ad-block') {
+      analyticsInstance.page(
+        'RudderJS-Initiated',
+        'ad-block page request',
+        { path: '/ad-blocked', title: errorMessage },
+        analyticsInstance.sendAdblockPageOptions,
+      );
+      // No need to proceed further for Ad-block errors
+      return '';
+    }
+  }
+
+  const customErrMessagePrefix = customMessage || '';
+  return `[handleError]::${customErrMessagePrefix} "${errorMessage}"`;
+};
+
+/**
+ * A function to determine whether the error should be notified or not
+ * @param {Error} error
+ * @returns
+ */
+const isAllowedToBeNotified = error => {
+  if (error.message) {
+    return !ERROR_MESSAGES_TO_BE_FILTERED.some(e => error.message.includes(e));
+  }
+  return true;
+};
+
+const handleError = (error, customMessage, analyticsInstance) => {
+  let errorMessage;
+
+  try {
+    errorMessage = normalizeError(error, customMessage, analyticsInstance);
+  } catch (err) {
+    logger.error('[handleError] Exception:: ', err);
+    logger.error('[handleError] Original error:: ', stringifyWithoutCircularV1(error));
+    notifyError(err);
+  }
+
+  if (!errorMessage) {
+    return;
+  }
+
+  logger.error(errorMessage);
+  // Check if the error is allowed to be notified
+  if (isAllowedToBeNotified(error)) {
+    notifyError(error);
+  }
+};
+
+export { handleError, normalizeError };

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

@@ -0,0 +1,10 @@
+export * as storage from './storage';
+export * as client_server_name from './client_server_name';
+export * as config_to_integration_names from './config_to_integration_names';
+export * as constants from './constants';
+export * as errorHandler from './errorHandler';
+export * as integration_cname from './integration_cname';
+export * as logUtil from './logUtil';
+export * as notifyError from './notifyError';
+export * as ObjectUtils from './ObjectUtils';
+export * as ScriptLoader from './ScriptLoader';