@mparticle/web-sdk 2.60.1 → 2.62.0

package/dist/types/src/mp-instance.d.ts

@@ -0,0 +1,76 @@
+import { IAPIClient } from './apiClient';
+import { ICookieSyncManager } from './cookieSyncManager';
+import { ISessionManager } from './sessionManager';
+import { IStore } from './store';
+import { IServerModel } from './serverModel';
+import ForwardingStatsUploader from './forwardingStatsUploader';
+import { IConsent } from './consent';
+import IdentityAPIClient from './identityApiClient';
+import IntegrationCapture from './integrationCapture';
+import { IPreInit } from './pre-init-utils';
+import { MParticleWebSDK, SDKHelpersApi } from './sdkRuntimeModels';
+import { Dictionary } from '@mparticle/web-sdk';
+import { IIdentity } from './identity.interfaces';
+import { IEvents } from './events.interfaces';
+import { IECommerce } from './ecommerce.interfaces';
+import { INativeSdkHelpers } from './nativeSdkHelpers.interfaces';
+import { IPersistence } from './persistence.interfaces';
+import ForegroundTimer from './foregroundTimeTracker';
+import RoktManager from './roktManager';
+import { ICookieConsentManager } from './cookieConsentManager';
+import { ErrorReportingDispatcher } from './reporting/errorReportingDispatcher';
+import { LoggingDispatcher } from './reporting/loggingDispatcher';
+export interface IErrorLogMessage {
+    message?: string;
+    name?: string;
+    stack?: string;
+}
+export interface IErrorLogMessageMinified {
+    m?: string;
+    s?: string;
+    t?: string;
+}
+export type IntegrationDelays = Dictionary<boolean>;
+export interface IMParticleWebSDKInstance extends MParticleWebSDK {
+    _APIClient: IAPIClient;
+    _Consent: IConsent;
+    _CookieSyncManager: ICookieSyncManager;
+    _Ecommerce: IECommerce;
+    _Events: IEvents;
+    _Forwarders: any;
+    _ForwardingStatsUploader: ForwardingStatsUploader;
+    _Helpers: SDKHelpersApi;
+    _Identity: IIdentity;
+    _IdentityAPIClient: typeof IdentityAPIClient;
+    _IntegrationCapture: IntegrationCapture;
+    _NativeSdkHelpers: INativeSdkHelpers;
+    _Persistence: IPersistence;
+    _CookieConsentManager: ICookieConsentManager;
+    _ErrorReportingDispatcher: ErrorReportingDispatcher;
+    _LoggingDispatcher: LoggingDispatcher;
+    _RoktManager: RoktManager;
+    _SessionManager: ISessionManager;
+    _ServerModel: IServerModel;
+    _Store: IStore;
+    _instanceName: string;
+    _preInit: IPreInit;
+    _timeOnSiteTimer: ForegroundTimer;
+    setLauncherInstanceGuid: () => void;
+    getLauncherInstanceGuid: () => string;
+    captureTiming(metricName: string): any;
+    processQueueOnIdentityFailure?: () => void;
+    processQueueOnNoFunctional?: () => void;
+}
+/**
+ * <p>All of the following methods can be called on the primary mParticle class. In version 2.10.0, we introduced <a href="https://docs.mparticle.com/developers/sdk/web/multiple-instances/">multiple instances</a>. If you are using multiple instances (self hosted environments only), you should call these methods on each instance.</p>
+ * <p>In current versions of mParticle, if your site has one instance, that instance name is 'default_instance'. Any methods called on mParticle on a site with one instance will be mapped to the `default_instance`.</p>
+ * <p>This is for simplicity and backwards compatibility. For example, calling mParticle.logPageView() automatically maps to mParticle.getInstance('default_instance').logPageView().</p>
+ * <p>If you have multiple instances, instances must first be initialized and then a method can be called on that instance. For example:</p>
+ * <code>
+ *  mParticle.init('apiKey', config, 'another_instance');
+ *  mParticle.getInstance('another_instance').logPageView();
+ * </code>
+ *
+ * @class mParticle & mParticleInstance
+ */
+export default function mParticleInstance(this: IMParticleWebSDKInstance, instanceName: string): void;

