ember-source 4.3.0-alpha.4 → 4.3.0

package/dist/packages/@ember/-internals/routing/lib/system/router.js

@@ -11,6 +11,10 @@ import { calculateCacheKey, extractRouteArgs, getActiveTargetName, resemblesURL
 import DSL from './dsl';
 import { defaultSerialize, getFullQueryParams, hasDefaultSerialize, ROUTE_CONNECTIONS } from './route';
 import RouterState from './router_state';
+/**
+@module @ember/routing
+*/
+
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
 
 function defaultDidTransition(infos) {
@@ -166,7 +170,9 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let name, nameParts, oldNameParts;
 
     for (let i = 1; i < routeInfos.length; i++) {
-      name = routeInfos[i].name;
+      let routeInfo = routeInfos[i];
+      assert('has routeInfo', routeInfo);
+      name = routeInfo.name;
       nameParts = name.split('.');
       oldNameParts = slice.call(path);
 
@@ -472,8 +478,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let defaultParentState;
     let liveRoutes = null;
 
-    for (let i = 0; i < routeInfos.length; i++) {
-      let route = routeInfos[i].route;
+    for (let routeInfo of routeInfos) {
+      let route = routeInfo.route;
       let connections = ROUTE_CONNECTIONS.get(route);
       let ownState;
 
@@ -549,9 +555,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
   /**
     Transition the application into another route. The route may
     be either a single route or route path:
-       See [transitionTo](/ember/release/classes/Route/methods/transitionTo?anchor=transitionTo) for more info.
        @method transitionTo
-    @param {String} name the name of the route or a URL
+    @param {String} [name] the name of the route or a URL
     @param {...Object} models the model(s) or identifier(s) to be used while
       transitioning to the route.
     @param {Object} [options] optional hash with a queryParams property
@@ -592,6 +597,23 @@ class EmberRouter extends EmberObject.extend(Evented) {
       }
     }
   }
+  /**
+    Similar to `transitionTo`, but instead of adding the destination to the browser's URL history,
+    it replaces the entry for the current route.
+    When the user clicks the "back" button in the browser, there will be fewer steps.
+    This is most commonly used to manage redirects in a way that does not cause confusing additions
+    to the user's browsing history.
+       @method replaceWith
+    @param {String} [name] the name of the route or a URL
+    @param {...Object} models the model(s) or identifier(s) to be used while
+      transitioning to the route.
+    @param {Object} [options] optional hash with a queryParams property
+      containing a mapping of query parameters
+    @return {Transition} the transition object associated with this
+      attempted transition
+    @public
+  */
+
 
   replaceWith(...args) {
     return this.transitionTo(...args).method('replace');
@@ -677,8 +699,11 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let instances = this._engineInstances;
 
     for (let name in instances) {
-      for (let id in instances[name]) {
-        run(instances[name][id], 'destroy');
+      let instance = instances[name];
+      assert('has instance', instance);
+
+      for (let id in instance) {
+        run(instance[id], 'destroy');
       }
     }
   }
@@ -891,7 +916,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
     }
   }
 
-  _doTransition(_targetRouteName, models, _queryParams, _keepDefaultQueryParamValues) {
+  _doTransition(_targetRouteName, models, _queryParams, _fromRouterService) {
     let targetRouteName = _targetRouteName || getActiveTargetName(this._routerMicrolib);
 
     assert(`The route ${targetRouteName} was not found`, Boolean(targetRouteName) && this._routerMicrolib.hasRoute(targetRouteName));
@@ -902,7 +927,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     Object.assign(queryParams, _queryParams);
 
-    this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_keepDefaultQueryParamValues));
+    this._prepareQueryParams(targetRouteName, models, queryParams, Boolean(_fromRouterService));
 
     let transition = this._routerMicrolib.transitionTo(targetRouteName, ...models, {
       queryParams
@@ -1000,12 +1025,11 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let qps = [];
     let qpsByUrlKey = DEBUG ? {} : null;
     let qpMeta;
-    let qp;
     let urlKey;
     let qpOther;
 
-    for (let i = 0; i < routeInfoLength; ++i) {
-      qpMeta = this._getQPMeta(routeInfos[i]);
+    for (let routeInfo of routeInfos) {
+      qpMeta = this._getQPMeta(routeInfo);
 
       if (!qpMeta) {
         shouldCache = false;
@@ -1013,9 +1037,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
       } // Loop over each QP to make sure we don't have any collisions by urlKey
 
 
-      for (let i = 0; i < qpMeta.qps.length; i++) {
-        qp = qpMeta.qps[i];
-
+      for (let qp of qpMeta.qps) {
         if (DEBUG) {
           urlKey = qp.urlKey;
           qpOther = qpsByUrlKey[urlKey];
@@ -1061,19 +1083,15 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let routeInfos = state.routeInfos;
     let qpMeta;
 
-    for (let i = 0, len = routeInfos.length; i < len; ++i) {
-      qpMeta = this._getQPMeta(routeInfos[i]);
+    for (let routeInfo of routeInfos) {
+      qpMeta = this._getQPMeta(routeInfo);
 
       if (!qpMeta) {
         continue;
       }
 
-      let qp;
-      let presentProp;
-
-      for (let j = 0, qpLen = qpMeta.qps.length; j < qpLen; ++j) {
-        qp = qpMeta.qps[j];
-        presentProp = qp.prop in queryParams && qp.prop || qp.scopedPropertyName in queryParams && qp.scopedPropertyName || qp.urlKey in queryParams && qp.urlKey;
+      for (let qp of qpMeta.qps) {
+        let presentProp = qp.prop in queryParams && qp.prop || qp.scopedPropertyName in queryParams && qp.scopedPropertyName || qp.urlKey in queryParams && qp.urlKey;
 
         if (presentProp) {
           if (presentProp !== qp.scopedPropertyName) {
@@ -1103,15 +1121,17 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let qp;
     let presentProp;
 
-    for (let i = 0; i < routeInfos.length; ++i) {
-      qpMeta = this._getQPMeta(routeInfos[i]);
+    for (let routeInfo of routeInfos) {
+      qpMeta = this._getQPMeta(routeInfo);
 
       if (!qpMeta) {
         continue;
-      }
+      } // Needs to stay for index loop to avoid throwIfClosureRequired
+
 
       for (let j = 0, qpLen = qpMeta.qps.length; j < qpLen; ++j) {
         qp = qpMeta.qps[j];
+        assert('expected qp', qp);
         presentProp = qp.prop in queryParams && qp.prop || qp.scopedPropertyName in queryParams && qp.scopedPropertyName || qp.urlKey in queryParams && qp.urlKey;
         assert(`You passed the \`${presentProp}\` query parameter during a transition into ${qp.route.routeName}, please update to ${qp.urlKey}`, function () {
           if (qp.urlKey === presentProp || qp.scopedPropertyName === presentProp) {
@@ -1188,12 +1208,16 @@ class EmberRouter extends EmberObject.extend(Evented) {
     mountPoint
   }) {
     let engineInstances = this._engineInstances;
+    let namedInstances = engineInstances[name];
+
+    if (!namedInstances) {
+      namedInstances = Object.create(null);
+      engineInstances[name] = namedInstances;
+    } // We just set these!
 
-    if (!engineInstances[name]) {
-      engineInstances[name] = Object.create(null);
-    }
 
-    let engineInstance = engineInstances[name][instanceId];
+    assert('has namedInstances', namedInstances);
+    let engineInstance = namedInstances[instanceId];
 
     if (!engineInstance) {
       let owner = getOwner(this);
@@ -1204,7 +1228,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
         mountPoint
       });
       engineInstance.boot();
-      engineInstances[name][instanceId] = engineInstance;
+      namedInstances[instanceId] = engineInstance;
     }
 
     return engineInstance;
@@ -1231,6 +1255,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 function forEachRouteAbove(routeInfos, callback) {
   for (let i = routeInfos.length - 1; i >= 0; --i) {
     let routeInfo = routeInfos[i];
+    assert('has routeInfo', routeInfo);
     let route = routeInfo.route; // routeInfo.handler being `undefined` generally means either:
     //
     // 1. an error occurred during creation of the route in question
@@ -1433,6 +1458,7 @@ export function triggerEvent(routeInfos, ignoreFailure, name, args) {
 
   for (let i = routeInfos.length - 1; i >= 0; i--) {
     routeInfo = routeInfos[i];
+    assert('has routeInfo', routeInfo);
     handler = routeInfo.route;
     actionHandler = handler && handler.actions && handler.actions[name];
 
@@ -1470,9 +1496,8 @@ function calculatePostTransitionState(emberRouter, leafRouteName, contexts) {
     params
   } = state;
 
-  for (let i = 0; i < routeInfos.length; ++i) {
-    let routeInfo = routeInfos[i]; // If the routeInfo is not resolved, we serialize the context into params
-
+  for (let routeInfo of routeInfos) {
+    // If the routeInfo is not resolved, we serialize the context into params
     if (!routeInfo.isResolved) {
       params[routeInfo.name] = routeInfo.serialize(routeInfo.context);
     } else {
@@ -1492,7 +1517,9 @@ function updatePaths(router) {
 
   let path = EmberRouter._routePath(infos);
 
-  let currentRouteName = infos[infos.length - 1].name;
+  let info = infos[infos.length - 1];
+  assert('expected info', info);
+  let currentRouteName = info.name;
   let location = router.location;
   assert('expected location to not be a string', typeof location !== 'string');
   let currentURL = location.getURL();

package/dist/packages/@ember/-internals/routing/lib/utils.js

@@ -5,22 +5,28 @@ import EmberError from '@ember/error';
 import { STATE_SYMBOL } from 'router_js';
 const ALL_PERIODS_REGEX = /\./g;
 export function extractRouteArgs(args) {
+  // SAFETY: This should just be the same thing
   args = args.slice();
-  let possibleQueryParams = args.pop();
+  let possibleOptions = args[args.length - 1];
   let queryParams;
 
-  if (hasQueryParams(possibleQueryParams)) {
-    queryParams = possibleQueryParams.queryParams;
+  if (isRouteOptions(possibleOptions)) {
+    args.pop(); // Remove options
+
+    queryParams = possibleOptions.queryParams;
   } else {
-    // Not query params so return to the array
-    args.push(possibleQueryParams);
     queryParams = {};
-  } // UNSAFE: these are simply assumed as the existing behavior of the system.
-  // However, this could break if upstream refactors change it, and the types
-  // here would not be able to tell us; we would lie to everything downstream.
+  }
+
+  let routeName;
+
+  if (typeof args[0] === 'string') {
+    routeName = args.shift(); // We just checked this!
+
+    assert('routeName is a string', typeof routeName === 'string');
+  } // SAFTEY: We removed the name and options if they existed, only models left.
 
 
-  let routeName = args.shift();
   let models = args;
   return {
     routeName,
@@ -30,7 +36,9 @@ export function extractRouteArgs(args) {
 }
 export function getActiveTargetName(router) {
   let routeInfos = router.activeTransition ? router.activeTransition[STATE_SYMBOL].routeInfos : router.state.routeInfos;
-  return routeInfos[routeInfos.length - 1].name;
+  let lastRouteInfo = routeInfos[routeInfos.length - 1];
+  assert('has last route info', lastRouteInfo);
+  return lastRouteInfo.name;
 }
 export function stashParamNames(router, routeInfos) {
   if (routeInfos['_namesStashed']) {
@@ -41,7 +49,9 @@ export function stashParamNames(router, routeInfos) {
   // Hopefully we can remove this in the future.
 
 
-  let targetRouteName = routeInfos[routeInfos.length - 1].name;
+  let routeInfo = routeInfos[routeInfos.length - 1];
+  assert('has route info', routeInfo);
+  let targetRouteName = routeInfo.name;
 
   let recogHandlers = router._routerMicrolib.recognizer.handlersFor(targetRouteName);
 
@@ -49,6 +59,7 @@ export function stashParamNames(router, routeInfos) {
 
   for (let i = 0; i < routeInfos.length; ++i) {
     let routeInfo = routeInfos[i];
+    assert('has route info', routeInfo);
     let names = recogHandlers[i].names;
 
     if (names.length) {
@@ -56,7 +67,7 @@ export function stashParamNames(router, routeInfos) {
     }
 
     routeInfo['_names'] = names;
-    let route = routeInfo.route;
+    let route = routeInfo.route; // SAFETY: This cast should be idential. I don't understand why it is needed.
 
     route._stashNames(routeInfo, dynamicParent);
   }
@@ -94,9 +105,7 @@ function _calculateCacheValuePrefix(prefix, part) {
 export function calculateCacheKey(prefix, parts = [], values) {
   let suffixes = '';
 
-  for (let i = 0; i < parts.length; ++i) {
-    let part = parts[i];
-
+  for (let part of parts) {
     let cacheValuePrefix = _calculateCacheValuePrefix(prefix, part);
 
     let value;
@@ -151,8 +160,8 @@ export function calculateCacheKey(prefix, parts = [], values) {
 export function normalizeControllerQueryParams(queryParams) {
   let qpMap = {};
 
-  for (let i = 0; i < queryParams.length; ++i) {
-    accumulateQueryParamDescriptors(queryParams[i], qpMap);
+  for (let queryParam of queryParams) {
+    accumulateQueryParamDescriptors(queryParam, qpMap);
   }
 
   return qpMap;
@@ -208,12 +217,14 @@ export function resemblesURL(str) {
 */
 
 export function prefixRouteNameArg(route, args) {
-  let routeName = args[0];
+  let routeName;
   let owner = getOwner(route);
   assert('Route is unexpectedly missing an owner', owner);
   let prefix = owner.mountPoint; // only alter the routeName if it's actually referencing a route.
 
-  if (owner.routable && typeof routeName === 'string') {
+  if (owner.routable && typeof args[0] === 'string') {
+    routeName = args[0];
+
     if (resemblesURL(routeName)) {
       throw new EmberError('Programmatic transitions by URL cannot be used within an Engine. Please use the route name instead.');
     } else {
@@ -260,7 +271,7 @@ export function deprecateTransitionMethods(frameworkClass, methodName) {
   });
 }
 
-function hasQueryParams(value) {
+function isRouteOptions(value) {
   if (value && typeof value === 'object') {
     let qps = value.queryParams;
 

package/dist/packages/@ember/-internals/runtime/lib/mixins/action_handler.js

@@ -21,16 +21,16 @@ const ActionHandler = Mixin.create({
   /**
     The collection of functions, keyed by name, available on this
     `ActionHandler` as action targets.
-       These functions will be invoked when a matching `{{action}}` is triggered
+     These functions will be invoked when a matching `{{action}}` is triggered
     from within a template and the application's current route is this route.
-       Actions can also be invoked from other parts of your application
+     Actions can also be invoked from other parts of your application
     via `ActionHandler#send`.
-       The `actions` hash will inherit action handlers from
+     The `actions` hash will inherit action handlers from
     the `actions` hash defined on extended parent classes
     or mixins rather than just replace the entire hash, e.g.:
-       ```app/mixins/can-display-banner.js
+     ```app/mixins/can-display-banner.js
     import Mixin from '@ember/mixin';
-       export default Mixin.create({
+     export default Mixin.create({
       actions: {
         displayBanner(msg) {
           // ...
@@ -38,28 +38,28 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-       ```app/routes/welcome.js
+     ```app/routes/welcome.js
     import Route from '@ember/routing/route';
     import CanDisplayBanner from '../mixins/can-display-banner';
-       export default Route.extend(CanDisplayBanner, {
+     export default Route.extend(CanDisplayBanner, {
       actions: {
         playMusic() {
           // ...
         }
       }
     });
-       // `WelcomeRoute`, when active, will be able to respond
+     // `WelcomeRoute`, when active, will be able to respond
     // to both actions, since the actions hash is merged rather
     // then replaced when extending mixins / parent classes.
     this.send('displayBanner');
     this.send('playMusic');
     ```
-       Within a Controller, Route or Component's action handler,
+     Within a Controller, Route or Component's action handler,
     the value of the `this` context is the Controller, Route or
     Component object:
-       ```app/routes/song.js
+     ```app/routes/song.js
     import Route from '@ember/routing/route';
-       export default Route.extend({
+     export default Route.extend({
       actions: {
         myAction() {
           this.controllerFor("song");
@@ -69,13 +69,13 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-       It is also possible to call `this._super(...arguments)` from within an
+     It is also possible to call `this._super(...arguments)` from within an
     action handler if it overrides a handler defined on a parent
     class or mixin:
-       Take for example the following routes:
-       ```app/mixins/debug-route.js
+     Take for example the following routes:
+     ```app/mixins/debug-route.js
     import Mixin from '@ember/mixin';
-       export default Mixin.create({
+     export default Mixin.create({
       actions: {
         debugRouteInformation() {
           console.debug("It's a-me, console.debug!");
@@ -83,54 +83,54 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-       ```app/routes/annoying-debug.js
+     ```app/routes/annoying-debug.js
     import Route from '@ember/routing/route';
     import DebugRoute from '../mixins/debug-route';
-       export default Route.extend(DebugRoute, {
+     export default Route.extend(DebugRoute, {
       actions: {
         debugRouteInformation() {
           // also call the debugRouteInformation of mixed in DebugRoute
           this._super(...arguments);
-             // show additional annoyance
+           // show additional annoyance
           window.alert(...);
         }
       }
     });
     ```
-       ## Bubbling
-       By default, an action will stop bubbling once a handler defined
+     ## Bubbling
+     By default, an action will stop bubbling once a handler defined
     on the `actions` hash handles it. To continue bubbling the action,
     you must return `true` from the handler:
-       ```app/router.js
+     ```app/router.js
     Router.map(function() {
       this.route("album", function() {
         this.route("song");
       });
     });
     ```
-       ```app/routes/album.js
+     ```app/routes/album.js
     import Route from '@ember/routing/route';
-       export default Route.extend({
+     export default Route.extend({
       actions: {
         startPlaying: function() {
         }
       }
     });
     ```
-       ```app/routes/album-song.js
+     ```app/routes/album-song.js
     import Route from '@ember/routing/route';
-       export default Route.extend({
+     export default Route.extend({
       actions: {
         startPlaying() {
           // ...
-             if (actionShouldAlsoBeTriggeredOnParentRoute) {
+           if (actionShouldAlsoBeTriggeredOnParentRoute) {
             return true;
           }
         }
       }
     });
     ```
-       @property actions
+     @property actions
     @type Object
     @default null
     @public
@@ -140,14 +140,14 @@ const ActionHandler = Mixin.create({
     Triggers a named action on the `ActionHandler`. Any parameters
     supplied after the `actionName` string will be passed as arguments
     to the action target function.
-       If the `ActionHandler` has its `target` property set, actions may
+     If the `ActionHandler` has its `target` property set, actions may
     bubble to the `target`. Bubbling happens when an `actionName` can
     not be found in the `ActionHandler`'s `actions` hash or if the
     action target function returns `true`.
-       Example
-       ```app/routes/welcome.js
+     Example
+     ```app/routes/welcome.js
     import Route from '@ember/routing/route';
-       export default Route.extend({
+     export default Route.extend({
       actions: {
         playTheme() {
           this.send('playMusic', 'theme.mp3');
@@ -158,7 +158,7 @@ const ActionHandler = Mixin.create({
       }
     });
     ```
-       @method send
+     @method send
     @param {String} actionName The action to trigger
     @param {*} context a context to send with the action
     @public

package/dist/packages/@ember/-internals/utils/index.js

@@ -507,6 +507,8 @@ function inspectObject(obj, depth, seen) {
     }
 
     let key = keys[i];
+    assert('has key', key); // Looping over array
+
     s += `${inspectKey(key)}: ${inspectValue(obj[key], depth, seen)}`;
   }
 

package/dist/packages/@ember/-internals/views/lib/system/utils.js

@@ -27,6 +27,7 @@ export function getRootViews(owner) {
   let rootViews = [];
   Object.keys(registry).forEach(id => {
     let view = registry[id];
+    assert('expected view', view);
 
     if (view.parentView === null) {
       rootViews.push(view);

package/dist/packages/@ember/canary-features/index.js

@@ -11,8 +11,8 @@ import { ENV } from '@ember/-internals/environment';
 */
 
 export const DEFAULT_FEATURES = {
-  EMBER_LIBRARIES_ISREGISTERED: null,
-  EMBER_IMPROVED_INSTRUMENTATION: null,
+  EMBER_LIBRARIES_ISREGISTERED: false,
+  EMBER_IMPROVED_INSTRUMENTATION: false,
   EMBER_NAMED_BLOCKS: true,
   EMBER_GLIMMER_HELPER_MANAGER: true,
   EMBER_GLIMMER_INVOKE_HELPER: true,

package/dist/packages/@ember/controller/index.js

@@ -1,61 +1,10 @@
 import { FrameworkObject } from '@ember/-internals/runtime';
 import { inject as metalInject } from '@ember/-internals/metal';
 import ControllerMixin from './lib/controller_mixin';
-/**
-@module @ember/controller
-*/
 
-/**
-  @class Controller
-  @extends EmberObject
-  @uses Ember.ControllerMixin
-  @public
-*/
+class Controller extends FrameworkObject.extend(ControllerMixin) {}
 
-const Controller = FrameworkObject.extend(ControllerMixin);
-/**
-  Creates a property that lazily looks up another controller in the container.
-  Can only be used when defining another controller.
-
-  Example:
-
-  ```app/controllers/post.js
-  import Controller, {
-    inject as controller
-  } from '@ember/controller';
-
-  export default class PostController extends Controller {
-    @controller posts;
-  }
-  ```
-
-  Classic Class Example:
-
-  ```app/controllers/post.js
-  import Controller, {
-    inject as controller
-  } from '@ember/controller';
-
-  export default Controller.extend({
-    posts: controller()
-  });
-  ```
-
-  This example will create a `posts` property on the `post` controller that
-  looks up the `posts` controller in the container, making it easy to reference
-  other controllers.
-
-  @method inject
-  @static
-  @for @ember/controller
-  @since 1.10.0
-  @param {String} name (optional) name of the controller to inject, defaults to
-         the property's name
-  @return {ComputedDecorator} injection decorator instance
-  @public
-*/
-
-export function inject() {
-  return metalInject('controller', ...arguments);
+export function inject(...args) {
+  return metalInject('controller', ...args);
 }
 export default Controller;