iureiure 1.0.0

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

@@ -0,0 +1,204 @@
+import type { Nullable } from './Nullable';
+import type { ApiCallback, ApiOptions } from './EventApi';
+import type { AnonymousIdOptions, ConsentOptions, LoadOptions } from './LoadOptions';
+import type { ApiObject } from './ApiObject';
+import type { ILogger } from './Logger';
+import type { IdentifyTraits } from './traits';
+
+export type AnalyticsIdentifyMethod = {
+  (
+    userId?: string,
+    traits?: Nullable<IdentifyTraits>,
+    options?: Nullable<ApiOptions>,
+    callback?: ApiCallback,
+  ): void;
+  (userId: string, traits: Nullable<IdentifyTraits>, callback: ApiCallback): void;
+  (userId: string, callback: ApiCallback): void;
+  (traits: Nullable<IdentifyTraits>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+  (traits: Nullable<IdentifyTraits>, callback?: ApiCallback): void;
+};
+
+export type AnalyticsPageMethod = {
+  (
+    category?: string,
+    name?: string,
+    properties?: Nullable<ApiObject>,
+    options?: Nullable<ApiOptions>,
+    callback?: ApiCallback,
+  ): void;
+  (category: string, name: string, properties: Nullable<ApiObject>, callback: ApiCallback): void;
+  (
+    name: string,
+    properties?: Nullable<ApiObject>,
+    options?: Nullable<ApiOptions>,
+    callback?: ApiCallback,
+  ): void;
+  (category: string, name: string, callback: ApiCallback): void;
+  (name: string, properties: Nullable<ApiObject>, callback: ApiCallback): void;
+  (name: string, callback: ApiCallback): void;
+  (properties: Nullable<ApiObject>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+  (properties: Nullable<ApiObject>, callback?: ApiCallback): void;
+};
+
+export type AnalyticsTrackMethod = {
+  (
+    event: string,
+    properties?: Nullable<ApiObject>,
+    options?: Nullable<ApiOptions>,
+    callback?: ApiCallback,
+  ): void;
+  (event: string, properties: Nullable<ApiObject>, callback: ApiCallback): void;
+  (event: string, callback: ApiCallback): void;
+};
+
+export type AnalyticsGroupMethod = {
+  (
+    groupId: string | number,
+    traits?: Nullable<ApiObject>,
+    options?: Nullable<ApiOptions>,
+    callback?: ApiCallback,
+  ): void;
+  (groupId: string | number, traits: Nullable<ApiObject>, callback: ApiCallback): void;
+  (groupId: string | number, callback: ApiCallback): void;
+  (traits: Nullable<ApiObject>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+  (traits: Nullable<ApiObject>, callback?: ApiCallback): void;
+};
+
+export type AnalyticsAliasMethod = {
+  (
+    to: Nullable<string>,
+    from?: string,
+    options?: Nullable<ApiOptions>,
+    callback?: ApiCallback,
+  ): void;
+  (to: Nullable<string>, from: string, callback: ApiCallback): void;
+  (to: Nullable<string>, options: Nullable<ApiOptions>, callback?: ApiCallback): void;
+  (to: Nullable<string>, callback: ApiCallback): void;
+  (to: ApiCallback): void;
+  (): void;
+};
+
+export interface IRudderAnalytics<T = any> {
+  analyticsInstances: Record<string, T>;
+  defaultAnalyticsKey: string;
+  logger: ILogger;
+
+  /**
+   * Set the writeKey of the analytics instance that should be default
+   */
+  setDefaultInstanceKey(writeKey: string, autoSet: boolean): void;
+
+  /**
+   * Get the instance of Analytics that is set as default
+   */
+  getAnalyticsInstance(writeKey?: string): T;
+
+  /**
+   * Trigger load event in buffer queue if exists
+   */
+  triggerBufferedLoadEvent(): void;
+
+  /**
+   * Call control pane to get client configs
+   */
+  load(writeKey: string, dataPlaneUrl: string, loadOptions?: Partial<LoadOptions>): void;
+
+  /**
+   * To register a callback for SDK ready state
+   */
+  ready(callback: ApiCallback): void;
+
+  /**
+   * To record a page view event
+   */
+  page: AnalyticsPageMethod;
+
+  /**
+   * To record a user track event
+   */
+  track: AnalyticsTrackMethod;
+
+  /**
+   * To record a user identification event
+   */
+  identify: AnalyticsIdentifyMethod;
+
+  /**
+   * To record a user alias event
+   */
+  alias: AnalyticsAliasMethod;
+
+  /**
+   * To record a user group event
+   */
+  group: AnalyticsGroupMethod;
+
+  /**
+   * Clear user information
+   *
+   * @param resetAnonymousId optionally clears anonymousId as well
+   */
+  reset(resetAnonymousId?: boolean): void;
+
+  /**
+   * To get anonymousId set in the SDK
+   *
+   * @param options options for anonymousId
+   */
+  getAnonymousId(options?: AnonymousIdOptions): string | undefined;
+
+  /**
+   * To set anonymousId
+   *
+   * @param anonymousId custom anonymousId value
+   * @param rudderAmpLinkerParam AMP Linker ID string
+   */
+  setAnonymousId(anonymousId?: string, rudderAmpLinkerParam?: string): void;
+
+  /**
+   * To get userId set in the SDK
+   */
+  getUserId(): Nullable<string> | undefined;
+
+  /**
+   * To get user traits set in the SDK
+   */
+  getUserTraits(): Nullable<ApiObject> | undefined;
+
+  /**
+   * To get groupId set in the SDK
+   */
+  getGroupId(): Nullable<string> | undefined;
+
+  /**
+   * To get group traits set in the SDK
+   */
+  getGroupTraits(): Nullable<ApiObject> | undefined;
+
+  /**
+   * To manually start user session in the SDK
+   */
+  startSession(sessionId?: number): void;
+
+  /**
+   * To manually end user session in the SDK
+   */
+  endSession(): void;
+
+  /**
+   * To set authorization token
+   * @param token token value
+   */
+  setAuthToken(token: string): void;
+
+  /**
+   * To fetch the current sessionId
+   */
+  getSessionId(): Nullable<number>;
+
+  /**
+   * To provide consent
+   * @param options Consent API options
+   */
+  consent(options?: ConsentOptions): void;
+}

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

@@ -0,0 +1,18 @@
+import type { ApiObject } from './ApiObject';
+
+export type DestinationIntgConfig = boolean | undefined | ApiObject;
+
+/**
+ * Represents the integration options object
+ * Example usages:
+ * integrationOptions { All: false, "Google Analytics": true, "Braze": true}
+ * integrationOptions { All: true, "Chartbeat": false, "Customer.io": false}
+ * integrationOptions { All: true, "GA4": { "clientId": "1234" }, "Google Analytics": false }
+ */
+export type IntegrationOpts = {
+  // Defaults to true
+  // If set to false, specific integration should be set to true to send the event
+  All?: boolean;
+  // Destination name: true/false/integration specific information
+  [index: string]: DestinationIntgConfig;
+};

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

@@ -0,0 +1,159 @@
+import type { LogLevel } from './Logger';
+import type { ResidencyServerRegion } from './DataResidency';
+import type { Nullable } from './Nullable';
+import type { PluginName } from './PluginsManager';
+import type { IntegrationOpts } from './Integration';
+import type { ApiOptions } from './EventApi';
+import type { ConsentManagementOptions } from './Consent';
+import type { ApiObject } from './ApiObject';
+import type { StorageOpts, CookieSameSite } from './Storage';
+
+export type UaChTrackLevel = 'none' | 'default' | 'full';
+
+/**
+ * Represents the options parameter for anonymousId
+ */
+export type AnonymousIdOptions = {
+  autoCapture?: {
+    enabled?: boolean;
+    source?: string;
+  };
+};
+
+export type SessionOpts = {
+  autoTrack?: boolean; // Defaults to true
+  timeout?: number; // Defaults to 30 minutes
+};
+
+export type EventMapping = {
+  from: string;
+  to: string;
+};
+
+export type Conversion = {
+  conversionLabel: string;
+  name: string;
+};
+
+export type EventFilteringOption = 'disable' | 'whitelistedEvents' | 'blacklistedEvents';
+
+/**
+ * Represents the beacon queue options parameter in loadOptions type
+ */
+export type BeaconQueueOpts = {
+  // Maximum number of events in storage
+  maxItems?: number;
+  // Time in milliseconds to flush the queue automatically
+  flushQueueInterval?: number;
+};
+
+export type EventsTransportMode = 'xhr' | 'beacon';
+
+export type BatchOpts = {
+  // Whether to enable batching
+  enabled: boolean;
+  // Maximum number of events in a batch
+  maxItems?: number;
+  // Maximum size of a batch request in bytes
+  maxSize?: number;
+  // Time in milliseconds to flush the queue automatically
+  flushInterval?: number;
+};
+
+/**
+ * Represents the queue options parameter in loadOptions type
+ */
+export type QueueOpts = {
+  // Upper cap on maximum delay for an event
+  maxRetryDelay?: number;
+  // Minimum delay before sending an event
+  minRetryDelay?: number;
+  // Exponential base
+  backoffFactor?: number;
+  // Jitter to be applied to the delay
+  backoffJitter?: number;
+  // Maximum number of attempts
+  maxAttempts?: number;
+  // Maximum number of events/events batch in storage
+  maxItems?: number;
+  // Options for batched requests
+  batch?: BatchOpts;
+};
+
+/**
+ * Represents the destinations queue options parameter in loadOptions type
+ */
+export type DestinationsQueueOpts = {
+  maxItems?: number;
+};
+
+export type OnLoadedCallback = (analytics: any) => void;
+
+export type DeliveryType = 'immediate' | 'buffer';
+
+export type StorageStrategy = 'none' | 'session' | 'anonymousId';
+
+export type PreConsentStorageOptions = {
+  strategy: StorageStrategy;
+};
+
+export type PreConsentEventsOptions = {
+  delivery: DeliveryType;
+};
+
+export type PreConsentOptions = {
+  enabled: boolean;
+  storage?: PreConsentStorageOptions;
+  events?: PreConsentEventsOptions;
+};
+
+/**
+ * Represents the options parameter in the load API
+ */
+export type LoadOptions = {
+  logLevel?: LogLevel; // defaults to ERROR
+  integrations?: IntegrationOpts; // defaults to { All : true }
+  configUrl?: string; // defaults to https://api.rudderstack.com
+  queueOptions?: QueueOpts;
+  loadIntegration?: boolean; // defaults to true.
+  sessions?: SessionOpts;
+  secureCookie?: boolean; // defaults to false.
+  destSDKBaseURL?: string; // defaults to https://cdn.rudderlabs.com/latest/v3/modern/js-integrations
+  pluginsSDKBaseURL?: string; // defaults to https://cdn.rudderlabs.com/latest/v3/modern/plugins
+  useBeacon?: boolean; // defaults to false.
+  beaconQueueOptions?: BeaconQueueOpts;
+  destinationsQueueOptions?: DestinationsQueueOpts;
+  anonymousIdOptions?: AnonymousIdOptions;
+  setCookieDomain?: string; // defaults to current domain.
+  sameSiteCookie?: CookieSameSite; // defaults to Lax.
+  lockIntegrationsVersion?: boolean; // defaults to false.
+  polyfillIfRequired?: boolean; // defaults to true. Controls whether the SDK should polyfill unsupported browser API's if they are detected as missing
+  onLoaded?: OnLoadedCallback;
+  uaChTrackLevel?: UaChTrackLevel;
+  residencyServer?: ResidencyServerRegion;
+  // TODO: define type for sourceConfig once the trimmed response is implemented
+  getSourceConfig?: () => string | ApiObject | Promise<ApiObject> | Promise<string>;
+  sendAdblockPage?: boolean;
+  sendAdblockPageOptions?: ApiOptions;
+  plugins?: Nullable<PluginName[]>;
+  polyfillURL?: string;
+  useGlobalIntegrationsConfigInEvents?: boolean;
+  bufferDataPlaneEventsUntilReady?: boolean;
+  dataPlaneEventsBufferTimeout?: number;
+  storage?: StorageOpts;
+  preConsent?: PreConsentOptions;
+  // transport mechanism to be used for sending batched requests
+  transportMode?: EventsTransportMode; // Unused for now. This will deprecate the useBeacon and beaconQueueOptions
+  consentManagement?: ConsentManagementOptions;
+  sameDomainCookiesOnly?: boolean;
+  externalAnonymousIdCookieName?: string;
+};
+
+export type ConsentOptions = {
+  storage?: StorageOpts;
+  consentManagement?: ConsentManagementOptions;
+  integrations?: IntegrationOpts;
+  discardPreConsentEvents?: boolean;
+  sendPageEvent?: boolean;
+  trackConsent?: boolean;
+};

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

@@ -0,0 +1,19 @@
+export type LoggerProvider = Record<
+  Exclude<Lowercase<LogLevel>, Lowercase<'NONE'>>,
+  (...data: any[]) => void
+>;
+
+export interface ILogger {
+  minLogLevel: number;
+  scope?: string;
+  logProvider: LoggerProvider;
+  log(...data: any[]): void;
+  info(...data: any[]): void;
+  debug(...data: any[]): void;
+  warn(...data: any[]): void;
+  error(...data: any[]): void;
+  setScope(scopeVal: string): void;
+  setMinLogLevel(logLevel: LogLevel): void;
+}
+
+export type LogLevel = 'LOG' | 'INFO' | 'DEBUG' | 'WARN' | 'ERROR' | 'NONE';

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

@@ -0,0 +1 @@
+export type Nullable<T> = T | null;

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

@@ -0,0 +1,41 @@
+import type { Nullable } from './Nullable';
+
+export interface ExtensionPoint {
+  [lifeCycleName: string]: (...args: any[]) => unknown;
+}
+
+/**
+ * ExtensionPoint can be nested, e.g. 'sdk.initialize.phase1'
+ * When index signature is provided, every key have to match the type, the types
+ * for 'name', 'deps',  and 'initialize' is added as index signature.
+ */
+export interface ExtensionPlugin {
+  name: string;
+  initialize?: (state?: any) => void;
+  deps?: string[];
+  [key: string]:
+    | string
+    | (() => void)
+    | ExtensionPoint
+    | ((...args: any[]) => unknown | void)
+    | string[]
+    | undefined;
+}
+
+export type PluginEngineConfig = {
+  throws?: boolean | RegExp;
+};
+
+export interface IPluginEngine {
+  plugins: ExtensionPlugin[];
+  byName: Record<string, ExtensionPlugin>;
+  cache: Record<string, ExtensionPlugin[]>;
+  config: PluginEngineConfig;
+  register: (plugin: ExtensionPlugin, state?: Record<string, any>) => void;
+  unregister: (name: string) => void;
+  getPlugin: (name: string) => ExtensionPlugin | undefined;
+  getPlugins: (extPoint?: string) => ExtensionPlugin[];
+  invoke: <T = any>(extPoint?: string, allowMultiple?: boolean, ...args: any[]) => Nullable<T>[];
+  invokeSingle: <T = any>(extPoint?: string, ...args: any[]) => Nullable<T>;
+  invokeMultiple: <T = any>(extPoint?: string, ...args: any[]) => Nullable<T>[];
+}

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

@@ -0,0 +1,29 @@
+import type { ExtensionPlugin, IPluginEngine } from './PluginEngine';
+import type { Nullable } from './Nullable';
+
+export interface IPluginsManager {
+  engine: IPluginEngine;
+  init(): void;
+  attachEffects(): void;
+  setActivePlugins(): void;
+  invokeMultiple<T = any>(extPoint?: string, ...args: any[]): Nullable<T>[];
+  invokeSingle<T = any>(extPoint?: string, ...args: any[]): Nullable<T>;
+  register(plugins: ExtensionPlugin[]): void;
+}
+
+export type PluginName =
+  | 'BeaconQueue'
+  | 'Bugsnag'
+  | 'CustomConsentManager'
+  | 'DeviceModeDestinations'
+  | 'DeviceModeTransformation'
+  | 'ErrorReporting'
+  | 'ExternalAnonymousId'
+  | 'GoogleLinker'
+  | 'KetchConsentManager'
+  | 'NativeDestinationQueue'
+  | 'OneTrustConsentManager'
+  | 'StorageEncryption'
+  | 'StorageEncryptionLegacy'
+  | 'StorageMigrator'
+  | 'XhrQueue';

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

@@ -0,0 +1,8 @@
+export type SessionInfo = {
+  autoTrack?: boolean;
+  manualTrack?: boolean;
+  timeout?: number;
+  expiresAt?: number;
+  id?: number;
+  sessionStart?: boolean;
+};

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

@@ -0,0 +1,21 @@
+import type { RegionDetails, ResidencyServerRegion } from './DataResidency';
+
+export type StatsCollection = {
+  errors: {
+    enabled: boolean;
+    provider?: string;
+  };
+  metrics: {
+    enabled: boolean;
+  };
+};
+
+export type SourceConfig = {
+  statsCollection?: StatsCollection;
+};
+
+export type Source = {
+  id: string;
+  config?: SourceConfig;
+  dataplanes?: Record<ResidencyServerRegion, RegionDetails[]>;
+};

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

@@ -0,0 +1,49 @@
+import type { UserSessionKey } from './UserSessionStorage';
+
+export type StorageEncryptionVersion = 'legacy' | 'v3'; // default is v3
+
+export type StorageType =
+  | 'cookieStorage'
+  | 'localStorage'
+  | 'memoryStorage'
+  | 'sessionStorage'
+  | 'none';
+
+export const SUPPORTED_STORAGE_TYPES = [
+  'localStorage',
+  'memoryStorage',
+  'cookieStorage',
+  'sessionStorage',
+  'none',
+];
+
+export const DEFAULT_STORAGE_TYPE = 'cookieStorage';
+
+export type StorageEncryption = {
+  version: StorageEncryptionVersion;
+};
+
+export type LoadOptionStorageEntry = {
+  type: StorageType;
+};
+
+export type StorageOpts = {
+  encryption?: StorageEncryption;
+  migrate?: boolean;
+  type?: StorageType;
+  cookie?: CookieOptions;
+  entries?: {
+    [key in UserSessionKey]?: LoadOptionStorageEntry;
+  };
+};
+
+export type CookieOptions = {
+  maxage?: number;
+  expires?: Date;
+  path?: string;
+  domain?: string;
+  samesite?: string;
+  secure?: boolean;
+};
+
+export type CookieSameSite = 'Strict' | 'Lax' | 'None';

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

@@ -0,0 +1,82 @@
+import type { IErrorHandler } from './ErrorHandler';
+import type { ILogger } from './Logger';
+import type { IPluginsManager } from './PluginsManager';
+import type { Nullable } from './Nullable';
+import type { StorageType, CookieOptions, CookieSameSite } from './Storage';
+
+export type StoreId = string;
+
+export interface IStoreConfig {
+  name: string;
+  id: StoreId;
+  isEncrypted?: boolean;
+  validKeys?: Record<string, string>;
+  noCompoundKey?: boolean;
+  errorHandler?: IErrorHandler;
+  logger?: ILogger;
+  type?: StorageType;
+}
+
+export interface IStoreManager {
+  stores?: Record<StoreId, IStore>;
+  isInitialized?: boolean;
+  errorHandler?: IErrorHandler;
+  logger?: ILogger;
+  init(): void;
+  initializeStorageState(): void;
+  setStore(storeConfig: IStoreConfig): IStore;
+  getStore(id: StoreId): IStore | undefined;
+}
+
+export interface IStore {
+  id: string;
+  name: string;
+  isEncrypted: boolean;
+  validKeys: Record<string, string>;
+  engine: IStorage;
+  originalEngine: IStorage;
+  noKeyValidation?: boolean;
+  noCompoundKey?: boolean;
+  errorHandler?: IErrorHandler;
+  logger?: ILogger;
+  pluginsManager?: IPluginsManager;
+  createValidKey(key: string): string | undefined;
+  swapQueueStoreToInMemoryEngine(): void;
+  set(key: string, value: any): void;
+  get<T = any>(key: string): Nullable<T>;
+  remove(key: string): void;
+  getOriginalEngine(): IStorage;
+  decrypt(value?: Nullable<string>): Nullable<string>;
+  encrypt(value: any): string;
+  crypto(value: string, mode: 'encrypt' | 'decrypt'): string;
+  onError(error: unknown): void;
+}
+
+export interface IStorage extends Storage {
+  configure?(options: StorageOptions): void;
+  isEnabled?: boolean;
+}
+
+export type StorageOptions = Partial<
+  ICookieStorageOptions | ILocalStorageOptions | IInMemoryStorageOptions
+>;
+
+export interface ICookieStorageOptions extends CookieOptions {
+  samesite?: CookieSameSite;
+  domain?: string;
+  secure?: boolean;
+  enabled?: boolean;
+  sameDomainCookiesOnly?: boolean;
+}
+
+export interface ILocalStorageOptions {
+  enabled?: boolean;
+}
+
+export interface IInMemoryStorageOptions {
+  enabled?: boolean;
+}
+
+export interface ISessionStorageOptions {
+  enabled?: boolean;
+}

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

@@ -0,0 +1,10 @@
+export type UserSessionKey =
+  | 'userId'
+  | 'userTraits'
+  | 'anonymousId'
+  | 'groupId'
+  | 'groupTraits'
+  | 'initialReferrer'
+  | 'initialReferringDomain'
+  | 'sessionInfo'
+  | 'authToken';