ember-source 3.24.0 → 3.24.4

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Ember Changelog
 
+### v3.24.4 (May 3, 2021)
+
+- [#19477](https://github.com/emberjs/ember.js/pull/19477) Allow `<LinkToExternal />` to override internal assertion
+
+### v3.24.3 (March 7, 2021)
+
+- [#19448](https://github.com/emberjs/ember.js/pull/19448) Ensure query params are preserved through an intermediate loading state transition
+- [#19450](https://github.com/emberjs/ember.js/pull/19450) Ensure `routerService.currentRoute.name` and `routerService.currentRouteName` match during loading states
+- [#19395](https://github.com/emberjs/ember.js/pull/19395) [BUGFIX] Ensure `<LinkTo>` can return a valid `href` most of the time
+- [#19397](https://github.com/emberjs/ember.js/pull/19397) [BUGFIX] Force building Ember bundles when `targets.node` is defined
+
+### v3.24.2 (February 10, 2021)
+
+- [#19326](https://github.com/emberjs/ember.js/pull/19326) / [#19387](https://github.com/emberjs/ember.js/pull/19387) [BUGFIX] Fix usage of `<LinkTo />` prior to routing (e.g. component rendering tests)
+
+### v3.24.1 (January 14, 2021)
+
+- [#19337](https://github.com/emberjs/ember.js/pull/19337) [BUGFIX] Ensure query param only `<LinkTo />` are properly scoped in engines
+
 ### v3.24.0 (December 28, 2020)
 
 - [#19224](https://github.com/emberjs/ember.js/pull/19224) [FEATURE] Add `{{page-title}}` helper to route template blueprints to implement [RFC #0654](https://github.com/emberjs/rfcs/blob/master/text/0645-add-ember-page-title-addon.md). 

package/build-metadata.json

@@ -1,6 +1,6 @@
 {
-  "version": "3.24.0",
+  "version": "3.24.4",
   "buildType": "tag",
-  "SHA": "75bb0c42dcf526c92ced96c404dc30edcc09c1da",
-  "assetPath": "/tag/shas/75bb0c42dcf526c92ced96c404dc30edcc09c1da.tgz"
+  "SHA": "0b53dcc356bd8bada09caec168675f835bd71950",
+  "assetPath": "/tag/shas/0b53dcc356bd8bada09caec168675f835bd71950.tgz"
 }

package/dist/dependencies/@glimmer/runtime.js

@@ -2800,31 +2800,29 @@ APPEND_OPCODES.add(51
   let attribute = vm.elements().setDynamicAttribute(name, value, !!trusting, namespace);
 
   if (!isConstRef(reference)) {
-    vm.updateWith(new UpdateDynamicAttributeOpcode(reference, attribute));
+    vm.updateWith(new UpdateDynamicAttributeOpcode(reference, attribute, vm.env));
   }
 });
 
 class UpdateDynamicAttributeOpcode extends UpdatingOpcode {
-  constructor(reference, attribute) {
+  constructor(reference, attribute, env) {
     super();
-    this.reference = reference;
-    this.attribute = attribute;
     this.type = 'patch-element';
-    this.lastValue = valueForRef(reference);
-  }
+    let initialized = false;
+    this.updateRef = createComputeRef(() => {
+      let value = valueForRef(reference);
 
-  evaluate(vm) {
-    let {
-      attribute,
-      reference,
-      lastValue
-    } = this;
-    let currentValue = valueForRef(reference);
+      if (initialized === true) {
+        attribute.update(value, env);
+      } else {
+        initialized = true;
+      }
+    });
+    valueForRef(this.updateRef);
+  }
 
-    if (currentValue !== lastValue) {
-      attribute.update(currentValue, vm.env);
-      this.lastValue = currentValue;
-    }
+  evaluate() {
+    valueForRef(this.updateRef);
   }
 
 }
@@ -3274,7 +3272,7 @@ function setDeferredAttr(vm, name, value, namespace, trusting = false) {
     let attribute = vm.elements().setDynamicAttribute(name, valueForRef(value), trusting, namespace);
 
     if (!isConstRef(value)) {
-      vm.updateWith(new UpdateDynamicAttributeOpcode(value, attribute));
+      vm.updateWith(new UpdateDynamicAttributeOpcode(value, attribute, vm.env));
     }
   }
 }

package/dist/dependencies/router_js.js

@@ -2,22 +2,27 @@ import { Promise } from 'rsvp';
 import { DEBUG } from '@glimmer/env';
 import RouteRecognizer from 'route-recognizer';
 
-const TransitionAbortedError = (function () {
-    TransitionAbortedError.prototype = Object.create(Error.prototype);
-    TransitionAbortedError.prototype.constructor = TransitionAbortedError;
-    function TransitionAbortedError(message) {
-        let error = Error.call(this, message);
-        this.name = 'TransitionAborted';
-        this.message = message || 'TransitionAborted';
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, TransitionAbortedError);
-        }
-        else {
-            this.stack = error.stack;
-        }
+function buildTransitionAborted() {
+    let error = new Error('TransitionAborted');
+    error.name = 'TransitionAborted';
+    error.code = 'TRANSITION_ABORTED';
+    return error;
+}
+function isTransitionAborted(maybeError) {
+    return (typeof maybeError === 'object' &&
+        maybeError !== null &&
+        maybeError.code === 'TRANSITION_ABORTED');
+}
+function isAbortable(maybeAbortable) {
+    return (typeof maybeAbortable === 'object' &&
+        maybeAbortable !== null &&
+        typeof maybeAbortable.isAborted === 'boolean');
+}
+function throwIfAborted(maybe) {
+    if (isAbortable(maybe) && maybe.isAborted) {
+        throw buildTransitionAborted();
     }
-    return TransitionAbortedError;
-})();
+}
 
 const slice = Array.prototype.slice;
 const hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -157,7 +162,7 @@ const STATE_SYMBOL = `__STATE__-2619860001345920-3322w3`;
 const PARAMS_SYMBOL = `__PARAMS__-261986232992830203-23323`;
 const QUERY_PARAMS_SYMBOL = `__QPS__-2619863929824844-32323`;
 /**
-  A Transition is a thennable (a promise-like object) that represents
+  A Transition is a thenable (a promise-like object) that represents
   an attempt to transition to another route. It can be aborted, either
   explicitly via `abort` or by attempting another transition while a
   previous one is still underway. An aborted transition can also
@@ -185,6 +190,7 @@ class Transition {
         this.isCausedByInitialTransition = false;
         this.isCausedByAbortingReplaceTransition = false;
         this._visibleQueryParams = {};
+        this.isIntermediate = false;
         this[STATE_SYMBOL] = state || router.state;
         this.intent = intent;
         this.router = router;
@@ -241,15 +247,9 @@ class Transition {
                 this.pivotHandler = handlerInfo.route;
             }
             this.sequence = router.currentSequence++;
-            this.promise = state
-                .resolve(() => {
-                if (this.isAborted) {
-                    return Promise.reject(false, promiseLabel('Transition aborted - reject'));
-                }
-                return Promise.resolve(true);
-            }, this)
-                .catch((result) => {
-                return Promise.reject(this.router.transitionDidError(result, this));
+            this.promise = state.resolve(this).catch((result) => {
+                let error = this.router.transitionDidError(result, this);
+                throw error;
             }, promiseLabel('Handle Abort'));
         }
         else {
@@ -285,7 +285,7 @@ class Transition {
       succeeds and rejects if it fails/redirects/aborts.
   
       Forwards to the internal `promise` property which you can
-      use in situations where you want to pass around a thennable,
+      use in situations where you want to pass around a thenable,
       but not the Transition itself.
   
       @method then
@@ -318,7 +318,7 @@ class Transition {
     /**
   
       Forwards to the internal `promise` property which you can
-      use in situations where you want to pass around a thennable,
+      use in situations where you want to pass around a thenable,
       but not the Transition itself.
   
       @method finally
@@ -482,7 +482,7 @@ class Transition {
  */
 function logAbort(transition) {
     log(transition.router, transition.sequence, 'detected abort.');
-    return new TransitionAbortedError();
+    return buildTransitionAborted();
 }
 function isTransition(obj) {
     return typeof obj === 'object' && obj instanceof Transition && obj.isTransition;
@@ -608,13 +608,19 @@ class InternalRouteInfo {
     serialize(_context) {
         return this.params || {};
     }
-    resolve(shouldContinue, transition) {
+    resolve(transition) {
         return Promise.resolve(this.routePromise)
-            .then((route) => this.checkForAbort(shouldContinue, route))
+            .then((route) => {
+            throwIfAborted(transition);
+            return route;
+        })
             .then(() => this.runBeforeModelHook(transition))
-            .then(() => this.checkForAbort(shouldContinue, null))
+            .then(() => throwIfAborted(transition))
             .then(() => this.getModel(transition))
-            .then((resolvedModel) => this.checkForAbort(shouldContinue, resolvedModel))
+            .then((resolvedModel) => {
+            throwIfAborted(transition);
+            return resolvedModel;
+        })
             .then((resolvedModel) => this.runAfterModelHook(transition, resolvedModel))
             .then((resolvedModel) => this.becomeResolved(transition, resolvedModel));
     }
@@ -637,7 +643,7 @@ class InternalRouteInfo {
         }
         return resolved;
     }
-    shouldSupercede(routeInfo) {
+    shouldSupersede(routeInfo) {
         // Prefer this newer routeInfo over `other` if:
         // 1) The other one doesn't exist
         // 2) The names don't match
@@ -717,13 +723,6 @@ class InternalRouteInfo {
             return transition.resolvedModels[name];
         });
     }
-    checkForAbort(shouldContinue, value) {
-        return Promise.resolve(shouldContinue()).then(function () {
-            // We don't care about shouldContinue's resolve value;
-            // pass along the original value passed to this fn.
-            return value;
-        }, null);
-    }
     stashResolvedModel(transition, resolvedModel) {
         transition.resolvedModels = transition.resolvedModels || {};
         transition.resolvedModels[this.name] = resolvedModel;
@@ -757,7 +756,7 @@ class ResolvedRouteInfo extends InternalRouteInfo {
         this.isResolved = true;
         this.context = context;
     }
-    resolve(_shouldContinue, transition) {
+    resolve(transition) {
         // A ResolvedRouteInfo just resolved with itself.
         if (transition && transition.resolvedModels) {
             transition.resolvedModels[this.name] = this.context;
@@ -873,6 +872,47 @@ class TransitionIntent {
     }
 }
 
+function handleError(currentState, transition, error) {
+    // This is the only possible
+    // reject value of TransitionState#resolve
+    let routeInfos = currentState.routeInfos;
+    let errorHandlerIndex = transition.resolveIndex >= routeInfos.length ? routeInfos.length - 1 : transition.resolveIndex;
+    let wasAborted = transition.isAborted;
+    throw new TransitionError(error, currentState.routeInfos[errorHandlerIndex].route, wasAborted, currentState);
+}
+function resolveOneRouteInfo(currentState, transition) {
+    if (transition.resolveIndex === currentState.routeInfos.length) {
+        // This is is the only possible
+        // fulfill value of TransitionState#resolve
+        return;
+    }
+    let routeInfo = currentState.routeInfos[transition.resolveIndex];
+    return routeInfo
+        .resolve(transition)
+        .then(proceed.bind(null, currentState, transition), null, currentState.promiseLabel('Proceed'));
+}
+function proceed(currentState, transition, resolvedRouteInfo) {
+    let wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex].isResolved;
+    // Swap the previously unresolved routeInfo with
+    // the resolved routeInfo
+    currentState.routeInfos[transition.resolveIndex++] = resolvedRouteInfo;
+    if (!wasAlreadyResolved) {
+        // Call the redirect hook. The reason we call it here
+        // vs. afterModel is so that redirects into child
+        // routes don't re-run the model hooks for this
+        // already-resolved route.
+        let { route } = resolvedRouteInfo;
+        if (route !== undefined) {
+            if (route.redirect) {
+                route.redirect(resolvedRouteInfo.context, transition);
+            }
+        }
+    }
+    // Proceed after ensuring that the redirect hook
+    // didn't abort this transition by transitioning elsewhere.
+    throwIfAborted(transition);
+    return resolveOneRouteInfo(currentState, transition);
+}
 class TransitionState {
     constructor() {
         this.routeInfos = [];
@@ -890,7 +930,7 @@ class TransitionState {
         });
         return promiseLabel("'" + targetName + "': " + label);
     }
-    resolve(shouldContinue, transition) {
+    resolve(transition) {
         // First, calculate params for this state. This is useful
         // information to provide to the various route hooks.
         let params = this.params;
@@ -899,62 +939,11 @@ class TransitionState {
             return true;
         });
         transition.resolveIndex = 0;
-        let currentState = this;
-        let wasAborted = false;
-        // The prelude RSVP.resolve() asyncs us into the promise land.
+        // The prelude RSVP.resolve() async moves us into the promise land.
         return Promise.resolve(null, this.promiseLabel('Start transition'))
-            .then(resolveOneRouteInfo, null, this.promiseLabel('Resolve route'))
-            .catch(handleError, this.promiseLabel('Handle error'));
-        function innerShouldContinue() {
-            return Promise.resolve(shouldContinue(), currentState.promiseLabel('Check if should continue')).catch(function (reason) {
-                // We distinguish between errors that occurred
-                // during resolution (e.g. before"Model/model/afterModel),
-                // and aborts due to a rejecting promise from shouldContinue().
-                wasAborted = true;
-                return Promise.reject(reason);
-            }, currentState.promiseLabel('Handle abort'));
-        }
-        function handleError(error) {
-            // This is the only possible
-            // reject value of TransitionState#resolve
-            let routeInfos = currentState.routeInfos;
-            let errorHandlerIndex = transition.resolveIndex >= routeInfos.length
-                ? routeInfos.length - 1
-                : transition.resolveIndex;
-            return Promise.reject(new TransitionError(error, currentState.routeInfos[errorHandlerIndex].route, wasAborted, currentState));
-        }
-        function proceed(resolvedRouteInfo) {
-            let wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex].isResolved;
-            // Swap the previously unresolved routeInfo with
-            // the resolved routeInfo
-            currentState.routeInfos[transition.resolveIndex++] = resolvedRouteInfo;
-            if (!wasAlreadyResolved) {
-                // Call the redirect hook. The reason we call it here
-                // vs. afterModel is so that redirects into child
-                // routes don't re-run the model hooks for this
-                // already-resolved route.
-                let { route } = resolvedRouteInfo;
-                if (route !== undefined) {
-                    if (route.redirect) {
-                        route.redirect(resolvedRouteInfo.context, transition);
-                    }
-                }
-            }
-            // Proceed after ensuring that the redirect hook
-            // didn't abort this transition by transitioning elsewhere.
-            return innerShouldContinue().then(resolveOneRouteInfo, null, currentState.promiseLabel('Resolve route'));
-        }
-        function resolveOneRouteInfo() {
-            if (transition.resolveIndex === currentState.routeInfos.length) {
-                // This is is the only possible
-                // fulfill value of TransitionState#resolve
-                return currentState;
-            }
-            let routeInfo = currentState.routeInfos[transition.resolveIndex];
-            return routeInfo
-                .resolve(innerShouldContinue, transition)
-                .then(proceed, null, currentState.promiseLabel('Proceed'));
-        }
+            .then(resolveOneRouteInfo.bind(null, this, transition), null, this.promiseLabel('Resolve route'))
+            .catch(handleError.bind(null, this, transition), this.promiseLabel('Handle error'))
+            .then(() => this);
     }
 }
 class TransitionError {
@@ -1032,7 +1021,7 @@ class NamedTransitionIntent extends TransitionIntent {
                 newHandlerInfo.context = oldContext;
             }
             let handlerToUse = oldHandlerInfo;
-            if (i >= invalidateIndex || newHandlerInfo.shouldSupercede(oldHandlerInfo)) {
+            if (i >= invalidateIndex || newHandlerInfo.shouldSupersede(oldHandlerInfo)) {
                 invalidateIndex = Math.min(i, invalidateIndex);
                 handlerToUse = newHandlerInfo;
             }
@@ -1049,6 +1038,9 @@ class NamedTransitionIntent extends TransitionIntent {
             this.invalidateChildren(newState.routeInfos, invalidateIndex);
         }
         merge(newState.queryParams, this.queryParams || {});
+        if (isIntermediate && oldState.queryParams) {
+            merge(newState.queryParams, oldState.queryParams);
+        }
         return newState;
     }
     invalidateChildren(handlerInfos, invalidateIndex) {
@@ -1180,12 +1172,12 @@ class URLTransitionIntent extends TransitionIntent {
                 checkHandlerAccessibility(route);
             }
             else {
-                // If the hanlder is being loaded asynchronously, check if we can
+                // If the handler is being loaded asynchronously, check if we can
                 // access it after it has resolved
                 newRouteInfo.routePromise = newRouteInfo.routePromise.then(checkHandlerAccessibility);
             }
             let oldRouteInfo = oldState.routeInfos[i];
-            if (statesDiffer || newRouteInfo.shouldSupercede(oldRouteInfo)) {
+            if (statesDiffer || newRouteInfo.shouldSupersede(oldRouteInfo)) {
                 statesDiffer = true;
                 newState.routeInfos[i] = newRouteInfo;
             }
@@ -1320,6 +1312,7 @@ class Router {
         }
         if (isIntermediate) {
             let transition = new Transition(this, undefined, newState);
+            transition.isIntermediate = true;
             this.toReadOnlyInfos(transition, newState);
             this.setupContexts(newState, transition);
             this.routeWillChange(transition);
@@ -1415,7 +1408,7 @@ class Router {
             return routeInfos[routeInfos.length - 1].route;
         }
         catch (e) {
-            if (!(e instanceof TransitionAbortedError)) {
+            if (!isTransitionAborted(e)) {
                 let infos = transition[STATE_SYMBOL].routeInfos;
                 transition.trigger(true, 'error', e, transition, infos[infos.length - 1].route);
                 transition.abort();
@@ -1539,9 +1532,7 @@ class Router {
                     route.enter(transition);
                 }
             }
-            if (transition && transition.isAborted) {
-                throw new TransitionAbortedError();
-            }
+            throwIfAborted(transition);
             route.context = context;
             if (route.contextDidChange !== undefined) {
                 route.contextDidChange();
@@ -1549,9 +1540,7 @@ class Router {
             if (route.setup !== undefined) {
                 route.setup(context, transition);
             }
-            if (transition && transition.isAborted) {
-                throw new TransitionAbortedError();
-            }
+            throwIfAborted(transition);
             currentRouteInfos.push(routeInfo);
             return route;
         }
@@ -1668,7 +1657,7 @@ class Router {
             // button
             let initial = transition.isCausedByInitialTransition;
             // say you are at / and you click a link to route /foo. In /foo's
-            // route, the transition is aborted using replacewith('/bar').
+            // route, the transition is aborted using replaceWith('/bar').
             // Because the current url is still /, the history entry for / is
             // removed from the history. Clicking back will take you to the page
             // you were on before /, which is often not even the app, thus killing
@@ -1883,23 +1872,23 @@ class Router {
             return false;
         }
         let targetHandler = targetRouteInfos[targetRouteInfos.length - 1].name;
-        let recogHandlers = this.recognizer.handlersFor(targetHandler);
+        let recognizerHandlers = this.recognizer.handlersFor(targetHandler);
         let index = 0;
-        for (len = recogHandlers.length; index < len; ++index) {
+        for (len = recognizerHandlers.length; index < len; ++index) {
             routeInfo = targetRouteInfos[index];
             if (routeInfo.name === routeName) {
                 break;
             }
         }
-        if (index === recogHandlers.length) {
+        if (index === recognizerHandlers.length) {
             // The provided route name isn't even in the route hierarchy.
             return false;
         }
         let testState = new TransitionState();
         testState.routeInfos = targetRouteInfos.slice(0, index + 1);
-        recogHandlers = recogHandlers.slice(0, index + 1);
+        recognizerHandlers = recognizerHandlers.slice(0, index + 1);
         let intent = new NamedTransitionIntent(this, targetHandler, undefined, contexts);
-        let newState = intent.applyToHandlers(testState, recogHandlers, targetHandler, true, true);
+        let newState = intent.applyToHandlers(testState, recognizerHandlers, targetHandler, true, true);
         let routesEqual = routeInfosEqual(newState.routeInfos, testState.routeInfos);
         if (!queryParams || !routesEqual) {
             return routesEqual;