ember-source 4.2.0-beta.1 → 4.3.0-alpha.4

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

@@ -80,7 +80,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
     this.currentRouteName = null;
     this.currentPath = null;
     this.currentRoute = null;
-    this._qpCache = Object.create(null);
+    this._qpCache = Object.create(null); // Set of QueryParam['urlKey']
+
     this._qpUpdates = new Set();
     this._queuedQPChanges = {};
     this._toplevelView = null;
@@ -186,7 +187,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
   _initRouterJs() {
     let location = get(this, 'location');
     let router = this;
-    let owner = getOwner(this);
+    const owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
     let seen = Object.create(null);
 
     class PrivateRouter extends Router {
@@ -203,6 +205,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
         }
 
         let fullRouteName = `route:${routeName}`;
+        assert('Route is unexpectedly missing an owner', routeOwner);
         let route = routeOwner.lookup(fullRouteName);
 
         if (seen[name]) {
@@ -367,7 +370,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let enableLoadingSubstates = this._hasModuleBasedResolver();
 
     let router = this;
-    let owner = getOwner(this);
+    const owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
     let options = {
       enableLoadingSubstates,
 
@@ -397,6 +401,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
   _hasModuleBasedResolver() {
     let owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
     let resolver = get(owner, 'application.__registry__.resolver.moduleBasedResolver');
     return Boolean(resolver);
   }
@@ -503,6 +508,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     if (!this._toplevelView) {
       let owner = getOwner(this);
+      assert('Router is unexpectedly missing an owner', owner);
       let OutletView = owner.factoryFor('view:-outlet');
       let application = owner.lookup('application:main');
       let environment = owner.lookup('-environment:main');
@@ -580,8 +586,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
       let infos = this._routerMicrolib.currentRouteInfos;
 
       if (this.namespace.LOG_TRANSITIONS) {
-        // eslint-disable-next-line no-console
-        assert('expected infos to be set', infos);
+        assert('expected infos to be set', infos); // eslint-disable-next-line no-console
+
         console.log(`Intermediate-transitioned into '${EmberRouter._routePath(infos)}'`);
       }
     }
@@ -686,7 +692,8 @@ class EmberRouter extends EmberObject.extend(Evented) {
   _activeQPChanged(queryParameterName, newValue) {
     this._queuedQPChanges[queryParameterName] = newValue;
     once(this, this._fireQueryParamTransition);
-  }
+  } // The queryParameterName is QueryParam['urlKey']
+
 
   _updatingQPChanged(queryParameterName) {
     this._qpUpdates.add(queryParameterName);
@@ -718,6 +725,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
     let location = this.location;
     let rootURL = this.rootURL;
     let owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
 
     if ('string' === typeof location) {
       let resolvedLocation = owner.lookup(`location:${location}`);
@@ -729,6 +737,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
           url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
           for: 'ember-source',
           since: {
+            available: '4.1.0',
             enabled: '4.1.0'
           }
         });
@@ -761,6 +770,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
             url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
             for: 'ember-source',
             since: {
+              available: '4.1.0',
               enabled: '4.1.0'
             }
           });
@@ -1187,6 +1197,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     if (!engineInstance) {
       let owner = getOwner(this);
+      assert('Router is unexpectedly missing an owner', owner);
       assert(`You attempted to mount the engine '${name}' in your router map, but the engine can not be found.`, owner.hasRegistration(`engine:${name}`));
       engineInstance = owner.buildChildEngineInstance(name, {
         routable: true,
@@ -1354,6 +1365,7 @@ function logError(_error, initialMessage) {
 
 function findRouteSubstateName(route, state) {
   let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
   let {
     routeName,
     fullRouteName,
@@ -1377,6 +1389,7 @@ function findRouteSubstateName(route, state) {
 
 function findRouteStateName(route, state) {
   let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
   let {
     routeName,
     fullRouteName,
@@ -1486,7 +1499,9 @@ function updatePaths(router) {
   set(router, 'currentPath', path);
   set(router, 'currentRouteName', currentRouteName);
   set(router, 'currentURL', currentURL);
-  let appController = getOwner(router).lookup('controller:application');
+  let owner = getOwner(router);
+  assert('Router is unexpectedly missing an owner', owner);
+  let appController = owner.lookup('controller:application');
 
   if (!appController) {
     // appController might not exist when top-level loading/error

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

@@ -1,21 +1,19 @@
 import { get } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
-import { deprecate } from '@ember/debug';
+import { assert, deprecate } from '@ember/debug';
 import EmberError from '@ember/error';
 import { STATE_SYMBOL } from 'router_js';
 const ALL_PERIODS_REGEX = /\./g;
 export function extractRouteArgs(args) {
   args = args.slice();
-  let possibleQueryParams = args[args.length - 1];
+  let possibleQueryParams = args.pop();
   let queryParams;
 
-  if (possibleQueryParams && Object.prototype.hasOwnProperty.call(possibleQueryParams, 'queryParams')) {
-    // SAFETY: this cast is safe because we have just checked whether
-    // `possibleQueryParams` -- defined as the last item in args -- both exists
-    // and has the property `queryParams`. If either of these invariants change,
-    // ***this is unsafe and should be changed***.
-    queryParams = args.pop().queryParams;
+  if (hasQueryParams(possibleQueryParams)) {
+    queryParams = possibleQueryParams.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
@@ -185,12 +183,12 @@ function accumulateQueryParamDescriptors(_desc, accum) {
       };
     }
 
-    tmp = accum[key] || {
+    let val = accum[key] || {
       as: null,
       scope: 'model'
     };
-    Object.assign(tmp, singleDesc);
-    accum[key] = tmp;
+    Object.assign(val, singleDesc);
+    accum[key] = val;
   }
 }
 /*
@@ -212,6 +210,7 @@ export function resemblesURL(str) {
 export function prefixRouteNameArg(route, args) {
   let routeName = args[0];
   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') {
@@ -253,9 +252,22 @@ export function deprecateTransitionMethods(frameworkClass, methodName) {
     id: 'routing.transition-methods',
     for: 'ember-source',
     since: {
+      available: '3.26.0',
       enabled: '3.26.0'
     },
     until: '5.0.0',
     url: 'https://deprecations.emberjs.com/v3.x/#toc_routing-transition-methods'
   });
+}
+
+function hasQueryParams(value) {
+  if (value && typeof value === 'object') {
+    let qps = value.queryParams;
+
+    if (qps && typeof qps === 'object') {
+      return Object.keys(qps).every(k => typeof k === 'string');
+    }
+  }
+
+  return false;
 }

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

@@ -53,7 +53,7 @@ function customTagForProxy(proxy, key, addMandatorySetter) {
 export default Mixin.create({
   /**
     The object whose properties will be forwarded.
-     @property content
+       @property content
     @type {unknown}
     @default null
     @public

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/runtime/lib/mixins/array.js

@@ -952,6 +952,7 @@ const ArrayMixin = Mixin.create(Enumerable, {
     @return {Object} The reduced value.
     @public
   */
+  // FIXME: When called without initialValue, behavior does not match native behavior
   reduce(callback, initialValue) {
     assert('`reduce` expects a function as first argument.', typeof callback === 'function');
     let ret = initialValue;

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

@@ -18,13 +18,13 @@ import { Mixin } from '@ember/-internals/metal';
 export default Mixin.create({
   /**
     __Required.__ You must implement this method to apply this mixin.
-     Override to return the result of the comparison of the two parameters. The
+       Override to return the result of the comparison of the two parameters. The
     compare method should return:
-     - `-1` if `a < b`
+       - `-1` if `a < b`
     - `0` if `a == b`
     - `1` if `a > b`
-     Default implementation raises an exception.
-     @method compare
+       Default implementation raises an exception.
+       @method compare
     @param a {Object} the first object to compare
     @param b {Object} the second object to compare
     @return {Number} the result of the comparison

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

@@ -15,7 +15,7 @@ import { Mixin } from '@ember/-internals/metal';
 let containerProxyMixin = {
   /**
    The container stores state.
-    @private
+      @private
    @property {Ember.Container} __container__
    */
   __container__: null,
@@ -23,16 +23,16 @@ let containerProxyMixin = {
   /**
    Returns an object that can be used to provide an owner to a
    manually created instance.
-    Example:
-    ```
+      Example:
+      ```
    import { getOwner } from '@ember/application';
-    let owner = getOwner(this);
-    User.create(
+      let owner = getOwner(this);
+      User.create(
      owner.ownerInjection(),
      { username: 'rwjblue' }
    )
    ```
-    @public
+      @public
    @method ownerInjection
    @since 2.3.0
    @return {Object}
@@ -43,30 +43,30 @@ let containerProxyMixin = {
 
   /**
    Given a fullName return a corresponding instance.
-    The default behavior is for lookup to return a singleton instance.
+      The default behavior is for lookup to return a singleton instance.
    The singleton is scoped to the container, allowing multiple containers
    to all have their own locally scoped singletons.
-    ```javascript
+      ```javascript
    let registry = new Registry();
    let container = registry.container();
-    registry.register('api:twitter', Twitter);
-    let twitter = container.lookup('api:twitter');
-    twitter instanceof Twitter; // => true
-    // by default the container will return singletons
+      registry.register('api:twitter', Twitter);
+      let twitter = container.lookup('api:twitter');
+      twitter instanceof Twitter; // => true
+      // by default the container will return singletons
    let twitter2 = container.lookup('api:twitter');
    twitter2 instanceof Twitter; // => true
-    twitter === twitter2; //=> true
+      twitter === twitter2; //=> true
    ```
-    If singletons are not wanted an optional flag can be provided at lookup.
-    ```javascript
+      If singletons are not wanted an optional flag can be provided at lookup.
+      ```javascript
    let registry = new Registry();
    let container = registry.container();
-    registry.register('api:twitter', Twitter);
-    let twitter = container.lookup('api:twitter', { singleton: false });
+      registry.register('api:twitter', Twitter);
+      let twitter = container.lookup('api:twitter', { singleton: false });
    let twitter2 = container.lookup('api:twitter', { singleton: false });
-    twitter === twitter2; //=> false
+      twitter === twitter2; //=> false
    ```
-    @public
+      @public
    @method lookup
    @param {String} fullName
    @param {Object} options
@@ -91,32 +91,32 @@ let containerProxyMixin = {
 
   /**
   Given a fullName return a factory manager.
-   This method returns a manager which can be used for introspection of the
+     This method returns a manager which can be used for introspection of the
   factory's class or for the creation of factory instances with initial
   properties. The manager is an object with the following properties:
-   * `class` - The registered or resolved class.
+     * `class` - The registered or resolved class.
   * `create` - A function that will create an instance of the class with
     any dependencies injected.
-   For example:
-   ```javascript
+     For example:
+     ```javascript
   import { getOwner } from '@ember/application';
-   let owner = getOwner(otherInstance);
+     let owner = getOwner(otherInstance);
   // the owner is commonly the `applicationInstance`, and can be accessed via
   // an instance initializer.
-   let factory = owner.factoryFor('service:bespoke');
-   factory.class;
+     let factory = owner.factoryFor('service:bespoke');
+     factory.class;
   // The registered or resolved class. For example when used with an Ember-CLI
   // app, this would be the default export from `app/services/bespoke.js`.
-   let instance = factory.create({
+     let instance = factory.create({
     someProperty: 'an initial property value'
   });
   // Create an instance with any injections and the passed options as
   // initial properties.
   ```
-   Any instances created via the factory's `.create()` method *must* be destroyed
+     Any instances created via the factory's `.create()` method *must* be destroyed
   manually by the caller of `.create()`. Typically, this is done during the creating
   objects own `destroy` or `willDestroy` methods.
-   @public
+     @public
   @method factoryFor
   @param {String} fullName
   @param {Object} options

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

@@ -98,7 +98,7 @@ export default Mixin.create({
   /**
     If the proxied promise is rejected this will contain the reason
     provided.
-     @property reason
+       @property reason
     @default null
     @public
   */
@@ -106,7 +106,7 @@ export default Mixin.create({
 
   /**
     Once the proxied promise has settled this will become `false`.
-     @property isPending
+       @property isPending
     @default true
     @public
   */
@@ -116,7 +116,7 @@ export default Mixin.create({
 
   /**
     Once the proxied promise has settled this will become `true`.
-     @property isSettled
+       @property isSettled
     @default false
     @public
   */
@@ -126,7 +126,7 @@ export default Mixin.create({
 
   /**
     Will become `true` if the proxied promise is rejected.
-     @property isRejected
+       @property isRejected
     @default false
     @public
   */
@@ -134,7 +134,7 @@ export default Mixin.create({
 
   /**
     Will become `true` if the proxied promise is fulfilled.
-     @property isFulfilled
+       @property isFulfilled
     @default false
     @public
   */
@@ -142,17 +142,17 @@ export default Mixin.create({
 
   /**
     The promise whose fulfillment value is being proxied by this object.
-     This property must be specified upon creation, and should not be
+       This property must be specified upon creation, and should not be
     changed once created.
-     Example:
-     ```javascript
+       Example:
+       ```javascript
     import ObjectProxy from '@ember/object/proxy';
     import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-     ObjectProxy.extend(PromiseProxyMixin).create({
+       ObjectProxy.extend(PromiseProxyMixin).create({
       promise: <thenable>
     });
     ```
-     @property promise
+       @property promise
     @public
   */
   promise: computed({
@@ -168,8 +168,8 @@ export default Mixin.create({
 
   /**
     An alias to the proxied promise's `then`.
-     See RSVP.Promise.then.
-     @method then
+       See RSVP.Promise.then.
+       @method then
     @param {Function} callback
     @return {RSVP.Promise}
     @public
@@ -178,8 +178,8 @@ export default Mixin.create({
 
   /**
     An alias to the proxied promise's `catch`.
-     See RSVP.Promise.catch.
-     @method catch
+       See RSVP.Promise.catch.
+       @method catch
     @param {Function} callback
     @return {RSVP.Promise}
     @since 1.3.0
@@ -189,8 +189,8 @@ export default Mixin.create({
 
   /**
     An alias to the proxied promise's `finally`.
-     See RSVP.Promise.finally.
-     @method finally
+       See RSVP.Promise.finally.
+       @method finally
     @param {Function} callback
     @return {RSVP.Promise}
     @since 1.3.0