Allow independent re-entrant history calls

Author: kurtextrem

plugins/3rd-party-optimizer/src/yieldGTMCalls.ts

@@ -348,28 +348,30 @@ const gtmObserver = new MutationObserver(() => {
 gtmObserver.observe(document.documentElement, { childList: true, subtree: true })
 
 // #region History/submit wrapper override
-const originalMethodsCalledInCurrentChain = new Set<Function>()
+const skippedWrappedListenerGenerations = new Map<Function, number>()
+let nextWrappedListenerGeneration = 0
 
-function callOriginalMethod(this: unknown, originalMethod: Function, args: unknown[]) {
-    if (originalMethodsCalledInCurrentChain.has(originalMethod)) return
-    originalMethod.apply(this, args)
-}
-
-function withOriginalMethodAlreadyCalled(originalMethod: Function, callback: VoidFunction) {
-    const alreadyMarked = originalMethodsCalledInCurrentChain.has(originalMethod)
-    originalMethodsCalledInCurrentChain.add(originalMethod)
+function withOlderWrappedListenersSkipped(originalMethod: Function, generation: number, callback: VoidFunction) {
+    const previousSkippedGeneration = skippedWrappedListenerGenerations.get(originalMethod)
+    skippedWrappedListenerGenerations.set(
+        originalMethod,
+        previousSkippedGeneration === undefined ? generation : Math.max(previousSkippedGeneration, generation)
+    )
     try {
         callback()
     } finally {
-        if (!alreadyMarked) {
-            originalMethodsCalledInCurrentChain.delete(originalMethod)
+        if (previousSkippedGeneration === undefined) {
+            skippedWrappedListenerGenerations.delete(originalMethod)
+        } else {
+            skippedWrappedListenerGenerations.set(originalMethod, previousSkippedGeneration)
         }
     }
 }
 
-function wrapListener(originalMethod: Function, value: Function) {
+function wrapListener(originalMethod: Function, value?: Function) {
+    const generation = nextWrappedListenerGeneration++
     // the function syntax is important here so we keep the correct `this`.
-    return function yieldingListener(this: unknown, ...args: unknown[]) {
+    function yieldingListener(this: unknown, ...args: unknown[]) {
         if (DEBUG) {
             console.log("Yielding for", originalMethod)
             console.timeStamp(originalMethod as unknown as string)
@@ -378,29 +380,31 @@ function wrapListener(originalMethod: Function, value: Function) {
         // We first call the original: This optimizes for UX & correctness of React components.
         // e.g., for pushState, when a component renders on a new route, it might set state and/or read from the URL. If the URL isn't
         // accurate, it might lead to wrong behavior.
-        // We don't want to call the underlying native method twice if an override calls a previously captured wrapper.
-        callOriginalMethod.call(this, originalMethod, args)
+        // If an override calls a previously captured wrapper, that older wrapper skips the native method;
+        // fresh calls through the current getter still update history/submit normally.
+        const skippedGeneration = skippedWrappedListenerGenerations.get(originalMethod)
+        if (skippedGeneration === undefined || generation >= skippedGeneration) {
+            originalMethod.apply(this, args)
+        }
+
+        if (!value) return
 
         // If `method` is overriden N times, it creates N yield points (as overrides might be chained)
         yieldUnlessUrgent(() => {
             // The arrow FN is important here so we keep the correct `this`.
-            withOriginalMethodAlreadyCalled(originalMethod, () => {
+            withOlderWrappedListenersSkipped(originalMethod, generation, () => {
                 value.apply(this, args)
             })
         })
     }
+
+    return yieldingListener
 }
 function overrideListener<T extends object>(target: T, method: keyof T) {
     // @ts-expect-error TS(2339): Prototype chain call. We try __proto__ first, as this will usually be the original method.
     const originalMethod: Function = (target.__proto__ as unknown as T)[method] ?? (target[method] as Function)
 
-    let mostRecentWrapper: Function | undefined = wrapListener(
-        originalMethod,
-        // The function syntax is important here so we keep the correct `this`.
-        function firstOverride(this: unknown, ...args: unknown[]) {
-            callOriginalMethod.call(this, originalMethod, args)
-        },
-    )
+    let mostRecentWrapper: Function | undefined = wrapListener(originalMethod)
 
     Object.defineProperty(target, method, {
         enumerable: true,