ember-source 4.5.0-alpha.4 → 4.5.0-beta.2

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

@@ -1,22 +1,14 @@
 /**
 @module ember
 */
-import { assert } from '@ember/debug';
 import { Mixin } from '@ember/-internals/metal';
-/**
-  RegistryProxyMixin is used to provide public access to specific
-  registry functionality.
-
-  @class RegistryProxyMixin
-  @private
-*/
-
-export default Mixin.create({
+import { assert } from '@ember/debug';
+const RegistryProxyMixin = Mixin.create({
   __registry__: null,
 
   /**
    Given a fullName return the corresponding factory.
-    @public
+      @public
    @method resolveRegistration
    @param {String} fullName
    @return {Function} fullName's factory
@@ -30,48 +22,48 @@ export default Mixin.create({
     Registers a factory that can be used for dependency injection (with
     `inject`) or for service lookup. Each factory is registered with
     a full name including two parts: `type:name`.
-     A simple example:
-     ```javascript
+       A simple example:
+       ```javascript
     import Application from '@ember/application';
     import EmberObject from '@ember/object';
-     let App = Application.create();
-     App.Orange = EmberObject.extend();
+       let App = Application.create();
+       App.Orange = EmberObject.extend();
     App.register('fruit:favorite', App.Orange);
     ```
-     Ember will resolve factories from the `App` namespace automatically.
+       Ember will resolve factories from the `App` namespace automatically.
     For example `App.CarsController` will be discovered and returned if
     an application requests `controller:cars`.
-     An example of registering a controller with a non-standard name:
-     ```javascript
+       An example of registering a controller with a non-standard name:
+       ```javascript
     import Application from '@ember/application';
     import Controller from '@ember/controller';
-     let App = Application.create();
+       let App = Application.create();
     let Session = Controller.extend();
-     App.register('controller:session', Session);
-     // The Session controller can now be treated like a normal controller,
+       App.register('controller:session', Session);
+       // The Session controller can now be treated like a normal controller,
     // despite its non-standard name.
     App.ApplicationController = Controller.extend({
       needs: ['session']
     });
     ```
-     Registered factories are **instantiated** by having `create`
+       Registered factories are **instantiated** by having `create`
     called on them. Additionally they are **singletons**, each time
     they are looked up they return the same instance.
-     Some examples modifying that default behavior:
-     ```javascript
+       Some examples modifying that default behavior:
+       ```javascript
     import Application from '@ember/application';
     import EmberObject from '@ember/object';
-     let App = Application.create();
-     App.Person = EmberObject.extend();
+       let App = Application.create();
+       App.Person = EmberObject.extend();
     App.Orange = EmberObject.extend();
     App.Email = EmberObject.extend();
     App.session = EmberObject.create();
-     App.register('model:user', App.Person, { singleton: false });
+       App.register('model:user', App.Person, { singleton: false });
     App.register('fruit:favorite', App.Orange);
     App.register('communication:main', App.Email, { singleton: false });
     App.register('session', App.session, { instantiate: false });
     ```
-     @method register
+       @method register
     @param  fullName {String} type:name (e.g., 'model:user')
     @param  factory {any} (e.g., App.Person)
     @param  options {Object} (optional) disable instantiation or singleton usage
@@ -81,17 +73,17 @@ export default Mixin.create({
 
   /**
    Unregister a factory.
-    ```javascript
+      ```javascript
    import Application from '@ember/application';
    import EmberObject from '@ember/object';
-    let App = Application.create();
+      let App = Application.create();
    let User = EmberObject.extend();
    App.register('model:user', User);
-    App.resolveRegistration('model:user').create() instanceof User //=> true
-    App.unregister('model:user')
+      App.resolveRegistration('model:user').create() instanceof User //=> true
+      App.unregister('model:user')
    App.resolveRegistration('model:user') === undefined //=> true
    ```
-    @public
+      @public
    @method unregister
    @param {String} fullName
    */
@@ -99,7 +91,7 @@ export default Mixin.create({
 
   /**
    Check if a factory is registered.
-    @public
+      @public
    @method hasRegistration
    @param {String} fullName
    @return {Boolean}
@@ -108,7 +100,7 @@ export default Mixin.create({
 
   /**
    Return a specific registered option for a particular factory.
-    @public
+      @public
    @method registeredOption
    @param  {String} fullName
    @param  {String} optionName
@@ -118,7 +110,7 @@ export default Mixin.create({
 
   /**
    Register options for a particular factory.
-    @public
+      @public
    @method registerOptions
    @param {String} fullName
    @param {Object} options
@@ -127,7 +119,7 @@ export default Mixin.create({
 
   /**
    Return registered options for a particular factory.
-    @public
+      @public
    @method registeredOptions
    @param  {String} fullName
    @return {Object} options
@@ -136,22 +128,22 @@ export default Mixin.create({
 
   /**
    Allow registering options for all factories of a type.
-    ```javascript
+      ```javascript
    import Application from '@ember/application';
-    let App = Application.create();
+      let App = Application.create();
    let appInstance = App.buildInstance();
-    // if all of type `connection` must not be singletons
+      // if all of type `connection` must not be singletons
    appInstance.registerOptionsForType('connection', { singleton: false });
-    appInstance.register('connection:twitter', TwitterConnection);
+      appInstance.register('connection:twitter', TwitterConnection);
    appInstance.register('connection:facebook', FacebookConnection);
-    let twitter = appInstance.lookup('connection:twitter');
+      let twitter = appInstance.lookup('connection:twitter');
    let twitter2 = appInstance.lookup('connection:twitter');
-    twitter === twitter2; // => false
-    let facebook = appInstance.lookup('connection:facebook');
+      twitter === twitter2; // => false
+      let facebook = appInstance.lookup('connection:facebook');
    let facebook2 = appInstance.lookup('connection:facebook');
-    facebook === facebook2; // => false
+      facebook === facebook2; // => false
    ```
-    @public
+      @public
    @method registerOptionsForType
    @param {String} type
    @param {Object} options
@@ -160,7 +152,7 @@ export default Mixin.create({
 
   /**
    Return the registered options for all factories of a type.
-    @public
+      @public
    @method registeredOptionsForType
    @param {String} type
    @return {Object} options
@@ -170,37 +162,37 @@ export default Mixin.create({
   /**
     Define a dependency injection onto a specific factory or all factories
     of a type.
-     When Ember instantiates a controller, view, or other framework component
+       When Ember instantiates a controller, view, or other framework component
     it can attach a dependency to that component. This is often used to
     provide services to a set of framework components.
-     An example of providing a session object to all controllers:
-     ```javascript
+       An example of providing a session object to all controllers:
+       ```javascript
     import { alias } from '@ember/object/computed';
     import Application from '@ember/application';
     import Controller from '@ember/controller';
     import EmberObject from '@ember/object';
-     let App = Application.create();
+       let App = Application.create();
     let Session = EmberObject.extend({ isAuthenticated: false });
-     // A factory must be registered before it can be injected
+       // A factory must be registered before it can be injected
     App.register('session:main', Session);
-     // Inject 'session:main' onto all factories of the type 'controller'
+       // Inject 'session:main' onto all factories of the type 'controller'
     // with the name 'session'
     App.inject('controller', 'session', 'session:main');
-     App.IndexController = Controller.extend({
+       App.IndexController = Controller.extend({
       isLoggedIn: alias('session.isAuthenticated')
     });
     ```
-     Injections can also be performed on specific factories.
-     ```javascript
+       Injections can also be performed on specific factories.
+       ```javascript
     App.inject(<full_name or type>, <property name>, <full_name>)
     App.inject('route', 'source', 'source:main')
     App.inject('route:application', 'email', 'model:email')
     ```
-     It is important to note that injections can only be performed on
+       It is important to note that injections can only be performed on
     classes that are instantiated by Ember itself. Instantiating a class
     directly (via `create` or `new`) bypasses the dependency injection
     system.
-     @public
+       @public
     @method inject
     @param  factoryNameOrType {String}
     @param  property {String}
@@ -211,7 +203,13 @@ export default Mixin.create({
 });
 
 function registryAlias(name) {
-  return function () {
-    return this.__registry__[name](...arguments);
+  return function (...args) {
+    // We need this cast because `Parameters` is deferred so that it is not
+    // possible for TS to see it will always produce the right type. However,
+    // since `AnyFn` has a rest type, it is allowed. See discussion on [this
+    // issue](https://github.com/microsoft/TypeScript/issues/47615).
+    return this.__registry__[name](...args);
   };
-}
+}
+
+export default RegistryProxyMixin;

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

@@ -5,19 +5,6 @@ import { context } from '@ember/-internals/environment';
 import { get, Mixin, computed } from '@ember/-internals/metal';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-/**
-`Ember.TargetActionSupport` is a mixin that can be included in a class
-to add a `triggerAction` method with semantics similar to the Handlebars
-`{{action}}` helper. In normal Ember usage, the `{{action}}` helper is
-usually the best choice. This mixin is most often useful when you are
-doing more complex event handling in Components.
-
-@class TargetActionSupport
-@namespace Ember
-@extends Mixin
-@private
-*/
-
 const TargetActionSupport = Mixin.create({
   target: null,
   action: null,
@@ -41,9 +28,9 @@ const TargetActionSupport = Mixin.create({
   /**
   Send an `action` with an `actionContext` to a `target`. The action, actionContext
   and target will be retrieved from properties of the object. For example:
-   ```javascript
+     ```javascript
   import { alias } from '@ember/object/computed';
-   App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+     App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
     target: alias('controller'),
     action: 'save',
     actionContext: alias('context'),
@@ -53,9 +40,9 @@ const TargetActionSupport = Mixin.create({
     }
   });
   ```
-   The `target`, `action`, and `actionContext` can be provided as properties of
+     The `target`, `action`, and `actionContext` can be provided as properties of
   an optional object argument to `triggerAction` as well.
-   ```javascript
+     ```javascript
   App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
     click() {
       this.triggerAction({
@@ -67,12 +54,12 @@ const TargetActionSupport = Mixin.create({
     }
   });
   ```
-   The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
+     The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
   But `target` and `action` must be specified either as properties or with the argument
   to `triggerAction`, or a combination:
-   ```javascript
+     ```javascript
   import { alias } from '@ember/object/computed';
-   App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
+     App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
     target: alias('controller'),
     click() {
       this.triggerAction({
@@ -82,7 +69,7 @@ const TargetActionSupport = Mixin.create({
     }
   });
   ```
-   @method triggerAction
+     @method triggerAction
   @param opts {Object} (optional, with the optional keys action, target and/or actionContext)
   @return {Boolean} true if the action was sent successfully and did not return false
   @private
@@ -100,14 +87,16 @@ const TargetActionSupport = Mixin.create({
       actionContext = get(this, 'actionContextObject') || this;
     }
 
+    let context = Array.isArray(actionContext) ? actionContext : [actionContext];
+
     if (target && action) {
       let ret;
 
-      if (target.send) {
-        ret = target.send(...[action].concat(actionContext));
+      if (isSendable(target)) {
+        ret = target.send(action, ...context);
       } else {
         assert(`The action '${action}' did not exist on ${target}`, typeof target[action] === 'function');
-        ret = target[action](...[].concat(actionContext));
+        ret = target[action](...context);
       }
 
       if (ret !== false) {
@@ -120,6 +109,10 @@ const TargetActionSupport = Mixin.create({
 
 });
 
+function isSendable(obj) {
+  return obj != null && typeof obj === 'object' && typeof obj.send === 'function';
+}
+
 function getTarget(instance) {
   let target = get(instance, 'target');
 

package/dist/packages/@ember/-internals/runtime/lib/system/array_proxy.js

@@ -8,12 +8,19 @@ import { isArray, MutableArray } from '../mixins/array';
 import { assert } from '@ember/debug';
 import { setCustomTagFor } from '@glimmer/manager';
 import { combine, consumeTag, validateTag, valueForTag, tagFor } from '@glimmer/validator';
+
+function isMutable(obj) {
+  return Array.isArray(obj) || typeof obj.replace === 'function';
+}
+
 const ARRAY_OBSERVER_MAPPING = {
   willChange: '_arrangedContentArrayWillChange',
   didChange: '_arrangedContentArrayDidChange'
 };
 
 function customTagForArrayProxy(proxy, key) {
+  assert('[BUG] Expected a proxy', proxy instanceof ArrayProxy);
+
   if (key === '[]') {
     proxy._revalidate();
 
@@ -26,90 +33,53 @@ function customTagForArrayProxy(proxy, key) {
 
   return tagFor(proxy, key);
 }
-/**
-  An ArrayProxy wraps any other object that implements `Array` and/or
-  `MutableArray,` forwarding all requests. This makes it very useful for
-  a number of binding use cases or other cases where being able to swap
-  out the underlying array is useful.
-
-  A simple example of usage:
-
-  ```javascript
-  import { A } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-
-  let pets = ['dog', 'cat', 'fish'];
-  let ap = ArrayProxy.create({ content: A(pets) });
-
-  ap.get('firstObject');                        // 'dog'
-  ap.set('content', ['amoeba', 'paramecium']);
-  ap.get('firstObject');                        // 'amoeba'
-  ```
-
-  This class can also be useful as a layer to transform the contents of
-  an array, as they are accessed. This can be done by overriding
-  `objectAtContent`:
-
-  ```javascript
-  import { A } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-
-  let pets = ['dog', 'cat', 'fish'];
-  let ap = ArrayProxy.create({
-      content: A(pets),
-      objectAtContent: function(idx) {
-          return this.get('content').objectAt(idx).toUpperCase();
-      }
-  });
-
-  ap.get('firstObject'); // . 'DOG'
-  ```
-
-  When overriding this class, it is important to place the call to
-  `_super` *after* setting `content` so the internal observers have
-  a chance to fire properly:
 
-  ```javascript
-  import { A } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-
-  export default ArrayProxy.extend({
-    init() {
-      this.set('content', A(['dog', 'cat', 'fish']));
-      this._super(...arguments);
-    }
-  });
-  ```
-
-  @class ArrayProxy
-  @extends EmberObject
-  @uses MutableArray
-  @public
-*/
-
-
-export default class ArrayProxy extends EmberObject {
-  init() {
-    super.init(...arguments);
+class ArrayProxy extends EmberObject {
+  constructor() {
+    super(...arguments);
     /*
       `this._objectsDirtyIndex` determines which indexes in the `this._objects`
       cache are dirty.
-       If `this._objectsDirtyIndex === -1` then no indexes are dirty.
+             If `this._objectsDirtyIndex === -1` then no indexes are dirty.
       Otherwise, an index `i` is dirty if `i >= this._objectsDirtyIndex`.
-       Calling `objectAt` with a dirty index will cause the `this._objects`
+             Calling `objectAt` with a dirty index will cause the `this._objects`
       cache to be recomputed.
     */
 
+    /** @internal */
+
     this._objectsDirtyIndex = 0;
+    /** @internal */
+
     this._objects = null;
+    /** @internal */
+
     this._lengthDirty = true;
+    /** @internal */
+
     this._length = 0;
+    /** @internal */
+
     this._arrangedContent = null;
+    /** @internal */
+
     this._arrangedContentIsUpdating = false;
+    /** @internal */
+
     this._arrangedContentTag = null;
+    /** @internal */
+
     this._arrangedContentRevision = null;
+    /** @internal */
+
     this._lengthTag = null;
+    /** @internal */
+
     this._arrTag = null;
+  }
+
+  init(props) {
+    super.init(props);
     setCustomTagFor(this, customTagForArrayProxy);
   }
 
@@ -120,20 +90,12 @@ export default class ArrayProxy extends EmberObject {
   willDestroy() {
     this._removeArrangedContentArrayObserver();
   }
-  /**
-    The content array. Must be an object that implements `Array` and/or
-    `MutableArray.`
-     @property content
-    @type EmberArray
-    @public
-  */
-
   /**
     Should actually retrieve the object at the specified index from the
     content. You can override this method in subclasses to transform the
     content item to something new.
-     This method will only be called if content is non-`null`.
-     @method objectAtContent
+       This method will only be called if content is non-`null`.
+       @method objectAtContent
     @param {Number} idx The index to retrieve.
     @return {Object} the value or undefined if none found
     @public
@@ -141,7 +103,9 @@ export default class ArrayProxy extends EmberObject {
 
 
   objectAtContent(idx) {
-    return objectAt(get(this, 'arrangedContent'), idx);
+    let arrangedContent = get(this, 'arrangedContent');
+    assert('[BUG] Called objectAtContent without content', arrangedContent);
+    return objectAt(arrangedContent, idx);
   } // See additional docs for `replace` from `MutableArray`:
   // https://api.emberjs.com/ember/release/classes/MutableArray/methods/replace?anchor=replace
 
@@ -154,19 +118,21 @@ export default class ArrayProxy extends EmberObject {
     Should actually replace the specified objects on the content array.
     You can override this method in subclasses to transform the content item
     into something new.
-     This method will only be called if content is non-`null`.
-     @method replaceContent
+       This method will only be called if content is non-`null`.
+       @method replaceContent
     @param {Number} idx The starting index
     @param {Number} amt The number of items to remove from the content.
-    @param {EmberArray} objects Optional array of objects to insert or null if no
-      objects.
+    @param {EmberArray} objects Optional array of objects to insert.
     @return {void}
     @public
   */
 
 
   replaceContent(idx, amt, objects) {
-    get(this, 'content').replace(idx, amt, objects);
+    let content = get(this, 'content');
+    assert('[BUG] Called objectAtContent without content', content);
+    assert('Mutating a non-mutable array is not allowed', isMutable(content));
+    content.replace(idx, amt, objects);
   } // Overriding objectAt is not supported.
 
 
@@ -184,6 +150,9 @@ export default class ArrayProxy extends EmberObject {
         let length = this._objects.length = get(arrangedContent, 'length');
 
         for (let i = this._objectsDirtyIndex; i < length; i++) {
+          // SAFETY: This is expected to only ever return an instance of T. In other words, there should
+          // be no gaps in the array. Unfortunately, we can't actually assert for it since T could include
+          // any types, including null or undefined.
           this._objects[i] = this.objectAtContent(i);
         }
       } else {
@@ -206,6 +175,7 @@ export default class ArrayProxy extends EmberObject {
       this._lengthDirty = false;
     }
 
+    assert('[BUG] _lengthTag is not set', this._lengthTag);
     consumeTag(this._lengthTag);
     return this._length;
   }
@@ -225,6 +195,7 @@ export default class ArrayProxy extends EmberObject {
     let content = get(this, 'content');
 
     if (content) {
+      assert('Mutating a non-mutable array is not allowed', isMutable(content));
       replace(content, value, removedCount, added);
 
       this._invalidate();
@@ -248,6 +219,7 @@ export default class ArrayProxy extends EmberObject {
 
   _addArrangedContentArrayObserver(arrangedContent) {
     if (arrangedContent && !arrangedContent.isDestroyed) {
+      // @ts-expect-error This check is still good for ensuring correctness
       assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
       assert(`ArrayProxy expects an Array or ArrayProxy, but you passed ${typeof arrangedContent}`, isArray(arrangedContent) || arrangedContent.isDestroyed);
       addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING);
@@ -263,7 +235,7 @@ export default class ArrayProxy extends EmberObject {
 
   _arrangedContentArrayWillChange() {}
 
-  _arrangedContentArrayDidChange(proxy, idx, removedCnt, addedCnt) {
+  _arrangedContentArrayDidChange(_proxy, idx, removedCnt, addedCnt) {
     arrayContentWillChange(this, idx, removedCnt, addedCnt);
     let dirtyIndex = idx;
 
@@ -316,13 +288,15 @@ export default class ArrayProxy extends EmberObject {
   }
 
 }
+
 ArrayProxy.reopen(MutableArray, {
   /**
     The array that the proxy pretends to be. In the default `ArrayProxy`
     implementation, this and `content` are the same. Subclasses of `ArrayProxy`
     can override this property to provide things like sorting and filtering.
-     @property arrangedContent
+       @property arrangedContent
     @public
   */
   arrangedContent: alias('content')
-});
+});
+export default ArrayProxy;

package/dist/packages/@ember/-internals/runtime/lib/system/object.js

@@ -1,6 +1,8 @@
 /**
 @module @ember/object
 */
+var _a;
+
 import { getFactoryFor } from '@ember/-internals/container';
 import { symbol } from '@ember/-internals/utils';
 import { addListener } from '@ember/-internals/metal';
@@ -21,15 +23,20 @@ export default EmberObject;
 let FrameworkObject = class FrameworkObject extends EmberObject {};
 
 if (DEBUG) {
-  let INIT_WAS_CALLED = symbol('INIT_WAS_CALLED');
+  const INIT_WAS_CALLED = Symbol('INIT_WAS_CALLED');
   let ASSERT_INIT_WAS_CALLED = symbol('ASSERT_INIT_WAS_CALLED');
   FrameworkObject = class DebugFrameworkObject extends EmberObject {
+    constructor() {
+      super(...arguments);
+      this[_a] = false;
+    }
+
     init(properties) {
       super.init(properties);
       this[INIT_WAS_CALLED] = true;
     }
 
-    [ASSERT_INIT_WAS_CALLED]() {
+    [(_a = INIT_WAS_CALLED, ASSERT_INIT_WAS_CALLED)]() {
       assert(`You must call \`super.init(...arguments);\` or \`this._super(...arguments)\` when overriding \`init\` on a framework object. Please update ${this} to call \`super.init(...arguments);\` from \`init\` when using native classes or \`this._super(...arguments)\` when using \`EmberObject.extend()\`.`, this[INIT_WAS_CALLED]);
     }