iureiure 1.0.0

package/packages/analytics-js-common/src/constants/integrations/TiktokAds/constants.ts

@@ -0,0 +1,97 @@
+const DIR_NAME = 'TiktokAds';
+const NAME = 'TIKTOK_ADS';
+const DISPLAY_NAME = 'TikTok Ads';
+
+const DISPLAY_NAME_TO_DIR_NAME_MAP = { [DISPLAY_NAME]: DIR_NAME };
+const CNameMapping = {
+  [NAME]: NAME,
+  TiktokAds: NAME,
+  'Tiktok ads': NAME,
+  'Tiktok Ads': NAME,
+  'Tik Tok Ads': NAME,
+  'tik tok ads': NAME,
+  tiktokads: NAME,
+};
+const PARTNER_NAME = 'RudderStack';
+
+const trackMapping = [
+  {
+    destKey: 'event_id',
+    sourceKeys: ['properties.eventId', 'properties.event_id', 'messageId'],
+  },
+  {
+    destKey: 'test_event_code',
+    sourceKeys: 'testEventCode',
+  },
+  {
+    destKey: 'contents',
+    sourceKeys: 'properties.contents',
+  },
+  {
+    destKey: 'content_category',
+    sourceKeys: 'properties.category',
+  },
+  {
+    destKey: 'status',
+    sourceKeys: 'properties.status',
+  },
+  {
+    destKey: 'content_name',
+    sourceKeys: 'properties.name',
+  },
+  {
+    destKey: 'content_id',
+    sourceKeys: ['properties.product_id', 'properties.productId'],
+  },
+  {
+    destKey: 'content_type',
+    sourceKeys: ['properties.contentType', 'properties.content_type'],
+  },
+  {
+    destKey: 'currency',
+    sourceKeys: 'properties.currency',
+  },
+  {
+    destKey: 'value',
+    sourceKeys: 'properties.value',
+  },
+  {
+    destKey: 'description',
+    sourceKeys: 'properties.description',
+  },
+  {
+    destKey: 'email',
+    sourceKeys: ['context.traits.email', 'traits.email', 'properties.email'],
+  },
+  {
+    destKey: 'phone',
+    sourceKeys: ['context.traits.phone', 'traits.phone', 'properties.phone'],
+  },
+];
+const eventNameMapping = {
+  'product added to wishlist': 'AddToWishlist',
+  'product added': 'AddToCart',
+  'checkout started': 'InitiateCheckout',
+  'payment info entered': 'AddPaymentInfo',
+  'checkout step completed': 'CompletePayment',
+  'order completed': 'PlaceAnOrder',
+  viewcontent: 'ViewContent',
+  clickbutton: 'ClickButton',
+  search: 'Search',
+  contact: 'Contact',
+  download: 'Download',
+  submitform: 'SubmitForm',
+  completeregistration: 'CompleteRegistration',
+  subscribe: 'Subscribe',
+};
+
+export {
+  NAME,
+  CNameMapping,
+  PARTNER_NAME,
+  trackMapping,
+  eventNameMapping,
+  DISPLAY_NAME_TO_DIR_NAME_MAP,
+  DISPLAY_NAME,
+  DIR_NAME,
+};

package/packages/analytics-js-common/src/constants/integrations/VWO/constants.ts

@@ -0,0 +1,17 @@
+const DIR_NAME = 'VWO';
+const NAME = 'VWO';
+const DISPLAY_NAME = 'VWO';
+
+const DISPLAY_NAME_TO_DIR_NAME_MAP = { [DISPLAY_NAME]: DIR_NAME };
+const CNameMapping = {
+  [NAME]: NAME,
+  VisualWebsiteOptimizer: NAME,
+  Visualwebsiteoptimizer: NAME,
+  visualwebsiteoptimizer: NAME,
+  vwo: NAME,
+  'Visual Website Optimizer': NAME,
+  'Visual website optimizer': NAME,
+  'visual website optimizer': NAME,
+};
+
+export { NAME, CNameMapping, DISPLAY_NAME_TO_DIR_NAME_MAP, DISPLAY_NAME, DIR_NAME };

package/packages/analytics-js-common/src/constants/integrations/Vero/constants.ts

