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

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

@@ -759,7 +759,6 @@ function getChainTags(chainTags, obj, path, tagMeta, meta$$1) {
           descriptor = currentMeta !== null ? currentMeta.peekDescriptors(segment) : undefined; // If the key is an alias, we need to bootstrap it
 
           if (descriptor !== undefined && typeof descriptor.altKey === 'string') {
-            // tslint:disable-next-line: no-unused-expression
             item[segment];
           }
         }
@@ -781,7 +780,6 @@ function getChainTags(chainTags, obj, path, tagMeta, meta$$1) {
       // bootstrap the alias. This is because aliases, unlike other CPs, should
       // always be in sync with the aliased value.
       if (CHAIN_PASS_THROUGH.has(descriptor)) {
-        // tslint:disable-next-line: no-unused-expression
         current[segment];
       }
 
@@ -1585,11 +1583,15 @@ class ComputedDecoratorImpl extends Function {
   } // TODO: Remove this when we can provide alternatives in the ecosystem to
   // addons such as ember-macro-helpers that use it.
 
+  /** @internal */
+
 
   get _getter() {
     return descriptorForDecorator(this)._getter;
   } // TODO: Refactor this, this is an internal API only
 
+  /** @internal */
+
 
   set enumerable(value) {
     descriptorForDecorator(this).enumerable = value;
@@ -1633,6 +1635,8 @@ function getCachedValueFor(obj, key) {
 
   if (meta$$1) {
     return meta$$1.valueFor(key);
+  } else {
+    return undefined;
   }
 }
 
@@ -1766,45 +1770,7 @@ if (DEBUG) {
       return Reflect.get(content, keyName, obj);
     }
   };
-} // ..........................................................
-// GET AND SET
-//
-// If we are on a platform that supports accessors we can use those.
-// Otherwise simulate accessors by looking up the property directly on the
-// object.
-
-/**
-  Gets the value of a property on an object. If the property is computed,
-  the function will be invoked. If the property is not defined but the
-  object implements the `unknownProperty` method then that will be invoked.
-
-  ```javascript
-  import { get } from '@ember/object';
-  get(obj, "name");
-  ```
-
-  If you plan to run on IE8 and older browsers then you should use this
-  method anytime you want to retrieve a property on an object that you don't
-  know for sure is private. (Properties beginning with an underscore '_'
-  are considered private.)
-
-  On all newer browsers, you only need to use this method to retrieve
-  properties if the property might not be defined on the object and you want
-  to respect the `unknownProperty` handler. Otherwise you can ignore this
-  method.
-
-  Note that if the object itself is `undefined`, this method will throw
-  an error.
-
-  @method get
-  @for @ember/object
-  @static
-  @param {Object} obj The object to retrieve from.
-  @param {String} keyName The property key to retrieve
-  @return {Object} the property value or `null`.
-  @public
-*/
-
+}
 
 function get(obj, keyName) {
   assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2);
@@ -2083,7 +2049,6 @@ class AliasedProperty extends ComputedDescriptor {
 }
 
 function AliasedProperty_readOnlySet(obj, keyName) {
-  // eslint-disable-line no-unused-vars
   throw new EmberError(`Cannot set read-only property '${keyName}' on object: ${inspect(obj)}`);
 }
 
