@rudderstack/analytics-js 3.12.0 → 3.14.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [3.14.0](https://github.com/rudderlabs/rudder-sdk-js/compare/@rudderstack/analytics-js@3.13.0...@rudderstack/analytics-js@3.14.0) (2025-01-31)
+
+### Dependency Updates
+
+* `@rudderstack/analytics-js-cookies` updated to version `0.4.20`
+* `@rudderstack/analytics-js-common` updated to version `3.16.0`
+* `@rudderstack/analytics-js-plugins` updated to version `3.7.0`
+
+### Features
+
+* move error reporting functionality to the core module ([#2011](https://github.com/rudderlabs/rudder-sdk-js/issues/2011)) ([78c50c7](https://github.com/rudderlabs/rudder-sdk-js/commit/78c50c7a6e4169560f3182be93148f4512d313ca)), closes [#2001](https://github.com/rudderlabs/rudder-sdk-js/issues/2001) [#2002](https://github.com/rudderlabs/rudder-sdk-js/issues/2002) [#2005](https://github.com/rudderlabs/rudder-sdk-js/issues/2005) [#2006](https://github.com/rudderlabs/rudder-sdk-js/issues/2006) [#2007](https://github.com/rudderlabs/rudder-sdk-js/issues/2007)
+
+## [3.13.0](https://github.com/rudderlabs/rudder-sdk-js/compare/@rudderstack/analytics-js@3.12.0...@rudderstack/analytics-js@3.13.0) (2025-01-28)
+
+
+### Features
+
+* lock plugins and integrations versions for npm package ([#2020](https://github.com/rudderlabs/rudder-sdk-js/issues/2020)) ([447e524](https://github.com/rudderlabs/rudder-sdk-js/commit/447e524dd1ee5782e6d7a8e834c03c57ebf3c196))
+
 ## [3.12.0](https://github.com/rudderlabs/rudder-sdk-js/compare/@rudderstack/analytics-js@3.11.17...@rudderstack/analytics-js@3.12.0) (2025-01-24)
 
 ### Dependency Updates

package/dist/npm/index.d.cts

@@ -1,3 +1,5 @@
+import { Event } from '@bugsnag/js';
+
 type LoggerProvider$1 = Record<Exclude<Lowercase<LogLevel>, Lowercase<'NONE'>>, (...data: any[]) => void>;
 interface ILogger {
     minLogLevel: number;
@@ -125,9 +127,20 @@ interface IPluginsManager {
     invokeSingle<T = any>(extPoint?: string, ...args: any[]): Nullable<T>;
     register(plugins: ExtensionPlugin[]): void;
 }
-type PluginName = 'BeaconQueue' | 'Bugsnag' | 'CustomConsentManager' | 'DeviceModeDestinations' | 'DeviceModeTransformation' | 'ErrorReporting' | 'ExternalAnonymousId' | 'GoogleLinker' | 'IubendaConsentManager' | 'KetchConsentManager' | 'NativeDestinationQueue' | 'OneTrustConsentManager' | 'StorageEncryption' | 'StorageEncryptionLegacy' | 'StorageMigrator' | 'XhrQueue';
+type PluginName = 'BeaconQueue' | 'CustomConsentManager' | 'DeviceModeDestinations' | 'DeviceModeTransformation' | 'ExternalAnonymousId' | 'GoogleLinker' | 'IubendaConsentManager' | 'KetchConsentManager' | 'NativeDestinationQueue' | 'OneTrustConsentManager' | 'StorageEncryption' | 'StorageEncryptionLegacy' | 'StorageMigrator' | 'XhrQueue';
 
+type OneTrustCookieCategory = {
+    oneTrustCookieCategory: string;
+};
+type ConsentManagementMetadata = {
+    providers: ConsentManagementProviderMetadata[];
+};
+type ConsentManagementProviderMetadata = {
+    provider: ConsentManagementProvider;
+    resolutionStrategy: ConsentResolutionStrategy;
+};
 type ConsentManagementProvider = 'iubenda' | 'oneTrust' | 'ketch' | 'custom';
+type ConsentResolutionStrategy = 'and' | 'or';
 type Consents = string[];
 type ConsentManagementOptions = {
     enabled?: boolean;
@@ -135,6 +148,12 @@ type ConsentManagementOptions = {
     allowedConsentIds?: Consents;
     deniedConsentIds?: Consents;
 };
+type KetchConsentPurpose = {
+    purpose: string;
+};
+type IubendaConsentPurpose = {
+    purpose: string;
+};
 
 type UserSessionKey = 'userId' | 'userTraits' | 'anonymousId' | 'groupId' | 'groupTraits' | 'initialReferrer' | 'initialReferringDomain' | 'sessionInfo' | 'authToken';
 
@@ -179,6 +198,15 @@ type SessionOpts = {
     autoTrack?: boolean;
     timeout?: number;
 };
+type EventMapping = {
+    from: string;
+    to: string;
+};
+type Conversion = {
+    conversionLabel: string;
+    name: string;
+};
+type EventFilteringOption = 'disable' | 'whitelistedEvents' | 'blacklistedEvents';
 /**
  * Represents the beacon queue options parameter in loadOptions type
  */
@@ -521,61 +549,13 @@ type RudderAnalyticsPreloader = {
     [index: string]: (...args: any[]) => any;
 };
 
-/**
- * A buffer queue to serve as a store for any type of data
- */
-declare class BufferQueue<T = any> {
-    items: T[];
-    constructor();
-    enqueue(item: T): void;
-    dequeue(): Nullable<T> | undefined;
-    isEmpty(): boolean;
-    size(): number;
-    clear(): void;
-}
-//# sourceMappingURL=BufferQueue.d.ts.map
-
-interface IExternalSourceLoadConfig {
-    url: string;
-    id: string;
-    callback?(id?: string): unknown;
-    async?: boolean;
-    timeout?: number;
-    extraAttributes?: Record<string, string>;
-}
-interface IExternalSrcLoader {
-    errorHandler?: {
-        onError(error: unknown, context?: string, customMessage?: string, shouldAlwaysThrow?: boolean): void;
-        leaveBreadcrumb(breadcrumb: string): void;
-        notifyError(error: Error, errorState: ErrorState): void;
-    };
-    logger?: ILogger;
-    timeout: number;
-    loadJSFile(config: IExternalSourceLoadConfig): void;
-}
-
 type SDKError = unknown | Error | ErrorEvent | Event | PromiseRejectionEvent;
 interface IErrorHandler {
-    logger?: ILogger;
-    pluginEngine?: IPluginEngine;
-    errorBuffer: BufferQueue<PreLoadErrorData>;
-    init(httpClient: IHttpClient, externalSrcLoader: IExternalSrcLoader): void;
-    onError(error: SDKError, context?: string, customMessage?: string, shouldAlwaysThrow?: boolean, errorType?: string): void;
+    httpClient: IHttpClient;
+    logger: ILogger;
+    onError(error: SDKError, context?: string, customMessage?: string, errorType?: string): void;
     leaveBreadcrumb(breadcrumb: string): void;
-    notifyError(error: Error, errorState: ErrorState): void;
-    attachErrorListeners(): void;
 }
-type ErrorState = {
-    severity: string;
-    unhandled: boolean;
-    severityReason: {
-        type: string;
-    };
-};
-type PreLoadErrorData = {
-    error: SDKError;
-    errorState: ErrorState;
-};
 
 interface IRequestConfig {
     url: string;
@@ -604,9 +584,8 @@ interface IXHRRequestOptions {
 type HTTPClientMethod = 'get' | 'GET' | 'delete' | 'DELETE' | 'head' | 'HEAD' | 'options' | 'OPTIONS' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'purge' | 'PURGE' | 'link' | 'LINK' | 'unlink' | 'UNLINK';
 interface IHttpClient {
     errorHandler?: IErrorHandler;
-    logger?: ILogger;
+    logger: ILogger;
     basicAuthHeader?: string;
-    hasErrorHandler: boolean;
     getData<T = any>(config: IRequestConfig): Promise<{
         data: T | string | undefined;
         details?: ResponseDetails;
@@ -614,6 +593,22 @@ interface IHttpClient {
     getAsyncData<T = any>(config: IAsyncRequestConfig<T>): void;
     setAuthHeader(value: string, noBto?: boolean): void;
     resetAuthHeader(): void;
+    init(errorHandler: IErrorHandler): void;
+}
+
+interface IExternalSourceLoadConfig {
+    url: string;
+    id: string;
+    callback?(id?: string): unknown;
+    async?: boolean;
+    timeout?: number;
+    extraAttributes?: Record<string, string>;
+}
+interface IExternalSrcLoader {
+    errorHandler: IErrorHandler;
+    logger: ILogger;
+    timeout: number;
+    loadJSFile(config: IExternalSourceLoadConfig): void;
 }
 
 type StoreId = string;
@@ -623,15 +618,15 @@ interface IStoreConfig {
     isEncrypted?: boolean;
     validKeys?: Record<string, string>;
     noCompoundKey?: boolean;
-    errorHandler?: IErrorHandler;
-    logger?: ILogger;
+    errorHandler: IErrorHandler;
+    logger: ILogger;
     type?: StorageType;
 }
 interface IStoreManager {
     stores?: Record<StoreId, IStore>;
     isInitialized?: boolean;
-    errorHandler?: IErrorHandler;
-    logger?: ILogger;
+    errorHandler: IErrorHandler;
+    logger: ILogger;
     init(): void;
     initializeStorageState(): void;
     setStore(storeConfig: IStoreConfig): IStore;
@@ -646,9 +641,9 @@ interface IStore {
     originalEngine: IStorage;
     noKeyValidation?: boolean;
     noCompoundKey?: boolean;
-    errorHandler?: IErrorHandler;
-    logger?: ILogger;
-    pluginsManager?: IPluginsManager;
+    errorHandler: IErrorHandler;
+    logger: ILogger;
+    pluginsManager: IPluginsManager;
     createValidKey(key: string): string | undefined;
     swapQueueStoreToInMemoryEngine(): void;
     set(key: string, value: any): void;
@@ -712,6 +707,20 @@ type GroupCallOptions = {
     callback?: ApiCallback;
 };
 
+/**
+ * A buffer queue to serve as a store for any type of data
+ */
+declare class BufferQueue<T = any> {
+    items: T[];
+    constructor();
+    enqueue(item: T): void;
+    dequeue(): Nullable<T> | undefined;
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+}
+//# sourceMappingURL=BufferQueue.d.ts.map
+
 /**
  * Store Implementation with dedicated storage
  */
@@ -724,11 +733,10 @@ declare class Store implements IStore {
     originalEngine: IStorage;
     noKeyValidation?: boolean;
     noCompoundKey?: boolean;
-    errorHandler?: IErrorHandler;
-    hasErrorHandler: boolean;
-    logger?: ILogger;
-    pluginsManager?: IPluginsManager;
-    constructor(config: IStoreConfig, engine?: IStorage, pluginsManager?: IPluginsManager);
+    errorHandler: IErrorHandler;
+    logger: ILogger;
+    pluginsManager: IPluginsManager;
+    constructor(config: IStoreConfig, engine: IStorage, pluginsManager: IPluginsManager);
     /**
      * Ensure the key is valid and with correct format
      */
@@ -794,13 +802,142 @@ interface IUserSessionManager {
     setAuthToken(token: Nullable<string>): void;
 }
 
+type DestinationConnectionMode = 'hybrid' | 'cloud' | 'device';
+type DestinationEvent = {
+    eventName: string;
+};
+type ConsentsConfig = {
+    consent: string;
+};
+type ConsentManagementProviderConfig = {
+    provider: ConsentManagementProvider;
+    consents: ConsentsConfig[];
+    resolutionStrategy: string | undefined;
+};
+type DestinationConfig = {
+    blacklistedEvents: DestinationEvent[];
+    whitelistedEvents: DestinationEvent[];
+    iubendaConsentPurposes?: IubendaConsentPurpose[];
+    oneTrustCookieCategories?: OneTrustCookieCategory[];
+    ketchConsentPurposes?: KetchConsentPurpose[];
+    consentManagement?: ConsentManagementProviderConfig[];
+    eventFilteringOption: EventFilteringOption;
+    clickEventConversions?: Conversion[];
+    pageLoadConversions?: Conversion[];
+    conversionID?: string;
+    conversionLinker?: boolean;
+    disableAdPersonalization?: boolean;
+    dynamicRemarketing?: boolean;
+    sendPageView?: boolean;
+    defaultPageConversion?: string;
+    enableConversionEventsFiltering?: boolean;
+    trackConversions?: boolean;
+    trackDynamicRemarketing?: boolean;
+    tagID?: string;
+    advertiserId?: string;
+    partnerId?: string;
+    measurementId?: string;
+    capturePageView?: string;
+    useNativeSDKToSend?: boolean;
+    connectionMode?: DestinationConnectionMode;
+    extendPageViewParams?: boolean;
+    eventMappingFromConfig?: EventMapping[];
+    appKey?: string;
+    dataCenter?: string;
+    enableBrazeLogging?: boolean;
+    enableNestedArrayOperations?: boolean;
+    enableSubscriptionGroupInGroupCall?: boolean;
+    supportDedup?: boolean;
+    trackAnonymousUser?: boolean;
+    serverUrl?: string;
+    containerID?: string;
+    fs_debug_mode?: boolean;
+    fs_org?: boolean;
+    siteID?: string;
+    [key: string]: any;
+};
+
+type StatsCollection = {
+    errors: {
+        enabled: boolean;
+        provider?: string;
+    };
+    metrics: {
+        enabled: boolean;
+    };
+};
+
+type DestinationDefinition = {
+    name: string;
+    displayName: string;
+    updatedAt: string;
+};
+type ConfigResponseDestinationItem = {
+    shouldApplyDeviceModeTransformation: boolean;
+    propagateEventsUntransformedOnError: boolean;
+    config: DestinationConfig;
+    updatedAt: string;
+    deleted: boolean;
+    destinationDefinition: DestinationDefinition;
+    enabled: boolean;
+    id: string;
+    name: string;
+};
+type Connection = {
+    createdAt: string;
+    deleted: boolean;
+    destinationId: string;
+    enabled: boolean;
+    id: string;
+    sourceId: string;
+    updatedAt: string;
+};
+type SourceDefinition = {
+    category: Nullable<any>;
+    config: Nullable<any>;
+    configSchema: Nullable<any>;
+    createdAt: string;
+    displayName: string;
+    id: string;
+    name: string;
+    options: Nullable<any>;
+    uiConfig: Nullable<any>;
+    updatedAt: string;
+};
+type SourceConfigResponse = {
+    consentManagementMetadata?: ConsentManagementMetadata;
+    source: {
+        destinations: ConfigResponseDestinationItem[];
+        sourceDefinitionId: string;
+        transient: boolean;
+        updatedAt: string;
+        workspaceId: string;
+        writeKey: string;
+        enabled: boolean;
+        id: string;
+        liveEventsConfig: {
+            eventUpload: boolean;
+            eventUploadTS: number;
+        };
+        name: string;
+        secretVersion: Nullable<string>;
+        sourceDefinition: SourceDefinition;
+        config: {
+            statsCollection: StatsCollection;
+        };
+        connections: Connection[];
+        createdAt: string;
+        createdBy: string;
+        deleted: boolean;
+    };
+};
 interface IConfigManager {
     httpClient: IHttpClient;
-    errorHandler?: IErrorHandler;
-    logger?: ILogger;
+    errorHandler: IErrorHandler;
+    logger: ILogger;
     init: () => void;
     getConfig: () => void;
-    processConfig: () => void;
+    processConfig: (response: SourceConfigResponse | string | undefined, details?: ResponseDetails) => void;
 }
 
 interface IEventManager {
@@ -810,8 +947,9 @@ interface IEventManager {
 }
 
 interface ICapabilitiesManager {
-    logger?: ILogger;
-    errorHandler?: IErrorHandler;
+    httpClient: IHttpClient;
+    errorHandler: IErrorHandler;
+    logger: ILogger;
     externalSrcLoader: IExternalSrcLoader;
     init(): void;
     detectBrowserCapabilities(): void;