@@ -0,0 +1,12 @@
+const DIR_NAME = 'Vero';
+const NAME = 'VERO';
+const DISPLAY_NAME = 'Vero';
+
+const DISPLAY_NAME_TO_DIR_NAME_MAP = { [DISPLAY_NAME]: DIR_NAME };
+const CNameMapping = {
+  [NAME]: NAME,
+  Vero: NAME,
+  vero: NAME,
+};
+
+export { NAME, CNameMapping, DISPLAY_NAME_TO_DIR_NAME_MAP, DISPLAY_NAME, DIR_NAME };

package/packages/analytics-js-common/src/constants/integrations/Woopra/constants.ts

@@ -0,0 +1,12 @@
+const DIR_NAME = 'Woopra';
+const NAME = 'WOOPRA';
+const DISPLAY_NAME = 'Woopra';
+
+const DISPLAY_NAME_TO_DIR_NAME_MAP = { [DISPLAY_NAME]: DIR_NAME };
+const CNameMapping = {
+  [NAME]: NAME,
+  Woopra: NAME,
+  woopra: NAME,
+};
+
+export { NAME, CNameMapping, DISPLAY_NAME_TO_DIR_NAME_MAP, DISPLAY_NAME, DIR_NAME };

package/packages/analytics-js-common/src/constants/integrations/YandexMetrica/constants.ts

@@ -0,0 +1,14 @@
+const DIR_NAME = 'YandexMetrica';
+const NAME = 'YANDEX_METRICA';
+const DISPLAY_NAME = 'Yandex.Metrica';
+
+const DISPLAY_NAME_TO_DIR_NAME_MAP = { [DISPLAY_NAME]: DIR_NAME };
+const CNameMapping = {
+  [NAME]: NAME,
+  Yandexmetrica: NAME,
+  yandexmetrica: NAME,
+  yandexMetrica: NAME,
+  YandexMetrica: NAME,
+};
+
+export { NAME, CNameMapping, DISPLAY_NAME_TO_DIR_NAME_MAP, DISPLAY_NAME, DIR_NAME };

package/packages/analytics-js-common/src/constants/integrationsConfig.ts

@@ -0,0 +1,5 @@
+const DEFAULT_INTEGRATIONS_CONFIG = {
+  All: true,
+};
+
+export { DEFAULT_INTEGRATIONS_CONFIG };

package/packages/analytics-js-common/src/constants/logMessages.ts

@@ -0,0 +1,24 @@
+const LOG_CONTEXT_SEPARATOR = ':: ';
+
+const SCRIPT_ALREADY_EXISTS_ERROR = (id: string): string =>
+  `A script with the id "${id}" is already loaded. Skipping the loading of this script to prevent conflicts.`;
+
+const SCRIPT_LOAD_ERROR = (id: string, url: string): string =>
+  `Failed to load the script with the id "${id}" from URL "${url}".`;
+
+const SCRIPT_LOAD_TIMEOUT_ERROR = (id: string, url: string, timeout: number): string =>
+  `A timeout of ${timeout} ms occurred while trying to load the script with id "${id}" from URL "${url}".`;
+
+const CIRCULAR_REFERENCE_WARNING = (context: string, key: string): string =>
+  `${context}${LOG_CONTEXT_SEPARATOR}A circular reference has been detected in the object and the property "${key}" has been dropped from the output.`;
+
+const JSON_STRINGIFY_WARNING = `Failed to convert the value to a JSON string.`;
+
+export {
+  LOG_CONTEXT_SEPARATOR,
+  SCRIPT_ALREADY_EXISTS_ERROR,
+  SCRIPT_LOAD_ERROR,
+  SCRIPT_LOAD_TIMEOUT_ERROR,
+  CIRCULAR_REFERENCE_WARNING,
+  JSON_STRINGIFY_WARNING
+}

package/packages/analytics-js-common/src/constants/loggerContexts.ts