@@ -2399,6 +2364,7 @@ if (DEBUG) {
   Libraries.prototype.logVersions = function () {
     let libs = this._registry;
     let nameLengths = libs.map(item => get(item, 'name.length'));
+    assert('nameLengths is number array', nameLengths instanceof Array && nameLengths.every(n => typeof n === 'number'));
     let maxNameLength = Math.max.apply(null, nameLengths);
     debug('-------------------------------');
 
@@ -2415,39 +2381,6 @@ if (DEBUG) {
 const LIBRARIES = new Libraries();
 LIBRARIES.registerCoreLibrary('Ember', VERSION);
 
-/**
- @module @ember/object
-*/
-
-/**
-  To get multiple properties at once, call `getProperties`
-  with an object followed by a list of strings or an array:
-
-  ```javascript
-  import { getProperties } from '@ember/object';
-
-  getProperties(record, 'firstName', 'lastName', 'zipCode');
-  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-  ```
-
-  is equivalent to:
-
-  ```javascript
-  import { getProperties } from '@ember/object';
-
-  getProperties(record, ['firstName', 'lastName', 'zipCode']);
-  // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
-  ```
-
-  @method getProperties
-  @static
-  @for @ember/object
-  @param {Object} obj
-  @param {String...|Array} list of keys to get
-  @return {Object}
-  @public
-*/
-
 function getProperties(obj, keys) {
   let ret = {};
   let propertyNames = arguments;
@@ -3076,6 +3009,7 @@ const MIXINS = new _WeakSet();
 */
 
 class Mixin {
+  /** @internal */
   constructor(mixins, properties) {
     MIXINS.add(this);
     this.properties = extractAccessors(properties);
@@ -3116,6 +3050,8 @@ class Mixin {
   } // returns the mixins currently applied to the specified object
   // TODO: Make `mixin`
 
+  /** @internal */
+
 
   static mixins(obj) {
     let meta$$1 = peekMeta(obj);
@@ -3137,6 +3073,7 @@ class Mixin {
     @method reopen
     @param arguments*
     @private
+    @internal
   */
 
 
@@ -3161,6 +3098,7 @@ class Mixin {
     @param obj
     @return applied object
     @private
+    @internal
   */
 
 
@@ -3172,6 +3110,8 @@ class Mixin {
     // _hideKeys disables enumerablity when applying the mixin. This is a hack, and we should stop mutating the array prototype by default 😫
     return applyMixin(obj, [this], _hideKeys);
   }
+  /** @internal */
+
 
   applyPartial(obj) {
     return applyMixin(obj, [this]);
@@ -3181,6 +3121,7 @@ class Mixin {
     @param obj
     @return {Boolean}
     @private
+    @internal
   */
 
 
@@ -3201,16 +3142,22 @@ class Mixin {
 
     return meta$$1.hasMixin(this);
   }
+  /** @internal */
+
 
   without(...args) {
     let ret = new Mixin([this]);
     ret._without = args;
     return ret;
   }
+  /** @internal */
+
 
   keys() {
     return _keys(this);
   }
+  /** @internal */
+
 
   toString() {
     return '(unknown mixin)';
@@ -3292,11 +3239,39 @@ function _keys(mixin, ret = new Set(), seen = new Set()) {
 
   return ret;
 }
+/**
+  Specify a method that observes property changes.
+
+  ```javascript
+  import EmberObject from '@ember/object';
+  import { observer } from '@ember/object';
+
+  export default EmberObject.extend({
+    valueObserver: observer('value', function() {
+      // Executes whenever the "value" property changes
+    })
+  });
+  ```
+
+  Also available as `Function.prototype.observes` if prototype extensions are
+  enabled.
+
+  @method observer
+  @for @ember/object
+  @param {String} propertyNames*
+  @param {Function} func
+  @return func
+  @public
+  @static
+*/
+
 
 function observer(...args) {
   let funcOrDef = args.pop();
   assert('observer must be provided a function or an observer definition', typeof funcOrDef === 'function' || typeof funcOrDef === 'object' && funcOrDef !== null);
-  let func, dependentKeys, sync;
+  let func;
+  let dependentKeys;
+  let sync;
 
   if (typeof funcOrDef === 'function') {
     func = funcOrDef;

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

@@ -144,10 +144,15 @@ ControllerMixin.reopen({
     @public
   */
   transitionToRoute(...args) {
+    var _a;
+
     deprecateTransitionMethods('controller', 'transitionToRoute'); // target may be either another controller or a router
 
-    let target = get(this, 'target');
-    let method = target.transitionToRoute || target.transitionTo;
+    let target = get(this, 'target'); // SAFETY: We can't actually assert that this is a full Controller or Router since some tests
+    // mock out an object that only has the single method. Since this is deprecated, I think it's
+    // ok to be a little less than proper here.
+
+    let method = (_a = target.transitionToRoute) !== null && _a !== void 0 ? _a : target.transitionTo;
     return method.apply(target, prefixRouteNameArg(this, args));
   },
 
@@ -201,10 +206,15 @@ ControllerMixin.reopen({
     @public
   */
   replaceRoute(...args) {
+    var _a;
+
     deprecateTransitionMethods('controller', 'replaceRoute'); // target may be either another controller or a router
 
-    let target = get(this, 'target');
-    let method = target.replaceRoute || target.replaceWith;
+    let target = get(this, 'target'); // SAFETY: We can't actually assert that this is a full Controller or Router since some tests
+    // mock out an object that only has the single method. Since this is deprecated, I think it's
+    // ok to be a little less than proper here.
+
+    let method = (_a = target.replaceRoute) !== null && _a !== void 0 ? _a : target.replaceWith;
     return method.apply(target, prefixRouteNameArg(this, args));
   }
 

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

@@ -93,6 +93,7 @@ export default {
       url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
       for: 'ember-source',
       since: {
+        available: '4.1.0',
         enabled: '4.1.0'
       }
     });

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

@@ -82,7 +82,9 @@ export default class AutoLocation extends EmberObject {
       implementation = 'none';
     }
 
-    let concrete = getOwner(this).lookup(`location:${implementation}`);
+    let owner = getOwner(this);
+    assert('AutoLocation is unexpectedly missing an owner', owner);
+    let concrete = owner.lookup(`location:${implementation}`);
     assert(`Could not find location '${implementation}'.`, concrete !== undefined);
     set(concrete, 'rootURL', rootURL);
     set(this, 'concreteImplementation', concrete);

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

@@ -56,7 +56,8 @@ export default class RouterService extends Service {
       return router;
     }
 
-    const owner = getOwner(this);
+    let owner = getOwner(this);
+    assert('RouterService is unexpectedly missing an owner', owner);
     router = owner.lookup('router:main');
     return this[ROUTER] = router;
   }
@@ -65,46 +66,6 @@ export default class RouterService extends Service {
     super.willDestroy(...arguments);
     this[ROUTER] = null;
   }
-  /**
-     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.
-        Calling `transitionTo` from the Router service will cause default query parameter values to be included in the URL.
-     This behavior is different from calling `transitionTo` on a route or `transitionToRoute` on a controller.
-     See the [Router Service RFC](https://github.com/emberjs/rfcs/blob/master/text/0095-router-service.md#query-parameter-semantics) for more info.
-        In the following example we use the Router service to navigate to a route with a
-     specific model from a Component in the first action, and in the second we trigger
-     a query-params only transition.
-        ```app/components/example.js
-     import Component from '@glimmer/component';
-     import { action } from '@ember/object';
-     import { service } from '@ember/service';
-        export default class extends Component {
-       @service router;
-          @action
-       goToComments(post) {
-         this.router.transitionTo('comments', post);
-       }
-          @action
-       fetchMoreComments(latestComment) {
-         this.router.transitionTo({
-           queryParams: { commentsAfter: latestComment }
-         });
-       }
-     }
-     ```
-        @method transitionTo
-     @param {String} [routeNameOrUrl] 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. May be supplied as the only
-      parameter to trigger a query-parameter-only transition.
-     @return {Transition} the transition object associated with this
-       attempted transition
-     @public
-   */
-
 
   transitionTo(...args) {
     if (resemblesURL(args[0])) {
@@ -157,9 +118,7 @@ export default class RouterService extends Service {
    */
 
 
-  replaceWith()
-  /* routeNameOrUrl, ...models, options */
-  {
+  replaceWith() {
     return this.transitionTo(...arguments).method('replace');
   }
   /**
@@ -304,10 +263,7 @@ export default class RouterService extends Service {
       // does not correctly account for `undefined` values for `routeName`.
       //  Spoilers: under the hood this currently uses router.js APIs which
       // *do not* account for this being `undefined`.
-      routeName, models, // UNSAFE: downstream consumers treat this as `QueryParam`, which the
-      // type system here *correctly* reports as incorrect, because it may be
-      // just an empty object.
-      queryParams, true
+      routeName, models, queryParams, true
       /* fromRouterService */
       );
 
@@ -398,7 +354,9 @@ if (true
 
       assert(`The route "${pivotRouteName}" was not found`, this._router.hasRoute(pivotRouteName));
       assert(`The route "${pivotRouteName}" is currently not active`, this.isActive(pivotRouteName));
-      let pivotRoute = getOwner(this).lookup(`route:${pivotRouteName}`);
+      let owner = getOwner(this);
+      assert('RouterService is unexpectedly missing an owner', owner);
+      let pivotRoute = owner.lookup(`route:${pivotRouteName}`);
       return this._router._routerMicrolib.refresh(pivotRoute);
     }
 

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

@@ -3,6 +3,7 @@
 */
 import { getOwner } from '@ember/-internals/owner';
 import { symbol } from '@ember/-internals/utils';
+import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
 const ROUTER = symbol('ROUTER');
@@ -25,7 +26,8 @@ export default class RoutingService extends Service {
       return router;
     }
 
-    const owner = getOwner(this);
+    let owner = getOwner(this);
+    assert('RoutingService is unexpectedly missing an owner', owner);
     router = owner.lookup('router:main');
     router.setupRouter();
     return this[ROUTER] = router;

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

@@ -88,7 +88,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
   _setRouteName(name) {
     this.routeName = name;
-    this.fullRouteName = getEngineRouteName(getOwner(this), name);
+    let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
+    this.fullRouteName = getEngineRouteName(owner, name);
   }
   /**
     @private
@@ -106,9 +108,10 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     if (!names.length) {
       routeInfo = dynamicParent;
       names = routeInfo && routeInfo['_names'] || [];
-    }
+    } // SAFETY: Since `_qp` is protected we can't infer the type
+
 
-    let qps = get(this, '_qp.qps');
+    let qps = get(this, '_qp').qps;
     let namePaths = new Array(names.length);
 
     for (let a = 0; a < names.length; ++a) {
@@ -187,7 +190,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   paramsFor(name) {
-    let route = getOwner(this).lookup(`route:${name}`);
+    let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
+    let route = owner.lookup(`route:${name}`);
 
     if (route === undefined) {
       return {};
@@ -301,8 +306,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   _internalReset(isExiting, transition) {
-    let controller = this.controller;
-    controller['_qpDelegate'] = get(this, '_qp.states.inactive');
+    let controller = this.controller; // SAFETY: Since `_qp` is protected we can't infer the type
+
+    controller['_qpDelegate'] = get(this, '_qp').states.inactive;
     this.resetController(controller, isExiting, transition);
   }
   /**
@@ -774,18 +780,18 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
       controller = definedController;
     } else {
       controller = this.generateController(controllerName);
-    } // Assign the route's controller so that it can more easily be
-    // referenced in action handlers. Side effects. Side effects everywhere.
+    } // SAFETY: Since `_qp` is protected we can't infer the type
 
 
+    let queryParams = get(this, '_qp'); // Assign the route's controller so that it can more easily be
+    // referenced in action handlers. Side effects. Side effects everywhere.
+
     if (!this.controller) {
-      let qp = get(this, '_qp');
-      let propNames = qp !== undefined ? get(qp, 'propertyNames') : [];
+      let propNames = queryParams.propertyNames;
       addQueryParamsObservers(controller, propNames);
       this.controller = controller;
     }
 
-    let queryParams = get(this, '_qp');
     let states = queryParams.states;
     controller._qpDelegate = states.allowOverrides;
 
@@ -994,8 +1000,9 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   model(params, transition) {
-    let name, sawParams, value;
-    let queryParams = get(this, '_qp.map');
+    let name, sawParams, value; // SAFETY: Since `_qp` is protected we can't infer the type
+
+    let queryParams = get(this, '_qp').map;
 
     for (let prop in params) {
       if (prop === 'queryParams' || queryParams && prop in queryParams) {
@@ -1105,7 +1112,6 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   setupController(controller, context, _transition) {
-    // eslint-disable-line no-unused-vars
     if (controller && context !== undefined) {
       set(controller, 'model', context);
     }
@@ -1134,6 +1140,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
   controllerFor(name, _skipAssert) {
     let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     let route = owner.lookup(`route:${name}`);
 
     if (route && route.controllerName) {
@@ -1167,6 +1174,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
   generateController(name) {
     let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     return generateController(owner, name);
   }
   /**
@@ -1208,6 +1216,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   modelFor(_name) {
     let name;
     let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     let transition = this._router && this._router._routerMicrolib ? this._router._routerMicrolib.activeTransition : undefined; // Only change the route name when there is an active transition.
     // Otherwise, use the passed in route name.
 
@@ -1329,7 +1338,8 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   get store() {
-    let owner = getOwner(this);
+    const owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     let routeName = this.routeName;
     return {
       find(name, value) {
@@ -1361,6 +1371,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     let combinedQueryParameterConfiguration;
     let controllerName = this.controllerName || this.routeName;
     let owner = getOwner(this);
+    assert('Route is unexpectedly missing an owner', owner);
     let controller = owner.lookup(`controller:${controllerName}`);
     let queryParameterConfiguraton = get(this, 'queryParams');
     let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
@@ -1398,7 +1409,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
       let desc = combinedQueryParameterConfiguration[propName];
       let scope = desc.scope || 'model';
-      let parts;
+      let parts = undefined;
 
       if (scope === 'controller') {
         parts = [];
@@ -1522,6 +1533,7 @@ function buildRenderOptions(route, nameOrOptions, options) {
 
   assert('You passed undefined as the outlet name.', isDefaultRender || !(options && 'outlet' in options && options.outlet === undefined));
   let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
   let name, templateName, into, outlet, model;
   let controller = undefined;
 
@@ -1594,13 +1606,12 @@ function buildRenderOptions(route, nameOrOptions, options) {
 }
 
 export function getFullQueryParams(router, state) {
-  if (state['fullQueryParams']) {
-    return state['fullQueryParams'];
+  if (state.fullQueryParams) {
+    return state.fullQueryParams;
   }
 
-  let fullQueryParamsState = {};
   let haveAllRouteInfosResolved = state.routeInfos.every(routeInfo => routeInfo.route);
-  Object.assign(fullQueryParamsState, state.queryParams);
+  let fullQueryParamsState = Object.assign({}, state.queryParams);
 
   router._deserializeQueryParams(state.routeInfos, fullQueryParamsState); // only cache query params state if all routeinfos have resolved; it's possible
   // for lazy routes to not have resolved when `getFullQueryParams` is called, so
@@ -1608,24 +1619,25 @@ export function getFullQueryParams(router, state) {
 
 
   if (haveAllRouteInfosResolved) {
-    state['fullQueryParams'] = fullQueryParamsState;
+    state.fullQueryParams = fullQueryParamsState;
   }
 
   return fullQueryParamsState;
 }
 
 function getQueryParamsFor(route, state) {
-  state['queryParamsFor'] = state['queryParamsFor'] || {};
+  state.queryParamsFor = state.queryParamsFor || {};
   let name = route.fullRouteName;
 
-  if (state['queryParamsFor'][name]) {
-    return state['queryParamsFor'][name];
+  if (state.queryParamsFor[name]) {
+    return state.queryParamsFor[name];
   }
 
   let fullQueryParams = getFullQueryParams(route._router, state);
-  let params = state['queryParamsFor'][name] = {}; // Copy over all the query params for this route/controller into params hash.
+  let params = state.queryParamsFor[name] = {}; // Copy over all the query params for this route/controller into params hash.
+  // SAFETY: Since `_qp` is protected we can't infer the type
 
-  let qps = get(route, '_qp.qps');
+  let qps = get(route, '_qp').qps;
 
   for (let i = 0; i < qps.length; ++i) {
     // Put deserialized qp on params hash.
@@ -1635,10 +1647,12 @@ function getQueryParamsFor(route, state) {
   }
 
   return params;
-}
+} // FIXME: This should probably actually return a `NativeArray` if the passed in value is an Array.
+
 
 function copyDefaultValue(value) {
   if (Array.isArray(value)) {
+    // SAFETY: We lost the type data about the array if we don't cast.
     return emberA(value.slice());
   }
 
@@ -1824,15 +1838,22 @@ Route.reopen({
     @private
     */
     queryParamsDidChange(changed, _totalPresent, removed) {
+      // SAFETY: Since `_qp` is protected we can't infer the type
       let qpMap = get(this, '_qp').map;
       let totalChanged = Object.keys(changed).concat(Object.keys(removed));
 
       for (let i = 0; i < totalChanged.length; ++i) {
         let qp = qpMap[totalChanged[i]];
 
-        if (qp && get(this._optionsForQueryParam(qp), 'refreshModel') && this._router.currentState) {
-          this.refresh();
-          break;
+        if (qp) {
+          let options = this._optionsForQueryParam(qp);
+
+          assert('options exists', options && typeof options === 'object');
+
+          if (get(options, 'refreshModel') && this._router.currentState) {
+            this.refresh();
+            break;
+          }
         }
       }
 
@@ -1867,7 +1888,8 @@ Route.reopen({
         // param URL key corresponds to a QP property on
         // this controller.
 
-        let value, svalue;
+        let value;
+        let svalue;
 
         if (changes.has(qp.urlKey)) {
           // Value updated in/before setupController
@@ -1885,9 +1907,10 @@ Route.reopen({
             svalue = qp.serializedDefaultValue;
             value = copyDefaultValue(qp.defaultValue);
           }
-        }
+        } // SAFETY: Since `_qp` is protected we can't infer the type
+
 
-        controller._qpDelegate = get(route, '_qp.states.inactive');
+        controller._qpDelegate = get(route, '_qp').states.inactive;
         let thisQueryParamChanged = svalue !== qp.serializedValue;
 
         if (thisQueryParamChanged) {
@@ -1932,6 +1955,7 @@ Route.reopen({
       }
 
       qpMeta.qps.forEach(qp => {
+        // SAFETY: Since `_qp` is protected we can't infer the type
         let routeQpMeta = get(qp.route, '_qp');
         let finalizedController = qp.route.controller;
         finalizedController['_qpDelegate'] = get(routeQpMeta, 'states.active');