@mparticle/web-sdk 3.6.2 → 3.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "3.6.2",
+    "version": "3.7.0",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [

package/src/consent.ts

@@ -4,7 +4,7 @@ import {
     GDPRConsentState,
     PrivacyConsentState,
 } from '@mparticle/web-sdk';
-import { Dictionary, isObject } from './utils';
+import { Dictionary, hasOwnProp, isObject } from './utils';
 import KitFilterHelper from './kitFilterHelper';
 import Constants from './constants';
 import { IMParticleUser } from './identity-user-interfaces';
@@ -287,7 +287,7 @@ export default function Consent(this: IConsent, mpInstance: IMParticleWebSDKInst
             const state: ConsentState = self.createConsentState();
             if (json.gdpr) {
                 for (const purpose in json.gdpr) {
-                    if (json.gdpr.hasOwnProperty(purpose)) {
+                    if (hasOwnProp(json.gdpr, purpose)) {
                         const gdprConsent = self.createPrivacyConsent(
                             json.gdpr[purpose].c,
                             json.gdpr[purpose].ts,
@@ -301,7 +301,7 @@ export default function Consent(this: IConsent, mpInstance: IMParticleWebSDKInst
             }
 
             if (json.ccpa) {
-                if (json.ccpa.hasOwnProperty(CCPAPurpose)) {
+                if (hasOwnProp(json.ccpa, CCPAPurpose)) {
                     const ccpaConsent = self.createPrivacyConsent(
                         json.ccpa[CCPAPurpose].c,
                         json.ccpa[CCPAPurpose].ts,

package/src/cookieConsentManager.ts

@@ -1,5 +1,6 @@
 import { NO_TARGETING_ATTRIBUTE } from './constants';
 import { IMParticleUser } from './identity-user-interfaces';
+import { hasOwnProp } from './utils';
 
 /**
  * Cookie consent flags control SDK behavior based on user consent preferences for Rokt integration.
@@ -77,9 +78,7 @@ export default class CookieConsentManager implements ICookieConsentManager {
         if (this.flags.noTargeting) {
             user.setUserAttribute(NO_TARGETING_ATTRIBUTE, true);
         } else if (
-            user
-                .getAllUserAttributes()
-                .hasOwnProperty(NO_TARGETING_ATTRIBUTE)
+            hasOwnProp(user.getAllUserAttributes(), NO_TARGETING_ATTRIBUTE)
         ) {
             user.removeUserAttribute(NO_TARGETING_ATTRIBUTE);
         }

package/src/cookieSyncManager.ts

@@ -87,76 +87,89 @@ export default function CookieSyncManager(
         }
 
         pixelConfigurations.forEach((pixelSettings: IPixelConfiguration) => {
-            // set requiresConsent to false to start each additional pixel configuration
-            // set to true only if filteringConsenRuleValues.values.length exists
-            let requiresConsent = false;
-            // Filtering rules as defined in UI
-            const {
-                filteringConsentRuleValues,
-                pixelUrl,
-                redirectUrl,
-                moduleId,
-                settings,
-                // Tells you how often we should do a cookie sync (in days)
-                frequencyCap,
-            } = pixelSettings;
-            const { values } = filteringConsentRuleValues || {};
-
-            if (isEmpty(pixelUrl)) {
-                return;
+            try {
+                // set requiresConsent to false to start each additional pixel configuration
+                // set to true only if filteringConsenRuleValues.values.length exists
+                let requiresConsent = false;
+                // Filtering rules as defined in UI
+                const {
+                    filteringConsentRuleValues,
+                    pixelUrl,
+                    redirectUrl,
+                    moduleId,
+                    settings,
+                    // Tells you how often we should do a cookie sync (in days)
+                    frequencyCap,
+                } = pixelSettings;
+                const { values } = filteringConsentRuleValues || {};
+
+                if (isEmpty(pixelUrl)) {
+                    return;
+                }
+
+                if (!isEmpty(values)) {
+                    requiresConsent = true;
+                }
+
+                // If MPID is new to cookies, we should not try to perform the cookie sync
+                // because a cookie sync can only occur once a user either consents or doesn't.
+                // we should not check if it's enabled if the user has a blank consent
+                if (requiresConsent && mpidIsNotInCookies) {
+                    return;
+                }
+
+                // For Rokt, block cookie sync when noTargeting privacy flag is true
+                if (moduleId === PARTNER_MODULE_IDS.Rokt && mpInstance._CookieConsentManager.getNoTargeting()) {
+                    return;
+                }
+
+                const { isEnabledForUserConsent } = mpInstance._Consent;
+
+                if (!isEnabledForUserConsent(filteringConsentRuleValues, mpInstance.Identity.getCurrentUser())) {
+                    return;
+                }
+
+                const cookieSyncDates: CookieSyncDates = persistence[mpid]?.csd ?? {};
+                const lastSyncDateForModule: number = cookieSyncDates[moduleId] || null;
+
+                if (!isLastSyncDateExpired(frequencyCap, lastSyncDateForModule)) {
+                    return;
+                }
+
+                // The Trade Desk requires a URL parameter for GDPR enabled users.
+                // It is optional but to simplify the code, we add it for all Trade
+                // // Desk cookie syncs.
+                const domain = moduleId === PARTNER_MODULE_IDS.TradeDesk ? window.location.hostname : undefined;
+
+                // Google Marketing Platform accepts a web-safe base64-encoded MPID via the
+                // `google_hm` query parameter, but only for accounts provisioned for Google
+                // Hosted Matching — Google returns errors otherwise. It is therefore gated
+                // behind the opt-in `enableHmTag` setting (off by default), which the server
+                // delivers as the string 'True' when the UI toggle is enabled.
+                const enableHmTag = settings?.enableHmTag?.toLowerCase() === 'true';
+                const isDoubleClickModule = moduleId === PARTNER_MODULE_IDS.DoubleclickDFP;
+                const usesHostedMatching = isDoubleClickModule && enableHmTag;
+                const base64Mpid = usesHostedMatching ? toWebSafeBase64(mpid) : undefined;
+
+                if (usesHostedMatching && !base64Mpid) {
+                    mpInstance.Logger.warning(
+                        'Unable to base64 encode the current MPID; omitting the google_hm parameter from this cookie sync'
+                    );
+                }
+
+                const fullUrl = createCookieSyncUrl(mpid, pixelUrl, redirectUrl, domain, base64Mpid);
+
+                self.performCookieSync(
+                    fullUrl,
+                    moduleId.toString(),
+                    mpid,
+                    cookieSyncDates
+                );
+            } catch (e) {
+                mpInstance.Logger.error(
+                    'Error performing cookie sync: ' + e
+                );
             }
-
-            if (!isEmpty(values)) {
-                requiresConsent = true;
-            }
-
-            // If MPID is new to cookies, we should not try to perform the cookie sync
-            // because a cookie sync can only occur once a user either consents or doesn't.
-            // we should not check if it's enabled if the user has a blank consent
-            if (requiresConsent && mpidIsNotInCookies) {
-                return;
-            }
-
-            // For Rokt, block cookie sync when noTargeting privacy flag is true
-            if (moduleId === PARTNER_MODULE_IDS.Rokt && mpInstance._CookieConsentManager.getNoTargeting()) {
-                return;
-            }
-
-            const { isEnabledForUserConsent } = mpInstance._Consent;
-
-            if (!isEnabledForUserConsent(filteringConsentRuleValues, mpInstance.Identity.getCurrentUser())) {
-                return;
-            }
-
-            const cookieSyncDates: CookieSyncDates = persistence[mpid]?.csd ?? {};
-            const lastSyncDateForModule: number = cookieSyncDates[moduleId] || null;
-
-            if (!isLastSyncDateExpired(frequencyCap, lastSyncDateForModule)) {
-                return;
-            }
-
-            // The Trade Desk requires a URL parameter for GDPR enabled users.
-            // It is optional but to simplify the code, we add it for all Trade
-            // // Desk cookie syncs.
-            const domain = moduleId === PARTNER_MODULE_IDS.TradeDesk ? window.location.hostname : undefined;
-
-            // Google Marketing Platform accepts a web-safe base64-encoded MPID via the
-            // `google_hm` query parameter, but only for accounts provisioned for Google
-            // Hosted Matching — Google returns errors otherwise. It is therefore gated
-            // behind the opt-in `enableHmTag` setting (off by default), which the server
-            // delivers as the string 'True' when the UI toggle is enabled.
-            const enableHmTag = settings?.enableHmTag?.toLowerCase() === 'true';
-            const isDoubleClickModule = moduleId === PARTNER_MODULE_IDS.DoubleclickDFP;
-            const base64Mpid = isDoubleClickModule && enableHmTag ? toWebSafeBase64(mpid) : undefined;
-
-            const fullUrl = createCookieSyncUrl(mpid, pixelUrl, redirectUrl, domain, base64Mpid);
-
-            self.performCookieSync(
-                fullUrl,
-                moduleId.toString(),
-                mpid,
-                cookieSyncDates
-            );
         });
     };
 

package/src/events.interfaces.ts

@@ -12,6 +12,7 @@ import {
     SDKProduct,
     SDKPromotion,
 } from './sdkRuntimeModels';
+import { IPageViewOptions } from './pageViewTracker';
 import { valueof } from './utils';
 import { EventType, ProductActionType, PromotionActionType } from './types';
 
@@ -40,7 +41,7 @@ export interface IEvents {
         eventOptions?: SDKEventOptions
     ): void;
     logOptOut(): void;
-    logPageView(): void;
+    logPageView(options?: IPageViewOptions): void;
     logProductActionEvent(
         productActionType: valueof<typeof ProductActionType>,
         product: SDKProduct | SDKProduct[],

package/src/events.ts

@@ -21,7 +21,11 @@ import {
     TransactionAttributes,
 } from '@mparticle/web-sdk';
 import { getHref, valueof } from './utils';
-import { allowedQueryParams } from './pageViewTracker';
+import {
+    allowedQueryParams,
+    autoPageViewAttribute,
+    IPageViewOptions,
+} from './pageViewTracker';
 
 interface DOMHandlerElement extends HTMLElement {
     href?: string;
@@ -149,7 +153,7 @@ export default function Events(
     // come from PageViewTracker instead, so both emitters attach the same
     // allowlisted query params — and this is the one that matters for campaign
     // attribution, since utm_*/gclid live on the entry URL.
-    this.logPageView = function(): void {
+    this.logPageView = function(options?: IPageViewOptions): void {
         self.logEvent({
             messageType: Types.MessageType.PageView,
             name: 'PageView',
@@ -159,6 +163,7 @@ export default function Events(
                 ...allowedQueryParams(getHref()),
                 hostname: window.location.hostname,
                 title: window.document.title,
+                ...autoPageViewAttribute(options && options.isAutoPageView),
             },
             eventType: Types.EventType.Unknown,
         });

package/src/filteredMparticleUser.ts

@@ -1,7 +1,7 @@
-import Types from './types';
+import Types, { getIdentityTypeFromStoredKey } from './types';
 import { IMParticleWebSDKInstance } from './mp-instance';
 import { MPID, UserIdentities } from '@mparticle/web-sdk';
-import { Dictionary } from './utils';
+import { Dictionary, hasOwnProp, isReservedStoredPropertyName } from './utils';
 import KitBlocker from './kitBlocking';
 import { MPForwarder } from './forwarders.interfaces';
 
@@ -42,7 +42,8 @@ function buildUserAttributesCopy(
 
     for (const prop in userAttributes) {
         if (
-            !userAttributes.hasOwnProperty(prop) ||
+            !hasOwnProp(userAttributes, prop) ||
+            isReservedStoredPropertyName(prop) ||
             !isAttributeKeyAllowed(kitBlocker, prop)
         ) {
             continue;
@@ -64,7 +65,8 @@ function buildUserAttributeLists(
 
     for (const key in userAttributes) {
         if (
-            !userAttributes.hasOwnProperty(key) ||
+            !hasOwnProp(userAttributes, key) ||
+            isReservedStoredPropertyName(key) ||
             !Array.isArray(userAttributes[key]) ||
             !isAttributeKeyAllowed(kitBlocker, key)
         ) {
@@ -79,19 +81,26 @@ function buildUserAttributeLists(
 
 function buildFilteredUserIdentities(
     identities: UserIdentities,
-    kitBlocker: KitBlocker | undefined,
-    parseNumber: (value: string | number) => number
+    kitBlocker: KitBlocker | undefined
 ): Dictionary<string> {
     const currentUserIdentities: Dictionary<string> = {};
     const identitiesByType = identities as Dictionary<string>;
 
     for (const identityType in identitiesByType) {
-        if (!identitiesByType.hasOwnProperty(identityType)) {
+        if (!hasOwnProp(identitiesByType, identityType)) {
+            continue;
+        }
+
+        const storedIdentityType = getIdentityTypeFromStoredKey(identityType);
+
+        // Must be `=== null`: IdentityType.Other is 0, so a falsy check would
+        // drop a valid stored Other identity.
+        if (storedIdentityType === null) {
             continue;
         }
 
         const identityName = Types.IdentityType.getIdentityName(
-            parseNumber(identityType)
+            storedIdentityType
         );
 
         if (!isIdentityAllowed(kitBlocker, identityName)) {
@@ -126,8 +135,7 @@ export default function filteredMparticleUser(
         getUserIdentities: function(): { userIdentities: Dictionary<string> } {
             let currentUserIdentities = buildFilteredUserIdentities(
                 mpInstance._Store.getUserIdentities(mpid),
-                kitBlocker,
-                mpInstance._Helpers.parseNumber
+                kitBlocker
             );
 
             currentUserIdentities = mpInstance._Helpers.filterUserIdentitiesForForwarders(

package/src/forwarders.ts

@@ -1,7 +1,7 @@
 import filteredMparticleUser, {
     isIdentityAllowed,
 } from './filteredMparticleUser';
-import { isEmpty, extend, Dictionary } from './utils';
+import { isEmpty, extend, hasOwnProp, Dictionary } from './utils';
 import KitFilterHelper from './kitFilterHelper';
 import Constants from './constants';
 import APIClient, { IForwardingStatsData } from './apiClient';
@@ -69,7 +69,7 @@ function userAttributesMatchFilter(
     filterObject: Partial<IFilteringUserAttributeValue>
 ): boolean {
     for (const attrName in userAttributes) {
-        if (!userAttributes.hasOwnProperty(attrName)) {
+        if (!hasOwnProp(userAttributes, attrName)) {
             continue;
         }
 

package/src/identity-utils.ts

@@ -1,5 +1,5 @@
 import Constants, { ONE_DAY_IN_SECONDS, MILLIS_IN_ONE_SEC } from './constants';
-import { Dictionary, Environment, parseNumber, isObject, generateHash, generateUniqueId, isEmpty, isFunction, getErrorMessage } from './utils';
+import { Dictionary, Environment, parseNumber, isObject, generateHash, generateUniqueId, hasOwnProp, isEmpty, isFunction, getErrorMessage } from './utils';
 import { BaseVault } from './vault';
 import Types from './types';
 import {
@@ -170,8 +170,7 @@ export const hasValidCachedIdentity = (
     );
     const hashedKey = generateHash(cacheKey);
 
-    // if cache doesn't have the cacheKey, there is no valid cached identity
-    if (!cache.hasOwnProperty(hashedKey)) {
+    if (!hasOwnProp(cache, hashedKey)) {
         return false;
     }
 

package/src/identity.ts

@@ -15,10 +15,13 @@ const { CacheIdentity } = FeatureFlags;
 const { Identify, Modify, Login, Logout } = IdentityMethods;
 import {
     generateDeprecationMessage,
+    hasOwnProp,
     isEmpty,
+    isReservedStoredPropertyName,
     isFunction,
     isObject,
 } from './utils';
+import { getIdentityTypeFromStoredKey } from './types';
 import { hasMPIDAndUserLoginChanged, hasMPIDChanged } from './user-utils';
 import { processReadyQueue } from './pre-init-utils';
 import { logDeprecatedMethodUsage } from './reporting/deprecatedMethodLogger';
@@ -893,13 +896,23 @@ export default function Identity(
                 const identities = mpInstance._Store.getUserIdentities(mpid);
 
                 for (const identityType in identities) {
-                    if (identities.hasOwnProperty(identityType)) {
-                        currentUserIdentities[
-                            Types.IdentityType.getIdentityName(
-                                mpInstance._Helpers.parseNumber(identityType)
-                            )
-                        ] = identities[identityType];
+                    if (!hasOwnProp(identities, identityType)) {
+                        continue;
+                    }
+
+                    const storedIdentityType = getIdentityTypeFromStoredKey(
+                        identityType
+                    );
+
+                    // Must be `=== null`: IdentityType.Other is 0, so a falsy
+                    // check would drop a valid stored Other identity.
+                    if (storedIdentityType === null) {
+                        continue;
                     }
+
+                    currentUserIdentities[
+                        Types.IdentityType.getIdentityName(storedIdentityType)
+                    ] = identities[identityType];
                 }
 
                 return {
@@ -1082,7 +1095,7 @@ export default function Identity(
 
                     delete userAttributes[key];
 
-                    if (cookies && cookies[mpid]) {
+                    if (cookies && isObject(cookies[mpid])) {
                         cookies[mpid].ua = userAttributes;
                         mpInstance._Persistence.savePersistence(cookies);
                     }
@@ -1228,7 +1241,7 @@ export default function Identity(
                     );
                     if (userAttributes) {
                         for (const prop in userAttributes) {
-                            if (userAttributes.hasOwnProperty(prop)) {
+                            if (hasOwnProp(userAttributes, prop)) {
                                 mpInstance._Forwarders.handleForwarderUserAttributes(
                                     'removeUserAttribute',
                                     prop,
@@ -1252,7 +1265,8 @@ export default function Identity(
                 userAttributes = this.getAllUserAttributes();
                 for (const key in userAttributes) {
                     if (
-                        userAttributes.hasOwnProperty(key) &&
+                        hasOwnProp(userAttributes, key) &&
+                        !isReservedStoredPropertyName(key) &&
                         Array.isArray(userAttributes[key])
                     ) {
                         userAttributesLists[key] = userAttributes[key].slice();
@@ -1273,7 +1287,10 @@ export default function Identity(
 
                 if (userAttributes) {
                     for (const prop in userAttributes) {
-                        if (userAttributes.hasOwnProperty(prop)) {
+                        if (
+                            hasOwnProp(userAttributes, prop) &&
+                            !isReservedStoredPropertyName(prop)
+                        ) {
                             const attrValue = userAttributes[prop];
                             if (Array.isArray(attrValue)) {
                                 userAttributesCopy[prop] = attrValue.slice();

package/src/integrationCapture.ts

@@ -120,6 +120,17 @@ const integrationMappingExternal: IntegrationIdMapping = {
         mappedKey: 'SnapchatConversions.ClickId',
         output: IntegrationOutputs.CUSTOM_FLAGS,
     },
+    // Pinterest
+    // https://developers.pinterest.com/docs/track-conversions/track-conversions-in-the-api/
+    // https://help.pinterest.com/en/business/article/pinterest-tag-parameters-and-cookies
+    epik: {
+        mappedKey: 'Pinterest.click_id',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
+    },
+    _epik: {
+        mappedKey: 'Pinterest.click_id',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
+    },
     // Snapchat
     // https://developers.snap.com/api/marketing-api/Conversions-API/UsingTheAPI#sending-click-id
     _scid: {
@@ -175,6 +186,8 @@ export default class IntegrationCapture {
         const cookies = this.captureCookies() || {};
         const localStorage = this.captureLocalStorage() || {};
 
+        this.applyPinterestRules(queryParams, localStorage, cookies);
+
         // Facebook Rules
         // Exclude _fbc if fbclid is present
         // https://developers.facebook.com/docs/marketing-api/conversions-api/parameters/fbp-and-fbc#retrieve-from-fbclid-url-query-parameter
@@ -324,6 +337,52 @@ export default class IntegrationCapture {
         return mappedClickIds;
     }
 
+    private normalizePinterestClickId(clickIds: Dictionary<string>): void {
+        // Deterministic tie-breaker when both aliases are present in the same source:
+        // keep _epik and drop epik.
+        if (!isEmpty(clickIds?.['_epik']) && !isEmpty(clickIds?.['epik'])) {
+            delete clickIds['epik'];
+        }
+    }
+
+    private hasPinterestAlias(clickIds: Dictionary<string>): boolean {
+        return !isEmpty(clickIds?.['epik']) || !isEmpty(clickIds?.['_epik']);
+    }
+
+    private applyPinterestRules(
+        queryParams: Dictionary<string>,
+        localStorage: Dictionary<string>,
+        cookies: Dictionary<string>,
+    ): void {
+        this.normalizePinterestClickId(queryParams);
+        this.normalizePinterestClickId(localStorage);
+        this.normalizePinterestClickId(cookies);
+
+        // Cross-source precedence: query params > localStorage > cookies.
+        // Within the same source, prefer _epik when both aliases are present.
+        if (
+            this.hasPinterestAlias(queryParams) ||
+            this.hasPinterestAlias(localStorage) ||
+            this.hasPinterestAlias(cookies)
+        ) {
+            delete this.clickIds?.['epik'];
+            delete this.clickIds?.['_epik'];
+        }
+
+        if (this.hasPinterestAlias(queryParams)) {
+            delete cookies['epik'];
+            delete cookies['_epik'];
+            delete localStorage['epik'];
+            delete localStorage['_epik'];
+            return;
+        }
+
+        if (this.hasPinterestAlias(localStorage)) {
+            delete cookies['epik'];
+            delete cookies['_epik'];
+        }
+    }
+
     private applyProcessors(
         clickIds: Dictionary<string>,
         url?: string,

package/src/mp-instance.ts

@@ -1454,7 +1454,9 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
                 mpInstance.Logger.verbose(
                     'mParticle APV: [sdk-init] creating new PageViewTracker for this instance'
                 );
-                mpInstance._PageViewTracker = new PageViewTracker(mpInstance);
+                mpInstance._PageViewTracker = new PageViewTracker(mpInstance, {
+                    isAutoPageView: true,
+                });
             }
 
             // The initial page view fires once per hard page load, not once per
@@ -1467,7 +1469,7 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
                 );
             } else {
                 markInitialPageViewFired();
-                mpInstance._Events.logPageView();
+                mpInstance._Events.logPageView({ isAutoPageView: true });
             }
 
             mpInstance._PageViewTracker.init();

package/src/pageViewTracker.ts

@@ -127,6 +127,13 @@ interface IPageSnapshot {
 interface IPageViewData extends IPageSnapshot {
     hostname: string;
     title: string;
+    isAutoPageView?: boolean;
+}
+
+// Options for the emitters the AutoLogPageView flag drives. Passing this is how
+// an emitter is told it is automatic; it never reads the feature flag itself.
+export interface IPageViewOptions {
+    isAutoPageView?: boolean;
 }
 
 interface IPendingNavigation {
@@ -147,6 +154,16 @@ interface IPendingNavigation {
 export const allowedQueryParams = (href: string): Dictionary<string> =>
     queryStringParser(href, ALLOWED_QUERY_PARAMS);
 
+export const AUTO_PAGE_VIEW_ATTRIBUTE = 'is_auto_page_view';
+
+// Absent rather than false on a manual page view, so the attribute is only ever
+// added by the automatic emitters. Shared by both of them so the key and that
+// rule have one definition instead of two that can drift.
+export const autoPageViewAttribute = (
+    isAutoPageView?: boolean
+): Dictionary<boolean> =>
+    isAutoPageView ? { [AUTO_PAGE_VIEW_ATTRIBUTE]: true } : {};
+
 // The captured params, in allowlist order. Ordering comes from the constant
 // rather than a sort: it is deterministic without needing a comparator, and it
 // does not depend on the object's insertion order, so reordering the query string
@@ -200,6 +217,7 @@ export const buildPageViewEvent = ({
     hostname,
     title,
     path,
+    isAutoPageView,
 }: IPageViewData): BaseEvent => ({
     messageType: MessageType.PageView,
     name: 'PageView',
@@ -211,6 +229,7 @@ export const buildPageViewEvent = ({
         hostname,
         title,
         path,
+        ...autoPageViewAttribute(isAutoPageView),
     },
     eventType: EventType.Unknown,
 });
@@ -411,8 +430,14 @@ export class PageViewTracker {
     private undoHistoryPatch: (() => void) | null = null;
     private popStateListener: (() => void) | null = null;
 
-    constructor(mpInstance: IMParticleWebSDKInstance) {
+    private readonly isAutoPageView: boolean;
+
+    constructor(
+        mpInstance: IMParticleWebSDKInstance,
+        options?: IPageViewOptions
+    ) {
         this.mpInstance = mpInstance;
+        this.isAutoPageView = !!(options && options.isAutoPageView);
     }
 
     // True while this tracker owns the history patch and is listening for
@@ -589,6 +614,7 @@ export class PageViewTracker {
             ...page,
             hostname: window.location.hostname,
             title,
+            isAutoPageView: this.isAutoPageView,
         });
 
         this.log(

package/src/persistence.ts

@@ -1023,7 +1023,7 @@ export default function _Persistence(
         if (csd) {
             let persistence = self.getPersistence();
             if (persistence) {
-                if (persistence[mpid]) {
+                if (mpInstance._Helpers.isObject(persistence[mpid])) {
                     persistence[mpid].csd = csd;
                 } else {
                     persistence[mpid] = {
@@ -1140,7 +1140,7 @@ export default function _Persistence(
         }
         let persistence = self.getPersistence();
         if (persistence) {
-            if (!persistence[mpid]) {
+            if (!mpInstance._Helpers.isObject(persistence[mpid])) {
                 persistence[mpid] = {};
             }
             if (!persistence[mpid].fst) {
@@ -1180,7 +1180,7 @@ export default function _Persistence(
             time = new Date().getTime();
         }
         let persistence = self.getPersistence();
-        if (persistence && persistence[mpid]) {
+        if (persistence && mpInstance._Helpers.isObject(persistence[mpid])) {
             persistence[mpid].lst = time;
             self.savePersistence(persistence);
         }

package/src/store.ts

@@ -533,7 +533,7 @@ export default function Store(
         this.syncPersistenceData();
 
         if (this.persistenceData) {
-            if (this.persistenceData[mpid]) {
+            if (isObject(this.persistenceData[mpid])) {
                 this.persistenceData[mpid][key] = value;
             } else {
                 this.persistenceData[mpid] = {