@@ -0,0 +1,33 @@
+const CAPABILITIES_MANAGER = 'CapabilitiesManager';
+const CONFIG_MANAGER = 'ConfigManager';
+const EVENT_MANAGER = 'EventManager';
+const PLUGINS_MANAGER = 'PluginsManager';
+const USER_SESSION_MANAGER = 'UserSessionManager';
+const ERROR_HANDLER = 'ErrorHandler';
+const PLUGIN_ENGINE = 'PluginEngine';
+const STORE_MANAGER = 'StoreManager';
+const READY_API = 'readyApi';
+const LOAD_CONFIGURATION = 'LoadConfiguration';
+const EVENT_REPOSITORY = 'EventRepository';
+const EXTERNAL_SRC_LOADER = 'ExternalSrcLoader';
+const HTTP_CLIENT = 'HttpClient';
+const RS_APP = 'RudderStackApplication';
+const ANALYTICS_CORE = 'AnalyticsCore';
+
+export {
+  CAPABILITIES_MANAGER,
+  CONFIG_MANAGER,
+  EVENT_MANAGER,
+  PLUGINS_MANAGER,
+  USER_SESSION_MANAGER,
+  ERROR_HANDLER,
+  PLUGIN_ENGINE,
+  STORE_MANAGER,
+  READY_API,
+  LOAD_CONFIGURATION,
+  EVENT_REPOSITORY,
+  EXTERNAL_SRC_LOADER,
+  HTTP_CLIENT,
+  RS_APP,
+  ANALYTICS_CORE,
+};

package/packages/analytics-js-common/src/constants/storages.ts

@@ -0,0 +1,9 @@
+import type { StorageType } from '../types/Storage';
+
+const COOKIE_STORAGE: StorageType = 'cookieStorage';
+const LOCAL_STORAGE: StorageType = 'localStorage';
+const SESSION_STORAGE: StorageType = 'sessionStorage';
+const MEMORY_STORAGE: StorageType = 'memoryStorage';
+const NO_STORAGE: StorageType = 'none';
+
+export { COOKIE_STORAGE, LOCAL_STORAGE, SESSION_STORAGE, MEMORY_STORAGE, NO_STORAGE };

package/packages/analytics-js-common/src/constants/timeouts.ts

@@ -0,0 +1,3 @@
+const DEFAULT_EXT_SRC_LOAD_TIMEOUT_MS = 10 * 1000; // 10 seconds
+
+export { DEFAULT_EXT_SRC_LOAD_TIMEOUT_MS };

package/packages/analytics-js-common/src/constants/urls.ts

@@ -0,0 +1,4 @@
+const CDN_INT_DIR = 'js-integrations';
+const CDN_PLUGINS_DIR = 'plugins';
+
+export { CDN_INT_DIR, CDN_PLUGINS_DIR };

package/packages/analytics-js-common/src/index.ts

@@ -0,0 +1,4 @@
+export * as constants from './constants';
+export * from './services/ExternalSrcLoader';
+export * as utilities from './utilities';
+export * as v1_1Utils from './v1.1/utils';

package/packages/analytics-js-common/src/services/BufferQueue/BufferQueue.ts

@@ -0,0 +1,37 @@
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+
+/**
+ * A buffer queue to serve as a store for any type of data
+ */
+class BufferQueue<T = any> {
+  items: T[];
+
+  constructor() {
+    this.items = [];
+  }
+
+  enqueue(item: T) {
+    this.items.push(item);
+  }
+
+  dequeue(): Nullable<T> | undefined {
+    if (this.items.length === 0) {
+      return null;
+    }
+    return this.items.shift();
+  }
+
+  isEmpty(): boolean {
+    return this.items.length === 0;
+  }
+
+  size(): number {
+    return this.items.length;
+  }
+
+  clear() {
+    this.items = [];
+  }
+}
+
+export { BufferQueue };

package/packages/analytics-js-common/src/services/ExternalSrcLoader/ExternalSrcLoader.ts

