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

package/dist/packages/@ember/-internals/views/lib/system/event_dispatcher.js

@@ -22,130 +22,132 @@ const ROOT_ELEMENT_SELECTOR = `.${ROOT_ELEMENT_CLASS}`;
   @extends Ember.Object
 */
 
-export default EmberObject.extend({
-  /**
-    The set of events names (and associated handler function names) to be setup
-    and dispatched by the `EventDispatcher`. Modifications to this list can be done
-    at setup time, generally via the `Application.customEvents` hash.
-     To add new events to be listened to:
-     ```javascript
-    import Application from '@ember/application';
-     let App = Application.create({
-      customEvents: {
-        paste: 'paste'
-      }
-    });
-    ```
-     To prevent default events from being listened to:
-     ```javascript
-    import Application from '@ember/application';
-     let App = Application.create({
-      customEvents: {
-        mouseenter: null,
-        mouseleave: null
-      }
-    });
-    ```
-    @property events
-    @type Object
-    @private
-  */
-  events: {
-    touchstart: 'touchStart',
-    touchmove: 'touchMove',
-    touchend: 'touchEnd',
-    touchcancel: 'touchCancel',
-    keydown: 'keyDown',
-    keyup: 'keyUp',
-    keypress: 'keyPress',
-    mousedown: 'mouseDown',
-    mouseup: 'mouseUp',
-    contextmenu: 'contextMenu',
-    click: 'click',
-    dblclick: 'doubleClick',
-    focusin: 'focusIn',
-    focusout: 'focusOut',
-    submit: 'submit',
-    input: 'input',
-    change: 'change',
-    dragstart: 'dragStart',
-    drag: 'drag',
-    dragenter: 'dragEnter',
-    dragleave: 'dragLeave',
-    dragover: 'dragOver',
-    drop: 'drop',
-    dragend: 'dragEnd'
-  },
-
-  /**
-    The root DOM element to which event listeners should be attached. Event
-    listeners will be attached to the document unless this is overridden.
-     Can be specified as a DOMElement or a selector string.
-     The default body is a string since this may be evaluated before document.body
-    exists in the DOM.
-     @private
-    @property rootElement
-    @type DOMElement
-    @default 'body'
-  */
-  rootElement: 'body',
-
-  init() {
-    this._super();
-
+export default class EventDispatcher extends EmberObject {
+  constructor() {
+    super(...arguments);
+    /**
+      The set of events names (and associated handler function names) to be setup
+      and dispatched by the `EventDispatcher`. Modifications to this list can be done
+      at setup time, generally via the `Application.customEvents` hash.
+             To add new events to be listened to:
+             ```javascript
+      import Application from '@ember/application';
+             let App = Application.create({
+        customEvents: {
+          paste: 'paste'
+        }
+      });
+      ```
+             To prevent default events from being listened to:
+             ```javascript
+      import Application from '@ember/application';
+             let App = Application.create({
+        customEvents: {
+          mouseenter: null,
+          mouseleave: null
+        }
+      });
+      ```
+      @property events
+      @type Object
+      @private
+    */
+
+    this.events = {
+      touchstart: 'touchStart',
+      touchmove: 'touchMove',
+      touchend: 'touchEnd',
+      touchcancel: 'touchCancel',
+      keydown: 'keyDown',
+      keyup: 'keyUp',
+      keypress: 'keyPress',
+      mousedown: 'mouseDown',
+      mouseup: 'mouseUp',
+      contextmenu: 'contextMenu',
+      click: 'click',
+      dblclick: 'doubleClick',
+      focusin: 'focusIn',
+      focusout: 'focusOut',
+      submit: 'submit',
+      input: 'input',
+      change: 'change',
+      dragstart: 'dragStart',
+      drag: 'drag',
+      dragenter: 'dragEnter',
+      dragleave: 'dragLeave',
+      dragover: 'dragOver',
+      drop: 'drop',
+      dragend: 'dragEnd'
+    };
+    /**
+      The root DOM element to which event listeners should be attached. Event
+      listeners will be attached to the document unless this is overridden.
+             Can be specified as a DOMElement or a selector string.
+             The default body is a string since this may be evaluated before document.body
+      exists in the DOM.
+             @private
+      @property rootElement
+      @type DOMElement
+      @default 'body'
+    */
+
+    this.rootElement = 'body';
     this._eventHandlers = Object.create(null);
     this._didSetup = false;
     this.finalEventNameMapping = null;
     this._sanitizedRootElement = null;
     this.lazyEvents = new Map();
-  },
-
+    this._reverseEventNameMapping = null;
+  }
   /**
     Sets up event listeners for standard browser events.
-     This will be called after the browser sends a `DOMContentReady` event. By
+       This will be called after the browser sends a `DOMContentReady` event. By
     default, it will set up all of the listeners on the document body. If you
     would like to register the listeners on a different element, set the event
     dispatcher's `root` property.
-     @private
+       @private
     @method setup
     @param addedEvents {Object}
   */
+
+
   setup(addedEvents, _rootElement) {
+    var _a;
+
     assert('EventDispatcher should never be setup in fastboot mode. Please report this as an Ember bug.', (() => {
       let owner = getOwner(this);
+      assert('[BUG] Missing owner', owner); // SAFETY: This is not guaranteed to be safe, but this is what we expect to be returned.
+
       let environment = owner.lookup('-environment:main');
       return environment.isInteractive;
     })());
-    let events = this.finalEventNameMapping = Object.assign({}, get(this, 'events'), addedEvents);
-    this._reverseEventNameMapping = Object.keys(events).reduce((result, key) => Object.assign(result, {
-      [events[key]]: key
-    }), {});
+    let events = this.finalEventNameMapping = Object.assign(Object.assign({}, get(this, 'events')), addedEvents);
+    this._reverseEventNameMapping = Object.keys(events).reduce((result, key) => {
+      let eventName = events[key];
+      return eventName ? Object.assign(Object.assign({}, result), {
+        [eventName]: key
+      }) : result;
+    }, {});
     let lazyEvents = this.lazyEvents;
 
     if (_rootElement !== undefined && _rootElement !== null) {
       set(this, 'rootElement', _rootElement);
     }
 
-    let rootElementSelector = get(this, 'rootElement');
-    let rootElement;
-
-    if (typeof rootElementSelector !== 'string') {
-      rootElement = rootElementSelector;
-    } else {
-      rootElement = document.querySelector(rootElementSelector);
-    }
-
-    assert(`You cannot use the same root element (${get(this, 'rootElement') || rootElement.tagName}) multiple times in an Ember.Application`, !rootElement.classList.contains(ROOT_ELEMENT_CLASS));
+    let specifiedRootElement = get(this, 'rootElement');
+    let rootElement = typeof specifiedRootElement !== 'string' ? specifiedRootElement : document.querySelector(specifiedRootElement);
+    assert(`Could not find rootElement (${specifiedRootElement})`, rootElement);
+    assert(`You cannot use the same root element (${specifiedRootElement}) multiple times in an Ember.Application`, !rootElement.classList.contains(ROOT_ELEMENT_CLASS));
     assert('You cannot make a new Ember.Application using a root element that is a descendent of an existing Ember.Application', (() => {
       let target = rootElement.parentNode;
 
-      do {
+      while (target instanceof Element) {
         if (target.classList.contains(ROOT_ELEMENT_CLASS)) {
           return false;
         }
 
         target = target.parentNode;
-      } while (target && target.nodeType === 1);
+      }
 
       return true;
     })());
@@ -157,55 +159,72 @@ export default EmberObject.extend({
 
     for (let event in events) {
       if (Object.prototype.hasOwnProperty.call(events, event)) {
-        lazyEvents.set(event, events[event]);
+        lazyEvents.set(event, (_a = events[event]) !== null && _a !== void 0 ? _a : null);
       }
     }
 
     this._didSetup = true;
-  },
-
+  }
   /**
     Setup event listeners for the given browser event name
-     @private
+       @private
     @method setupHandlerForBrowserEvent
     @param event the name of the event in the browser
   */
+
+
   setupHandlerForBrowserEvent(event) {
-    this.setupHandler(this._sanitizedRootElement, event, this.finalEventNameMapping[event]);
-  },
+    var _a;
 
+    assert('[BUG] Expected finalEventNameMapping to be set', this.finalEventNameMapping);
+    assert('[BUG] Expected _santizedRootElement to be set', this._sanitizedRootElement);
+    this.setupHandler(this._sanitizedRootElement, event, (_a = this.finalEventNameMapping[event]) !== null && _a !== void 0 ? _a : null);
+  }
   /**
     Setup event listeners for the given Ember event name (camel case)
-     @private
+       @private
     @method setupHandlerForEmberEvent
     @param eventName
   */
+
+
   setupHandlerForEmberEvent(eventName) {
-    this.setupHandler(this._sanitizedRootElement, this._reverseEventNameMapping[eventName], eventName);
-  },
+    var _a;
+
+    assert('[BUG] Expected _sanitizedRootElement to be set', this._sanitizedRootElement);
+    let event = (_a = this._reverseEventNameMapping) === null || _a === void 0 ? void 0 : _a[eventName];
 
+    if (event) {
+      this.setupHandler(this._sanitizedRootElement, event, eventName);
+    }
+  }
   /**
     Registers an event listener on the rootElement. If the given event is
     triggered, the provided event handler will be triggered on the target view.
-     If the target view does not implement the event handler, or if the handler
+       If the target view does not implement the event handler, or if the handler
     returns `false`, the parent view will be called. The event will continue to
     bubble to each successive parent view until it reaches the top.
-     @private
+       @private
     @method setupHandler
     @param {Element} rootElement
     @param {String} event the name of the event in the browser
     @param {String} eventName the name of the method to call on the view
   */
+
+
   setupHandler(rootElement, event, eventName) {
     if (eventName === null || !this.lazyEvents.has(event)) {
       return; // nothing to do
     }
 
     let viewHandler = (target, event) => {
+      // SAFETY: SimpleElement is supposed to be a subset of Element so this _should_ be safe.
+      // However, the types are more specific in some places which necessitates the `as`.
       let view = getElementView(target);
       let result = true;
 
       if (view) {
+        // SAFETY: As currently written, this is not safe. Though it seems to always be true.
         result = view.handleEvent(eventName, event);
       }
 
@@ -214,30 +233,37 @@ export default EmberObject.extend({
 
     let actionHandler = (target, event) => {
       let actionId = target.getAttribute('data-ember-action');
-      let actions = ActionManager.registeredActions[actionId]; // In Glimmer2 this attribute is set to an empty string and an additional
+      let actions; // In Glimmer2 this attribute is set to an empty string and an additional
       // attribute it set for each action on a given element. In this case, the
       // attributes need to be read so that a proper set of action handlers can
       // be coalesced.
 
       if (actionId === '') {
-        let attributes = target.attributes;
-        let attributeCount = attributes.length;
         actions = [];
 
-        for (let i = 0; i < attributeCount; i++) {
-          let attr = attributes.item(i);
+        for (let attr of target.attributes) {
           let attrName = attr.name;
 
           if (attrName.indexOf('data-ember-action-') === 0) {
-            actions = actions.concat(ActionManager.registeredActions[attr.value]);
+            let action = ActionManager.registeredActions[attr.value];
+            assert('[BUG] Missing action', action);
+            actions.push(action);
           }
         }
+      } else if (actionId) {
+        // FIXME: This branch is never called in tests. Improve tests or remove
+        let actionState = ActionManager.registeredActions[actionId];
+
+        if (actionState) {
+          actions = [actionState];
+        }
       } // We have to check for actions here since in some cases, jQuery will trigger
       // an event on `removeChild` (i.e. focusout) after we've already torn down the
       // action handlers for the view.
 
 
       if (!actions) {
+        // FIXME: This branch is never called in tests. Improve tests or remove
         return;
       }
 
@@ -257,8 +283,11 @@ export default EmberObject.extend({
 
     let handleEvent = this._eventHandlers[event] = event => {
       let target = event.target;
+      assert(`[BUG] Received event without an Element target: ${event.type}, ${target}`, target instanceof Element);
 
       do {
+        // SAFETY: SimpleElement is supposed to be a subset of Element so this _should_ be safe.
+        // However, the types are more specific in some places which necessitates the `as`.
         if (getElementView(target)) {
           if (viewHandler(target, event) === false) {
             event.preventDefault();
@@ -274,26 +303,19 @@ export default EmberObject.extend({
         }
 
         target = target.parentNode;
-      } while (target && target.nodeType === 1);
+      } while (target instanceof Element);
     };
 
     rootElement.addEventListener(event, handleEvent);
     this.lazyEvents.delete(event);
-  },
+  }
 
   destroy() {
     if (this._didSetup === false) {
       return;
     }
 
-    let rootElementSelector = get(this, 'rootElement');
-    let rootElement;
-
-    if (rootElementSelector.nodeType) {
-      rootElement = rootElementSelector;
-    } else {
-      rootElement = document.querySelector(rootElementSelector);
-    }
+    let rootElement = this._sanitizedRootElement;
 
     if (!rootElement) {
       return;
@@ -305,10 +327,10 @@ export default EmberObject.extend({
 
     rootElement.classList.remove(ROOT_ELEMENT_CLASS);
     return this._super(...arguments);
-  },
+  }
 
   toString() {
     return '(EventDispatcher)';
   }
 
-});
+}

package/dist/packages/@ember/-internals/views/lib/system/utils.js

@@ -186,7 +186,7 @@ export function getViewBoundingClientRect(view) {
   @param {String} selector
 */
 
-export const elMatches = typeof Element !== 'undefined' ? Element.prototype.matches || Element.prototype['matchesSelector'] || Element.prototype['mozMatchesSelector'] || Element.prototype['msMatchesSelector'] || Element.prototype['oMatchesSelector'] || Element.prototype['webkitMatchesSelector'] : undefined;
+export const elMatches = typeof Element !== 'undefined' ? Element.prototype.matches : undefined;
 export function matches(el, selector) {
   assert('cannot call `matches` in fastboot mode', elMatches !== undefined);
   return elMatches.call(el, selector);

package/dist/packages/@ember/-internals/views/lib/views/states/destroying.js

@@ -1,6 +1,6 @@
 import EmberError from '@ember/error';
 import _default from './default';
-const destroying = Object.assign({}, _default, {
+const destroying = Object.assign(Object.assign({}, _default), {
   appendChild() {
     throw new EmberError("You can't call appendChild on a view being destroyed");
   },

package/dist/packages/@ember/-internals/views/lib/views/states/has_element.js

@@ -1,9 +1,9 @@
 import _default from './default';
 import { join } from '@ember/runloop';
 import { flaggedInstrument } from '@ember/instrumentation';
-const hasElement = Object.assign({}, _default, {
+const hasElement = Object.assign(Object.assign({}, _default), {
   rerender(view) {
-    view.renderer.rerender(view);
+    view.renderer.rerender();
   },
 
   destroy(view) {

package/dist/packages/@ember/-internals/views/lib/views/states/in_dom.js

@@ -1,8 +1,9 @@
 import { teardownMandatorySetter } from '@ember/-internals/utils';
+import { assert } from '@ember/debug';
 import EmberError from '@ember/error';
 import { DEBUG } from '@glimmer/env';
 import hasElement from './has_element';
-const inDOM = Object.assign({}, hasElement, {
+const inDOM = Object.assign(Object.assign({}, hasElement), {
   enter(view) {
     // Register the view for event handling. This hash is used by
     // Ember.EventDispatcher to dispatch incoming events.
@@ -10,6 +11,7 @@ const inDOM = Object.assign({}, hasElement, {
 
     if (DEBUG) {
       let elementId = view.elementId;
+      assert('[BUG] Expected teardownMandatorySetter to be set in DEBUG mode', teardownMandatorySetter);
       teardownMandatorySetter(view, 'elementId');
       Object.defineProperty(view, 'elementId', {
         configurable: true,

package/dist/packages/@ember/application/instance.js

@@ -184,6 +184,7 @@ class ApplicationInstance extends EngineInstance {
     let applicationCustomEvents = get(this.application, 'customEvents');
     let instanceCustomEvents = get(this, 'customEvents');
     let customEvents = Object.assign({}, applicationCustomEvents, instanceCustomEvents);
+    assert('[BUG] Tried to set up dispatcher with an invalid root element', this.rootElement === null || typeof this.rootElement === 'string' || this.rootElement instanceof Element);
     dispatcher.setup(customEvents, this.rootElement);
     return dispatcher;
   }

package/dist/packages/@ember/application/lib/application.js

@@ -335,11 +335,18 @@ class Application extends Engine {
 
 
   waitForDOMReady() {
-    const document = this._document;
+    const document = this._document; // SAFETY: Casting as Document should be safe since we're just reading a property.
+    // If it's not actually a Document then it will evaluate false which is fine for our
+    // purposes.
 
     if (document === null || document.readyState !== 'loading') {
       schedule('actions', this, this.domReady);
     } else {
+      // Ideally we'd just check `document instanceof Document` but currently some tests pass a fake document.
+      assert('[BUG] Called waitForDOMReady with an invalid document', function (d) {
+        return typeof d.removeEventListener === 'function';
+      }(document));
+
       let callback = () => {
         document.removeEventListener('DOMContentLoaded', callback);
         run(this, this.domReady);

package/dist/packages/@ember/canary-features/index.js

@@ -11,8 +11,8 @@ import { ENV } from '@ember/-internals/environment';
 */
 
 export const DEFAULT_FEATURES = {
-  EMBER_LIBRARIES_ISREGISTERED: null,
-  EMBER_IMPROVED_INSTRUMENTATION: null,
+  EMBER_LIBRARIES_ISREGISTERED: false,
+  EMBER_IMPROVED_INSTRUMENTATION: false,
   EMBER_UNIQUE_ID_HELPER: true,
   EMBER_DEFAULT_HELPER_MANAGER: true
 };

package/dist/packages/@ember/engine/instance.js

@@ -6,7 +6,7 @@ import { assert } from '@ember/debug';
 import EmberError from '@ember/error';
 import { Registry, privatize as P } from '@ember/-internals/container';
 import { guidFor } from '@ember/-internals/utils';
-import { getEngineParent, setEngineParent } from './lib/engine-parent';
+import { ENGINE_PARENT, getEngineParent, setEngineParent } from './lib/engine-parent';
 import RegistryProxyMixin from '@ember/-internals/runtime/lib/mixins/registry_proxy';
 import ContainerProxyMixin from '@ember/-internals/runtime/lib/mixins/container_proxy';
 import { isFactory } from '@ember/-internals/owner';

package/dist/packages/@ember/engine/lib/engine-parent.js

@@ -1,8 +1,4 @@
-/**
-@module @ember/engine
-*/
-import { symbol } from '@ember/-internals/utils';
-const ENGINE_PARENT = symbol('ENGINE_PARENT');
+export const ENGINE_PARENT = Symbol('ENGINE_PARENT');
 /**
   `getEngineParent` retrieves an engine instance's parent instance.
 

package/dist/packages/@ember/renderer/index.js

@@ -0,0 +1,28 @@
+/**
+  @module @ember/renderer
+  @public
+*/
+
+/**
+ * @class Renderer
+ * @public
+ */
+
+/**
+  Returns a promise which will resolve when rendering has completed. In
+  this context, rendering is completed when all auto-tracked state that is
+  consumed in the template (including any tracked state in models, services,
+    etc.  that are then used in a template) has been updated in the DOM.
+
+    For example, in a test you might want to update some tracked state and
+    then run some assertions after rendering has completed. You _could_ use
+    `await settled()` in that location, but in some contexts you don't want to
+    wait for full settledness (which includes test waiters, pending AJAX/fetch,
+    run loops, etc) but instead only want to know when that updated value has
+    been rendered in the DOM. **THAT** is what `await rerender()` is _perfect_
+    for.
+  @method renderSettled
+  @returns {Promise<void>} a promise which fulfills when rendering has completed
+  @public
+*/
+export { renderSettled } from '@ember/-internals/glimmer';

package/dist/packages/ember/version.js

@@ -1 +1 @@
-export default "4.5.0-alpha.4";
+export default "4.5.0-beta.2";