ember-source 4.4.0-alpha.6 → 4.4.0-alpha.7

package/dist/header/license.js

@@ -5,5 +5,5 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.4.0-alpha.6
+ * @version   4.4.0-alpha.7
  */

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

@@ -396,7 +396,6 @@ class FactoryManager {
     this.normalizedName = normalizedName;
     this.madeToString = undefined;
     this.injections = undefined;
-    setFactoryFor(this, this);
   }
 
   toString() {

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

@@ -2492,16 +2492,40 @@ function isCurlyManager(manager) {
 }
 
 let lazyEventsProcessed = new WeakMap();
-const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassNamesSupport, TargetActionSupport, ActionSupport, ViewMixin, {
-  isComponent: true,
 
-  init() {
-    this._super(...arguments);
+class Component extends CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassNamesSupport, TargetActionSupport, ActionSupport, ViewMixin, {
+  // These need to be overridable via extend/create but should still
+  // have a default. Defining them here is the best way to achieve that.
+  didReceiveAttrs() {},
+
+  didRender() {},
+
+  didUpdate() {},
+
+  didUpdateAttrs() {},
+
+  willRender() {},
+
+  willUpdate() {}
+
+}) {
+  constructor() {
+    super(...arguments);
+    this.isComponent = true;
+  }
+
+  init(properties) {
+    super.init(properties); // Handle methods from ViewMixin.
+    // The native class inheritance will not work for mixins. To work around this,
+    // we copy the existing rerender method provided by the mixin and swap in the
+    // new rerender method from our class.
 
+    this._superRerender = this.rerender;
+    this.rerender = this._rerender;
     this[IS_DISPATCHING_ATTRS] = false;
     this[DIRTY_TAG] = createTag();
     this[BOUNDS] = null;
-    let eventDispatcher = this._dispatcher;
+    const eventDispatcher = this._dispatcher;
 
     if (eventDispatcher) {
       let lazyEventsProcessedForComponentClass = lazyEventsProcessed.get(eventDispatcher);
@@ -2531,7 +2555,7 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
       for (let key in events) {
         let methodName = events[key];
 
-        if (typeof this[methodName] === 'function') {
+        if (methodName && typeof this[methodName] === 'function') {
           eventNames.push(methodName);
         }
       } // If in a tagless component, assert that no event handlers are defined
@@ -2539,7 +2563,7 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
 
       assert(`You can not define \`${eventNames}\` function(s) to handle DOM event in the \`${this}\` tagless component since it doesn't have any DOM element.`, !eventNames.length);
     }
-  },
+  }
 
   get _dispatcher() {
     if (this.__dispatcher === undefined) {
@@ -2547,8 +2571,9 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
       assert('Component is unexpectedly missing an owner', owner);
 
       if (owner.lookup('-environment:main').isInteractive) {
-        this.__dispatcher = owner.lookup('event_dispatcher:main');
-        assert('Expected dispatcher to be an EventDispatcher', this.__dispatcher instanceof EventDispatcher);
+        let dispatcher = owner.lookup('event_dispatcher:main');
+        assert('Expected dispatcher to be an EventDispatcher', dispatcher instanceof EventDispatcher);
+        this.__dispatcher = dispatcher;
       } else {
         // In FastBoot we have no EventDispatcher. Set to null to not try again to look it up.
         this.__dispatcher = null;
@@ -2556,20 +2581,24 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
     }
 
     return this.__dispatcher;
-  },
+  }
 
-  on(eventName) {
+  on(name, target, method) {
     var _a;
 
-    (_a = this._dispatcher) === null || _a === void 0 ? void 0 : _a.setupHandlerForEmberEvent(eventName);
-    return this._super(...arguments);
-  },
+    (_a = this._dispatcher) === null || _a === void 0 ? void 0 : _a.setupHandlerForEmberEvent(name); // The `on` method here comes from the Evented mixin. Since this mixin
+    // is applied to the parent of this class, however, we are still able
+    // to use `super`.
 
-  rerender() {
+    return super.on(name, target, method);
+  } // Changed to `rerender` on init
+
+
+  _rerender() {
     dirtyTag(this[DIRTY_TAG]);
 
-    this._super();
-  },
+    this._superRerender();
+  }
 
   [PROPERTY_DID_CHANGE](key, value) {
     if (this[IS_DISPATCHING_ATTRS]) {
@@ -2582,39 +2611,40 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
     if (reference !== undefined && isUpdatableRef(reference)) {
       updateRef(reference, arguments.length === 2 ? value : get(this, key));
     }
-  },
+  }
 
   getAttr(key) {
     // TODO Intimate API should be deprecated
     return this.get(key);
-  },
-
+  }
   /**
     Normally, Ember's component model is "write-only". The component takes a
     bunch of attributes that it got passed in, and uses them to render its
     template.
-     One nice thing about this model is that if you try to set a value to the
+       One nice thing about this model is that if you try to set a value to the
     same thing as last time, Ember (through HTMLBars) will avoid doing any
     work on the DOM.
-     This is not just a performance optimization. If an attribute has not
+       This is not just a performance optimization. If an attribute has not
     changed, it is important not to clobber the element's "hidden state".
     For example, if you set an input's `value` to the same value as before,
     it will clobber selection state and cursor position. In other words,
     setting an attribute is not **always** idempotent.
-     This method provides a way to read an element's attribute and also
+       This method provides a way to read an element's attribute and also
     update the last value Ember knows about at the same time. This makes
     setting an attribute idempotent.
-     In particular, what this means is that if you get an `<input>` element's
+       In particular, what this means is that if you get an `<input>` element's
     `value` attribute and then re-render the template with the same value,
     it will avoid clobbering the cursor and selection position.
     Since most attribute sets are idempotent in the browser, you typically
     can get away with reading attributes using jQuery, but the most reliable
     way to do so is through this method.
     @method readDOMAttr
-     @param {String} name the name of the attribute
+       @param {String} name the name of the attribute
     @return String
     @public
-   */
+    */
+
+
   readDOMAttr(name) {
     // TODO revisit this
     let _element = getViewElement(this);
@@ -2634,205 +2664,60 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
     }
 
     return element[normalized];
-  },
-
-  /**
-   The WAI-ARIA role of the control represented by this view. For example, a
-   button may have a role of type 'button', or a pane may have a role of
-   type 'alertdialog'. This property is used by assistive software to help
-   visually challenged users navigate rich web applications.
-    The full list of valid WAI-ARIA roles is available at:
-   [https://www.w3.org/TR/wai-aria/#roles_categorization](https://www.w3.org/TR/wai-aria/#roles_categorization)
-    @property ariaRole
-   @type String
-   @default null
-   @public
-   */
-
-  /**
-   Enables components to take a list of parameters as arguments.
-   For example, a component that takes two parameters with the names
-   `name` and `age`:
-    ```app/components/my-component.js
-   import Component from '@ember/component';
-    let MyComponent = Component.extend();
-    MyComponent.reopenClass({
-     positionalParams: ['name', 'age']
-   });
-    export default MyComponent;
-   ```
-    It can then be invoked like this:
-    ```hbs
-   {{my-component "John" 38}}
-   ```
-    The parameters can be referred to just like named parameters:
-    ```hbs
-   Name: {{name}}, Age: {{age}}.
-   ```
-    Using a string instead of an array allows for an arbitrary number of
-   parameters:
-    ```app/components/my-component.js
-   import Component from '@ember/component';
-    let MyComponent = Component.extend();
-    MyComponent.reopenClass({
-     positionalParams: 'names'
-   });
-    export default MyComponent;
-   ```
-    It can then be invoked like this:
-    ```hbs
-   {{my-component "John" "Michael" "Scott"}}
-   ```
-   The parameters can then be referred to by enumerating over the list:
-    ```hbs
-   {{#each names as |name|}}{{name}}{{/each}}
-   ```
-    @static
-   @public
-   @property positionalParams
-   @since 1.13.0
-   */
-
-  /**
-   Called when the attributes passed into the component have been updated.
-   Called both during the initial render of a container and during a rerender.
-   Can be used in place of an observer; code placed here will be executed
-   every time any attribute updates.
-   @method didReceiveAttrs
-   @public
-   @since 1.13.0
-   */
-  didReceiveAttrs() {},
-
-  /**
-   Called when the attributes passed into the component have been updated.
-   Called both during the initial render of a container and during a rerender.
-   Can be used in place of an observer; code placed here will be executed
-   every time any attribute updates.
-   @event didReceiveAttrs
-   @public
-   @since 1.13.0
-   */
-
-  /**
-   Called after a component has been rendered, both on initial render and
-   in subsequent rerenders.
-   @method didRender
-   @public
-   @since 1.13.0
-   */
-  didRender() {},
-
-  /**
-   Called after a component has been rendered, both on initial render and
-   in subsequent rerenders.
-   @event didRender
-   @public
-   @since 1.13.0
-   */
-
-  /**
-   Called before a component has been rendered, both on initial render and
-   in subsequent rerenders.
-   @method willRender
-   @public
-   @since 1.13.0
-   */
-  willRender() {},
-
-  /**
-   Called before a component has been rendered, both on initial render and
-   in subsequent rerenders.
-   @event willRender
-   @public
-   @since 1.13.0
-   */
-
-  /**
-   Called when the attributes passed into the component have been changed.
-   Called only during a rerender, not during an initial render.
-   @method didUpdateAttrs
-   @public
-   @since 1.13.0
-   */
-  didUpdateAttrs() {},
-
-  /**
-   Called when the attributes passed into the component have been changed.
-   Called only during a rerender, not during an initial render.
-   @event didUpdateAttrs
-   @public
-   @since 1.13.0
-   */
+  }
 