package/dist/types/src/mparticle-instance-manager.d.ts

@@ -0,0 +1,2 @@
+declare const mParticleManager: any;
+export default mParticleManager;

package/dist/types/src/nativeSdkHelpers.d.ts

@@ -0,0 +1,12 @@
+export default function NativeSdkHelpers(mpInstance: any): void;
+export default class NativeSdkHelpers {
+    constructor(mpInstance: any);
+    initializeSessionAttributes: (apiKey: any) => void;
+    isBridgeV2Available: (bridgeName: any) => boolean;
+    isWebviewEnabled: (requiredWebviewBridgeName: any, minWebviewBridgeVersion: any) => any;
+    isBridgeV1Available: () => boolean;
+    sendToNative: (path: any, value: any) => void;
+    sendViaBridgeV1: (path: any, value: any) => void;
+    sendViaIframeToIOS: (path: any, value: any) => void;
+    sendViaBridgeV2: (path: any, value: any, requiredWebviewBridgeName: any) => void;
+}

package/dist/types/src/nativeSdkHelpers.interfaces.d.ts

@@ -0,0 +1,10 @@
+export interface INativeSdkHelpers {
+    initializeSessionAttributes: (apiKey: string) => void;
+    isBridgeV2Available: (bridgeName: string) => boolean;
+    isWebviewEnabled: (requiredWebviewBridgeName: string, minWebviewBridgeVersion: number) => boolean;
+    isBridgeV1Available: () => boolean;
+    sendToNative: (path: string, value?: string) => void;
+    sendViaBridgeV1: (path: string, value: string) => void;
+    sendViaIframeToIOS: (path: string, value: string) => void;
+    sendViaBridgeV2: (path: string, value: string, requiredWebviewBridgeName: boolean) => void;
+}

package/dist/types/src/persistence.d.ts

@@ -0,0 +1,44 @@
+export default function _Persistence(mpInstance: any): void;
+export default class _Persistence {
+    constructor(mpInstance: any);
+    useLocalStorage: () => any;
+    initializeStorage: () => void;
+    update: () => void;
+    storeDataInMemory: (obj: any, currentMPID: any) => void;
+    determineLocalStorageAvailability: (storage: any) => any;
+    setLocalStorage: () => void;
+    getLocalStorage: () => {};
+    expireCookies: (cookieName: any) => void;
+    getCookie: () => any;
+    setCookie: () => void;
+    reduceAndEncodePersistence: (persistence: any, expires: any, domain: any, maxCookieSize: any) => string;
+    findPrevCookiesBasedOnUI: (identityApiData: any) => void;
+    encodePersistence: (persistence: any) => string;
+    decodePersistence: (persistence: any) => string;
+    getCookieDomain: () => any;
+    getDomain: (doc: any, locationHostname: any) => any;
+    saveUserCookieSyncDatesToPersistence: (mpid: any, csd: any) => void;
+    swapCurrentUser: (previousMPID: any, currentMPID: any, currentSessionMPIDs: any) => void;
+    savePersistence: (persistence: any) => void;
+    getPersistence: () => any;
+    getFirstSeenTime: (mpid: any) => any;
+    /**
+     * set the "first seen" time for a user. the time will only be set once for a given
+     * mpid after which subsequent calls will be ignored
+     */
+    setFirstSeenTime: (mpid: any, time: any) => void;
+    /**
+     * returns the "last seen" time for a user. If the mpid represents the current user, the
+     * return value will always be the current time, otherwise it will be to stored "last seen"
+     * time
+     */
+    getLastSeenTime: (mpid: any) => any;
+    setLastSeenTime: (mpid: any, time: any) => void;
+    getDeviceId: () => any;
+    setDeviceId: (guid: any) => void;
+    resetPersistence: () => void;
+    forwardingStatsBatches: {
+        uploadsTable: {};
+        forwardingStatsEventQueue: any[];
+    };
+}

