@oracle/oraclejet 15.1.12 → 15.1.13

package/dist/css/stable/oj-stable.css

@@ -333,7 +333,7 @@
   visibility: hidden; }
 
 .oj-theme-json {
-  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v15.1.12"}' !important; }
+  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v15.1.13"}' !important; }
 
 .oj-helper-hidden-accessible {
   border: 0;

package/dist/js/libs/oj/debug/ojcore-base.js

@@ -37,12 +37,12 @@ define(['ojs/ojlogger'], function (Logger) { 'use strict';
      * @global
      * @member {string} version JET version numberr
      */
-    version: '15.1.12',
+    version: '15.1.13',
     /**
      * @global
      * @member {string} revision JET source code revision number
      */
-    revision: '2024-08-27_12-07-50',
+    revision: '2024-08-27_12-08-15',
 
     // This function is only meant to be used outside the library, so quoting the name
     // to avoid renaming is appropriate

package/dist/js/libs/oj/debug/ojcorerouter.js

@@ -5,7 +5,7 @@
  * as shown at https://oss.oracle.com/licenses/upl/
  * @ignore
  */
-define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (ojobservable, UrlPathAdapter, Logger) { 'use strict';
+define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (Logger, ojobservable, UrlPathAdapter) { 'use strict';
 
   UrlPathAdapter = UrlPathAdapter && Object.prototype.hasOwnProperty.call(UrlPathAdapter, 'default') ? UrlPathAdapter['default'] : UrlPathAdapter;
 
@@ -79,9 +79,6 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
   // similar to how history-tracking routers use URL segments
   let noHistorySegments = [];
 
-  // Pending transitions array to hold extra transitions passed to go()
-  let pendingTransitions = [];
-
   /**
    * Test if two routes are equivalent. Routes are equivalent if they have the
    * same paths and parameter values.
@@ -564,36 +561,16 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
    * @ojsignature {target: "Type", value: "Promise<CoreRouter.CoreRouterState<D, P>>", for: "returns"}
    */
   CoreRouter.prototype.sync = function () {
-    let route;
-    if (pendingTransitions.length) {
-      // Use the pending transition as the new state to sync
-      const transition = pendingTransitions.shift();
-      const newRoutes = this._getParentRoutes().concat(this._getPendingState(transition));
-      const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-      window.history.replaceState(null, 'path', newPath);
-      route = transition;
-    } else {
-      route = this._getRouteSegment();
-    }
     // Transition to the new route, or a default one if no current one exists
-    return this._execute(route || { path: '', params: {} })
-      .then((state) => {
-        // Synchronize the next child router
-        var p = state;
-        var childRouter = this.childRouter;
-        if (childRouter) {
-          p = childRouter.sync();
-        } else if (!this._noHistory) {
-          // Cleanup noHistorySegments after navigating any history-tracking routers
-          noHistorySegments = [];
-        }
-        return p;
-      })
-      .catch((ex) => {
-        // Clear transitions if transition rejected
-        pendingTransitions = [];
-        throw ex;
-      });
+    return this._execute(this._getRouteSegment() || { path: '', params: {} }).then((state) => {
+      // Synchronize the next child router
+      var p = state;
+      var childRouter = this.childRouter;
+      if (childRouter) {
+        p = childRouter.sync();
+      }
+      return p;
+    });
   };
 
   /**
@@ -726,16 +703,9 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
       const path = transitions.map((t) => t.path).join('/');
       Logger.info(`Navigating router(${this._name}) to ${path}`);
 
-      // Use first transition and store remaining for next child router to read
-      const first = transitions[0];
-
       // Get the current routes for all active routers, and compare that to the
       // new routes for this transition.
       const currentPath = urlAdapter.getUrlForRoutes(getActiveRoutes());
-      // Insert the new transitions after the current router's route offset
-      const newRoutes = this._getParentRoutes().concat(this._getPendingState(first, true));
-      const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-
       const prevNoHistorySegments = noHistorySegments;
       if (this._noHistory) {
         Logger.info(`Navigating non-history tracking router(${this._name}) to ${path}`);
@@ -743,12 +713,22 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
         // to store their transitions. Replace the segments after our index with
         // the new transitions
         noHistorySegments = noHistorySegments.slice(0, this._noHistoryOffset).concat(transitions);
-      } else if (currentPath !== newPath) {
-        window.history.pushState(null, 'path', newPath);
+      } else {
+        // Cleanup noHistorySegments when navigating any history-tracking routers
+        noHistorySegments = [];
+        // Insert the new transitions after the current router's route offset
+        const newRoutes = this._getParentRoutes().concat(
+          // only first transition is for this router
+          this._getPendingState(transitions[0]),
+          // remaining are for child routers
+          transitions.slice(1)
+        );
+        const newPath = urlAdapter.getUrlForRoutes(newRoutes);
+        if (currentPath !== newPath) {
+          window.history.pushState(null, 'path', newPath);
+        }
       }
       goP = this.sync().catch((ex) => {
-        // Clear transitions if transition rejected
-        pendingTransitions = [];
         if (this._noHistory) {
           noHistorySegments = prevNoHistorySegments;
         } else {
@@ -756,7 +736,6 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
         }
         throw ex;
       });
-      pendingTransitions = transitions.slice(1);
     }
     return goP;
   };
@@ -809,7 +788,7 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
       if (activeSync !== this._activeSync) {
         // If this isn't the latest sync, then reject the Promise because another
         // sync() is already underway
-        return Promise.reject();
+        return Promise.reject('sync overridden');
       }
       return s;
     });
@@ -844,10 +823,7 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
    */
   CoreRouter.prototype._setupNavigationListener = function () {
     if (this === rootRouter) {
-      this._popstateHandler = () => {
-        pendingTransitions = [];
-        this.sync();
-      };
+      this._popstateHandler = () => this.sync();
       window.addEventListener('popstate', this._popstateHandler, false);
     }
   };
@@ -872,12 +848,10 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
    * configured states. This CoreRouterState object will similar to the matched configured
    * state, except will have its own path and params values.
    * @param {CoreRouter.Route} transition The transition for the CoreRouterState
-   * @param {boolean} createEmpty Create an empty state object for the transition,
-   * even if a matching route doesn't exist.
    * @return {CoreRouter.RouterState} The CoreRouterState associated for the transition
    * @private
    */
-  CoreRouter.prototype._getPendingState = function (transition, createEmpty) {
+  CoreRouter.prototype._getPendingState = function (transition) {
     var pending;
     var path = transition.path;
     var params = transition.params || {};
@@ -896,13 +870,6 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
         _match: match._match
       };
       Object.freeze(pending);
-    } else if (createEmpty) {
-      pending = {
-        path,
-        params: {},
-        detail: {},
-        pathParams: []
-      };
     }
     return pending;
   };
@@ -1026,6 +993,13 @@ define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (o
    * @export
    */
   CoreRouter.prototype.destroy = function () {
+    if (this.childRouter) {
+      this.childRouter.destroy();
+    }
+
+    this.beforeStateChange.observers.forEach((subscription) => subscription());
+    this.currentState.observers.forEach((subscription) => subscription());
+
     if (this === rootRouter) {
       window.removeEventListener('popstate', this._popstateHandler, false);
       rootRouter = null;

package/dist/js/libs/oj/debug/ojselectbase.js

@@ -4940,19 +4940,139 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
         }
       }
 
-      // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
-      // If we get a value update, while we are waiting for the valueItem update microtask, we can safely
-      // ignore the value update, if and only if the value is the same as the valueItem that we are currently
-      // processing.
-      if (
-        key === 'value' &&
-        this._currentProcessingValueItem &&
-        this._currentProcessingValueItem.key === value
-      ) {
-        return;
+      // JET-64632 - DataProvider refresh event can wipe out currently selected value
+      // If we get a DP refresh event we may re-set the currently selected value so that we fetch
+      // new data for it, in which case we don't want to fire a change event, so don't call the
+      // superclass.
+      var bSkipSuperclassCall = key === 'value' && this.options.value === value;
+
+      if (!bSkipSuperclassCall) {
+        this._super(key, value, flags);
       }
 
-      this._super(key, value, flags);
+      // In vdom architecture, there are multiple issues with value and valueItem property that we need to
+      // handle.
+      //
+      // JET-51307 - Wrapping select single with value item and value integrations going into loop
+      // with multiple instances of LOV in a page
+      // If we're wrapped by a VComponent and there are multiple instances on the page
+      // all bound to the same valueItem, then if the user selects a new value in one instance,
+      // the page can go into an infinite loop.
+      // If we synchronously update the value on our DOM element here, then when the next preact
+      // render compares the stale vcomp value property against the new value in the DOM, preact
+      // determines it must push the stale value property back down onto us, which then causes
+      // the valueItem to get sync'ed again, and the loop goes on.
+      //
+      // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
+      // In preact, when value & valueItem are set at the same time, we will receive them one after the other.
+      // So, if we process the value when we get it, then we might initiate an unnecessary fetch as we will
+      // later get the data from valueItem.
+      //
+      // JET-64359 - select - single handling of mutation on both value and valueItem properties coming from preact
+      // Also, when either value or valueItem property is ignored when updating props in the wrapper vcomponent,
+      // we will get a setOption call with a null / default value for that property. In these cases, depending on the
+      // order we receive the call, we might incorrectly end up setting the null / default value.
+      //
+      // In order to address all these cases, if we know we are in the vdom land, we will queue a microtask to process
+      // the value and valueItem. Since, preact calls setOptions synchronously for each option, in our microtask callback
+      // we will have access to the latest value for all the properties. We will be setting some flags here to determine
+      // which properties are set by the preact. Then we can use the flags as well as the latest value to determine
+      // how to process the value and valueItem correctly.
+      const elemState = ojcustomelementUtils.CustomElementUtils.getElementState(this.OuterWrapper);
+      if (elemState.getBindingProviderType() === 'preact') {
+        const processValueAndValueItem = () => {
+          // Get the latest value and valueItem
+          const _valueItem = this.options[this._GetValueItemPropertyName()];
+          const _value = this.options.value;
+          // Determine empty states
+          // Note that _Is*****ForPlaceholder simply checks whether the value/valueItem
+          // represents the empty/null state.
+          const isEmptyValue = this._IsValueForPlaceholder(_value);
+          const isEmptyValueItem = this._IsValueItemForPlaceholder(_valueItem);
+
+          // Cleanup function - things to do when exiting the microtask
+          const cleanup = () => {
+            // reset all the flags
+            this._processingSetOptionsMicroTask = false;
+            this._processingValue = false;
+            this._processingValueItem = false;
+          };
+
+          // This will use the value for updating the component
+          const updateUsingValue = () => {
+            abstractLovBase.setValue(_value);
+
+            //  - placeholder is not displayed after removing selections from select many
+            //  - resetting value when value-item and placeholder are set throws exception
+            if (isEmptyValue) {
+              // Note that _GetDefaultValueItemForPlaceholder is just a getter for the
+              // valueItem representing the empty state.
+              this._SetValueItem(this._GetDefaultValueItemForPlaceholder());
+            } else {
+              // update valueItem
+              this._UpdateValueItem(_value);
+            }
+
+            // need to update display value again after valueItem is set correctly
+            this._SetDisplayValue();
+          };
+          // This will use the valueItem for updating the component
+          const updateUsingValueItem = () => {
+            this._valueItemSetInternally = false;
+            this._SyncValueWithValueItem(_valueItem, _value);
+          };
+
+          // If both value and valueItem are provided, then compare them to decide
+          // what to do
+          if (this._processingValue && this._processingValueItem) {
+            // if valueItem and value are not null, and they are conflicting then
+            // throw an error
+            if (!isEmptyValue && !isEmptyValueItem && _valueItem.key !== _value) {
+              // make sure to clean up before throwing an error
+              cleanup();
+              throw new Error('Select Single: conflicting value-item and value');
+            }
+
+            // At this point, either one of them is empty or they both have the same
+            // key. So, if valueItem is not empty, use it. Otherwise, use the value.
+            if (!isEmptyValueItem) {
+              updateUsingValueItem();
+            } else {
+              updateUsingValue();
+            }
+          }
+          // If only value is provided, then use the value
+          else if (this._processingValue) {
+            updateUsingValue();
+          }
+          // If only valueItem is provided then use the valueItem for updating the value
+          else if (this._processingValueItem) {
+            updateUsingValueItem();
+          }
+
+          // Finally clean things up
+          cleanup();
+        };
+
+        // If we receive a value or valueItem setOption call, set the flag and
+        // defer processing them
+        if (key === 'value') {
+          this._processingValue = true;
+        } else if (key === this._GetValueItemPropertyName()) {
+          this._processingValueItem = true;
+        }
+
+        // if we are processing value or valueItem, then queue a microtask to
+        // process them together. Do this only if it is not already queued. Then
+        // return early without doing anything else.
+        if (this._processingValue || this._processingValueItem) {
+          if (!this._processingSetOptionsMicroTask) {
+            this._processingSetOptionsMicroTask = true;
+            window.queueMicrotask(processValueAndValueItem);
+          }
+          return;
+        }
+      }
 
       var processSetOptions;
       if (this._processSetOptions && this._processSetOptions.length > 0) {
@@ -4963,36 +5083,7 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
       //  - need to be able to specify the initial value of select components bound to dprv
       if (key === this._GetValueItemPropertyName()) {
         this._valueItemSetInternally = false;
-
-        // JET-51307 - Wrapping select single with value item and value integrations going into loop
-        // with multiple instances of LOV in a page
-        // If we're wrapped by a VComponent and there are multiple instances on the page
-        // all bound to the same valueItem, then if the user selects a new value in one instance,
-        // the page can go into an infinite loop.
-        // If we synchronously update the value on our DOM element here, then when the next preact
-        // render compares the stale vcomp value property against the new value in the DOM, preact
-        // determines it must push the stale value property back down onto us, which then causes
-        // the valueItem to get sync'ed again, and the loop goes on.
-        // By delaying updating the value on the DOM element here, we avoid preact finding a
-        // difference between its properties and the DOM value, so preact does not push the stale
-        // value prop back down on us.
-        const elemState = ojcustomelementUtils.CustomElementUtils.getElementState(this.OuterWrapper);
-        if (elemState.getBindingProviderType() === 'preact') {
-          // JET-55775 - oj-select-single initiates fetch even when valueItem is provided in preact wrapper
-          // In preact, when value & valueItem are set at the same time, we will receive them one after the other.
-          // Also, we get the valueItem update before the value update. So, we need to treat it as a single update
-          // and ignore the value update when we are waiting for the following microtask to run.
-          this._currentProcessingValueItem = value;
-          window.queueMicrotask(
-            function () {
-              this._SyncValueWithValueItem(value, this.options.value);
-              // as we processed the valueItem, delete the flag
-              this._currentProcessingValueItem = undefined;
-            }.bind(this)
-          );
-        } else {
-          this._SyncValueWithValueItem(value, this.options.value);
-        }
+        this._SyncValueWithValueItem(value, this.options.value);
       } else if (key === 'value') {
         // JET-34601 - SELECT SINGLE- CHANGING DISABLED PROPERTY GIVES A GLOWING EFFECT
         // save the processing function for execution in _setOptions

package/dist/js/libs/oj/debug/ojselectcombobox.js

@@ -9033,7 +9033,7 @@ var __oj_select_many_metadata =
             if (
               (!selectionData && value !== '') ||
               (selectionData && selectionData.label !== value) ||
-              (!this.ojContext.isValid() && value !== this._previousDisplayValue)
+              (!this.ojContext.isValid() && value !== this.ojContext._GetDisplayValue())
             ) {
               var onSelectReturn = this._onSelect(valopt, options, e);
               optionalCleanupPromise = onSelectReturn;

package/dist/js/libs/oj/debug/ojselectsingle.js

@@ -1560,6 +1560,7 @@ var __oj_select_single_metadata =
       }
 
       var newVal = this.options.value;
+      var origVal = this.options.value;
       if (event.type === 'mutate') {
         if (event.detail.remove != null) {
           var keys = event.detail.remove.keys;
@@ -1575,18 +1576,41 @@ var __oj_select_single_metadata =
         }
       }
 
-      // JET-42413: set flag while we're processing a value change so that if an app makes
-      // changes to the component from within the change listener, we can defer processing the
-      // new change until after we're done processing the current change
-      var resolveValueChangeFunc = this._StartMakingInternalValueChange();
+      var resolveBusyState = this._AddBusyState('ojSelectSingle processing DataProvider event');
+
+      // JET-64632 - DataProvider refresh event can wipe out currently selected value
+      // defer handling the event until the throttle promise (which is hooked into JET's Knockout
+      // throttling timeout) resolves so that we can correctly handle the case where we get both a
+      // new value set and a DP event
+      var throttlePromise = this._GetThrottlePromise();
+      throttlePromise.then(
+        function () {
+          // if the component was released before the promise resolved, simply resolve the busy
+          // state and return
+          if (this._bReleasedResources) {
+            resolveBusyState();
+            return;
+          }
 
-      // if the event wasn't dispatched internally, need to re-set the value now that the label may
-      // be available, or because a mutation event removed a selected value
-      this._setOption('value', newVal);
+          // if the event wasn't dispatched internally, and if the value has not been changed since
+          // the event was received, need to re-set the value now that the label may be available,
+          // or because a mutation event removed a selected value
+          if (origVal === this.options.value) {
+            // JET-42413: set flag while we're processing a value change so that if an app makes
+            // changes to the component from within the change listener, we can defer processing the
+            // new change until after we're done processing the current change
+            var resolveValueChangeFunc = this._StartMakingInternalValueChange();
 
-      resolveValueChangeFunc();
+            this._setOption('value', newVal);
 
-      this._abstractLovBase.handleDataProviderEvent(event);
+            resolveValueChangeFunc();
+          }
+
+          this._abstractLovBase.handleDataProviderEvent(event);
+
+          resolveBusyState();
+        }.bind(this)
+      );
     },
 
     /**

package/dist/js/libs/oj/debug_esm/ojcore-base.js

@@ -37,12 +37,12 @@ const oj = {
    * @global
    * @member {string} version JET version numberr
    */
-  version: '15.1.12',
+  version: '15.1.13',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2024-08-27_12-07-50',
+  revision: '2024-08-27_12-08-15',
 
   // This function is only meant to be used outside the library, so quoting the name
   // to avoid renaming is appropriate

package/dist/js/libs/oj/debug_esm/ojcorerouter.js

@@ -5,9 +5,9 @@
  * as shown at https://oss.oracle.com/licenses/upl/
  * @ignore
  */
+import { info } from 'ojs/ojlogger';
 import { BehaviorSubject } from 'ojs/ojobservable';
 import UrlPathAdapter from 'ojs/ojurlpathadapter';
-import { info } from 'ojs/ojlogger';
 
 /**
  * An interface describing the object used by {@link CoreRouter} to represent
@@ -79,9 +79,6 @@ let urlAdapter;
 // similar to how history-tracking routers use URL segments
 let noHistorySegments = [];
 
-// Pending transitions array to hold extra transitions passed to go()
-let pendingTransitions = [];
-
 /**
  * Test if two routes are equivalent. Routes are equivalent if they have the
  * same paths and parameter values.
@@ -564,36 +561,16 @@ CoreRouter.prototype._configure = function (routes = []) {
  * @ojsignature {target: "Type", value: "Promise<CoreRouter.CoreRouterState<D, P>>", for: "returns"}
  */
 CoreRouter.prototype.sync = function () {
-  let route;
-  if (pendingTransitions.length) {
-    // Use the pending transition as the new state to sync
-    const transition = pendingTransitions.shift();
-    const newRoutes = this._getParentRoutes().concat(this._getPendingState(transition));
-    const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-    window.history.replaceState(null, 'path', newPath);
-    route = transition;
-  } else {
-    route = this._getRouteSegment();
-  }
   // Transition to the new route, or a default one if no current one exists
-  return this._execute(route || { path: '', params: {} })
-    .then((state) => {
-      // Synchronize the next child router
-      var p = state;
-      var childRouter = this.childRouter;
-      if (childRouter) {
-        p = childRouter.sync();
-      } else if (!this._noHistory) {
-        // Cleanup noHistorySegments after navigating any history-tracking routers
-        noHistorySegments = [];
-      }
-      return p;
-    })
-    .catch((ex) => {
-      // Clear transitions if transition rejected
-      pendingTransitions = [];
-      throw ex;
-    });
+  return this._execute(this._getRouteSegment() || { path: '', params: {} }).then((state) => {
+    // Synchronize the next child router
+    var p = state;
+    var childRouter = this.childRouter;
+    if (childRouter) {
+      p = childRouter.sync();
+    }
+    return p;
+  });
 };
 
 /**
@@ -726,16 +703,9 @@ CoreRouter.prototype.go = function (...transitions) {
     const path = transitions.map((t) => t.path).join('/');
     info(`Navigating router(${this._name}) to ${path}`);
 
-    // Use first transition and store remaining for next child router to read
-    const first = transitions[0];
-
     // Get the current routes for all active routers, and compare that to the
     // new routes for this transition.
     const currentPath = urlAdapter.getUrlForRoutes(getActiveRoutes());
-    // Insert the new transitions after the current router's route offset
-    const newRoutes = this._getParentRoutes().concat(this._getPendingState(first, true));
-    const newPath = urlAdapter.getUrlForRoutes(newRoutes);
-
     const prevNoHistorySegments = noHistorySegments;
     if (this._noHistory) {
       info(`Navigating non-history tracking router(${this._name}) to ${path}`);
@@ -743,12 +713,22 @@ CoreRouter.prototype.go = function (...transitions) {
       // to store their transitions. Replace the segments after our index with
       // the new transitions
       noHistorySegments = noHistorySegments.slice(0, this._noHistoryOffset).concat(transitions);
-    } else if (currentPath !== newPath) {
-      window.history.pushState(null, 'path', newPath);
+    } else {
+      // Cleanup noHistorySegments when navigating any history-tracking routers
+      noHistorySegments = [];
+      // Insert the new transitions after the current router's route offset
+      const newRoutes = this._getParentRoutes().concat(
+        // only first transition is for this router
+        this._getPendingState(transitions[0]),
+        // remaining are for child routers
+        transitions.slice(1)
+      );
+      const newPath = urlAdapter.getUrlForRoutes(newRoutes);
+      if (currentPath !== newPath) {
+        window.history.pushState(null, 'path', newPath);
+      }
     }
     goP = this.sync().catch((ex) => {
-      // Clear transitions if transition rejected
-      pendingTransitions = [];
       if (this._noHistory) {
         noHistorySegments = prevNoHistorySegments;
       } else {
@@ -756,7 +736,6 @@ CoreRouter.prototype.go = function (...transitions) {
       }
       throw ex;
     });
-    pendingTransitions = transitions.slice(1);
   }
   return goP;
 };
@@ -809,7 +788,7 @@ CoreRouter.prototype._prepublish = function (state) {
     if (activeSync !== this._activeSync) {
       // If this isn't the latest sync, then reject the Promise because another
       // sync() is already underway
-      return Promise.reject();
+      return Promise.reject('sync overridden');
     }
     return s;
   });
@@ -844,10 +823,7 @@ CoreRouter.prototype._publish = function (state) {
  */
 CoreRouter.prototype._setupNavigationListener = function () {
   if (this === rootRouter) {
-    this._popstateHandler = () => {
-      pendingTransitions = [];
-      this.sync();
-    };
+    this._popstateHandler = () => this.sync();
     window.addEventListener('popstate', this._popstateHandler, false);
   }
 };
@@ -872,12 +848,10 @@ CoreRouter.prototype._isCurrentState = function (state) {
  * configured states. This CoreRouterState object will similar to the matched configured
  * state, except will have its own path and params values.
  * @param {CoreRouter.Route} transition The transition for the CoreRouterState
- * @param {boolean} createEmpty Create an empty state object for the transition,
- * even if a matching route doesn't exist.
  * @return {CoreRouter.RouterState} The CoreRouterState associated for the transition
  * @private
  */
-CoreRouter.prototype._getPendingState = function (transition, createEmpty) {
+CoreRouter.prototype._getPendingState = function (transition) {
   var pending;
   var path = transition.path;
   var params = transition.params || {};
@@ -896,13 +870,6 @@ CoreRouter.prototype._getPendingState = function (transition, createEmpty) {
       _match: match._match
     };
     Object.freeze(pending);
-  } else if (createEmpty) {
-    pending = {
-      path,
-      params: {},
-      detail: {},
-      pathParams: []
-    };
   }
   return pending;
 };
@@ -1026,6 +993,13 @@ CoreRouter.prototype.createChildRouter = function (routes, options = {}) {
  * @export
  */
 CoreRouter.prototype.destroy = function () {
+  if (this.childRouter) {
+    this.childRouter.destroy();
+  }
+
+  this.beforeStateChange.observers.forEach((subscription) => subscription());
+  this.currentState.observers.forEach((subscription) => subscription());
+
   if (this === rootRouter) {
     window.removeEventListener('popstate', this._popstateHandler, false);
     rootRouter = null;