ember-source 4.2.0-alpha.7 → 4.3.0-alpha.3

package/dist/packages/@ember/-internals/meta/lib/meta.js

@@ -36,9 +36,16 @@ export const UNDEFINED = symbol('undefined');
 let currentListenerVersion = 1;
 export class Meta {
   // DEBUG
+
+  /** @internal */
   constructor(obj) {
+    /** @internal */
     this._listenersVersion = 1;
+    /** @internal */
+
     this._inheritedEnd = -1;
+    /** @internal */
+
     this._flattenedVersion = 0;
 
     if (DEBUG) {
@@ -59,6 +66,8 @@ export class Meta {
     this.proto = obj.constructor === undefined ? undefined : obj.constructor.prototype;
     this._listeners = undefined;
   }
+  /** @internal */
+
 
   get parent() {
     let parent = this._parent;
@@ -74,26 +83,38 @@ export class Meta {
   setInitializing() {
     this._isInit = true;
   }
+  /** @internal */
+
 
   unsetInitializing() {
     this._isInit = false;
   }
+  /** @internal */
+
 
   isInitializing() {
     return this._isInit;
   }
+  /** @internal */
+
 
   isPrototypeMeta(obj) {
     return this.proto === this.source && this.source === obj;
   }
+  /** @internal */
+
 
   _getOrCreateOwnMap(key) {
     return this[key] || (this[key] = Object.create(null));
   }
+  /** @internal */
+
 
   _getOrCreateOwnSet(key) {
     return this[key] || (this[key] = new Set());
   }
+  /** @internal */
+
 
   _findInheritedMap(key, subkey) {
     let pointer = this;
@@ -112,6 +133,8 @@ export class Meta {
       pointer = pointer.parent;
     }
   }
+  /** @internal */
+
 
   _hasInInheritedSet(key, value) {
     let pointer = this;
@@ -128,28 +151,38 @@ export class Meta {
 
     return false;
   }
+  /** @internal */
+
 
   valueFor(key) {
     let values = this._values;
     return values !== undefined ? values[key] : undefined;
   }
+  /** @internal */
+
 
   setValueFor(key, value) {
     let values = this._getOrCreateOwnMap('_values');
 
     values[key] = value;
   }
+  /** @internal */
+
 
   revisionFor(key) {
     let revisions = this._revisions;
     return revisions !== undefined ? revisions[key] : undefined;
   }
+  /** @internal */
+
 
   setRevisionFor(key, revision) {
     let revisions = this._getOrCreateOwnMap('_revisions');
 
     revisions[key] = revision;
   }
+  /** @internal */
+
 
   writableLazyChainsFor(key) {
     if (DEBUG) {
@@ -166,6 +199,8 @@ export class Meta {
 
     return chains;
   }
+  /** @internal */
+
 
   readableLazyChainsFor(key) {
     if (DEBUG) {
@@ -180,6 +215,8 @@ export class Meta {
 
     return undefined;
   }
+  /** @internal */
+
 
   addMixin(mixin) {
     assert(isDestroyed(this.source) ? `Cannot add mixins of \`${toString(mixin)}\` on \`${toString(this.source)}\` call addMixin after it has been destroyed.` : '', !isDestroyed(this.source));
@@ -188,10 +225,14 @@ export class Meta {
 
     set.add(mixin);
   }
+  /** @internal */
+
 
   hasMixin(mixin) {
     return this._hasInInheritedSet('_mixins', mixin);
   }
+  /** @internal */
+
 
   forEachMixins(fn) {
     let pointer = this;
@@ -214,22 +255,30 @@ export class Meta {
       pointer = pointer.parent;
     }
   }
+  /** @internal */
+
 
   writeDescriptors(subkey, value) {
     assert(isDestroyed(this.source) ? `Cannot update descriptors for \`${subkey}\` on \`${toString(this.source)}\` after it has been destroyed.` : '', !isDestroyed(this.source));
     let map = this._descriptors || (this._descriptors = new Map());
     map.set(subkey, value);
   }
+  /** @internal */
+
 
   peekDescriptors(subkey) {
     let possibleDesc = this._findInheritedMap('_descriptors', subkey);
 
     return possibleDesc === UNDEFINED ? undefined : possibleDesc;
   }
+  /** @internal */
+
 
   removeDescriptors(subkey) {
     this.writeDescriptors(subkey, UNDEFINED);
   }
+  /** @internal */
+
 
   forEachDescriptors(fn) {
     let pointer = this;
@@ -254,6 +303,8 @@ export class Meta {
       pointer = pointer.parent;
     }
   }
+  /** @internal */
+
 
   addToListeners(eventName, target, method, once, sync) {
     if (DEBUG) {
@@ -266,6 +317,8 @@ export class Meta {
     /* ADD */
     , sync);
   }
+  /** @internal */
+
 
   removeFromListeners(eventName, target, method) {
     if (DEBUG) {
@@ -311,8 +364,8 @@ export class Meta {
       && listener.kind !== 2
       /* REMOVE */
       ) {
-          listeners.splice(i, 1);
-        } else {
+        listeners.splice(i, 1);
+      } else {
         assert(`You attempted to add an observer for the same method on '${event.split(':')[0]}' twice to ${target} as both sync and async. Observers must be either sync or async, they cannot be both. This is likely a mistake, you should either remove the code that added the observer a second time, or update it to always be sync or async. The method was ${method}.`, !(listener.kind === 0
         /* ADD */
         && kind === 0
@@ -416,6 +469,8 @@ export class Meta {
 
     return this._listeners;
   }
+  /** @internal */
+
 
   matchingListeners(eventName) {
     let listeners = this.flattenedListeners();
@@ -450,6 +505,8 @@ export class Meta {
 
     return result;
   }
+  /** @internal */
+
 
   observerEvents() {
     let listeners = this.flattenedListeners();

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;