package/dist/types/src/persistence.interfaces.d.ts

@@ -0,0 +1,73 @@
+import { Context } from '@mparticle/event-models';
+import { IdentityApiData, MPID, Product, UserIdentities } from '@mparticle/web-sdk';
+import { IForwardingStatsData } from './apiClient';
+import { IntegrationAttributes, ServerSettings, SessionAttributes, LocalSessionAttributes } from './store';
+import { Dictionary } from './utils';
+import { IMinifiedConsentJSONObject } from './consent';
+import { UserAttributes } from './identity-user-interfaces';
+import { CookieSyncDates } from './cookieSyncManager';
+export type UploadsTable = Dictionary<any>;
+export interface iForwardingStatsBatches {
+    uploadsTable: UploadsTable;
+    forwardingStatsEventQueue: IForwardingStatsData[];
+}
+export interface IGlobalStoreV2MinifiedKeys {
+    sid: string;
+    ie: boolean;
+    sa: SessionAttributes;
+    lsa?: LocalSessionAttributes;
+    ss: ServerSettings;
+    dt: string;
+    av: string;
+    cgid: string;
+    das: string;
+    ia: IntegrationAttributes;
+    c: Context;
+    csm: MPID[];
+    les: number;
+    ssd: number;
+}
+export interface IPersistenceMinified extends Dictionary {
+    cu: MPID;
+    gs: IGlobalStoreV2MinifiedKeys;
+    l: boolean;
+}
+export interface IUserPersistenceMinified extends Dictionary {
+    csd: CookieSyncDates;
+    con: IMinifiedConsentJSONObject;
+    ui: UserIdentities;
+    ua: UserAttributes;
+    cp: Product[];
+    fst: number;
+    lst: number;
+}
+export interface IPersistence {
+    useLocalStorage(): boolean;
+    initializeStorage(): void;
+    update(): void;
+    storeDataInMemory(obj: IPersistenceMinified, currentMPID: MPID): void;
+    determineLocalStorageAvailability(storage: Storage): boolean;
+    setLocalStorage(): void;
+    getLocalStorage(): IPersistenceMinified | null;
+    expireCookies(cookieName: string): void;
+    getCookie(): IPersistenceMinified | null;
+    setCookie(): void;
+    reduceAndEncodePersistence(persistence: IPersistenceMinified, expires: string, domain: string, maxCookieSize: number): string;
+    findPrevCookiesBasedOnUI(identityApiData: IdentityApiData): void;
+    encodePersistence(persistence: IPersistenceMinified): string;
+    decodePersistence(persistenceString: string): string;
+    getCookieDomain(): string;
+    getDomain(doc: string, locationHostname: string): string;
+    saveUserCookieSyncDatesToPersistence(mpid: MPID, csd: CookieSyncDates): void;
+    savePersistence(persistance: IPersistenceMinified): void;
+    getPersistence(): IPersistenceMinified;
+    getFirstSeenTime(mpid: MPID): string | null;
+    setFirstSeenTime(mpid: MPID, time: number): void;
+    getLastSeenTime(mpid: MPID): number | null;
+    setLastSeenTime(mpid: MPID, time: number): void;
+    getDeviceId(): string;
+    setDeviceId(guid: string): void;
+    resetPersistence(): void;
+    swapCurrentUser(previousMPID: MPID, currentMPID: MPID, currentSessionMPIDs?: MPID[]): void;
+    forwardingStatsBatches: iForwardingStatsBatches;
+}

package/dist/types/src/polyfill.d.ts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export function forEach(callback: any, thisArg: any, ...args: any[]): void;
+    export function map(callback: any, thisArg: any, ...args: any[]): any[];
+    export function filter(fun: any, ...args: any[]): any[];
+    export function isArray(arg: any): boolean;
+    export { Base64 };
+}
+export default _default;
+declare namespace Base64 {
+    let _keyStr: string;
+    function encode(input: any): string;
+    function _encode(input: any): string;
+    function decode(input: any): string;
+    function _decode(input: any): string;
+}

package/dist/types/src/pre-init-utils.d.ts