-  /**
-   Called when the component is about to update and rerender itself.
-   Called only during a rerender, not during an initial render.
-   @method willUpdate
-   @public
-   @since 1.13.0
-   */
-  willUpdate() {},
+  static toString() {
+    return '@ember/component';
+  }
 
-  /**
-   Called when the component is about to update and rerender itself.
-   Called only during a rerender, not during an initial render.
-   @event willUpdate
-   @public
-   @since 1.13.0
-   */
+}
 
-  /**
-   Called when the component has updated and rerendered itself.
-   Called only during a rerender, not during an initial render.
-   @method didUpdate
-   @public
-   @since 1.13.0
-   */
-  didUpdate() {}
-  /**
-   Called when the component has updated and rerendered itself.
-   Called only during a rerender, not during an initial render.
-   @event didUpdate
-   @public
-   @since 1.13.0
-   */
+Component.isComponentFactory = true; // We continue to use reopenClass here so that positionalParams can be overridden with reopenClass in subclasses.
 
+Component.reopenClass({
   /**
-    The HTML `id` of the component's element in the DOM. You can provide this
-    value yourself but it must be unique (just as in HTML):
-     ```handlebars
-    {{my-component elementId="a-really-cool-id"}}
+   Enables components to take a list of parameters as arguments.
+    For example, a component that takes two parameters with the names
+    `name` and `age`:
+       ```app/components/my-component.js
+    import Component from '@ember/component';
+       let MyComponent = Component.extend();
+       MyComponent.reopenClass({
+      positionalParams: ['name', 'age']
+    });
+       export default MyComponent;
     ```
-     ```handlebars
-    <MyComponent @elementId="a-really-cool-id" />
+       It can then be invoked like this:
+       ```hbs
+    {{my-component "John" 38}}
     ```
-    If not manually set a default value will be provided by the framework.
-    Once rendered an element's `elementId` is considered immutable and you
-    should never change it. If you need to compute a dynamic value for the
-    `elementId`, you should do this when the component or element is being
-    instantiated:
-     ```javascript
-    export default Component.extend({
-      init() {
-        this._super(...arguments);
-         var index = this.get('index');
-        this.set('elementId', `component-id${index}`);
-      }
+       The parameters can be referred to just like named parameters:
+       ```hbs
+    Name: {{name}}, Age: {{age}}.
+    ```
+       Using a string instead of an array allows for an arbitrary number of
+    parameters:
+       ```app/components/my-component.js
+    import Component from '@ember/component';
+       let MyComponent = Component.extend();
+       MyComponent.reopenClass({
+      positionalParams: 'names'
     });
+       export default MyComponent;
+    ```
+       It can then be invoked like this:
+       ```hbs
+    {{my-component "John" "Michael" "Scott"}}
     ```
-     @property elementId
-    @type String
+    The parameters can then be referred to by enumerating over the list:
+       ```hbs
+    {{#each names as |name|}}{{name}}{{/each}}
+    ```
+       @static
     @public
-  */
-
-
-});
-
-Component.toString = () => '@ember/component';
-
-Component.reopenClass({
-  isComponentFactory: true,
+    @property positionalParams
+    @since 1.13.0
+    */
   positionalParams: []
 });
 setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
