iureiure 1.0.0

package/packages/analytics-js/src/browser.ts

@@ -0,0 +1,55 @@
+import { RudderAnalytics } from './app/RudderAnalytics';
+
+/*
+ * Create new RudderAnalytics facade singleton
+ */
+const {
+  setDefaultInstanceKey,
+  getAnalyticsInstance,
+  load,
+  ready,
+  page,
+  track,
+  identify,
+  alias,
+  group,
+  reset,
+  getAnonymousId,
+  setAnonymousId,
+  getUserId,
+  getUserTraits,
+  getGroupId,
+  getGroupTraits,
+  startSession,
+  endSession,
+  getSessionId,
+  consent,
+  setAuthToken,
+} = new RudderAnalytics();
+
+/*
+ * Export as global object the RudderAnalytics facade singleton methods
+ */
+export {
+  setDefaultInstanceKey,
+  getAnalyticsInstance,
+  load,
+  ready,
+  page,
+  track,
+  identify,
+  alias,
+  group,
+  reset,
+  getAnonymousId,
+  setAnonymousId,
+  getUserId,
+  getUserTraits,
+  getGroupId,
+  getGroupTraits,
+  startSession,
+  endSession,
+  getSessionId,
+  consent,
+  setAuthToken,
+};

package/packages/analytics-js/src/components/capabilitiesManager/CapabilitiesManager.ts

