iureiure 1.0.0

package/packages/analytics-js/rollup.config.mjs

@@ -0,0 +1,387 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import path from 'path';
+import babel from '@rollup/plugin-babel';
+import commonjs from '@rollup/plugin-commonjs';
+import resolve from '@rollup/plugin-node-resolve';
+import replace from '@rollup/plugin-replace';
+import terser from '@rollup/plugin-terser';
+import json from '@rollup/plugin-json';
+import { visualizer } from 'rollup-plugin-visualizer';
+import filesize from 'rollup-plugin-filesize';
+import livereload from 'rollup-plugin-livereload';
+import serve from 'rollup-plugin-serve';
+import htmlTemplate from 'rollup-plugin-generate-html-template';
+import typescript from 'rollup-plugin-typescript2';
+import nodePolyfills from 'rollup-plugin-polyfill-node';
+import { DEFAULT_EXTENSIONS } from '@babel/core';
+import del from 'rollup-plugin-delete';
+import dts from 'rollup-plugin-dts';
+import alias from '@rollup/plugin-alias';
+import federation from '@originjs/vite-plugin-federation';
+import externalGlobals from 'rollup-plugin-external-globals';
+import * as dotenv from 'dotenv';
+import pkg from './package.json' assert { type: 'json' };
+
+dotenv.config();
+const isLegacyBuild = process.env.BROWSERSLIST_ENV !== 'modern';
+const variantSubfolder = isLegacyBuild ? '/legacy' : '/modern';
+const bundledPluginsList = process.env.BUNDLED_PLUGINS;
+const isDynamicCustomBuild = Boolean(bundledPluginsList);
+const isContentScriptBuild = process.env.NO_EXTERNAL_HOST;
+const isModuleFederatedBuild = !isDynamicCustomBuild && !isLegacyBuild;
+const sourceMapType =
+  process.env.PROD_DEBUG === 'inline' ? 'inline' : process.env.PROD_DEBUG === 'true';
+const cdnPath = isDynamicCustomBuild ? `dynamicCdnBundle`: `cdn`
+const remotePluginsBasePath = process.env.REMOTE_MODULES_BASE_PATH || `http://localhost:3002/${cdnPath}/`;
+const outDirNpmRoot = `dist/npm`;
+const outDirCDNRoot = isDynamicCustomBuild ? `dist/${cdnPath}`: `dist/${cdnPath}`;
+let outDirNpm = `${outDirNpmRoot}${variantSubfolder}`;
+const outDirCDN = `${outDirCDNRoot}${variantSubfolder}`;
+const distName = 'rsa';
+const modName = 'rudderanalytics';
+const remotePluginsExportsFilename = `rsa-plugins`;
+const remotePluginsHostPromise = 'Promise.resolve(window.RudderStackGlobals && window.RudderStackGlobals.app && window.RudderStackGlobals.app.pluginsCDNPath ? "" + window.RudderStackGlobals.app.pluginsCDNPath + "/' + `${remotePluginsExportsFilename}.js` + '" : ' + `"${remotePluginsBasePath}/${remotePluginsExportsFilename}.js` + '")';
+const moduleType = process.env.MODULE_TYPE || 'cdn';
+const isNpmPackageBuild = moduleType === 'npm';
+const isCDNPackageBuild = moduleType === 'cdn';
+let bugsnagSDKUrl = 'https://d2wy8f7a9ursnm.cloudfront.net/v6/bugsnag.min.js';
+let polyfillIoUrl = 'https://polyfill.io/v3/polyfill.min.js';
+
+// For Chrome extension as content script any references in code to third party URLs
+// throw violations at approval phase even if relevant code is not used
+if(isContentScriptBuild) {
+  bugsnagSDKUrl = '';
+  polyfillIoUrl = '';
+}
+
+// Set paths for other bundling variant named exports contents
+if(isContentScriptBuild) {
+  outDirNpm = `${outDirNpm}/content-script`;
+} else if(isDynamicCustomBuild) {
+  outDirNpm = `${outDirNpm}/bundled`;
+}
+
+// Configuration to exclude plugin imports for generated bundle
+const getExternalsConfig = () => {
+  const externalGlobalsConfig = {}
+
+  if(isModuleFederatedBuild) {
+    externalGlobalsConfig['./bundledBuildPluginImports'] = '{}';
+    return externalGlobalsConfig;
+  } else {
+    externalGlobalsConfig['./federatedModulesBuildPluginImports'] = '{}';
+  }
+
+  if(bundledPluginsList === 'all') {
+    return externalGlobalsConfig;
+  }
+
+  if(isDynamicCustomBuild) {
+    if (!bundledPluginsList.includes('BeaconQueue')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/beaconQueue'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('Bugsnag')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/bugsnag'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('CustomConsentManager')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/customConsentManager'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('DeviceModeDestinations')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/deviceModeDestinations'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('DeviceModeTransformation')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/deviceModeTransformation'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('ErrorReporting')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/errorReporting'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('ExternalAnonymousId')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/externalAnonymousId'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('GoogleLinker')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/googleLinker'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('KetchConsentManager')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/ketchConsentManager'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('NativeDestinationQueue')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/nativeDestinationQueue'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('OneTrustConsentManager')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/oneTrustConsentManager'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('StorageEncryption')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/storageEncryption'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('StorageEncryptionLegacy')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/storageEncryptionLegacy'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('StorageMigrator')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/storageMigrator'] = '{}';
+    }
+
+    if (!bundledPluginsList.includes('XhrQueue') && bundledPluginsList.includes('BeaconQueue')) {
+      externalGlobalsConfig['@rudderstack/analytics-js-plugins/xhrQueue'] = '{}';
+    }
+  }
+
+  return externalGlobalsConfig;
+}
+
+// Output in console to assist debugging bundle builds
+const configSummaryOutput = () => {
+  if(isDynamicCustomBuild) {
+    console.log(`Custom Bundle. Including plugins: ${bundledPluginsList}`);
+  }
+
+  if(isLegacyBuild) {
+    console.log(`Legacy Bundle.`)
+  }
+
+  if(isModuleFederatedBuild) {
+    console.log(`Federated Modules Bundle.`)
+  }
+
+  console.log(`Replaces imports in build time: `, getExternalsConfig());
+}
+
+export function getDefaultConfig(distName) {
+  const version = process.env.VERSION || 'dev-snapshot';
+  const isLocalServerEnabled = isCDNPackageBuild && process.env.DEV_SERVER;
+  configSummaryOutput();
+
+  return {
+    watch: {
+      include: ['src/**'],
+    },
+    external: [
+      /rudderAnalyticsRemotePlugins\/.*/,
+      ...Object.keys(pkg.peerDependencies || {})
+    ],
+    onwarn(warning, warn) {
+      // Silence 'this' has been rewritten to 'undefined' warning
+      // https://rollupjs.org/guide/en/#error-this-is-undefined
+      if (warning.code === 'THIS_IS_UNDEFINED') {
+        return;
+      }
+
+      warn(warning);
+    },
+    plugins: [
+      replace({
+        preventAssignment: true,
+        __BUNDLE_ALL_PLUGINS__: isLegacyBuild || isDynamicCustomBuild,
+        __IS_DYNAMIC_CUSTOM_BUNDLE__: isDynamicCustomBuild,
+        __BUNDLED_PLUGINS_LIST__: bundledPluginsList ?? '',
+        __IS_LEGACY_BUILD__: isLegacyBuild,
+        __PACKAGE_VERSION__: version,
+        __MODULE_TYPE__: moduleType,
+        __RS_BUGSNAG_API_KEY__: process.env.BUGSNAG_API_KEY || '{{__RS_BUGSNAG_API_KEY__}}',
+        __RS_BUGSNAG_RELEASE_STAGE__: process.env.BUGSNAG_RELEASE_STAGE || 'production',
+        __SDK_BUNDLE_FILENAME__: distName,
+        __RS_POLYFILLIO_SDK_URL__: polyfillIoUrl,
+        __RS_BUGSNAG_SDK_URL__: bugsnagSDKUrl,
+      }),
+      resolve({
+        jsnext: true,
+        browser: true,
+        preferBuiltins: false,
+        extensions: ['.js', '.ts', '.mjs'],
+      }),
+      nodePolyfills({
+        include: ['crypto'],
+      }),
+      commonjs({
+        include: /node_modules/,
+        requireReturnsDefault: 'auto',
+      }),
+      json(),
+      typescript({
+        tsconfig: './tsconfig.json',
+        useTsconfigDeclarationDir: true,
+      }),
+      babel({
+        compact: true,
+        babelHelpers: 'bundled',
+        exclude: ['node_modules/@babel/**', 'node_modules/core-js/**'],
+        extensions: [...DEFAULT_EXTENSIONS, '.ts'],
+        sourcemap: sourceMapType,
+      }),
+      externalGlobals(getExternalsConfig()),
+      !isLegacyBuild &&
+      federation({
+        remotes: {
+          rudderAnalyticsRemotePlugins: {
+            // use promise to set the path to allow override via loadOption value in case of proxy
+            // https://github.com/originjs/vite-plugin-federation#externaltype-urlpromise
+            external: remotePluginsHostPromise,
+            externalType: 'promise',
+            format: 'esm'
+          },
+        }
+      }),
+      process.env.UGLIFY === 'true' &&
+        terser({
+          safari10: isLegacyBuild,
+          ecma: isLegacyBuild ? 2015 : 2017,
+          format: {
+            comments: false,
+          },
+        }),
+      filesize({
+        showBeforeSizes: 'build',
+        showBrotliSize: true,
+      }),
+      process.env.VISUALIZER === 'true' &&
+        visualizer({
+          filename: `./stats/${distName}.html`,
+          title: `Rollup Visualizer - ${distName}`,
+          sourcemap: true,
+          open: true,
+          gzipSize: true,
+          brotliSize: true,
+        }),
+      isLocalServerEnabled &&
+        htmlTemplate({
+          template: process.env.TEST_FILE_PATH || 'public/index.html',
+          target: 'index.html',
+          attrs: ['async'],
+          replaceVars: {
+            __WRITE_KEY__: process.env.WRITE_KEY,
+            __DATAPLANE_URL__: process.env.DATAPLANE_URL,
+            __CONFIG_SERVER_HOST__:
+              process.env.CONFIG_SERVER_HOST || '',
+            __DEST_SDK_BASE_URL__: process.env.DEST_SDK_BASE_URL,
+            __PLUGINS_BASE_URL__: remotePluginsBasePath,
+            __SDK_BUNDLE_FILENAME__: distName,
+          },
+        }),
+      isLocalServerEnabled &&
+        serve({
+          open: true,
+          openPage: `/${cdnPath}/${isLegacyBuild ? 'legacy' : 'modern'}/iife/index.html`,
+          contentBase: ['dist'],
+          host: 'localhost',
+          port: 3001,
+          headers: {
+            'Access-Control-Allow-Origin': '*',
+          },
+        }),
+      isLocalServerEnabled && livereload(),
+    ],
+  };
+}
+
+const outputFilesNpm = [
+  {
+    entryFileNames: `index.js`,
+    dir: outDirNpm + '/esm/',
+    format: 'esm',
+    name: modName,
+    sourcemap: sourceMapType,
+    generatedCode: {
+      preset: isLegacyBuild ? 'es5' : 'es2015',
+    },
+  },
+  {
+    entryFileNames: `index.js`,
+    dir: outDirNpm + '/cjs',
+    format: 'cjs',
+    name: modName,
+    sourcemap: sourceMapType,
+    generatedCode: {
+      preset: isLegacyBuild ? 'es5' : 'es2015',
+    },
+  },
+  {
+    entryFileNames: `index.js`,
+    dir: outDirNpm + '/umd',
+    format: 'umd',
+    name: modName,
+    sourcemap: sourceMapType,
+    generatedCode: {
+      preset: isLegacyBuild ? 'es5' : 'es2015',
+    },
+  },
+];
+
+const outputFilesCdn = [
+  {
+    entryFileNames: `${distName}${process.env.UGLIFY === 'true' ? '.min' : ''}.js`,
+    dir: outDirCDN + '/iife',
+    format: 'iife',
+    name: modName,
+    sourcemap: sourceMapType,
+    generatedCode: {
+      preset: isLegacyBuild ? 'es5' : 'es2015',
+    },
+  },
+];
+
+const buildConfig = () => {
+  return {
+    ...getDefaultConfig(distName),
+  };
+};
+
+const buildEntries = () => {
+  const outputFiles = isCDNPackageBuild ? outputFilesCdn : outputFilesNpm;
+
+  if(isCDNPackageBuild) {
+    return[{
+      ...buildConfig(),
+      input: 'src/browser.ts',
+      output: outputFiles,
+    }];
+  }
+
+  return [
+    {
+      ...buildConfig(),
+      input: 'src/index.ts',
+      output: outputFiles,
+    },
+    {
+      input: `dist/dts/packages/analytics-js/src/index.d.ts`,
+      plugins: [
+        alias({
+          entries: [
+            {
+              find: '@rudderstack/analytics-js',
+              replacement: path.resolve('./dist/dts/packages/analytics-js/src'),
+            },
+            {
+              find: '@rudderstack/analytics-js-plugins',
+              replacement: path.resolve('./dist/dts/packages/analytics-js-plugins/src'),
+            },
+            {
+              find: '@rudderstack/analytics-js-common',
+              replacement: path.resolve('./dist/dts/packages/analytics-js-common/src'),
+            }
+          ]
+        }),
+        dts(),
+        del({ hook: "buildEnd", targets: "./dist/dts" }),
+      ],
+      output: {
+        file: `${outDirNpmRoot}/index.d.ts`,
+        format: 'es',
+      },
+    }
+  ];
+}
+
+export default buildEntries();