@@ -2845,8 +2730,8 @@ const RECOMPUTE_TAG = symbol('RECOMPUTE_TAG');
 const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
 
 class Helper extends FrameworkObject {
-  init() {
-    super.init();
+  init(properties) {
+    super.init(properties);
     this[RECOMPUTE_TAG] = createTag();
   }
   /**

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

@@ -367,7 +367,7 @@ export class Meta {
       ) {
         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
+        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 ${String(method)}.`, !(listener.kind === 0
         /* ADD */
         && kind === 0
         /* ADD */

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

@@ -1771,6 +1771,9 @@ if (DEBUG) {
   };
 }
 
+function hasUnknownProperty(val) {
+  return typeof val === 'object' && val !== null && typeof val.unknownProperty === 'function';
+}
 function get(obj, keyName) {
   assert(`Get must be called with two arguments; an object and a property key`, arguments.length === 2);
   assert(`Cannot call get with '${keyName}' on an undefined object.`, obj !== undefined && obj !== null);
@@ -1792,7 +1795,7 @@ function _getProp(obj, keyName) {
       value = obj[keyName];
     }
 
-    if (value === undefined && typeof obj === 'object' && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
+    if (value === undefined && typeof obj === 'object' && !(keyName in obj) && hasUnknownProperty(obj)) {
       value = obj.unknownProperty(keyName);
     }
 
@@ -2182,7 +2185,7 @@ function isEmpty(obj) {
     return true;
   }
 
-  if (typeof obj.unknownProperty !== 'function' && typeof obj.size === 'number') {
+  if (!hasUnknownProperty(obj) && typeof obj.size === 'number') {
     return !obj.size;
   }
 
@@ -3576,4 +3579,4 @@ function throwCachedInvalidArgsError(args = []) {
   @public
 */
 
-export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, _getProp, set, _setProp, trySet, objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, eachProxyArrayWillChange, eachProxyArrayDidChange, addListener, hasListeners, on, removeListener, sendEvent, isNone, isEmpty, isBlank, isPresent, beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PROPERTY_DID_CHANGE, defineProperty, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, LIBRARIES as libraries, Libraries, getProperties, setProperties, expandProperties, ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, Mixin, mixin, observer, applyMixin, inject, DEBUG_INJECTION_FUNCTIONS, tagForProperty, tagForObject, markObjectAsDirty, tracked, TrackedDescriptor, cached, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled };
+export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, _getProp, hasUnknownProperty, set, _setProp, trySet, objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, eachProxyArrayWillChange, eachProxyArrayDidChange, addListener, hasListeners, on, removeListener, sendEvent, isNone, isEmpty, isBlank, isPresent, beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PROPERTY_DID_CHANGE, defineProperty, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, LIBRARIES as libraries, Libraries, getProperties, setProperties, expandProperties, ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, Mixin, mixin, observer, applyMixin, inject, DEBUG_INJECTION_FUNCTIONS, tagForProperty, tagForObject, markObjectAsDirty, tracked, TrackedDescriptor, cached, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled };

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

@@ -1,4 +1,8 @@
 export {};
+/**
+ @module @ember/routing
+*/
+
 /**
   A `RouteInfoWithAttributes` is an object that contains
   metadata, including the resolved value from the routes

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

@@ -1,4 +1,8 @@
 "use strict";
+/**
+ @module @ember/routing
+*/
+
 /**
   A Transition is a thennable (a promise-like object) that represents
   an attempt to transition to another route. It can be aborted, either