@@ -0,0 +1,199 @@
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { IExternalSrcLoader } from '@rudderstack/analytics-js-common/services/ExternalSrcLoader/types';
+import { ExternalSrcLoader } from '@rudderstack/analytics-js-common/services/ExternalSrcLoader';
+import { batch, effect } from '@preact/signals-core';
+import {
+  COOKIE_STORAGE,
+  LOCAL_STORAGE,
+  SESSION_STORAGE,
+} from '@rudderstack/analytics-js-common/constants/storages';
+import { CAPABILITIES_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import { getTimezone } from '@rudderstack/analytics-js-common/utilities/timezone';
+import { POLYFILL_SCRIPT_LOAD_ERROR } from '../../constants/logMessages';
+import { getLanguage, getUserAgent } from '../utilities/page';
+import { getStorageEngine } from '../../services/StoreManager/storages';
+import { state } from '../../state';
+import { getUserAgentClientHint } from './detection/clientHint';
+import type { ICapabilitiesManager } from './types';
+import { POLYFILL_LOAD_TIMEOUT, POLYFILL_SCRIPT_ID, POLYFILL_URL } from './polyfill';
+import {
+  getScreenDetails,
+  hasBeacon,
+  hasCrypto,
+  hasUAClientHints,
+  isIE11,
+  isLegacyJSEngine,
+  isStorageAvailable,
+} from './detection';
+import { detectAdBlockers } from './detection/adBlockers';
+import { debounce } from '../utilities/globals';
+
+// TODO: replace direct calls to detection methods with state values when possible
+class CapabilitiesManager implements ICapabilitiesManager {
+  logger?: ILogger;
+  errorHandler?: IErrorHandler;
+  externalSrcLoader: IExternalSrcLoader;
+
+  constructor(errorHandler?: IErrorHandler, logger?: ILogger) {
+    this.logger = logger;
+    this.errorHandler = errorHandler;
+    this.externalSrcLoader = new ExternalSrcLoader(this.errorHandler, this.logger);
+    this.onError = this.onError.bind(this);
+    this.onReady = this.onReady.bind(this);
+  }
+
+  init() {
+    try {
+      this.prepareBrowserCapabilities();
+      this.attachWindowListeners();
+    } catch (err) {
+      this.onError(err);
+    }
+  }
+
+  /**
+   * Detect supported capabilities and set values in state
+   */
+  // eslint-disable-next-line class-methods-use-this
+  detectBrowserCapabilities() {
+    batch(() => {
+      // Storage related details
+      state.capabilities.storage.isCookieStorageAvailable.value = isStorageAvailable(
+        COOKIE_STORAGE,
+        getStorageEngine(COOKIE_STORAGE),
+        this.logger,
+      );
+      state.capabilities.storage.isLocalStorageAvailable.value = isStorageAvailable(
+        LOCAL_STORAGE,
+        undefined,
+        this.logger,
+      );
+      state.capabilities.storage.isSessionStorageAvailable.value = isStorageAvailable(
+        SESSION_STORAGE,
+        undefined,
+        this.logger,
+      );
+
+      // Browser feature detection details
+      state.capabilities.isBeaconAvailable.value = hasBeacon();
+      state.capabilities.isUaCHAvailable.value = hasUAClientHints();
+      state.capabilities.isCryptoAvailable.value = hasCrypto();
+      state.capabilities.isIE11.value = isIE11();
+      state.capabilities.isOnline.value = globalThis.navigator.onLine;
+
+      // Get page context details
+      state.context.userAgent.value = getUserAgent();
+      state.context.locale.value = getLanguage();
+      state.context.screen.value = getScreenDetails();
+      state.context.timezone.value = getTimezone();
+
+      if (hasUAClientHints()) {
+        getUserAgentClientHint((uach?: UADataValues) => {
+          state.context['ua-ch'].value = uach;
+        }, state.loadOptions.value.uaChTrackLevel);
+      }
+    });
+
+    // Ad blocker detection
+    effect(() => {
+      if (
+        state.loadOptions.value.sendAdblockPage === true &&
+        state.lifecycle.sourceConfigUrl.value !== undefined
+      ) {
+        detectAdBlockers(this.errorHandler, this.logger);
+      }
+    });
+  }
+
+  /**
+   * Detect if polyfills are required and then load script from polyfill URL
+   */
+  prepareBrowserCapabilities() {
+    state.capabilities.isLegacyDOM.value = isLegacyJSEngine();
+    let polyfillUrl = state.loadOptions.value.polyfillURL ?? POLYFILL_URL;
+    const shouldLoadPolyfill =
+      state.loadOptions.value.polyfillIfRequired &&
+      state.capabilities.isLegacyDOM.value &&
+      Boolean(polyfillUrl);
+
+    if (shouldLoadPolyfill) {
+      const isDefaultPolyfillService = polyfillUrl !== state.loadOptions.value.polyfillURL;
+      if (isDefaultPolyfillService) {
+        // write key specific callback
+        // NOTE: we're not putting this into RudderStackGlobals as providing the property path to the callback function in the polyfill URL is not possible
+        const polyfillCallbackName = `RS_polyfillCallback_${state.lifecycle.writeKey.value}`;
+
+        const polyfillCallback = (): void => {
+          this.onReady();
+
+          // Remove the entry from window so we don't leave room for calling it again
+          delete (globalThis as any)[polyfillCallbackName];
+        };
+
+        (globalThis as any)[polyfillCallbackName] = polyfillCallback;
+
+        polyfillUrl = `${polyfillUrl}&callback=${polyfillCallbackName}`;
+      }
+
+      this.externalSrcLoader?.loadJSFile({
+        url: polyfillUrl,
+        id: POLYFILL_SCRIPT_ID,
+        async: true,
+        timeout: POLYFILL_LOAD_TIMEOUT,
+        callback: (scriptId?: string) => {
+          if (!scriptId) {
+            this.onError(new Error(POLYFILL_SCRIPT_LOAD_ERROR(POLYFILL_SCRIPT_ID, polyfillUrl)));
+          } else if (!isDefaultPolyfillService) {
+            this.onReady();
+          }
+        },
+      });
+    } else {
+      this.onReady();
+    }
+  }
+
+  /**
+   * Attach listeners to window to observe event that update capabilities state values
+   */
+  attachWindowListeners() {
+    globalThis.addEventListener('offline', () => {
+      state.capabilities.isOnline.value = false;
+    });
+
+    globalThis.addEventListener('online', () => {
+      state.capabilities.isOnline.value = true;
+    });
+
+    globalThis.addEventListener(
+      'resize',
+      debounce(() => {
+        state.context.screen.value = getScreenDetails();
+      }, this),
+    );
+  }
+
+  /**
+   * Set the lifecycle status to next phase
+   */
+  // eslint-disable-next-line class-methods-use-this
+  onReady() {
+    this.detectBrowserCapabilities();
+    state.lifecycle.status.value = 'browserCapabilitiesReady';
+  }
+
+  /**
+   * Handles error
+   * @param error The error object
+   */
+  onError(error: unknown): void {
+    if (this.errorHandler) {
+      this.errorHandler.onError(error, CAPABILITIES_MANAGER);
+    } else {
+      throw error;
+    }
+  }
+}
+
+export { CapabilitiesManager };

package/packages/analytics-js/src/components/capabilitiesManager/detection/adBlockers.ts

@@ -0,0 +1,38 @@
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { HttpClient } from '../../../services/HttpClient/HttpClient';
+import { state } from '../../../state';
+
+const detectAdBlockers = (errorHandler?: IErrorHandler, logger?: ILogger): void => {
+  // Apparently, '?view=ad' is a query param that is blocked by majority of adblockers
+
+  // Use source config URL here as it is very unlikely to be blocked by adblockers
+  // Only the extra query param should make it vulnerable to adblockers
+  // This will work even if the users proxies it.
+  // The edge case where this doesn't work is when HEAD method is not allowed by the server (user's)
+  const baseUrl = new URL(state.lifecycle.sourceConfigUrl.value as string);
+  const url = `${baseUrl.origin}${baseUrl.pathname}?view=ad`;
+
+  const httpClient = new HttpClient(errorHandler, logger);
+  httpClient.setAuthHeader(state.lifecycle.writeKey.value as string);
+
+  httpClient.getAsyncData({
+    url,
+    options: {
+      // We actually don't need the response from the request, so we are using HEAD
+      method: 'HEAD',
+      headers: {
+        'Content-Type': undefined,
+      },
+    },
+    isRawResponse: true,
+    callback: (result, details) => {
+      // not ad blocked if the request is successful or it is not internally redirected on the client side
+      // Often adblockers instead of blocking the request, they redirect it to an internal URL
+      state.capabilities.isAdBlocked.value =
+        details?.error !== undefined || details?.xhr?.responseURL !== url;
+    },
+  });
+};
+
+export { detectAdBlockers };

package/packages/analytics-js/src/components/capabilitiesManager/detection/browser.ts

@@ -0,0 +1,24 @@
+import {
+  isUndefined,
+  isNull,
+  isNullOrUndefined,
+  isFunction,
+} from '@rudderstack/analytics-js-common/utilities/checks';
+
+const isBrowser = (): boolean => !isUndefined(globalThis) && !isUndefined(globalThis.document);
+
+const isNode = (): boolean =>
+  !isUndefined(process) && !isNull(process.versions) && !isNull(process.versions.node);
+
+const hasCrypto = (): boolean =>
+  !isNullOrUndefined(globalThis.crypto) && isFunction(globalThis.crypto.getRandomValues);
+
+const hasUAClientHints = (): boolean => !isNullOrUndefined(globalThis.navigator.userAgentData);
+
+const hasBeacon = (): boolean =>
+  !isNullOrUndefined(globalThis.navigator.sendBeacon) &&
+  isFunction(globalThis.navigator.sendBeacon);
+
+const isIE11 = (): boolean => Boolean(globalThis.navigator.userAgent.match(/Trident.*rv:11\./));
+
+export { isBrowser, isNode, hasCrypto, hasUAClientHints, hasBeacon, isIE11 };

package/packages/analytics-js/src/components/capabilitiesManager/detection/clientHint.ts

@@ -0,0 +1,31 @@
+const getUserAgentClientHint = (callback: (uaCH?: UADataValues) => void, 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: any) => {
+        callback(ua);
+      })
+      .catch(() => {
+        callback();
+      });
+  }
+};
+
+export { getUserAgentClientHint };

