ember-source 4.8.0-alpha.5 → 4.8.0-beta.2

package/dist/packages/@ember/object/evented.js

@@ -1,2 +1,93 @@
-export { Evented as default } from '@ember/-internals/runtime';
-export { on } from '@ember/-internals/metal';
+import { addListener, removeListener, hasListeners, sendEvent } from '@ember/-internals/metal';
+import Mixin from '@ember/object/mixin';
+export { on } from '@ember/-internals/metal';
+const Evented = Mixin.create({
+  /**
+    Subscribes to a named event with given function.
+       ```javascript
+    person.on('didLoad', function() {
+      // fired once the person has loaded
+    });
+    ```
+       An optional target can be passed in as the 2nd argument that will
+    be set as the "this" for the callback. This is a good way to give your
+    function access to the object triggering the event. When the target
+    parameter is used the callback method becomes the third argument.
+       @method on
+    @param {String} name The name of the event
+    @param {Object} [target] The "this" binding for the callback
+    @param {Function|String} method A function or the name of a function to be called on `target`
+    @return this
+    @public
+  */
+  on(name, target, method) {
+    addListener(this, name, target, method);
+    return this;
+  },
+
+  /**
+    Subscribes a function to a named event and then cancels the subscription
+    after the first time the event is triggered. It is good to use ``one`` when
+    you only care about the first time an event has taken place.
+       This function takes an optional 2nd argument that will become the "this"
+    value for the callback. When the target parameter is used the callback method
+    becomes the third argument.
+       @method one
+    @param {String} name The name of the event
+    @param {Object} [target] The "this" binding for the callback
+    @param {Function|String} method A function or the name of a function to be called on `target`
+    @return this
+    @public
+  */
+  one(name, target, method) {
+    addListener(this, name, target, method, true);
+    return this;
+  },
+
+  /**
+    Triggers a named event for the object. Any additional arguments
+    will be passed as parameters to the functions that are subscribed to the
+    event.
+       ```javascript
+    person.on('didEat', function(food) {
+      console.log('person ate some ' + food);
+    });
+       person.trigger('didEat', 'broccoli');
+       // outputs: person ate some broccoli
+    ```
+    @method trigger
+    @param {String} name The name of the event
+    @param {Object...} args Optional arguments to pass on
+    @public
+  */
+  trigger(name, ...args) {
+    sendEvent(this, name, args);
+  },
+
+  /**
+    Cancels subscription for given name, target, and method.
+       @method off
+    @param {String} name The name of the event
+    @param {Object} target The target of the subscription
+    @param {Function|String} method The function or the name of a function of the subscription
+    @return this
+    @public
+  */
+  off(name, target, method) {
+    removeListener(this, name, target, method);
+    return this;
+  },
+
+  /**
+    Checks to see if object has any subscriptions for named event.
+       @method has
+    @param {String} name The name of the event
+    @return {Boolean} does the object have a subscription for event
+    @public
+   */
+  has(name) {
+    return hasListeners(this, name);
+  }
+
+});
+export default Evented;

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

@@ -1,7 +1,21 @@
 import { assert } from '@ember/debug';
-import { isElementDescriptor, setClassicDecorator } from '@ember/-internals/metal';
-export { Object as default } from '@ember/-internals/runtime';
-export { notifyPropertyChange, defineProperty, get, set, getProperties, setProperties, observer, computed, trySet } from '@ember/-internals/metal';
+import { ENV } from '@ember/-internals/environment';
+import { isElementDescriptor, expandProperties, setClassicDecorator } from '@ember/-internals/metal';
+import { getFactoryFor } from '@ember/-internals/container';
+import { setObservers } from '@ember/-internals/utils';
+import CoreObject from '@ember/object/core';
+import Observable from '@ember/object/observable';
+export { notifyPropertyChange, defineProperty, get, set, getProperties, setProperties, computed, trySet } from '@ember/-internals/metal';
+
+class EmberObject extends CoreObject.extend(Observable) {
+  get _debugContainerKey() {
+    let factory = getFactoryFor(this);
+    return factory !== undefined && factory.fullName;
+  }
+
+}
+
+export default EmberObject;
 /**
   Decorator that turns the target function into an Action which can be accessed
   directly by reference.
@@ -179,4 +193,62 @@ export function action(...args) {
   return setupAction(target, key, actionFn);
 } // SAFETY: TS types are weird with decorators. This should work.
 
-setClassicDecorator(action);
+setClassicDecorator(action);
+/**
+  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
+*/
+
+export 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;
+  let dependentKeys;
+  let sync;
+
+  if (typeof funcOrDef === 'function') {
+    func = funcOrDef;
+    dependentKeys = args;
+    sync = !ENV._DEFAULT_ASYNC_OBSERVERS;
+  } else {
+    func = funcOrDef.fn;
+    dependentKeys = funcOrDef.dependentKeys;
+    sync = funcOrDef.sync;
+  }
+
+  assert('observer called without a function', typeof func === 'function');
+  assert('observer called without valid path', Array.isArray(dependentKeys) && dependentKeys.length > 0 && dependentKeys.every(p => typeof p === 'string' && Boolean(p.length)));
+  assert('observer called without sync', typeof sync === 'boolean');
+  let paths = [];
+
+  for (let dependentKey of dependentKeys) {
+    expandProperties(dependentKey, path => paths.push(path));
+  }
+
+  setObservers(func, {
+    paths,
+    sync
+  });
+  return func;
+}

package/dist/packages/@ember/object/internals.js

@@ -1,2 +1,3 @@
-export { getCachedValueFor as cacheFor } from '@ember/-internals/metal';
-export { guidFor } from '@ember/-internals/utils';
+// This is a legacy location to keep the reexports test happy.
+// Don't add anything new here.
+export { cacheFor, guidFor } from './-internals';

package/dist/packages/@ember/object/lib/computed/computed_macros.js

@@ -1,5 +1,7 @@
-import { get, set, computed, isElementDescriptor, isEmpty, isNone, alias, expandProperties } from '@ember/-internals/metal';
+import { computed, isElementDescriptor, alias, expandProperties } from '@ember/-internals/metal';
+import { get, set } from '@ember/object';
 import { assert, deprecate } from '@ember/debug';
+import { isEmpty, isNone } from '@ember/utils';
 /**
 @module @ember/object
 */

package/dist/packages/@ember/object/lib/computed/reduce_computed_macros.js

@@ -3,9 +3,10 @@
 */
 import { DEBUG } from '@glimmer/env';
 import { assert } from '@ember/debug';
-import { computed, autoComputed, get, isElementDescriptor } from '@ember/-internals/metal';
-import { compare, A as emberA, uniqBy as uniqByArray } from '@ember/-internals/runtime';
-import EmberArray from '@ember/-internals/runtime/lib/mixins/array';
+import { autoComputed, isElementDescriptor } from '@ember/-internals/metal';
+import { computed, get } from '@ember/object';
+import { compare } from '@ember/utils';
+import EmberArray, { A as emberA, uniqBy as uniqByArray } from '@ember/array';
 
 function isNativeOrEmberArray(obj) {
   return Array.isArray(obj) || EmberArray.detect(obj);