@@ -0,0 +1,11 @@
+import { IPixelConfiguration } from './cookieSyncManager';
+import { MPForwarder } from './forwarders.interfaces';
+import { IntegrationDelays } from './mp-instance';
+export interface IPreInit {
+    readyQueue: Function[] | any[];
+    integrationDelays: IntegrationDelays;
+    forwarderConstructors: MPForwarder[];
+    pixelConfigurations?: IPixelConfiguration[];
+    isDevelopmentMode?: boolean;
+}
+export declare const processReadyQueue: (readyQueue: any) => Function[];

package/dist/types/src/public-types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+export type { Batch, } from '@mparticle/event-models';
+export type { EventType, CommerceEventType, IdentityType, ProductActionType, PromotionActionType, MessageType, } from './types';
+export type { SDKInitConfig, DataPlanConfig, BaseEvent, SDKEventCustomFlags, LogLevelType, MParticleWebSDK, } from './sdkRuntimeModels';
+export type { IMParticleUser, IdentityCallback, IdentityResult, IdentityResultBody, IdentityModifyResultBody, ISDKUserIdentity, ISDKUserAttributes, } from './identity-user-interfaces';
+export type { SDKIdentityApi, IAliasRequest, IAliasCallback, IAliasResult, SDKIdentityTypeEnum, } from './identity.interfaces';
+export type { SDKECommerceAPI, SDKCart, } from './ecommerce.interfaces';
+export type { SDKProduct, SDKPromotion, SDKImpression, SDKProductImpression, } from './sdkRuntimeModels';
+export type { SDKConsentApi, SDKConsentState, SDKConsentStateData, SDKGDPRConsentState, SDKCCPAConsentState, } from './consent';
+export type { Dictionary, valueof } from './utils';

package/dist/types/src/reporting/errorReportingDispatcher.d.ts

@@ -0,0 +1,8 @@
+import { SDKLoggerApi } from '../sdkRuntimeModels';
+import { IErrorReportingService, ISDKError } from './types';
+export declare class ErrorReportingDispatcher implements IErrorReportingService {
+    private readonly services;
+    logger?: SDKLoggerApi;
+    register(service: IErrorReportingService): void;
+    report(error: ISDKError): void;
+}

package/dist/types/src/reporting/loggingDispatcher.d.ts

@@ -0,0 +1,8 @@
+import { SDKLoggerApi } from '../sdkRuntimeModels';
+import { ILoggingService, ISDKLogEntry } from './types';
+export declare class LoggingDispatcher implements ILoggingService {
+    private readonly services;
+    logger?: SDKLoggerApi;
+    register(service: ILoggingService): void;
+    log(entry: ISDKLogEntry): void;
+}

package/dist/types/src/reporting/types.d.ts

@@ -0,0 +1,37 @@
+import { valueof } from '../utils';
+export declare const ErrorCodes: {
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly UNHANDLED_EXCEPTION: "UNHANDLED_EXCEPTION";
+    readonly IDENTITY_REQUEST: "IDENTITY_REQUEST";
+    readonly IDENTITY_MISMATCH: "IDENTITY_MISMATCH";
+    readonly ROKT_KIT_ATTACHED: "ROKT_KIT_ATTACHED";
+};
+export type ErrorCodes = valueof<typeof ErrorCodes>;
+export declare const WSDKErrorSeverity: {
+    readonly ERROR: "ERROR";
+    readonly INFO: "INFO";
+    readonly WARNING: "WARNING";
+};
+export type WSDKErrorSeverity = (typeof WSDKErrorSeverity)[keyof typeof WSDKErrorSeverity];
+/** Structured error object for reporting. */
+export interface ISDKError {
+    message: string;
+    code?: ErrorCodes;
+    severity: WSDKErrorSeverity;
+    stackTrace?: string;
+    additionalInformation?: Record<string, string>;
+}
+/** Structured log entry for informational logging. */
+export interface ISDKLogEntry {
+    message: string;
+    code?: ErrorCodes;
+    additionalInformation?: Record<string, string>;
+}
+/** Contract for error/warning reporting services. */
+export interface IErrorReportingService {
+    report(error: ISDKError): void;
+}
+/** Contract for informational logging services. */
+export interface ILoggingService {
+    log(entry: ISDKLogEntry): void;
+}