package/packages/analytics-js/src/components/capabilitiesManager/detection/dom.ts

@@ -0,0 +1,54 @@
+import { isFunction, isUndefined } from '@rudderstack/analytics-js-common/utilities/checks';
+
+const isDatasetAvailable = (): boolean => {
+  const testElement = document.createElement('div');
+  testElement.setAttribute('data-a-b', 'c');
+  return testElement.dataset ? testElement.dataset.aB === 'c' : false;
+};
+
+const legacyJSEngineRequiredPolyfills: Record<string, () => boolean> = {
+  URL: () => !isFunction(globalThis.URL) || !globalThis.URLSearchParams,
+  MutationObserver: () => isUndefined(MutationObserver),
+  Promise: () => isUndefined(Promise),
+  'Number.isNaN': () => !Number.isNaN,
+  'Number.isInteger': () => !Number.isInteger,
+  'Array.from': () => !Array.from,
+  'Array.prototype.find': () => !Array.prototype.find,
+  'Array.prototype.includes': () => !Array.prototype.includes,
+  'String.prototype.endsWith': () => !String.prototype.endsWith,
+  'String.prototype.startsWith': () => !String.prototype.startsWith,
+  'String.prototype.includes': () => !String.prototype.includes,
+  'Object.entries': () => !Object.entries,
+  'Object.values': () => !Object.values,
+  'Object.assign': () => typeof Object.assign !== 'function',
+  'Element.prototype.dataset': () => !isDatasetAvailable(),
+  'String.prototype.replaceAll': () => !String.prototype.replaceAll,
+  TextEncoder: () => isUndefined(TextEncoder) || isUndefined(TextDecoder),
+  'String.fromCodePoint': () => !String.fromCodePoint,
+  requestAnimationFrame: () =>
+    !isFunction(globalThis.requestAnimationFrame) || !isFunction(globalThis.cancelAnimationFrame),
+  CustomEvent: () => !isFunction(globalThis.CustomEvent),
+  /* eslint-disable-next-line */
+  'navigator.sendBeacon': () => !isFunction(navigator.sendBeacon),
+  ArrayBuffer: () => !isFunction(Uint8Array),
+};
+
+const isLegacyJSEngine = (): boolean => {
+  const requiredCapabilitiesList = Object.keys(legacyJSEngineRequiredPolyfills);
+  let needsPolyfill = false;
+
+  /* eslint-disable-next-line unicorn/no-for-loop */
+  for (let i = 0; i < requiredCapabilitiesList.length; i++) {
+    const isCapabilityMissing =
+      legacyJSEngineRequiredPolyfills[requiredCapabilitiesList[i] as string];
+
+    if (isFunction(isCapabilityMissing) && isCapabilityMissing()) {
+      needsPolyfill = true;
+      break;
+    }
+  }
+
+  return needsPolyfill;
+};
+
+export { isDatasetAvailable, legacyJSEngineRequiredPolyfills, isLegacyJSEngine };

