@mparticle/web-sdk 2.79.0 → 2.79.2

package/src/{helpers.js → helpers.ts}

@@ -1,14 +1,72 @@
 import Types from './types';
 import Constants from './constants';
 import * as utils from './utils';
+import { Dictionary } from './utils';
 import Validators from './validators';
 import KitFilterHelper from './kitFilterHelper';
+import { IMParticleWebSDKInstance } from './mp-instance';
+import { SDKHelpersApi } from './sdkRuntimeModels';
+import { IMParticleUser, IdentityCallback, IdentityResult, ISDKUserIdentity } from './identity-user-interfaces';
+import { IAliasResult } from './identity.interfaces';
+import { AliasUsersCallback, MPID } from '@mparticle/web-sdk';
 
-var StorageNames = Constants.StorageNames;
+const StorageNames = Constants.StorageNames;
 
-export default function Helpers(mpInstance) {
-    var self = this;
-    this.canLog = function() {
+function appendFilteredUserIdentity(
+    filteredUserIdentities: ISDKUserIdentity[],
+    identity: ISDKUserIdentity,
+    userIdentityType: number
+): void {
+    if (userIdentityType === Types.IdentityType.CustomerId) {
+        filteredUserIdentities.unshift(identity);
+    } else {
+        filteredUserIdentities.push(identity);
+    }
+}
+
+function buildFilteredUserIdentities(
+    userIdentitiesObject: utils.Dictionary<string> | null | undefined,
+    filterList: number[],
+    inArray: (items: any[], value: any) => boolean
+): ISDKUserIdentity[] {
+    const filteredUserIdentities: ISDKUserIdentity[] = [];
+
+    if (!userIdentitiesObject || !Object.keys(userIdentitiesObject).length) {
+        return filteredUserIdentities;
+    }
+
+    for (const userIdentityName in userIdentitiesObject) {
+        if (!userIdentitiesObject.hasOwnProperty(userIdentityName)) {
+            continue;
+        }
+
+        const userIdentityType = Types.IdentityType.getIdentityType(
+            userIdentityName
+        );
+
+        if (inArray(filterList, userIdentityType)) {
+            continue;
+        }
+
+        appendFilteredUserIdentity(
+            filteredUserIdentities,
+            {
+                Type: userIdentityType,
+                Identity: userIdentitiesObject[userIdentityName],
+            },
+            userIdentityType
+        );
+    }
+
+    return filteredUserIdentities;
+}
+
+export default function Helpers(
+    this: SDKHelpersApi,
+    mpInstance: IMParticleWebSDKInstance
+): void {
+    const self = this;
+    this.canLog = function(): boolean {
         if (
             mpInstance._Store.isEnabled &&
             (mpInstance._Store.devToken ||
@@ -20,7 +78,7 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.getFeatureFlag = function(feature) {
+    this.getFeatureFlag = function(feature: string): boolean | string {
         if (mpInstance._Store.SDKConfig.flags.hasOwnProperty(feature)) {
             return mpInstance._Store.SDKConfig.flags[feature];
         }
@@ -28,12 +86,12 @@ export default function Helpers(mpInstance) {
     };
 
     this.invokeCallback = function(
-        callback,
-        code,
-        body,
-        mParticleUser,
-        previousMpid
-    ) {
+        callback: IdentityCallback,
+        code: number,
+        body: string,
+        mParticleUser?: IMParticleUser,
+        previousMpid?: MPID
+    ): void {
         if (!callback) {
             mpInstance.Logger.warning('There is no callback provided');
         }
@@ -51,9 +109,9 @@ export default function Helpers(mpInstance) {
                     },
                     getPreviousUser: function() {
                         if (!previousMpid) {
-                            var users = mpInstance.Identity.getUsers();
-                            var mostRecentUser = users.shift();
-                            var currentUser =
+                            const users = mpInstance.Identity.getUsers();
+                            let mostRecentUser = users.shift();
+                            const currentUser =
                                 mParticleUser ||
                                 mpInstance.Identity.getCurrentUser();
                             if (
@@ -69,7 +127,7 @@ export default function Helpers(mpInstance) {
                             return mpInstance.Identity.getUser(previousMpid);
                         }
                     },
-                });
+                } as unknown as IdentityResult);
             }
         } catch (e) {
             mpInstance.Logger.error(
@@ -78,19 +136,23 @@ export default function Helpers(mpInstance) {
         }
     };
 
-    this.invokeAliasCallback = function(callback, code, message) {
+    this.invokeAliasCallback = function(
+        callback: AliasUsersCallback,
+        code: number,
+        message?: string
+    ): void {
         if (!callback) {
             mpInstance.Logger.warning('There is no callback provided');
         }
         try {
             if (self.Validators.isFunction(callback)) {
-                var callbackMessage = {
+                const callbackMessage: Dictionary = {
                     httpCode: code,
                 };
                 if (message) {
                     callbackMessage.message = message;
                 }
-                callback(callbackMessage);
+                callback(callbackMessage as IAliasResult);
             }
         } catch (e) {
             mpInstance.Logger.error(
@@ -101,12 +163,15 @@ export default function Helpers(mpInstance) {
 
     this.extend = utils.extend;
 
-    this.createServiceUrl = function(secureServiceUrl, devToken) {
-        var serviceScheme =
+    this.createServiceUrl = function(
+        secureServiceUrl: string,
+        devToken?: string
+    ): string {
+        const serviceScheme =
             window.mParticle && mpInstance._Store.SDKConfig.forceHttps
                 ? 'https://'
                 : window.location.protocol + '//';
-        var baseUrl;
+        let baseUrl;
         if (mpInstance._Store.SDKConfig.forceHttps) {
             baseUrl = 'https://' + secureServiceUrl;
         } else {
@@ -118,8 +183,8 @@ export default function Helpers(mpInstance) {
         return baseUrl;
     };
 
-    this.createXHR = function(cb) {
-        var xhr;
+    this.createXHR = function(cb: () => void): XMLHttpRequest {
+        let xhr;
 
         try {
             xhr = new window.XMLHttpRequest();
@@ -129,11 +194,13 @@ export default function Helpers(mpInstance) {
 
         if (xhr && cb && 'withCredentials' in xhr) {
             xhr.onreadystatechange = cb;
-        } else if (typeof window.XDomainRequest !== 'undefined') {
+        } else if (
+            typeof (window as Dictionary).XDomainRequest !== 'undefined'
+        ) {
             mpInstance.Logger.verbose('Creating XDomainRequest object');
 
             try {
-                xhr = new window.XDomainRequest();
+                xhr = new (window as Dictionary).XDomainRequest();
                 xhr.onload = cb;
             } catch (e) {
                 mpInstance.Logger.error('Error creating XDomainRequest object');
@@ -143,41 +210,25 @@ export default function Helpers(mpInstance) {
         return xhr;
     };
 
-    this.filterUserIdentities = function(userIdentitiesObject, filterList) {
-        var filteredUserIdentities = [];
-
-        if (userIdentitiesObject && Object.keys(userIdentitiesObject).length) {
-            for (var userIdentityName in userIdentitiesObject) {
-                if (userIdentitiesObject.hasOwnProperty(userIdentityName)) {
-                    var userIdentityType = Types.IdentityType.getIdentityType(
-                        userIdentityName
-                    );
-                    if (!self.inArray(filterList, userIdentityType)) {
-                        var identity = {
-                            Type: userIdentityType,
-                            Identity: userIdentitiesObject[userIdentityName],
-                        };
-                        if (
-                            userIdentityType === Types.IdentityType.CustomerId
-                        ) {
-                            filteredUserIdentities.unshift(identity);
-                        } else {
-                            filteredUserIdentities.push(identity);
-                        }
-                    }
-                }
-            }
-        }
-
-        return filteredUserIdentities;
+    this.filterUserIdentities = function(
+        userIdentitiesObject: Dictionary<string>,
+        filterList: number[]
+    ): ISDKUserIdentity[] {
+        return buildFilteredUserIdentities(
+            userIdentitiesObject,
+            filterList,
+            self.inArray
+        );
     };
 
     this.filterUserIdentitiesForForwarders =
         KitFilterHelper.filterUserIdentities;
     this.filterUserAttributes = KitFilterHelper.filterUserAttributes;
 
-    this.isEventType = function(type) {
-        for (var prop in Types.EventType) {
+    this.isEventType = function(
+        type: utils.valueof<typeof Types.EventType>
+    ): boolean {
+        for (const prop in Types.EventType) {
             if (Types.EventType.hasOwnProperty(prop)) {
                 if (Types.EventType[prop] === type) {
                     return true;
@@ -187,14 +238,17 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.sanitizeAttributes = function(attrs, name) {
+    this.sanitizeAttributes = function(
+        attrs: Dictionary,
+        name: string
+    ): Dictionary<string> | null {
         if (!attrs || !self.isObject(attrs)) {
             return null;
         }
 
-        var sanitizedAttrs = {};
+        const sanitizedAttrs: Dictionary<string> = {};
 
-        for (var prop in attrs) {
+        for (const prop in attrs) {
             // Make sure that attribute values are not objects or arrays, which are not valid
             if (
                 attrs.hasOwnProperty(prop) &&
@@ -216,17 +270,17 @@ export default function Helpers(mpInstance) {
     };
 
     this.isDelayedByIntegration = function(
-        delayedIntegrations,
-        timeoutStart,
-        now
-    ) {
+        delayedIntegrations: Dictionary<boolean>,
+        timeoutStart: number,
+        now: number
+    ): boolean {
         if (
             now - timeoutStart >
             mpInstance._Store.SDKConfig.integrationDelayTimeout
         ) {
             return false;
         }
-        for (var integration in delayedIntegrations) {
+        for (const integration in delayedIntegrations) {
             if (delayedIntegrations[integration] === true) {
                 return true;
             } else {
@@ -236,7 +290,7 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.createMainStorageName = function(workspaceToken) {
+    this.createMainStorageName = function(workspaceToken: string): string {
         if (workspaceToken) {
             return StorageNames.currentStorageName + '_' + workspaceToken;
         } else {

package/src/mp-instance.ts

@@ -297,6 +297,14 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
             window.localStorage
         );
         instance._Events.stopTracking();
+
+        const instanceTracker = instance._PageViewTracker;
+        if (instanceTracker) {
+            instanceTracker.teardown();
+            instance._PageViewTracker = undefined;
+        }
+        PageViewTracker.resetWindowState(instanceTracker);
+
         if (!keepPersistence) {
             instance._Persistence.resetPersistence();
         }
@@ -1585,14 +1593,36 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
         mpInstance._SessionManager.initialize();
         mpInstance._Events.logAST();
 
+        // Note: APV uses window-level singletons (WIN_TRACKER_KEY, WIN_INIT_PV_KEY)
+        // that assume a single active SDK instance. Multiple-instance support is
+        // out of scope
         if (getFeatureFlag(AutoLogPageView)) {
-            mpInstance._Events.logPageView();
-
             if (!mpInstance._PageViewTracker) {
+                mpInstance.Logger.verbose(
+                    'mParticle APV: [sdk-init] creating new PageViewTracker for this instance'
+                );
                 mpInstance._PageViewTracker = new PageViewTracker(mpInstance);
+
+                // Fire the initial page view once per page load (hard navigation).
+                // The flag survives module re-evaluation so repeated init() calls
+                // from SPA re-renders don't fire duplicate logPageView() events.
+                if (PageViewTracker.hasInitialPageViewFired()) {
+                    mpInstance.Logger.verbose(
+                        'mParticle APV: [sdk-init] initial page view already logged this page load, skipping'
+                    );
+                } else {
+                    PageViewTracker.markInitialPageViewFired();
+                    mpInstance._Events.logPageView();
+                }
+            } else {
+                mpInstance.Logger.verbose(
+                    'mParticle APV: [sdk-init] tracker already on this instance, skipping logPageView'
+                );
             }
             mpInstance._PageViewTracker.init();
         } else if (mpInstance._PageViewTracker) {
+            // AutoLogPageView was disabled on re-init: tear down the active tracker
+            // so it stops listening. Re-created if the flag is re-enabled later.
             mpInstance._PageViewTracker.teardown();
         }
 

package/src/pageViewTracker.ts

@@ -9,11 +9,59 @@ type MarkedHistoryMethod = HistoryStateMethod & {
     [WRAPPED_MARKER]?: boolean;
 };
 
+// window key under which the single active tracker is stored.
+// Survives module re-evaluation (Next.js re-executes the bundle on every SPA
+// navigation, resetting all module-level state, but window persists for the
+// lifetime of the tab).
+export const WIN_TRACKER_KEY = '__mpApvTracker__';
+
+// Guards the initial page view so repeated mParticle.init() calls from SPA
+// re-renders don't fire duplicate logPageView() events for the same page.
+export const WIN_INIT_PV_KEY = '__mpApvInitPVLogged__' as const;
+
+export type WindowWithApvFlags = Window & {
+    [WIN_TRACKER_KEY]?: PageViewTracker;
+    [WIN_INIT_PV_KEY]?: boolean;
+};
+
+type NavigationSource = 'pushState' | 'replaceState' | 'popstate';
+
 export class PageViewTracker {
+    static hasInitialPageViewFired(): boolean {
+        return !!(window as WindowWithApvFlags)[WIN_INIT_PV_KEY];
+    }
+
+    static markInitialPageViewFired(): void {
+        (window as WindowWithApvFlags)[WIN_INIT_PV_KEY] = true;
+    }
+
+    // Tears down any window-registered tracker that differs from instanceTracker
+    // (e.g. left by a previous module load), then clears both APV window flags.
+    // Call from _resetForTests after tearing down the instance-level tracker.
+    static resetWindowState(instanceTracker?: PageViewTracker): void {
+        const windowTracker = getWindowTracker();
+        if (windowTracker && windowTracker !== instanceTracker) {
+            windowTracker.teardown();
+        }
+        if (typeof window !== 'undefined') {
+            delete (window as WindowWithApvFlags)[WIN_INIT_PV_KEY];
+        }
+        setWindowTracker(undefined);
+    }
+
     mpInstance: IMParticleWebSDKInstance;
 
     private lastPath: string | null = null;
-    private isActive = false;
+    private _isActive = false;
+
+    get isActive(): boolean {
+        return this._isActive;
+    }
+
+    private pendingNavigations: Array<{
+        path: string;
+        timeoutId: ReturnType<typeof setTimeout>;
+    }> = [];
 
     private originalPushState: HistoryStateMethod | null = null;
     private originalReplaceState: HistoryStateMethod | null = null;
@@ -37,9 +85,7 @@ export class PageViewTracker {
     }
 
     public init(): void {
-        this.mpInstance.Logger.verbose(
-            'mParticle APV: [init] PageViewTracker Init'
-        );
+        this.mpInstance.Logger.verbose('mParticle APV: [init] PageViewTracker Init');
         if (!this.isSupportedEnvironment()) {
             this.mpInstance.Logger.verbose(
                 'mParticle APV: [init] unsupported environment (no History API), not starting'
@@ -47,14 +93,32 @@ export class PageViewTracker {
             return;
         }
 
-        if (this.isActive) {
+        // Tear down any tracker left over from a previous module load.
+        // window[WIN_TRACKER_KEY] outlives module re-evaluation; this is the
+        // only way to reach a tracker instance in a dead module scope.
+        // Transfer any pending navigations first so a route change that queued a
+        // deferred fire before module re-evaluation occurs is not silently dropped.
+        const prev = getWindowTracker();
+        let inheritedPaths: string[] = [];
+        if (prev && prev !== this) {
+            this.mpInstance.Logger.verbose(
+                'mParticle APV: [init] found stale tracker from previous module load — transferring pending navigations and tearing down'
+            );
+            inheritedPaths = prev.takePendingNavigations();
+            prev.teardown();
+        }
+
+        if (this._isActive) {
             this.mpInstance.Logger.verbose(
                 'mParticle APV: [init] starting (teardown-first for idempotency)'
             );
+            // Preserve pending navigations through the self-teardown so a route
+            // change queued before mParticle.init() was called again is not lost.
+            inheritedPaths = [...inheritedPaths, ...this.takePendingNavigations()];
             this.teardown();
         }
 
-        this.isActive = true;
+        this._isActive = true;
 
         this.lastPath = this.getCurrentKey();
 
@@ -65,9 +129,26 @@ export class PageViewTracker {
         this.patchHistoryMethods();
         this.addNavigationListeners();
 
+        setWindowTracker(this);
+
         this.mpInstance.Logger.verbose(
             'mParticle APV: [init] patched pushState/replaceState + listening for popstate'
         );
+
+        // Re-fire navigations that the stale tracker had queued but not yet flushed
+        // when module re-evaluation occurred. Title is read at flush time so the
+        // router's post-navigation render commit still has a chance to update it.
+        inheritedPaths.forEach(path => {
+            const timeoutId = setTimeout(() => {
+                this.pendingNavigations = this.pendingNavigations.filter(
+                    p => p.timeoutId !== timeoutId
+                );
+                if (!this._isActive) return;
+                this.mpInstance._SessionManager.resetSessionTimer();
+                this.firePageView(path);
+            }, 0);
+            this.pendingNavigations.push({ path, timeoutId });
+        });
     }
 
     private patchHistoryMethods(): void {
@@ -76,7 +157,7 @@ export class PageViewTracker {
         const installed = window.history.pushState as MarkedHistoryMethod;
         if (installed[WRAPPED_MARKER]) {
             this.mpInstance.Logger.verbose(
-                'mParticle APV: [patch] history already wrapped, skipping to avoid double-wrap'
+                'mParticle APV: [patch] history already wrapped, skipping to avoid double-wrap — STACKED WRAPPER DETECTED'
             );
             return;
         }
@@ -91,7 +172,9 @@ export class PageViewTracker {
             ...args: Parameters<HistoryStateMethod>
         ): void {
             const result = originalPushState.apply(this, args);
-            self.safeHandleNavigation('pushState');
+            if (self._isActive) {
+                self.safeHandleNavigation('pushState');
+            }
             return result;
         };
 
@@ -100,7 +183,9 @@ export class PageViewTracker {
             ...args: Parameters<HistoryStateMethod>
         ): void {
             const result = originalReplaceState.apply(this, args);
-            self.safeHandleNavigation('replaceState');
+            if (self._isActive) {
+                self.safeHandleNavigation('replaceState');
+            }
             return result;
         };
 
@@ -147,7 +232,7 @@ export class PageViewTracker {
         window.addEventListener('popstate', this.popStateListener);
     }
 
-    private safeHandleNavigation(source: string): void {
+    private safeHandleNavigation(source: NavigationSource): void {
         try {
             this.handleNavigation(source);
         } catch (e) {
@@ -161,7 +246,7 @@ export class PageViewTracker {
         return window.location.pathname;
     }
 
-    private handleNavigation(source: string): void {
+    private handleNavigation(source: NavigationSource): void {
         const candidatePath = this.getCurrentKey();
 
         this.mpInstance.Logger.verbose(
@@ -187,8 +272,11 @@ export class PageViewTracker {
         // commit has a chance to update document.title first.
         const capturedPath = candidatePath;
 
-        setTimeout(() => {
-            if (!this.isActive) {
+        const timeoutId = setTimeout(() => {
+            this.pendingNavigations = this.pendingNavigations.filter(
+                p => p.timeoutId !== timeoutId
+            );
+            if (!this._isActive) {
                 this.mpInstance.Logger.verbose(
                     'mParticle APV: [defer] fire aborted, tracker inactive (torn down before flush)'
                 );
@@ -198,6 +286,7 @@ export class PageViewTracker {
             this.mpInstance._SessionManager.resetSessionTimer();
             this.firePageView(capturedPath);
         }, 0);
+        this.pendingNavigations.push({ path: capturedPath, timeoutId });
     }
 
     // Mirrors the event shape of the public mParticle.logPageView(), but carries
@@ -221,47 +310,73 @@ export class PageViewTracker {
         });
     }
 
+    // Cancels pending deferred fires and returns their captured paths so a
+    // successor tracker can re-schedule them. Call before teardown() during
+    // module-replacement handoff.
+    public takePendingNavigations(): string[] {
+        const paths = this.pendingNavigations.map(p => p.path);
+        this.pendingNavigations.forEach(p => clearTimeout(p.timeoutId));
+        this.pendingNavigations = [];
+        return paths;
+    }
+
+    private restoreHistoryMethod(
+        methodName: 'pushState' | 'replaceState',
+        original: HistoryStateMethod | null,
+        wrapper: HistoryStateMethod | null
+    ): void {
+        if (!original) return;
+        const stillOurs = wrapper !== null && window.history[methodName] === wrapper;
+        if (stillOurs) {
+            window.history[methodName] = original;
+            this.mpInstance.Logger.verbose(
+                `mParticle APV: [teardown] restored original ${methodName}`
+            );
+        } else {
+            this.mpInstance.Logger.verbose(
+                `mParticle APV: [teardown] ${methodName} no longer ours; leaving in place, gating callback to no-op`
+            );
+        }
+    }
+
     public teardown(): void {
+        // Cancel any pending deferred fires (e.g. when the feature flag is
+        // disabled on re-init). For module-replacement, call takePendingNavigations()
+        // before teardown() instead so paths are transferred, not discarded.
+        this.pendingNavigations.forEach(p => clearTimeout(p.timeoutId));
+        this.pendingNavigations = [];
+
         if (this.popStateListener) {
             window.removeEventListener('popstate', this.popStateListener);
             this.popStateListener = null;
         }
-        const pushStateStillOurs =
-            this.pushStateWrapper !== null &&
-            window.history.pushState === this.pushStateWrapper;
-        if (this.originalPushState) {
-            if (pushStateStillOurs) {
-                window.history.pushState = this.originalPushState;
-                this.mpInstance.Logger.verbose(
-                    'mParticle APV: [teardown] restored original pushState'
-                );
-            } else {
-                this.mpInstance.Logger.verbose(
-                    'mParticle APV: [teardown] pushState no longer ours; leaving in place, gating callback to no-op'
-                );
-            }
-            this.originalPushState = null;
-            this.pushStateWrapper = null;
-        }
 
-        const replaceStateStillOurs =
-            this.replaceStateWrapper !== null &&
-            window.history.replaceState === this.replaceStateWrapper;
-        if (this.originalReplaceState) {
-            if (replaceStateStillOurs) {
-                window.history.replaceState = this.originalReplaceState;
-                this.mpInstance.Logger.verbose(
-                    'mParticle APV: [teardown] restored original replaceState'
-                );
-            } else {
-                this.mpInstance.Logger.verbose(
-                    'mParticle APV: [teardown] replaceState no longer ours; leaving in place, gating callback to no-op'
-                );
-            }
-            this.originalReplaceState = null;
-            this.replaceStateWrapper = null;
+        this.restoreHistoryMethod('pushState', this.originalPushState, this.pushStateWrapper);
+        this.originalPushState = null;
+        this.pushStateWrapper = null;
+
+        this.restoreHistoryMethod('replaceState', this.originalReplaceState, this.replaceStateWrapper);
+        this.originalReplaceState = null;
+        this.replaceStateWrapper = null;
+
+        this._isActive = false;
+        if (getWindowTracker() === this) {
+            setWindowTracker(undefined);
         }
+    }
+}
+
+function getWindowTracker(): PageViewTracker | undefined {
+    if (typeof window === 'undefined') return undefined;
+    return (window as WindowWithApvFlags)[WIN_TRACKER_KEY];
+}
 
-        this.isActive = false;
+function setWindowTracker(tracker: PageViewTracker | undefined): void {
+    if (typeof window === 'undefined') return;
+    const win = window as WindowWithApvFlags;
+    if (tracker) {
+        win[WIN_TRACKER_KEY] = tracker;
+    } else {
+        delete win[WIN_TRACKER_KEY];
     }
 }