@oracle/oraclejet 15.1.11 → 15.1.12

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.11"}' !important; }
+  font-family: '{"name":"stable","targetPlatform":"all","behavior":"redwood","jetReleaseVersion":"v15.1.12"}' !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.11',
+    version: '15.1.12',
     /**
      * @global
      * @member {string} revision JET source code revision number
      */
-    revision: '2024-04-19_19-35-38',
+    revision: '2024-08-27_12-07-50',
 
     // 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/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (Logger, ojobservable, UrlPathAdapter) { 'use strict';
+define(['ojs/ojobservable', 'ojs/ojurlpathadapter', 'ojs/ojlogger'], function (ojobservable, UrlPathAdapter, Logger) { 'use strict';
 
   UrlPathAdapter = UrlPathAdapter && Object.prototype.hasOwnProperty.call(UrlPathAdapter, 'default') ? UrlPathAdapter['default'] : UrlPathAdapter;
 
@@ -79,6 +79,9 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
   // 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.
@@ -561,16 +564,36 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
    * @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(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;
-    });
+    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;
+      });
   };
 
   /**
@@ -703,9 +726,16 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
       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}`);
@@ -713,22 +743,12 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
         // to store their transitions. Replace the segments after our index with
         // the new transitions
         noHistorySegments = noHistorySegments.slice(0, this._noHistoryOffset).concat(transitions);
-      } 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);
-        }
+      } else 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 {
@@ -736,6 +756,7 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
         }
         throw ex;
       });
+      pendingTransitions = transitions.slice(1);
     }
     return goP;
   };
@@ -788,7 +809,7 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
       if (activeSync !== this._activeSync) {
         // If this isn't the latest sync, then reject the Promise because another
         // sync() is already underway
-        return Promise.reject('sync overridden');
+        return Promise.reject();
       }
       return s;
     });
@@ -823,7 +844,10 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
    */
   CoreRouter.prototype._setupNavigationListener = function () {
     if (this === rootRouter) {
-      this._popstateHandler = () => this.sync();
+      this._popstateHandler = () => {
+        pendingTransitions = [];
+        this.sync();
+      };
       window.addEventListener('popstate', this._popstateHandler, false);
     }
   };
@@ -848,10 +872,12 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
    * 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) {
+  CoreRouter.prototype._getPendingState = function (transition, createEmpty) {
     var pending;
     var path = transition.path;
     var params = transition.params || {};
@@ -870,6 +896,13 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
         _match: match._match
       };
       Object.freeze(pending);
+    } else if (createEmpty) {
+      pending = {
+        path,
+        params: {},
+        detail: {},
+        pathParams: []
+      };
     }
     return pending;
   };
@@ -993,13 +1026,6 @@ define(['ojs/ojlogger', 'ojs/ojobservable', 'ojs/ojurlpathadapter'], function (L
    * @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,140 +4940,20 @@ define(['exports', 'ojs/ojeditablevalue', 'ojs/ojpopupcore', 'ojs/ojinputtext',
         }
       }
 
-      // 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);
-      }
-
-      // 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;
-        }
+      // 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;
       }
 
+      this._super(key, value, flags);
+
       var processSetOptions;
       if (this._processSetOptions && this._processSetOptions.length > 0) {
         // use the last processSetOptions object, which is the one for the current _setOptions call
@@ -5083,7 +4963,36 @@ 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;
-        this._SyncValueWithValueItem(value, this.options.value);
+
+        // 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);
+        }
       } 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.ojContext._GetDisplayValue())
+              (!this.ojContext.isValid() && value !== this._previousDisplayValue)
             ) {
               var onSelectReturn = this._onSelect(valopt, options, e);
               optionalCleanupPromise = onSelectReturn;

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

@@ -1560,7 +1560,6 @@ 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;
@@ -1576,41 +1575,18 @@ var __oj_select_single_metadata =
         }
       }
 
-      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, 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();
-
-            this._setOption('value', newVal);
+      // 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();
-          }
+      // 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);
 
-          this._abstractLovBase.handleDataProviderEvent(event);
+      resolveValueChangeFunc();
 
-          resolveBusyState();
-        }.bind(this)
-      );
+      this._abstractLovBase.handleDataProviderEvent(event);
     },
 
     /**

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.11',
+  version: '15.1.12',
   /**
    * @global
    * @member {string} revision JET source code revision number
    */
-  revision: '2024-04-19_19-35-38',
+  revision: '2024-08-27_12-07-50',
 
   // 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,6 +79,9 @@ 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.
@@ -561,16 +564,36 @@ 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(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;
-  });
+  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;
+    });
 };
 
 /**
@@ -703,9 +726,16 @@ 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}`);
@@ -713,22 +743,12 @@ 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 {
-      // 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);
-      }
+    } else 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 {
@@ -736,6 +756,7 @@ CoreRouter.prototype.go = function (...transitions) {
       }
       throw ex;
     });
+    pendingTransitions = transitions.slice(1);
   }
   return goP;
 };
@@ -788,7 +809,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('sync overridden');
+      return Promise.reject();
     }
     return s;
   });
@@ -823,7 +844,10 @@ CoreRouter.prototype._publish = function (state) {
  */
 CoreRouter.prototype._setupNavigationListener = function () {
   if (this === rootRouter) {
-    this._popstateHandler = () => this.sync();
+    this._popstateHandler = () => {
+      pendingTransitions = [];
+      this.sync();
+    };
     window.addEventListener('popstate', this._popstateHandler, false);
   }
 };
@@ -848,10 +872,12 @@ 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) {
+CoreRouter.prototype._getPendingState = function (transition, createEmpty) {
   var pending;
   var path = transition.path;
   var params = transition.params || {};
@@ -870,6 +896,13 @@ CoreRouter.prototype._getPendingState = function (transition) {
       _match: match._match
     };
     Object.freeze(pending);
+  } else if (createEmpty) {
+    pending = {
+      path,
+      params: {},
+      detail: {},
+      pathParams: []
+    };
   }
   return pending;
 };
@@ -993,13 +1026,6 @@ 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;