package/packages/analytics-js/src/components/capabilitiesManager/detection/index.ts

@@ -0,0 +1,6 @@
+export { detectAdBlockers } from './adBlockers';
+export { isBrowser, isNode, hasCrypto, hasUAClientHints, hasBeacon, isIE11 } from './browser';
+export { getUserAgentClientHint } from './clientHint';
+export { isDatasetAvailable, legacyJSEngineRequiredPolyfills, isLegacyJSEngine } from './dom';
+export { getScreenDetails } from './screen';
+export { isStorageAvailable, isStorageQuotaExceeded } from './storage';

package/packages/analytics-js/src/components/capabilitiesManager/detection/screen.ts

@@ -0,0 +1,23 @@
+import type { ScreenInfo } from '@rudderstack/analytics-js-common/types/EventContext';
+
+const getScreenDetails = (): ScreenInfo => {
+  let screenDetails: ScreenInfo = {
+    density: 0,
+    width: 0,
+    height: 0,
+    innerWidth: 0,
+    innerHeight: 0,
+  };
+
+  screenDetails = {
+    width: globalThis.screen.width,
+    height: globalThis.screen.height,
+    density: globalThis.devicePixelRatio,
+    innerWidth: globalThis.innerWidth,
+    innerHeight: globalThis.innerHeight,
+  };
+
+  return screenDetails;
+};
+
+export { getScreenDetails };

package/packages/analytics-js/src/components/capabilitiesManager/detection/storage.ts

