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

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

@@ -685,8 +685,7 @@ function finishLazyChains(meta$$1, key, value) {
   }
 
   if (isObject(value)) {
-    for (let i = 0; i < lazyTags.length; i++) {
-      let [tag, deps] = lazyTags[i];
+    for (let [tag, deps] of lazyTags) {
       updateTag(tag, getChainTagsForKey(value, deps, tagMetaFor(value), peekMeta(value)));
     }
   }
@@ -696,8 +695,8 @@ function finishLazyChains(meta$$1, key, value) {
 function getChainTagsForKeys(obj, keys, tagMeta, meta$$1) {
   let tags = [];
 
-  for (let i = 0; i < keys.length; i++) {
-    getChainTags(tags, obj, keys[i], tagMeta, meta$$1);
+  for (let key of keys) {
+    getChainTags(tags, obj, key, tagMeta, meta$$1);
   }
 
   return combine(tags);
@@ -759,7 +758,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 +779,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];
       }
 
@@ -1315,8 +1312,8 @@ class ComputedProperty extends ComputedDescriptor {
       args.push(property);
     }
 
-    for (let i = 0; i < passedArgs.length; i++) {
-      expandProperties(passedArgs[i], addArg);
+    for (let arg of passedArgs) {
+      expandProperties(arg, addArg);
     }
 
     this._dependentKeys = args;
@@ -1585,11 +1582,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;
@@ -1601,13 +1602,16 @@ function computed(...args) {
   assert(`@computed can only be used directly as a native decorator. If you're using tracked in classic classes, add parenthesis to call it like a function: computed()`, !(isElementDescriptor(args.slice(0, 3)) && args.length === 5 && args[4] === true));
 
   if (isElementDescriptor(args)) {
+    // SAFETY: We passed in the impl for this class
     let decorator = makeComputedDecorator(new ComputedProperty([]), ComputedDecoratorImpl);
     return decorator(args[0], args[1], args[2]);
-  }
+  } // SAFETY: We passed in the impl for this class
+
 
   return makeComputedDecorator(new ComputedProperty(args), ComputedDecoratorImpl);
 }
 function autoComputed(...config) {
+  // SAFETY: We passed in the impl for this class
   return makeComputedDecorator(new AutoComputedProperty(config), ComputedDecoratorImpl);
 }
 /**
@@ -1633,6 +1637,8 @@ function getCachedValueFor(obj, key) {
 
   if (meta$$1) {
     return meta$$1.valueFor(key);
+  } else {
+    return undefined;
   }
 }
 
@@ -1766,45 +1772,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);
@@ -1850,12 +1818,12 @@ function _getPath(root, path) {
   let obj = root;
   let parts = typeof path === 'string' ? path.split('.') : path;
 
-  for (let i = 0; i < parts.length; i++) {
+  for (let part of parts) {
     if (obj === undefined || obj === null || obj.isDestroyed) {
       return undefined;
     }
 
-    obj = _getProp(obj, parts[i]);
+    obj = _getProp(obj, part);
   }
 
   return obj;
@@ -2007,7 +1975,8 @@ function trySet(root, path, value) {
 }
 
 function alias(altKey) {
-  assert('You attempted to use @alias as a decorator directly, but it requires a `altKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments)));
+  assert('You attempted to use @alias as a decorator directly, but it requires a `altKey` parameter', !isElementDescriptor(Array.prototype.slice.call(arguments))); // SAFETY: We passed in the impl for this class
+
   return makeComputedDecorator(new AliasedProperty(altKey), AliasDecoratorImpl);
 } // TODO: This class can be svelted once `meta` has been deprecated
 
@@ -2083,7 +2052,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)}`);
 }
 
@@ -2347,11 +2315,10 @@ class Libraries {
 
   _getLibraryByName(name) {
     let libs = this._registry;
-    let count = libs.length;
 
-    for (let i = 0; i < count; i++) {
-      if (libs[i].name === name) {
-        return libs[i];
+    for (let lib of libs) {
+      if (lib.name === name) {
+        return lib;
       }
     }
 
@@ -2399,11 +2366,11 @@ 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('-------------------------------');
 
-    for (let i = 0; i < libs.length; i++) {
-      let lib = libs[i];
+    for (let lib of libs) {
       let spaces = new Array(maxNameLength - lib.name.length + 1).join(' ');
       debug([lib.name, spaces, ' : ', lib.version].join(''));
     }
@@ -2415,39 +2382,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;
@@ -2501,10 +2435,8 @@ function setProperties(obj, properties) {
 
   changeProperties(() => {
     let props = Object.keys(properties);
-    let propertyName;
 
-    for (let i = 0; i < props.length; i++) {
-      propertyName = props[i];
+    for (let propertyName of props) {
       set(obj, propertyName, properties[propertyName]);
     }
   });
@@ -2551,9 +2483,8 @@ function findNamespaces() {
   let lookup = context.lookup;
   let keys = Object.keys(lookup);
 
-  for (let i = 0; i < keys.length; i++) {
-    let key = keys[i]; // Only process entities that start with uppercase A-Z
-
+  for (let key of keys) {
+    // Only process entities that start with uppercase A-Z
     if (!isUppercase(key.charCodeAt(0))) {
       continue;
     }
@@ -2586,8 +2517,8 @@ function processAllNamespaces() {
   if (unprocessedNamespaces || unprocessedMixins) {
     let namespaces = NAMESPACES;
 
-    for (let i = 0; i < namespaces.length; i++) {
-      processNamespace(namespaces[i]);
+    for (let namespace of namespaces) {
+      processNamespace(namespace);
     }
 
     unprocessedMixins = false;
@@ -2663,10 +2594,7 @@ const {
 
 function extractAccessors(properties) {
   if (properties !== undefined) {
-    let keys = Object.keys(properties);
-
-    for (let i = 0; i < keys.length; i++) {
-      let key = keys[i];
+    for (let key of Object.keys(properties)) {
       let desc = Object.getOwnPropertyDescriptor(properties, key);
 
       if (desc.get !== undefined || desc.set !== undefined) {
@@ -2748,7 +2676,8 @@ function giveDecoratorSuper(key, decorator, property, descs) {
     }]);
     newProperty._readOnly = property._readOnly;
     newProperty._meta = property._meta;
-    newProperty.enumerable = property.enumerable;
+    newProperty.enumerable = property.enumerable; // SAFETY: We passed in the impl for this class
+
     return makeComputedDecorator(newProperty, ComputedProperty);
   }
 
@@ -2799,8 +2728,7 @@ function applyMergedProperties(key, value, values) {
   let hasFunction = false;
   let props = Object.keys(value);
 
-  for (let i = 0; i < props.length; i++) {
-    let prop = props[i];
+  for (let prop of props) {
     let propValue = value[prop];
 
     if (typeof propValue === 'function') {
@@ -2863,8 +2791,7 @@ function mergeProps(meta$$1, props, descs, values, base, keys, keysWithSuper) {
   let mergings = concatenatedMixinProperties('mergedProperties', props, values, base);
   let propKeys = Object.keys(props);
 
-  for (let i = 0; i < propKeys.length; i++) {
-    let key = propKeys[i];
+  for (let key of propKeys) {
     let value = props[key];
     if (value === undefined) continue;
 
@@ -2927,16 +2854,16 @@ function updateObserversAndListeners(obj, key, fn, add) {
   if (observers !== undefined) {
     let updateObserver = add ? addObserver : removeObserver;
 
-    for (let i = 0; i < observers.paths.length; i++) {
-      updateObserver(obj, observers.paths[i], null, key, observers.sync);
+    for (let path of observers.paths) {
+      updateObserver(obj, path, null, key, observers.sync);
     }
   }
 
   if (listeners !== undefined) {
     let updateListener = add ? addListener : removeListener;
 
-    for (let i = 0; i < listeners.length; i++) {
-      updateListener(obj, listeners[i], null, key);
+    for (let listener of listeners) {
+      updateListener(obj, listener, null, key);
     }
   }
 }
@@ -2957,8 +2884,7 @@ function applyMixin(obj, mixins, _hideKeys = false) {
 
   mergeMixins(mixins, meta$$1, descs, values, obj, keys, keysWithSuper);
 
-  for (let i = 0; i < keys.length; i++) {
-    let key = keys[i];
+  for (let key of keys) {
     let value = values[key];
     let desc = descs[key];
 
@@ -3076,6 +3002,7 @@ const MIXINS = new _WeakSet();
 */
 
 class Mixin {
+  /** @internal */
   constructor(mixins, properties) {
     MIXINS.add(this);
     this.properties = extractAccessors(properties);
@@ -3116,6 +3043,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 +3066,7 @@ class Mixin {
     @method reopen
     @param arguments*
     @private
+    @internal
   */
 
 
@@ -3161,6 +3091,7 @@ class Mixin {
     @param obj
     @return applied object
     @private
+    @internal
   */
 
 
@@ -3172,6 +3103,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 +3114,7 @@ class Mixin {
     @param obj
     @return {Boolean}
     @private
+    @internal
   */
 
 
@@ -3201,16 +3135,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 +3232,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;
@@ -3313,8 +3281,8 @@ function observer(...args) {
   assert('observer called without sync', typeof sync === 'boolean');
   let paths = [];
 
-  for (let i = 0; i < dependentKeys.length; ++i) {
-    expandProperties(dependentKeys[i], path => paths.push(path));
+  for (let dependentKey of dependentKeys) {
+    expandProperties(dependentKey, path => paths.push(path));
   }
 
   setObservers(func, {
@@ -3332,8 +3300,14 @@ if (DEBUG) {
 
 function inject(type, ...args) {
   assert('a string type must be provided to inject', typeof type === 'string');
-  let calledAsDecorator = isElementDescriptor(args);
-  let name = calledAsDecorator ? undefined : args[0];
+  let elementDescriptor;
+  let name;
+
+  if (isElementDescriptor(args)) {
+    elementDescriptor = args;
+  } else if (typeof args[0] === 'string') {
+    name = args[0];
+  }
 
   let getInjection = function (propertyName) {
     let owner = getOwner(this) || this.container; // fallback to `container` for backwards compat
@@ -3358,8 +3332,8 @@ function inject(type, ...args) {
 
   });
 
-  if (calledAsDecorator) {
-    return decorator(args[0], args[1], args[2]);
+  if (elementDescriptor) {
+    return decorator(elementDescriptor[0], elementDescriptor[1], elementDescriptor[2]);
   } else {
     return decorator;
   }

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

@@ -131,23 +131,28 @@ ControllerMixin.reopen({
     aController.transitionToRoute({ queryParams: { sort: 'date' } });
     ```
        See also [replaceRoute](/ember/release/classes/Ember.ControllerMixin/methods/replaceRoute?anchor=replaceRoute).
-       @param {String} name the name of the route or a URL
+       @for Ember.ControllerMixin
+    @method transitionToRoute
+    @deprecated Use transitionTo from the Router service instead.
+    @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
-    @for Ember.ControllerMixin
-    @method transitionToRoute
     @return {Transition} the transition object associated with this
       attempted transition
-    @deprecated Use transitionTo from the Router service instead.
     @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));
   },
 
@@ -190,21 +195,28 @@ ControllerMixin.reopen({
     aController.replaceRoute('/');
     aController.replaceRoute('/blog/post/1/comment/13');
     ```
-       @param {String} name the name of the route or a URL
+       @for Ember.ControllerMixin
+    @method replaceRoute
+    @deprecated Use replaceWith from the Router service instead.
+    @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.
-    @for Ember.ControllerMixin
-    @method replaceRoute
+    @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
-    @deprecated Use replaceWith from the Router service instead.
     @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);