@@ -0,0 +1,63 @@
+import { EXTERNAL_SRC_LOADER } from '../../constants/loggerContexts';
+import { DEFAULT_EXT_SRC_LOAD_TIMEOUT_MS } from '../../constants/timeouts';
+import { isFunction } from '../../utilities/checks';
+import type { IErrorHandler } from '../../types/ErrorHandler';
+import type { ILogger } from '../../types/Logger';
+import type { IExternalSourceLoadConfig, IExternalSrcLoader } from './types';
+import { jsFileLoader } from './jsFileLoader';
+
+/**
+ * Service to load external resources/files
+ */
+class ExternalSrcLoader implements IExternalSrcLoader {
+  errorHandler?: IErrorHandler;
+  logger?: ILogger;
+  hasErrorHandler = false;
+  timeout: number;
+
+  constructor(
+    errorHandler?: IErrorHandler,
+    logger?: ILogger,
+    timeout = DEFAULT_EXT_SRC_LOAD_TIMEOUT_MS,
+  ) {
+    this.errorHandler = errorHandler;
+    this.logger = logger;
+    this.timeout = timeout;
+    this.hasErrorHandler = Boolean(this.errorHandler);
+    this.onError = this.onError.bind(this);
+  }
+
+  /**
+   * Load external resource of type javascript
+   */
+  loadJSFile(config: IExternalSourceLoadConfig) {
+    const { url, id, timeout, async, callback, extraAttributes } = config;
+    const isFireAndForget = !isFunction(callback);
+
+    jsFileLoader(url, id, timeout || this.timeout, async, extraAttributes)
+      .then((id?: string) => {
+        if (!isFireAndForget) {
+          callback(id);
+        }
+      })
+      .catch(err => {
+        this.onError(err);
+        if (!isFireAndForget) {
+          callback();
+        }
+      });
+  }
+
+  /**
+   * Handle errors
+   */
+  onError(error: unknown) {
+    if (this.hasErrorHandler) {
+      this.errorHandler?.onError(error, EXTERNAL_SRC_LOADER);
+    } else {
+      throw error;
+    }
+  }
+}
+
+export { ExternalSrcLoader };

package/packages/analytics-js-common/src/services/ExternalSrcLoader/index.ts

@@ -0,0 +1 @@
+export { ExternalSrcLoader } from './ExternalSrcLoader';

package/packages/analytics-js-common/src/services/ExternalSrcLoader/jsFileLoader.ts