package/packages/analytics-js/src/app/IRudderStackGlobals.ts

@@ -0,0 +1,21 @@
+import type { ApplicationState } from '@rudderstack/analytics-js-common/types/ApplicationState';
+import type { PreloadedEventCall } from '../components/preloadBuffer/types';
+
+/**
+ * Exposed values that can be accessed as global objects per analytics instance
+ * TODO: find all values that need to be exposed in globals if anything else
+ */
+export type ExposedGlobals = {
+  state?: ApplicationState;
+  preloadedEventsBuffer?: PreloadedEventCall[];
+  pluginsCDNPath?: string;
+  [key: string]: any;
+};
+
+/**
+ * Exposing all globally accessible values for all analytics instances
+ * As key, we use the value of writeKey assigned to analytics instance that the values belong to
+ */
+export interface IRudderStackGlobals {
+  [key: string]: ExposedGlobals;
+}

package/packages/analytics-js/src/app/RudderAnalytics.ts

@@ -0,0 +1,296 @@
+/* eslint-disable unicorn/prefer-export-from */
+import { clone } from 'ramda';
+import {
+  aliasArgumentsToCallOptions,
+  groupArgumentsToCallOptions,
+  identifyArgumentsToCallOptions,
+  pageArgumentsToCallOptions,
+  trackArgumentsToCallOptions,
+} from '@rudderstack/analytics-js-common/utilities/eventMethodOverloads';
+import type { IRudderAnalytics } from '@rudderstack/analytics-js-common/types/IRudderAnalytics';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type {
+  AnonymousIdOptions,
+  ConsentOptions,
+  LoadOptions,
+} from '@rudderstack/analytics-js-common/types/LoadOptions';
+import type { ApiCallback, ApiOptions } from '@rudderstack/analytics-js-common/types/EventApi';
+import type { ApiObject } from '@rudderstack/analytics-js-common/types/ApiObject';
+import { RS_APP } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import { isString } from '@rudderstack/analytics-js-common/utilities/checks';
+import type { IdentifyTraits } from '@rudderstack/analytics-js-common/types/traits';
+import { GLOBAL_PRELOAD_BUFFER } from '../constants/app';
+import {
+  getPreloadedLoadEvent,
+  promotePreloadedConsentEventsToTop,
+} from '../components/preloadBuffer';
+import type { PreloadedEventCall } from '../components/preloadBuffer/types';
+import { setExposedGlobal } from '../components/utilities/globals';
+import type { IAnalytics } from '../components/core/IAnalytics';
+import { Analytics } from '../components/core/Analytics';
+import { defaultLogger } from '../services/Logger/Logger';
+import { EMPTY_GROUP_CALL_ERROR, WRITE_KEY_NOT_A_STRING_ERROR } from '../constants/logMessages';
+import { defaultErrorHandler } from '../services/ErrorHandler';
+
+// TODO: add analytics restart/reset mechanism
+
+/*
+ * RudderAnalytics facade singleton that is exposed as global object and will:
+ * expose overloaded methods
+ * handle multiple Analytics instances
+ * consume SDK preload event buffer
+ */
+class RudderAnalytics implements IRudderAnalytics<IAnalytics> {
+  static globalSingleton: Nullable<RudderAnalytics> = null;
+  analyticsInstances: Record<string, IAnalytics> = {};
+  defaultAnalyticsKey = '';
+  logger = defaultLogger;
+
+  // Singleton with constructor bind methods
+  constructor() {
+    if (RudderAnalytics.globalSingleton) {
+      // START-NO-SONAR-SCAN
+      // eslint-disable-next-line no-constructor-return
+      return RudderAnalytics.globalSingleton;
+      // END-NO-SONAR-SCAN
+    }
+    defaultErrorHandler.attachErrorListeners();
+
+    this.setDefaultInstanceKey = this.setDefaultInstanceKey.bind(this);
+    this.getAnalyticsInstance = this.getAnalyticsInstance.bind(this);
+    this.load = this.load.bind(this);
+    this.ready = this.ready.bind(this);
+    this.triggerBufferedLoadEvent = this.triggerBufferedLoadEvent.bind(this);
+    this.page = this.page.bind(this);
+    this.track = this.track.bind(this);
+    this.identify = this.identify.bind(this);
+    this.alias = this.alias.bind(this);
+    this.group = this.group.bind(this);
+    this.reset = this.reset.bind(this);
+    this.getAnonymousId = this.getAnonymousId.bind(this);
+    this.setAnonymousId = this.setAnonymousId.bind(this);
+    this.getUserId = this.getUserId.bind(this);
+    this.getUserTraits = this.getUserTraits.bind(this);
+    this.getGroupId = this.getGroupId.bind(this);
+    this.getGroupTraits = this.getGroupTraits.bind(this);
+    this.startSession = this.startSession.bind(this);
+    this.endSession = this.endSession.bind(this);
+    this.getSessionId = this.getSessionId.bind(this);
+    this.setAuthToken = this.setAuthToken.bind(this);
+    this.consent = this.consent.bind(this);
+
+    RudderAnalytics.globalSingleton = this;
+
+    // start loading if a load event was buffered or wait for explicit load call
+    this.triggerBufferedLoadEvent();
+
+    // Assign to global "rudderanalytics" object after processing the preload buffer (if any exists)
+    // for CDN bundling IIFE exports covers this but for npm ESM and CJS bundling has to be done explicitly
+    (globalThis as typeof window).rudderanalytics = this;
+  }
+
+  /**
+   * Set instance to use if no specific writeKey is provided in methods
+   * automatically for the first created instance
+   * TODO: to support multiple analytics instances in the near future
+   */
+  setDefaultInstanceKey(writeKey: string) {
+    if (writeKey) {
+      this.defaultAnalyticsKey = writeKey;
+    }
+  }
+
+  /**
+   * Retrieve an existing analytics instance
+   */
+  getAnalyticsInstance(writeKey?: string): IAnalytics {
+    const instanceId = writeKey ?? this.defaultAnalyticsKey;
+
+    const analyticsInstanceExists = Boolean(this.analyticsInstances[instanceId]);
+
+    if (!analyticsInstanceExists) {
+      this.analyticsInstances[instanceId] = new Analytics();
+    }
+
+    return this.analyticsInstances[instanceId] as IAnalytics;
+  }
+
+  /**
+   * Create new analytics instance and trigger application lifecycle start
+   */
+  load(writeKey: string, dataPlaneUrl: string, loadOptions?: Partial<LoadOptions>) {
+    if (!isString(writeKey)) {
+      this.logger.error(WRITE_KEY_NOT_A_STRING_ERROR(RS_APP, writeKey));
+      return;
+    }
+
+    if (this.analyticsInstances[writeKey]) {
+      return;
+    }
+
+    this.setDefaultInstanceKey(writeKey);
+    this.analyticsInstances[writeKey] = new Analytics();
+    this.getAnalyticsInstance(writeKey).load(writeKey, dataPlaneUrl, loadOptions);
+  }
+
+  /**
+   * Trigger load event in buffer queue if exists and stores the
+   * remaining preloaded events array in global object
+   */
+  triggerBufferedLoadEvent() {
+    const preloadedEventsArray = Array.isArray((globalThis as typeof window).rudderanalytics)
+      ? ((globalThis as typeof window).rudderanalytics as PreloadedEventCall[])
+      : ([] as PreloadedEventCall[]);
+
+    // The array will be mutated in the below method
+    promotePreloadedConsentEventsToTop(preloadedEventsArray);
+
+    // Get any load method call that is buffered if any
+    // BTW, load method is also removed from the array
+    // So, the Analytics object can directly consume the remaining events
+    const loadEvent: PreloadedEventCall = getPreloadedLoadEvent(preloadedEventsArray);
+
+    // Set the final preloaded events array in global object
+    setExposedGlobal(GLOBAL_PRELOAD_BUFFER, clone(preloadedEventsArray));
+
+    // Process load method if present in the buffered requests
+    if (loadEvent.length > 0) {
+      // Remove the event name from the Buffered Event array and keep only arguments
+      loadEvent.shift();
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      this.load.apply(null, loadEvent);
+    }
+  }
+
+  /**
+   * Get ready callback arguments and forward to ready call
+   */
+  ready(callback: ApiCallback) {
+    this.getAnalyticsInstance().ready(callback);
+  }
+
+  /**
+   * Process page arguments and forward to page call
+   */
+  page(
+    category?: string | Nullable<ApiObject> | ApiCallback,
+    name?: string | Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback,
+    properties?: Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback,
+    options?: Nullable<ApiOptions> | ApiCallback,
+    callback?: ApiCallback,
+  ) {
+    this.getAnalyticsInstance().page(
+      pageArgumentsToCallOptions(category, name, properties, options, callback),
+    );
+  }
+
+  /**
+   * Process track arguments and forward to page call
+   */
+  track(
+    event: string,
+    properties?: Nullable<ApiObject> | ApiCallback,
+    options?: Nullable<ApiOptions> | ApiCallback,
+    callback?: ApiCallback,
+  ) {
+    this.getAnalyticsInstance().track(
+      trackArgumentsToCallOptions(event, properties, options, callback),
+    );
+  }
+
+  /**
+   * Process identify arguments and forward to page call
+   */
+  identify(
+    userId?: string | number | Nullable<IdentifyTraits>,
+    traits?: Nullable<IdentifyTraits> | Nullable<ApiOptions> | ApiCallback,
+    options?: Nullable<ApiOptions> | ApiCallback,
+    callback?: ApiCallback,
+  ) {
+    this.getAnalyticsInstance().identify(
+      identifyArgumentsToCallOptions(userId, traits, options, callback),
+    );
+  }
+
+  /**
+   * Process alias arguments and forward to page call
+   */
+  alias(
+    to?: Nullable<string> | ApiCallback,
+    from?: string | Nullable<ApiOptions> | ApiCallback,
+    options?: Nullable<ApiOptions> | ApiCallback,
+    callback?: ApiCallback,
+  ) {
+    this.getAnalyticsInstance().alias(aliasArgumentsToCallOptions(to, from, options, callback));
+  }
+
+  /**
+   * Process group arguments and forward to page call
+   */
+  group(
+    groupId: string | number | Nullable<ApiObject> | ApiCallback,
+    traits?: Nullable<ApiOptions> | Nullable<ApiObject> | ApiCallback,
+    options?: Nullable<ApiOptions> | ApiCallback,
+    callback?: ApiCallback,
+  ) {
+    if (arguments.length === 0) {
+      this.logger.error(EMPTY_GROUP_CALL_ERROR(RS_APP));
+      return;
+    }
+
+    this.getAnalyticsInstance().group(
+      groupArgumentsToCallOptions(groupId, traits, options, callback),
+    );
+  }
+
+  reset(resetAnonymousId?: boolean) {
+    this.getAnalyticsInstance().reset(resetAnonymousId);
+  }
+
+  getAnonymousId(options?: AnonymousIdOptions) {
+    return this.getAnalyticsInstance().getAnonymousId(options);
+  }
+
+  setAnonymousId(anonymousId?: string, rudderAmpLinkerParam?: string) {
+    this.getAnalyticsInstance().setAnonymousId(anonymousId, rudderAmpLinkerParam);
+  }
+
+  getUserId() {
+    return this.getAnalyticsInstance().getUserId();
+  }
+
+  getUserTraits() {
+    return this.getAnalyticsInstance().getUserTraits();
+  }
+
+  getGroupId() {
+    return this.getAnalyticsInstance().getGroupId();
+  }
+
+  getGroupTraits() {
+    return this.getAnalyticsInstance().getGroupTraits();
+  }
+
+  startSession(sessionId?: number) {
+    return this.getAnalyticsInstance().startSession(sessionId);
+  }
+
+  endSession() {
+    return this.getAnalyticsInstance().endSession();
+  }
+
+  getSessionId() {
+    return this.getAnalyticsInstance().getSessionId();
+  }
+
+  setAuthToken(token: string) {
+    return this.getAnalyticsInstance().setAuthToken(token);
+  }
+
+  consent(options?: ConsentOptions) {
+    return this.getAnalyticsInstance().consent(options);
+  }
+}
+
+export { RudderAnalytics };