@mparticle/web-sdk 2.61.0 → 2.63.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.61.0",
+    "version": "2.63.0",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -12,6 +12,7 @@
         "dist/mparticle.common.js",
         "dist/mparticle.esm.js",
         "dist/mparticle.js",
+        "dist/types/",
         "src/"
     ],
     "publishConfig": {
@@ -21,9 +22,18 @@
     },
     "main": "dist/mparticle.common.js",
     "module": "dist/mparticle.esm.js",
+    "types": "dist/types/src/public-types.d.ts",
+    "typesVersions": {
+        "*": {
+            "internal": [
+                "dist/types/src/internal-types.d.ts"
+            ]
+        }
+    },
     "repository": "https://github.com/mParticle/mparticle-web-sdk",
     "scripts": {
-        "build": "cross-env ENVIRONMENT=prod BUILDALL=true rollup --config rollup.config.js",
+        "build": "cross-env ENVIRONMENT=prod BUILDALL=true rollup --config rollup.config.js && npm run build:types",
+        "build:types": "rm -rf dist/types && (tsc -p tsconfig.types.json || true) && test -f dist/types/src/public-types.d.ts && test -f dist/types/src/internal-types.d.ts",
         "build:cbt": "rollup --config test/cross-browser-testing/rollup.CBT.config.js",
         "build:dev": "cross-env ENVIRONMENT=dev BUILD=iife rollup --config rollup.config.js",
         "build:iife": "cross-env ENVIRONMENT=prod BUILD=iife rollup --config rollup.config.js",
@@ -148,6 +158,9 @@
         "webpack": "^5.36.2",
         "webpack-cli": "^5.0.2"
     },
+    "peerDependencies": {
+        "@mparticle/event-models": "^1.1.9"
+    },
     "dependencies": {
         "@babel/runtime": "^7.23.2"
     }

package/src/batchUploader.ts

@@ -333,6 +333,19 @@ export class BatchUploader {
                     entry[1],
                     mpInstance
                 );
+
+                if (uploadBatchObject) {
+                    try {
+                        mpInstance._Forwarders.sendBatchToForwarders(
+                            uploadBatchObject
+                        );
+                    } catch (e) {
+                        mpInstance.Logger.error(
+                            `Error forwarding batch to kits. ${e}`
+                        );
+                    }
+                }
+
                 const onCreateBatchCallback =
                     mpInstance._Store.SDKConfig.onCreateBatch;
 

package/src/forwarders.interfaces.ts

@@ -2,6 +2,8 @@ import { SDKEvent, SDKEventCustomFlags } from './sdkRuntimeModels';
 import { Dictionary } from './utils';
 import { IKitConfigs, IKitFilterSettings } from './configAPIClient';
 import { IdentityApiData, IdentityType } from '@mparticle/web-sdk';
+import { Batch } from '@mparticle/event-models';
+
 import {
     IMParticleUser,
     ISDKUserIdentity,
@@ -89,6 +91,46 @@ export interface ConfiguredKit
     hasSandbox: boolean;
 }
 
+export interface KitInterface {
+    id: number;
+    name: string;
+    init(
+        settings: Dictionary<unknown>,
+        service: forwardingStatsCallback,
+        testMode?: boolean,
+        trackerId?: string | null,
+        userAttributes?: UserAttributes,
+        userIdentities?: ISDKUserIdentity,
+        appVersion?: string,
+        appName?: string,
+        customFlags?: SDKEventCustomFlags,
+        clientId?: string
+    ): string;
+    onIdentifyComplete?(
+        user: IMParticleUser,
+        filteredIdentityRequest: IdentityApiData
+    ): string;
+    onLoginComplete?(
+        user: IMParticleUser,
+        filteredIdentityRequest: IdentityApiData
+    ): string;
+    onLogoutComplete?(
+        user: IMParticleUser,
+        filteredIdentityRequest: IdentityApiData
+    ): string;
+    onModifyComplete?(
+        user: IMParticleUser,
+        filteredIdentityRequest: IdentityApiData
+    ): string;
+    onUserIdentified?(user: IMParticleUser): string;
+    process?(event: SDKEvent): string;
+    processBatch?(batch: Batch): string;
+    setOptOut?(isOptingOut: boolean): string;
+    removeUserAttribute?(key: string): string;
+    setUserAttribute?(key: string, value: string): string;
+    setUserIdentity?(id: UserIdentityId, type: UserIdentityType): void;
+}
+
 export type UserIdentityId = string;
 export type UserIdentityType = number;
 export type UserAttributeFilters = number[];