@@ -0,0 +1,124 @@
+import { getMutatedError } from '../../utilities/errors';
+import { EXTERNAL_SOURCE_LOAD_ORIGIN } from '../../constants/htmlAttributes';
+import {
+  SCRIPT_ALREADY_EXISTS_ERROR,
+  SCRIPT_LOAD_ERROR,
+  SCRIPT_LOAD_TIMEOUT_ERROR,
+} from '../../constants/logMessages';
+
+/**
+ * Create the DOM element to load a script marked as RS SDK originated
+ *
+ * @param {*} url The URL of the script to be loaded
+ * @param {*} id ID for the script tag
+ * @param {*} async Whether to load the script in async mode. Defaults to `true` [optional]
+ * @param {*} onload callback to invoke onload [optional]
+ * @param {*} onerror callback to invoke onerror [optional]
+ * @param {*} extraAttributes key/value pair with html attributes to add in html tag [optional]
+ *
+ * @returns HTMLScriptElement
+ */
+const createScriptElement = (
+  url: string,
+  id: string,
+  async = true,
+  onload: ((this: GlobalEventHandlers, ev: Event) => any) | null = null,
+  onerror: OnErrorEventHandler = null,
+  extraAttributes: Record<string, string> = {},
+) => {
+  const scriptElement = document.createElement('script');
+  scriptElement.type = 'text/javascript';
+  scriptElement.onload = onload;
+  scriptElement.onerror = onerror;
+  scriptElement.src = url;
+  scriptElement.id = id;
+  scriptElement.async = async;
+  scriptElement.setAttribute('data-append-origin', EXTERNAL_SOURCE_LOAD_ORIGIN);
+
+  Object.keys(extraAttributes).forEach(attributeName => {
+    scriptElement.setAttribute(attributeName, extraAttributes[attributeName] as string);
+  });
+
+  return scriptElement;
+};
+
+/**
+ * Add script DOM element to DOM
+ *
+ * @param {*} newScriptElement the script element to add
+ *
+ * @returns
+ */
+const insertScript = (newScriptElement: HTMLScriptElement) => {
+  // First try to add it to the head
+  const headElements = document.getElementsByTagName('head');
+  if (headElements.length > 0) {
+    headElements[0]?.insertBefore(newScriptElement, headElements[0]?.firstChild);
+    return;
+  }
+
+  // Else wise add it before the first script tag
+  const scriptElements = document.getElementsByTagName('script');
+  if (scriptElements.length > 0 && scriptElements[0]?.parentNode) {
+    scriptElements[0]?.parentNode.insertBefore(newScriptElement, scriptElements[0]);
+    return;
+  }
+
+  // Create a new head element and add the script as fallback
+  const headElement = document.createElement('head');
+  headElement.appendChild(newScriptElement);
+
+  const htmlElement = document.getElementsByTagName('html')[0];
+  htmlElement?.insertBefore(headElement, htmlElement.firstChild);
+};
+
+/**
+ * Loads external js file as a script html tag
+ *
+ * @param {*} url The URL of the script to be loaded
+ * @param {*} id ID for the script tag
+ * @param {*} timeout loading timeout
+ * @param {*} async Whether to load the script in async mode. Defaults to `true` [optional]
+ * @param {*} extraAttributes key/value pair with html attributes to add in html tag [optional]
+ *
+ * @returns
+ */
+const jsFileLoader = (
+  url: string,
+  id: string,
+  timeout: number,
+  async = true,
+  extraAttributes?: Record<string, string>,
+): Promise<string | undefined> =>
+  new Promise((resolve, reject) => {
+    const scriptExists = document.getElementById(id);
+    if (scriptExists) {
+      reject(new Error(SCRIPT_ALREADY_EXISTS_ERROR(id)));
+    }
+
+    try {
+      let timeoutID: number;
+
+      const onload = () => {
+        (globalThis as typeof window).clearTimeout(timeoutID);
+        resolve(id);
+      };
+
+      const onerror = () => {
+        (globalThis as typeof window).clearTimeout(timeoutID);
+        reject(new Error(SCRIPT_LOAD_ERROR(id, url)));
+      };
+
+      // Create the DOM element to load the script and add it to the DOM
+      insertScript(createScriptElement(url, id, async, onload, onerror, extraAttributes));
+
+      // Reject on timeout
+      timeoutID = (globalThis as typeof window).setTimeout(() => {
+        reject(new Error(SCRIPT_LOAD_TIMEOUT_ERROR(id, url, timeout)));
+      }, timeout);
+    } catch (err) {
+      reject(getMutatedError(err, SCRIPT_LOAD_ERROR(id, url)));
+    }
+  });
+
+export { jsFileLoader, insertScript, createScriptElement };

package/packages/analytics-js-common/src/services/ExternalSrcLoader/types.ts

@@ -0,0 +1,26 @@
+import type { ILogger } from '../../types/Logger';
+
+export interface IExternalSourceLoadConfig {
+  url: string;
+  id: string;
+  callback?(id?: string): unknown;
+  async?: boolean;
+  timeout?: number;
+  extraAttributes?: Record<string, string>;
+}
+
+export interface IExternalSrcLoader {
+  errorHandler?: {
+    onError(
+      error: unknown,
+      context?: string,
+      customMessage?: string,
+      shouldAlwaysThrow?: boolean,
+    ): void;
+    leaveBreadcrumb(breadcrumb: string): void;
+    notifyError(error: Error): void;
+  };
+  logger?: ILogger;
+  timeout: number;
+  loadJSFile(config: IExternalSourceLoadConfig): void;
+}

package/packages/analytics-js-common/src/types/ApiObject.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents a generic object in the APIs
+ * Use for parameters like properties, traits etc.
+ */
+export type ApiObject = {
+  [index: string]:
+    | string
+    | number
+    | boolean
+    | ApiObject
+    | null
+    | (string | number | boolean | null | ApiObject)[]
+    | undefined;
+};

package/packages/analytics-js-common/src/types/ApplicationLifecycle.ts

@@ -0,0 +1,12 @@
+export type LifecycleStatus =
+  | 'mounted'
+  | 'browserCapabilitiesReady'
+  | 'configured'
+  | 'pluginsLoading'
+  | 'pluginsReady'
+  | 'initialized'
+  | 'loaded'
+  | 'destinationsLoading'
+  | 'destinationsReady'
+  | 'ready'
+  | 'readyExecuted';