@@ -0,0 +1,77 @@
+import { CAPABILITIES_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import type { IStorage } from '@rudderstack/analytics-js-common/types/Store';
+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 type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import {
+  STORAGE_TEST_COOKIE,
+  STORAGE_TEST_LOCAL_STORAGE,
+  STORAGE_TEST_SESSION_STORAGE,
+} from '../../../constants/storage';
+import { STORAGE_UNAVAILABILITY_ERROR_PREFIX } from '../../../constants/logMessages';
+
+const isStorageQuotaExceeded = (e: DOMException | any): boolean => {
+  const matchingNames = ['QuotaExceededError', 'NS_ERROR_DOM_QUOTA_REACHED']; // [everything except Firefox, Firefox]
+  const matchingCodes = [22, 1014]; // [everything except Firefox, Firefox]
+  const isQuotaExceededError = matchingNames.includes(e.name) || matchingCodes.includes(e.code);
+
+  return e instanceof DOMException && isQuotaExceededError;
+};
+
+// TODO: also check for SecurityErrors
+//  https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage#exceptions
+const isStorageAvailable = (
+  type: StorageType = LOCAL_STORAGE,
+  storageInstance?: IStorage,
+  logger?: ILogger,
+) => {
+  let storage;
+  let testData;
+
+  try {
+    switch (type) {
+      case MEMORY_STORAGE:
+        return true;
+      case COOKIE_STORAGE:
+        storage = storageInstance;
+        testData = STORAGE_TEST_COOKIE;
+        break;
+      case LOCAL_STORAGE:
+        storage = storageInstance ?? globalThis.localStorage;
+        testData = STORAGE_TEST_LOCAL_STORAGE; // was STORAGE_TEST_LOCAL_STORAGE in ours and generateUUID() in segment retry one
+        break;
+      case SESSION_STORAGE:
+        storage = storageInstance ?? globalThis.sessionStorage;
+        testData = STORAGE_TEST_SESSION_STORAGE;
+        break;
+      default:
+        return false;
+    }
+
+    if (!storage) {
+      return false;
+    }
+
+    storage.setItem(testData, 'true');
+    if (storage.getItem(testData)) {
+      storage.removeItem(testData);
+      return true;
+    }
+    return false;
+  } catch (err) {
+    const msgPrefix = STORAGE_UNAVAILABILITY_ERROR_PREFIX(CAPABILITIES_MANAGER, type);
+    let reason = 'unavailable';
+    if (isStorageQuotaExceeded(err)) {
+      reason = 'full';
+    }
+    logger?.error(`${msgPrefix}${reason}.`, err);
+    return false;
+  }
+};
+
+export { isStorageQuotaExceeded, isStorageAvailable };

package/packages/analytics-js/src/components/capabilitiesManager/index.ts

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

package/packages/analytics-js/src/components/capabilitiesManager/polyfill/index.ts

@@ -0,0 +1,14 @@
+import { legacyJSEngineRequiredPolyfills } from '../detection/dom';
+
+// eslint-disable-next-line no-constant-condition
+const POLYFILL_URL = '__RS_POLYFILLIO_SDK_URL__'
+  ? `__RS_POLYFILLIO_SDK_URL__?version=3.111.0&features=${Object.keys(
+      legacyJSEngineRequiredPolyfills,
+    ).join('%2C')}`
+  : '';
+
+const POLYFILL_LOAD_TIMEOUT = 10 * 1000; // 10 seconds
+
+const POLYFILL_SCRIPT_ID = 'rudderstackPolyfill';
+
+export { POLYFILL_URL, POLYFILL_LOAD_TIMEOUT, POLYFILL_SCRIPT_ID };

package/packages/analytics-js/src/components/capabilitiesManager/types.ts

@@ -0,0 +1,14 @@
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { IExternalSrcLoader } from '@rudderstack/analytics-js-common/services/ExternalSrcLoader/types';
+
+export interface ICapabilitiesManager {
+  logger?: ILogger;
+  errorHandler?: IErrorHandler;
+  externalSrcLoader?: IExternalSrcLoader;
+  init(): void;
+  detectBrowserCapabilities(): void;
+  prepareBrowserCapabilities(): void;
+  attachWindowListeners(): void;
+  onReady(): void;
+}