package/dist/types/src/roktManager.d.ts

@@ -0,0 +1,176 @@
+import { IKitConfigs } from "./configAPIClient";
+import { UserAttributeFilters } from "./forwarders.interfaces";
+import { IMParticleUser } from "./identity-user-interfaces";
+import { Dictionary, AttributeValue } from "./utils";
+import { SDKIdentityApi } from "./identity.interfaces";
+import { SDKLoggerApi } from "./sdkRuntimeModels";
+import { IStore, LocalSessionAttributes } from "./store";
+import { IErrorReportingService, ILoggingService } from "./reporting/types";
+export type RoktAttributeValueArray = Array<string | number | boolean>;
+export type RoktAttributeValueType = string | number | boolean | undefined | null;
+export type RoktAttributeValue = RoktAttributeValueType | RoktAttributeValueArray;
+export type RoktAttributes = Record<string, RoktAttributeValue>;
+export interface IRoktPartnerExtensionData<T> {
+    [extensionName: string]: T;
+}
+export interface IRoktSelectPlacementsOptions {
+    attributes: RoktAttributes;
+    identifier?: string;
+}
+interface IRoktPlacement {
+}
+export interface IRoktSelection {
+    close: () => void;
+    getPlacements: () => Promise<IRoktPlacement[]>;
+}
+export interface IRoktLauncher {
+    selectPlacements: (options: IRoktSelectPlacementsOptions) => Promise<IRoktSelection>;
+    hashAttributes: (attributes: RoktAttributes) => Promise<Record<string, string>>;
+    use: <T>(name: string) => Promise<T>;
+}
+export interface IRoktMessage {
+    messageId: string;
+    methodName: string;
+    payload: any;
+    resolve?: Function;
+    reject?: Function;
+}
+export interface RoktKitFilterSettings {
+    userAttributeFilters?: UserAttributeFilters;
+    filterUserAttributes?: (userAttributes: Dictionary<string>, filterList: number[]) => Dictionary<string>;
+    filteredUser?: IMParticleUser | null;
+}
+export interface IRoktKitSettings {
+    accountId?: string;
+    placementAttributesMapping?: string;
+    hashedEmailUserIdentityType?: string;
+}
+export interface IRoktKit {
+    filters: RoktKitFilterSettings;
+    filteredUser: IMParticleUser | null;
+    launcher: IRoktLauncher | null;
+    userAttributes: Dictionary<string>;
+    hashAttributes: (attributes: RoktAttributes) => Promise<RoktAttributes>;
+    selectPlacements: (options: IRoktSelectPlacementsOptions) => Promise<IRoktSelection>;
+    setExtensionData<T>(extensionData: IRoktPartnerExtensionData<T>): void;
+    use: <T>(name: string) => Promise<T>;
+    launcherOptions?: Dictionary<any>;
+    settings?: IRoktKitSettings;
+    integrationName?: string;
+}
+export interface IRoktOptions {
+    sandbox?: boolean;
+    launcherOptions?: IRoktLauncherOptions;
+    domain?: string;
+}
+export type IRoktLauncherOptions = Dictionary<any>;
+export default class RoktManager {
+    kit: IRoktKit;
+    filters: RoktKitFilterSettings;
+    private currentUser;
+    private messageQueue;
+    private sandbox;
+    private placementAttributesMapping;
+    private identityService;
+    private store;
+    private launcherOptions?;
+    private logger;
+    private errorReporter;
+    private loggingService;
+    private domain?;
+    private mappedEmailShaIdentityType?;
+    private captureTiming?;
+    private onReadyCallback;
+    private initialized;
+    /**
+     * Sets a callback to be invoked when RoktManager becomes ready
+     */
+    setOnReadyCallback(callback: () => void): void;
+    /**
+     * Initializes the RoktManager with configuration settings and user data.
+     *
+     * @param {IKitConfigs} roktConfig - Configuration object containing user attribute filters and settings
+     * @param {IMParticleUser} filteredUser - User object with filtered attributes
+     * @param {SDKIdentityApi} identityService - The mParticle Identity instance
+     * @param {SDKLoggerApi} logger - The mParticle Logger instance
+     * @param {IRoktOptions} options - Options for the RoktManager
+     * @param {Function} captureTiming - Function to capture performance timing marks
+     * @param {IErrorReportingService} errorReporter - Dispatcher for error/warning reporting
+     * @param {ILoggingService} loggingService - Dispatcher for informational logging
+     *
+     * @throws Logs error to console if placementAttributesMapping parsing fails
+     */
+    init(roktConfig: IKitConfigs, filteredUser: IMParticleUser, identityService: SDKIdentityApi, store: IStore, logger?: SDKLoggerApi, options?: IRoktOptions, captureTiming?: (metricsName: string) => void, errorReporter?: IErrorReportingService, loggingService?: ILoggingService): void;
+    get isInitialized(): boolean;
+    attachKit(kit: IRoktKit): void;
+    /**
+     * Renders ads based on the options provided
+     *
+     * @param {IRoktSelectPlacementsOptions} options - The options for selecting placements, including attributes and optional identifier
+     * @returns {Promise<IRoktSelection>} A promise that resolves to the selection
+     *
+     * @example
+     * // Correct usage with await
+     * await window.mParticle.Rokt.selectPlacements({
+     *   attributes: {
+     *     email: 'user@example.com',
+     *     customAttr: 'value'
+     *   }
+     * });
+     */
+    selectPlacements(options: IRoktSelectPlacementsOptions): Promise<IRoktSelection>;
+    /**
+     * Hashes attributes and returns both original and hashed versions
+     * with Rokt-compatible key names (like emailsha256, mobilesha256)
+     *
+     *
+     * @param {RoktAttributes} attributes - Attributes to hash
+     * @returns {Promise<RoktAttributes>} Object with both original and hashed attributes
+     *
+     */
+    hashAttributes(attributes: RoktAttributes): Promise<RoktAttributes>;
+    setExtensionData<T>(extensionData: IRoktPartnerExtensionData<T>): void;
+    use<T>(name: string): Promise<T>;
+    /**
+     * Hashes an attribute using SHA-256
+     *
+     * @param {string | number | boolean | undefined | null} attribute - The value to hash
+     * @returns {Promise<string | undefined | null>} SHA-256 hashed value or undefined/null
+     *
+     */
+    hashSha256(attribute: RoktAttributeValueType): Promise<string | undefined | null>;
+    getLocalSessionAttributes(): LocalSessionAttributes;
+    setLocalSessionAttribute(key: string, value: AttributeValue): void;
+    isReady(): boolean;
+    private setUserAttributes;
+    private mapPlacementAttributes;
+    onIdentityComplete(): void;
+    processMessageQueue(): void;
+    private queueMessage;
+    private deferredCall;
+    /**
+     * Hashes a string input using SHA-256 and returns the hex digest
+     * Uses the Web Crypto API for secure hashing
+     *
+     * @param {string} input - The string to hash
+     * @returns {Promise<string>} The SHA-256 hash as a hexadecimal string
+     */
+    private sha256Hex;
+    /**
+     * Converts an ArrayBuffer to a hexadecimal string representation
+     * Each byte is converted to a 2-character hex string with leading zeros
+     *
+     * @param {ArrayBuffer} buffer - The buffer to convert
+     * @returns {string} The hexadecimal string representation
+     */
+    private arrayBufferToHex;
+    /**
+     * Checks if an identity value has changed by comparing current and new values
+     *
+     * @param {string | undefined} currentValue - The current identity value
+     * @param {string | undefined} newValue - The new identity value to compare against
+     * @returns {boolean} True if the identity has changed (new value exists and differs from current), false otherwise
+     */
+    private hasIdentityChanged;
+}
+export {};