@mparticle/web-sdk 3.8.1 → 3.9.0

package/dist/mparticle.js

@@ -204,7 +204,7 @@ var mParticle = (function () {
       Base64: Base64$1
     };
 
-    var version = "3.8.1";
+    var version = "3.9.0";
 
     var Constants = {
       sdkVersion: version,
@@ -5882,7 +5882,7 @@ var mParticle = (function () {
         }
         date.setTime(date.getTime() - 24 * 60 * 60 * 1000);
         expires = '; expires=' + date.toUTCString();
-        document.cookie = cookieName + '=' + '' + expires + '; path=/' + domain;
+        writeCookie(cookieName + '=' + '' + expires + '; path=/' + domain);
       };
       this.getCookie = function () {
         var cookies,
@@ -5964,7 +5964,7 @@ var mParticle = (function () {
         }
         encodedCookiesWithExpirationAndPath = self.reduceAndEncodePersistence(cookies, expires, domain, mpInstance._Store.SDKConfig.maxCookieSize);
         mpInstance.Logger.verbose(Messages$4.InformationMessages.CookieSet);
-        window.document.cookie = encodeURIComponent(key) + '=' + encodedCookiesWithExpirationAndPath;
+        writeCookie(encodeURIComponent(key) + '=' + encodedCookiesWithExpirationAndPath);
       };
       /*  This function determines if a cookie is greater than the configured maxCookieSize.
           - If it is, we remove an MPID and its associated UI/UA/CSD from the cookie.
@@ -6056,6 +6056,10 @@ var mParticle = (function () {
         }
         return removeCurrentSessionMpidsByAge(persistence, currentSessionMPIDs, expires, domain, maxCookieSize);
       };
+      function writeCookie(cookie) {
+        var isHttpsPage = window.location.protocol === 'https:';
+        window.document.cookie = isHttpsPage ? cookie + ';Secure' : cookie;
+      }
       function createFullEncodedCookie(persistence, expires, domain) {
         return self.encodePersistence(JSON.stringify(persistence)) + ';expires=' + expires + ';path=/' + domain;
       }
@@ -6319,7 +6323,7 @@ var mParticle = (function () {
         }
         if (mpInstance._Store.SDKConfig.useCookieStorage) {
           var encodedCookiesWithExpirationAndPath = self.reduceAndEncodePersistence(persistence, expires, domain, mpInstance._Store.SDKConfig.maxCookieSize);
-          window.document.cookie = encodeURIComponent(key) + '=' + encodedCookiesWithExpirationAndPath;
+          writeCookie(encodeURIComponent(key) + '=' + encodedCookiesWithExpirationAndPath);
         } else {
           if (mpInstance._Store.isLocalStorageAvailable) {
             try {
@@ -6433,6 +6437,144 @@ var mParticle = (function () {
 
     var HISTORY_METHODS = ['pushState', 'replaceState'];
     var WRAPPED_MARKER = '__mpApvWrapped__';
+    var supportsHistoryTracking = function supportsHistoryTracking(win) {
+      return !!win && win.history !== undefined && typeof win.history.pushState === 'function' && typeof win.addEventListener === 'function';
+    };
+    // Wraps pushState/replaceState so `onNavigate` runs after the real method, and
+    // returns the single function that undoes it — or null when nothing was
+    // installed (history is already wrapped, or a frozen/sealed History rejected the
+    // assignment). Handing back one undo closure keeps the wrapper and original
+    // references out of the tracker entirely: there is no half-patched state for a
+    // caller to inspect, and no way to restore the wrong pair.
+    var patchHistory = function patchHistory(onNavigate, log) {
+      if (window.history.pushState[WRAPPED_MARKER]) {
+        log('[patch] history already wrapped, skipping to avoid double-wrap — STACKED WRAPPER DETECTED');
+        return null;
+      }
+      var originals = {};
+      var wrappers = {};
+      HISTORY_METHODS.forEach(function (name) {
+        var original = window.history[name];
+        originals[name] = original;
+        var wrapper = function wrapper() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var result = original.apply(this, args);
+          onNavigate(name);
+          return result;
+        };
+        Object.defineProperty(wrapper, WRAPPED_MARKER, {
+          value: true,
+          enumerable: false
+        });
+        wrappers[name] = wrapper;
+      });
+      // Restore per method: a third party may have patched one of the two on top of
+      // ours after we installed. Clobbering theirs would break their tracking, so
+      // leave anything that is no longer ours in place.
+      var restore = function restore() {
+        return HISTORY_METHODS.forEach(function (name) {
+          if (window.history[name] === wrappers[name]) {
+            window.history[name] = originals[name];
+            log("[teardown] restored original ".concat(name));
+          } else {
+            log("[teardown] ".concat(name, " no longer ours; leaving in place, gating callback to no-op"));
+          }
+        });
+      };
+      try {
+        HISTORY_METHODS.forEach(function (name) {
+          window.history[name] = wrappers[name];
+        });
+      } catch (e) {
+        log("[error] failed to patch history methods (frozen/sealed), rolling back: ".concat(e));
+        try {
+          restore();
+        } catch (restoreError) {
+          log("[error] failed to restore history methods after patch failure: ".concat(restoreError));
+        }
+        return null;
+      }
+      return restore;
+    };
+    // One History patch for the whole SDK, so page-view tracking and preselection do not
+    // stack two wrappers.
+    //
+    // State lives on `window`, not module scope, because Next.js re-executes the bundle per
+    // SPA navigation while the patch from the previous execution stays installed.
+    var WIN_ROUTE_MONITOR_KEY = '__mpRouteMonitor__';
+    var monitorState = function monitorState() {
+      var win = window;
+      if (!win[WIN_ROUTE_MONITOR_KEY]) {
+        win[WIN_ROUTE_MONITOR_KEY] = {
+          listeners: {},
+          undoHistoryPatch: null,
+          popStateListener: null
+        };
+      }
+      return win[WIN_ROUTE_MONITOR_KEY];
+    };
+    // Reads the shared state at call time, so a wrapper installed by a previous bundle
+    // execution still reaches the current listeners.
+    var emit = function emit(source) {
+      Object.values(monitorState().listeners).forEach(function (listener) {
+        try {
+          listener(source);
+        } catch (e) {
+          // One subscriber must not stop the others, and must never break navigation.
+        }
+      });
+    };
+    var install = function install(state, log) {
+      if (state.undoHistoryPatch || state.popStateListener) {
+        return;
+      }
+      state.undoHistoryPatch = patchHistory(emit, log);
+      state.popStateListener = function () {
+        return emit('popstate');
+      };
+      window.addEventListener('popstate', state.popStateListener);
+    };
+    var uninstall = function uninstall(state) {
+      if (state.popStateListener) {
+        window.removeEventListener('popstate', state.popStateListener);
+        state.popStateListener = null;
+      }
+      if (state.undoHistoryPatch) {
+        state.undoHistoryPatch();
+        state.undoHistoryPatch = null;
+      }
+    };
+    // Installs on the first subscriber and tears down after the last leaves, so a workspace
+    // that needs neither is never patched. Unsubscribing only removes the listener while it
+    // still owns its key, so an outgoing instance cannot remove its replacement.
+    var subscribeToRouteChange = function subscribeToRouteChange(key, listener, log) {
+      if (log === void 0) {
+        log = function log() {
+          return undefined;
+        };
+      }
+      if (!supportsHistoryTracking(typeof window === 'undefined' ? null : window)) {
+        return function () {
+          return undefined;
+        };
+      }
+      var state = monitorState();
+      state.listeners[key] = listener;
+      install(state, log);
+      return function () {
+        if (state.listeners[key] !== listener) {
+          return;
+        }
+        delete state.listeners[key];
+        if (Object.keys(state.listeners).length === 0) {
+          uninstall(state);
+        }
+      };
+    };
+
     // All APV state hangs off one window key, and it is the public debugging
     // contract: `window.__mpApv__` is what you inspect in a console to see whether
     // tracking is live.
@@ -6531,9 +6673,6 @@ var mParticle = (function () {
     var isNewPage = function isNewPage(lastKey, candidateKey) {
       return candidateKey !== lastKey;
     };
-    var supportsHistoryTracking = function supportsHistoryTracking(win) {
-      return !!win && win.history !== undefined && typeof win.history.pushState === 'function' && typeof win.addEventListener === 'function';
-    };
     // Mirrors the event shape of the public mParticle.logPageView(), but carries the
     // path and query params captured when the navigation was accepted rather than the
     // live location.
@@ -6650,65 +6789,6 @@ var mParticle = (function () {
     // ---------------------------------------------------------------------------
     // History patching
     // ---------------------------------------------------------------------------
-    // Wraps pushState/replaceState so `onNavigate` runs after the real method, and
-    // returns the single function that undoes it — or null when nothing was
-    // installed (history is already wrapped, or a frozen/sealed History rejected the
-    // assignment). Handing back one undo closure keeps the wrapper and original
-    // references out of the tracker entirely: there is no half-patched state for a
-    // caller to inspect, and no way to restore the wrong pair.
-    var patchHistory = function patchHistory(onNavigate, log) {
-      if (window.history.pushState[WRAPPED_MARKER]) {
-        log('[patch] history already wrapped, skipping to avoid double-wrap — STACKED WRAPPER DETECTED');
-        return null;
-      }
-      var originals = {};
-      var wrappers = {};
-      HISTORY_METHODS.forEach(function (name) {
-        var original = window.history[name];
-        originals[name] = original;
-        var wrapper = function wrapper() {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-          }
-          var result = original.apply(this, args);
-          onNavigate(name);
-          return result;
-        };
-        Object.defineProperty(wrapper, WRAPPED_MARKER, {
-          value: true,
-          enumerable: false
-        });
-        wrappers[name] = wrapper;
-      });
-      // Restore per method: a third party may have patched one of the two on top of
-      // ours after we installed. Clobbering theirs would break their tracking, so
-      // leave anything that is no longer ours in place.
-      var restore = function restore() {
-        return HISTORY_METHODS.forEach(function (name) {
-          if (window.history[name] === wrappers[name]) {
-            window.history[name] = originals[name];
-            log("[teardown] restored original ".concat(name));
-          } else {
-            log("[teardown] ".concat(name, " no longer ours; leaving in place, gating callback to no-op"));
-          }
-        });
-      };
-      try {
-        HISTORY_METHODS.forEach(function (name) {
-          window.history[name] = wrappers[name];
-        });
-      } catch (e) {
-        log("[error] failed to patch history methods (frozen/sealed), rolling back: ".concat(e));
-        try {
-          restore();
-        } catch (restoreError) {
-          log("[error] failed to restore history methods after patch failure: ".concat(restoreError));
-        }
-        return null;
-      }
-      return restore;
-    };
     // ---------------------------------------------------------------------------
     // Tracker
     // ---------------------------------------------------------------------------
@@ -6718,7 +6798,6 @@ var mParticle = (function () {
         this.active = false;
         this.pendingNavigations = [];
         this.undoHistoryPatch = null;
-        this.popStateListener = null;
         this.mpInstance = mpInstance;
         this.isAutoPageView = !!(options && options.isAutoPageView);
       }
@@ -6753,15 +6832,11 @@ var mParticle = (function () {
         this.active = true;
         this.lastPage = currentPage();
         this.log("[init] seeded lastPage: ".concat(describePage(this.lastPage)));
-        this.undoHistoryPatch = patchHistory(function (source) {
+        this.undoHistoryPatch = subscribeToRouteChange('pageView', function (source) {
           return _this.safeHandleNavigation(source);
         }, function (message) {
           return _this.log(message);
         });
-        this.popStateListener = function () {
-          return _this.safeHandleNavigation('popstate');
-        };
-        window.addEventListener('popstate', this.popStateListener);
         setActiveTracker(this);
         this.log('[init] patched pushState/replaceState + listening for popstate');
         inheritedPages.forEach(function (page) {
@@ -6773,10 +6848,6 @@ var mParticle = (function () {
         // re-init). A handoff calls takePendingNavigations() first, so by this
         // point those paths are already transferred rather than dropped.
         this.takePendingNavigations();
-        if (this.popStateListener) {
-          window.removeEventListener('popstate', this.popStateListener);
-          this.popStateListener = null;
-        }
         if (this.undoHistoryPatch) {
           this.undoHistoryPatch();
           this.undoHistoryPatch = null;
@@ -10608,7 +10679,10 @@ var mParticle = (function () {
     //
     // https://github.com/mparticle-integrations/mparticle-javascript-integration-rokt
     var RoktManager = /** @class */function () {
-      function RoktManager() {
+      // Keys this manager's route subscription, so a re-executed bundle's manager replaces
+      // it while a second named instance keeps its own.
+      function RoktManager(instanceName) {
+        this.instanceName = instanceName;
         this.kit = null;
         this.filters = {};
         this.currentUser = null;
@@ -10618,6 +10692,7 @@ var mParticle = (function () {
         this.onReadyCallback = null;
         this.initialized = false;
         this.isShoppableAdsLoaded = false;
+        this.stopRouteChangeWatch = null;
       }
       /**
        * Sets a callback to be invoked when RoktManager becomes ready
@@ -10695,6 +10770,7 @@ var mParticle = (function () {
       RoktManager.prototype.attachKit = function (kit) {
         var _a, _b, _c, _d;
         this.kit = kit;
+        this.watchRouteChanges();
         if ((_a = kit.settings) === null || _a === void 0 ? void 0 : _a.accountId) {
           this.store.setRoktAccountId(kit.settings.accountId);
         }
@@ -10708,6 +10784,37 @@ var mParticle = (function () {
           (_d = this.logger) === null || _d === void 0 ? void 0 : _d.error('RoktManager: Error in onReadyCallback: ' + e);
         }
       };
+      // Core already emits a page view per navigation when AutoLogPageView is on, so the kit
+      // is only told about route changes when it is off.
+      RoktManager.prototype.watchRouteChanges = function () {
+        var _this = this;
+        var _a, _b;
+        if (!isFunction((_a = this.kit) === null || _a === void 0 ? void 0 : _a.onRouteChange) || this.isAutoLogPageViewEnabled()) {
+          (_b = this.stopRouteChangeWatch) === null || _b === void 0 ? void 0 : _b.call(this);
+          this.stopRouteChangeWatch = null;
+          return;
+        }
+        if (!this.stopRouteChangeWatch) {
+          this.stopRouteChangeWatch = subscribeToRouteChange("rokt:".concat(this.instanceName), function () {
+            return _this.notifyRouteChange();
+          });
+        }
+        // A full navigation lands on the trigger route without a route change of its own.
+        this.notifyRouteChange();
+      };
+      // Reads `this.kit` at call time, so a kit attached by a later init() takes over.
+      RoktManager.prototype.notifyRouteChange = function () {
+        var _a, _b, _c;
+        try {
+          (_b = (_a = this.kit) === null || _a === void 0 ? void 0 : _a.onRouteChange) === null || _b === void 0 ? void 0 : _b.call(_a);
+        } catch (e) {
+          (_c = this.logger) === null || _c === void 0 ? void 0 : _c.error("RoktManager: Error in onRouteChange: ".concat(getErrorMessage(e)));
+        }
+      };
+      RoktManager.prototype.isAutoLogPageViewEnabled = function () {
+        var _a, _b, _c;
+        return ((_c = (_b = (_a = this.store) === null || _a === void 0 ? void 0 : _a.SDKConfig) === null || _b === void 0 ? void 0 : _b.flags) === null || _c === void 0 ? void 0 : _c[Constants.FeatureFlags.AutoLogPageView]) === true;
+      };
       /**
        * Renders ads based on the options provided
        *
@@ -11335,7 +11442,7 @@ var mParticle = (function () {
       };
       this._ErrorReportingDispatcher = new ErrorReportingDispatcher();
       this._LoggingDispatcher = new LoggingDispatcher();
-      this._RoktManager = new RoktManager();
+      this._RoktManager = new RoktManager(instanceName);
       this._RoktManager.setOnReadyCallback(function () {
         self.processQueueOnIdentityFailure();
       });

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

@@ -1,8 +1,6 @@
 import { IMParticleWebSDKInstance } from './mp-instance';
 import { BaseEvent } from './sdkRuntimeModels';
 import { Dictionary } from './utils';
-type HistoryMethodName = 'pushState' | 'replaceState';
-type NavigationSource = HistoryMethodName | 'popstate';
 export declare const WIN_APV_KEY = "__mpApv__";
 export declare const ALLOWED_QUERY_PARAMS: string[];
 interface IPageSnapshot {
@@ -22,20 +20,17 @@ export declare const AUTO_PAGE_VIEW_ATTRIBUTE = "is_auto_page_view";
 export declare const autoPageViewAttribute: (isAutoPageView?: boolean) => Dictionary<boolean>;
 export declare const pageKey: (page: IPageSnapshot) => string;
 export declare const isNewPage: (lastKey: string | null, candidateKey: string) => boolean;
-export declare const supportsHistoryTracking: (win: Window | null) => boolean;
 export declare const buildPageViewEvent: ({ params, hostname, title, path, isAutoPageView, }: IPageViewData) => BaseEvent;
 export declare const getActiveTracker: () => PageViewTracker | undefined;
 export declare const hasInitialPageViewFired: () => boolean;
 export declare const markInitialPageViewFired: () => void;
 export declare const resetPageViewTracking: () => void;
-export declare const patchHistory: (onNavigate: (source: NavigationSource) => void, log: (message: string) => void) => (() => void) | null;
 export declare class PageViewTracker {
     private readonly mpInstance;
     private lastPage;
     private active;
     private pendingNavigations;
     private undoHistoryPatch;
-    private popStateListener;
     private readonly isAutoPageView;
     constructor(mpInstance: IMParticleWebSDKInstance, options?: IPageViewOptions);
     get isActive(): boolean;

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

@@ -58,6 +58,7 @@ export interface IRoktKit {
     use: <T>(name: string) => Promise<T>;
     onShoppableAdsReady(callback: () => void): void;
     terminate?: () => Promise<void>;
+    onRouteChange?: () => void;
     launcherOptions?: Dictionary<any>;
     settings?: IRoktKitSettings;
     integrationName?: string;
@@ -69,6 +70,7 @@ export interface IRoktOptions {
 }
 export type { IRoktLauncherOptions } from "./roktLauncherOptions";
 export default class RoktManager {
+    private readonly instanceName?;
     kit: IRoktKit;
     filters: RoktKitFilterSettings;
     private currentUser;
@@ -88,6 +90,8 @@ export default class RoktManager {
     private onReadyCallback;
     private initialized;
     private isShoppableAdsLoaded;
+    private stopRouteChangeWatch;
+    constructor(instanceName?: string);
     /**
      * Sets a callback to be invoked when RoktManager becomes ready
      */
@@ -109,6 +113,9 @@ export default class RoktManager {
     init(roktConfig: IKitConfigs, filteredUser: IMParticleUser, identityService: SDKIdentityApi, store: IStore, logger?: SDKLoggerApi, options?: IRoktOptions, captureTiming?: (metricsName: string) => void, errorReporter?: IErrorReportingService, loggingService?: ILoggingService, integrationCapture?: IntegrationCapture): void;
     get isInitialized(): boolean;
     attachKit(kit: IRoktKit): void;
+    private watchRouteChanges;
+    private notifyRouteChange;
+    private isAutoLogPageViewEnabled;
     /**
      * Renders ads based on the options provided
      *

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

@@ -0,0 +1,9 @@
+type HistoryMethodName = 'pushState' | 'replaceState';
+export type RouteChangeSource = HistoryMethodName | 'popstate';
+export type RouteChangeListener = (source: RouteChangeSource) => void;
+export declare const supportsHistoryTracking: (win: Window | null) => boolean;
+export declare const patchHistory: (onNavigate: RouteChangeListener, log: (message: string) => void) => (() => void) | null;
+export declare const WIN_ROUTE_MONITOR_KEY = "__mpRouteMonitor__";
+export declare const subscribeToRouteChange: (key: string, listener: RouteChangeListener, log?: (message: string) => void) => (() => void);
+export declare const resetRouteChangeMonitor: () => void;
+export {};

package/package.json

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

package/src/mp-instance.ts

@@ -159,7 +159,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
     this._ErrorReportingDispatcher = new ErrorReportingDispatcher();
     this._LoggingDispatcher = new LoggingDispatcher();
 
-    this._RoktManager = new RoktManager();
+    this._RoktManager = new RoktManager(instanceName);
     
     this._RoktManager.setOnReadyCallback(() => {
         self.processQueueOnIdentityFailure();

package/src/pageViewTracker.ts

@@ -2,18 +2,13 @@ import { IMParticleWebSDKInstance } from './mp-instance';
 import { BaseEvent } from './sdkRuntimeModels';
 import { EventType, MessageType } from './types';
 import { Dictionary, getHref, hasOwnProp, queryStringParser } from './utils';
+import {
+    subscribeToRouteChange,
+    supportsHistoryTracking,
+    type RouteChangeSource,
+} from './routeChangeMonitor';
 
-type HistoryStateMethod = History['pushState'];
-type HistoryMethodName = 'pushState' | 'replaceState';
-type NavigationSource = HistoryMethodName | 'popstate';
-
-const HISTORY_METHODS: HistoryMethodName[] = ['pushState', 'replaceState'];
-
-const WRAPPED_MARKER = '__mpApvWrapped__';
-
-type MarkedHistoryMethod = HistoryStateMethod & {
-    [WRAPPED_MARKER]?: boolean;
-};
+type NavigationSource = RouteChangeSource;
 
 // All APV state hangs off one window key, and it is the public debugging
 // contract: `window.__mpApv__` is what you inspect in a console to see whether
@@ -203,12 +198,6 @@ export const isNewPage = (
     candidateKey: string
 ): boolean => candidateKey !== lastKey;
 
-export const supportsHistoryTracking = (win: Window | null): boolean =>
-    !!win &&
-    win.history !== undefined &&
-    typeof win.history.pushState === 'function' &&
-    typeof win.addEventListener === 'function';
-
 // Mirrors the event shape of the public mParticle.logPageView(), but carries the
 // path and query params captured when the navigation was accepted rather than the
 // live location.
@@ -339,82 +328,6 @@ const describePage = (page: IPageSnapshot | null): string => {
 // History patching
 // ---------------------------------------------------------------------------
 
-// Wraps pushState/replaceState so `onNavigate` runs after the real method, and
-// returns the single function that undoes it — or null when nothing was
-// installed (history is already wrapped, or a frozen/sealed History rejected the
-// assignment). Handing back one undo closure keeps the wrapper and original
-// references out of the tracker entirely: there is no half-patched state for a
-// caller to inspect, and no way to restore the wrong pair.
-export const patchHistory = (
-    onNavigate: (source: NavigationSource) => void,
-    log: (message: string) => void
-): (() => void) | null => {
-    if ((window.history.pushState as MarkedHistoryMethod)[WRAPPED_MARKER]) {
-        log(
-            '[patch] history already wrapped, skipping to avoid double-wrap — STACKED WRAPPER DETECTED'
-        );
-        return null;
-    }
-
-    const originals = {} as Record<HistoryMethodName, HistoryStateMethod>;
-    const wrappers = {} as Record<HistoryMethodName, HistoryStateMethod>;
-
-    HISTORY_METHODS.forEach(name => {
-        const original = window.history[name];
-        originals[name] = original;
-
-        const wrapper = function(
-            this: History,
-            ...args: Parameters<HistoryStateMethod>
-        ): void {
-            const result = original.apply(this, args);
-            onNavigate(name);
-            return result;
-        };
-
-        Object.defineProperty(wrapper, WRAPPED_MARKER, {
-            value: true,
-            enumerable: false,
-        });
-
-        wrappers[name] = wrapper;
-    });
-
-    // Restore per method: a third party may have patched one of the two on top of
-    // ours after we installed. Clobbering theirs would break their tracking, so
-    // leave anything that is no longer ours in place.
-    const restore = (): void =>
-        HISTORY_METHODS.forEach(name => {
-            if (window.history[name] === wrappers[name]) {
-                window.history[name] = originals[name];
-                log(`[teardown] restored original ${name}`);
-            } else {
-                log(
-                    `[teardown] ${name} no longer ours; leaving in place, gating callback to no-op`
-                );
-            }
-        });
-
-    try {
-        HISTORY_METHODS.forEach(name => {
-            window.history[name] = wrappers[name];
-        });
-    } catch (e) {
-        log(
-            `[error] failed to patch history methods (frozen/sealed), rolling back: ${e}`
-        );
-        try {
-            restore();
-        } catch (restoreError) {
-            log(
-                `[error] failed to restore history methods after patch failure: ${restoreError}`
-            );
-        }
-        return null;
-    }
-
-    return restore;
-};
 
 // ---------------------------------------------------------------------------
 // Tracker
@@ -428,7 +341,6 @@ export class PageViewTracker {
     private pendingNavigations: IPendingNavigation[] = [];
 
     private undoHistoryPatch: (() => void) | null = null;
-    private popStateListener: (() => void) | null = null;
 
     private readonly isAutoPageView: boolean;
 
@@ -473,12 +385,11 @@ export class PageViewTracker {
         this.lastPage = currentPage();
         this.log(`[init] seeded lastPage: ${describePage(this.lastPage)}`);
 
-        this.undoHistoryPatch = patchHistory(
+        this.undoHistoryPatch = subscribeToRouteChange(
+            'pageView',
             source => this.safeHandleNavigation(source),
             message => this.log(message)
         );
-        this.popStateListener = () => this.safeHandleNavigation('popstate');
-        window.addEventListener('popstate', this.popStateListener);
 
         setActiveTracker(this);
 
@@ -495,11 +406,6 @@ export class PageViewTracker {
         // point those paths are already transferred rather than dropped.
         this.takePendingNavigations();
 
-        if (this.popStateListener) {
-            window.removeEventListener('popstate', this.popStateListener);
-            this.popStateListener = null;
-        }
-
         if (this.undoHistoryPatch) {
             this.undoHistoryPatch();
             this.undoHistoryPatch = null;

package/src/persistence.ts

@@ -407,7 +407,7 @@ export default function _Persistence(
 
         date.setTime(date.getTime() - 24 * 60 * 60 * 1000);
         expires = '; expires=' + date.toUTCString();
-        document.cookie = cookieName + '=' + '' + expires + '; path=/' + domain;
+        writeCookie(cookieName + '=' + '' + expires + '; path=/' + domain);
     };
 
     this.getCookie = function(): IPersistenceMinified | null {
@@ -532,8 +532,9 @@ export default function _Persistence(
 
         mpInstance.Logger.verbose(Messages.InformationMessages.CookieSet);
 
-        window.document.cookie =
-            encodeURIComponent(key) + '=' + encodedCookiesWithExpirationAndPath;
+        writeCookie(
+            encodeURIComponent(key) + '=' + encodedCookiesWithExpirationAndPath
+        );
     };
 
     /*  This function determines if a cookie is greater than the configured maxCookieSize.
@@ -730,6 +731,11 @@ export default function _Persistence(
         );
     };
 
+    function writeCookie(cookie: string): void {
+        const isHttpsPage = window.location.protocol === 'https:';
+        window.document.cookie = isHttpsPage ? cookie + ';Secure' : cookie;
+    }
+
     function createFullEncodedCookie(persistence: IPersistenceMinified, expires: string, domain: string): string {
         return (
             self.encodePersistence(JSON.stringify(persistence)) +
@@ -1086,10 +1092,11 @@ export default function _Persistence(
                 domain,
                 mpInstance._Store.SDKConfig.maxCookieSize
             );
-            window.document.cookie =
+            writeCookie(
                 encodeURIComponent(key) +
-                '=' +
-                encodedCookiesWithExpirationAndPath;
+                    '=' +
+                    encodedCookiesWithExpirationAndPath
+            );
         } else {
             if (mpInstance._Store.isLocalStorageAvailable) {
                 try {