package/src/forwarders.js

@@ -405,6 +405,34 @@ export default function Forwarders(mpInstance, kitBlocker) {
         }
     };
 
+    this.sendBatchToForwarders = function(batch) {
+        if (
+            mpInstance._Store.webviewBridgeEnabled ||
+            !mpInstance._Store.activeForwarders
+        ) {
+            return;
+        }
+
+        for (const forwarder of mpInstance._Store.activeForwarders) {
+            if (forwarder.processBatch) {
+                try {
+                    const batchCopy = mpInstance._Helpers.extend(
+                        true,
+                        {},
+                        batch
+                    );
+                    const result = forwarder.processBatch(batchCopy);
+
+                    if (result) {
+                        mpInstance.Logger.verbose(result);
+                    }
+                } catch (e) {
+                    mpInstance.Logger.verbose(e);
+                }
+            }
+        }
+    };
+
     this.handleForwarderUserAttributes = function(functionNameKey, key, value) {
         if (
             (kitBlocker && kitBlocker.isAttributeKeyBlocked(key)) ||
@@ -747,7 +775,6 @@ export default function Forwarders(mpInstance, kitBlocker) {
             config.filteringConsentRuleValues || {};
         newForwarder.excludeAnonymousUser =
             config.excludeAnonymousUser || false;
-
         return newForwarder;
     };
 

package/src/internal-types.ts

@@ -0,0 +1,66 @@
+/**
+ * Internal types for @mparticle/web-sdk
+ *
+ * These types are shared between mParticle and Rokt SDKs but are NOT part of
+ * the public API. They may change without notice between minor versions.
+ *
+ * Usage:
+ *   import type { IKitFilterSettings, IRoktKit, SDKProduct } from '@mparticle/web-sdk/internal';
+ *
+ * This entry point re-exports all public types so that internal consumers
+ * only need a single import path.
+ *
+ * Customers should NOT import from this path.
+ */
+
+// Re-export all public types so internal consumers have a single import path
+export * from './public-types';
+
+export type {
+    KitInterface,
+} from './forwarders.interfaces';
+
+// Rokt integration types
+export type {
+    RoktAttributeValue,
+    RoktAttributeValueType,
+    RoktAttributeValueArray,
+    RoktAttributes,
+    IRoktPartnerExtensionData,
+    IRoktSelectPlacementsOptions,
+    IRoktSelection,
+    IRoktLauncher,
+    IRoktMessage,
+    RoktKitFilterSettings,
+    IRoktKitSettings,
+    IRoktKit,
+    IRoktOptions,
+    IRoktLauncherOptions,
+} from './roktManager';
+
+// Reporting / Error types (type-only to avoid runtime mismatch with entry point)
+export type {
+    ErrorCodes,
+    WSDKErrorSeverity,
+} from './reporting/types';
+
+export type {
+    ISDKError,
+    ISDKLogEntry,
+    IErrorReportingService,
+    ILoggingService,
+} from './reporting/types';
+
+// SDK internals shared between kits
+export type {
+    SDKEvent,
+    SDKProductAction,
+    SDKProductActionType,
+    SDKPromotionAction,
+    SDKShoppingCart,
+    SDKGeoLocation,
+    SDKDataPlan,
+    SDKLoggerApi,
+    SDKConfigApi,
+    IMParticleInstanceManager,
+} from './sdkRuntimeModels';

package/src/public-types.ts

@@ -0,0 +1,84 @@
+/**
+ * Public types for @mparticle/web-sdk
+ *
+ * These types are part of the stable public API and are safe for customers
+ * to import. Only add types here that are intended for external consumption.
+ *
+ * Usage:
+ *   import type { SDKInitConfig, EventType } from '@mparticle/web-sdk';
+ *
+ * Note: Types from @types/mparticle__web-sdk (e.g., MPConfiguration, MPID,
+ * ConsentState) are NOT re-exported here to avoid circular references.
+ * Consumers get those automatically via DefinitelyTyped until they are
+ * natively defined in this SDK and the DT package is deprecated.
+ */
+
+// Re-export types from @mparticle/event-models
+// Consumers should not need to install @mparticle/event-models directly
+export type {
+    Batch,
+} from '@mparticle/event-models';
+
+// Enums / Constants (type-only to avoid runtime mismatch with entry point)
+export type {
+    EventType,
+    CommerceEventType,
+    IdentityType,
+    ProductActionType,
+    PromotionActionType,
+    MessageType,
+} from './types';
+
+// Configuration
+export type {
+    SDKInitConfig,
+    DataPlanConfig,
+    BaseEvent,
+    SDKEventCustomFlags,
+    LogLevelType,
+    MParticleWebSDK,
+} from './sdkRuntimeModels';
+
+// User & Identity
+export type {
+    IMParticleUser,
+    IdentityCallback,
+    IdentityResult,
+    IdentityResultBody,
+    IdentityModifyResultBody,
+    ISDKUserIdentity,
+    ISDKUserAttributes,
+} from './identity-user-interfaces';
+
+export type {
+    SDKIdentityApi,
+    IAliasRequest,
+    IAliasCallback,
+    IAliasResult,
+    SDKIdentityTypeEnum,
+} from './identity.interfaces';
+
+// eCommerce
+export type {
+    SDKECommerceAPI,
+    SDKCart,
+} from './ecommerce.interfaces';
+
+export type {
+    SDKProduct,
+    SDKPromotion,
+    SDKImpression,
+    SDKProductImpression,
+} from './sdkRuntimeModels';
+
+// Consent
+export type {
+    SDKConsentApi,
+    SDKConsentState,
+    SDKConsentStateData,
+    SDKGDPRConsentState,
+    SDKCCPAConsentState,
+} from './consent';
+
+// Utilities
+export type { Dictionary, valueof } from './utils';

package/src/roktManager.ts

@@ -305,27 +305,39 @@ export default class RoktManager {
             }
             
             if (!isEmpty(newIdentities)) {
-                // Call identify with the new user identities
+                // Fire-and-forget identify — best-effort, does not block selectPlacements
                 try {
-                    await new Promise<void>((resolve, reject) => {
-                        this.identityService.identify({
+                    this.identityService.identify(
+                        {
                             userIdentities: {
                                 ...currentUserIdentities,
-                                ...newIdentities
+                                ...newIdentities,
+                            },
+                        },
+                        (result) => {
+                            const httpCode = Number(result?.httpCode);
+                            if (httpCode && (httpCode >= 400 || httpCode < 0)) {
+                                this.logger.error(
+                                    'Background identify failed with HTTP ' + httpCode
+                                );
                             }
-                        }, () => {
-                            resolve();
-                        });
-                    });
+                            // Drain any selectPlacements calls that were deferred while
+                            // identify was in-flight. By the time this callback fires,
+                            // identityCallInFlight has already been reset to false.
+                            this.processMessageQueue();
+                        }
+                    );
                 } catch (error) {
                     const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-                    this.logger.error('Failed to identify user with updated identities: ' + errorMessage);
+                    this.logger.error('Background identify threw an error: ' + errorMessage);
                 }
             }
-            
-            // Refresh current user identities to ensure we have the latest values before building enrichedAttributes
-            this.currentUser = this.identityService.getCurrentUser();
-            const finalUserIdentities = this.currentUser?.getUserIdentities()?.userIdentities || {};
+
+            // Optimistic merge: apply the pending identity changes locally so
+            // enrichedAttributes are correct without waiting for the identify round-trip.
+            // The next call to selectPlacements re-fetches currentUser (see line above),
+            // so stale identity state does not persist beyond this invocation.
+            const finalUserIdentities = { ...currentUserIdentities, ...newIdentities };
 
             this.setUserAttributes(mappedAttributes);