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

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

@@ -1 +1,341 @@
-export { Observable as default } from '@ember/-internals/runtime';
+/**
+@module @ember/object/observable
+*/
+import { peekMeta } from '@ember/-internals/meta';
+import { hasListeners, beginPropertyChanges, notifyPropertyChange, endPropertyChanges, addObserver, removeObserver } from '@ember/-internals/metal';
+import { get, set, getProperties, setProperties } from '@ember/object';
+import Mixin from '@ember/object/mixin';
+import { assert } from '@ember/debug';
+const Observable = Mixin.create({
+  /**
+    Retrieves the value of a property from the object.
+       This method is usually similar to using `object[keyName]` or `object.keyName`,
+    however it supports both computed properties and the unknownProperty
+    handler.
+       Because `get` unifies the syntax for accessing all these kinds
+    of properties, it can make many refactorings easier, such as replacing a
+    simple property with a computed property, or vice versa.
+       ### Computed Properties
+       Computed properties are methods defined with the `property` modifier
+    declared at the end, such as:
+       ```javascript
+    import { computed } from '@ember/object';
+       fullName: computed('firstName', 'lastName', function() {
+      return this.get('firstName') + ' ' + this.get('lastName');
+    })
+    ```
+       When you call `get` on a computed property, the function will be
+    called and the return value will be returned instead of the function
+    itself.
+       ### Unknown Properties
+       Likewise, if you try to call `get` on a property whose value is
+    `undefined`, the `unknownProperty()` method will be called on the object.
+    If this method returns any value other than `undefined`, it will be returned
+    instead. This allows you to implement "virtual" properties that are
+    not defined upfront.
+       @method get
+    @param {String} keyName The property to retrieve
+    @return {Object} The property value or undefined.
+    @public
+  */
+  get(keyName) {
+    return get(this, keyName);
+  },
+
+  /**
+    To get the values of multiple properties at once, call `getProperties`
+    with a list of strings or an array:
+       ```javascript
+    record.getProperties('firstName', 'lastName', 'zipCode');
+    // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+    ```
+       is equivalent to:
+       ```javascript
+    record.getProperties(['firstName', 'lastName', 'zipCode']);
+    // { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
+    ```
+       @method getProperties
+    @param {String...|Array} list of keys to get
+    @return {Object}
+    @public
+  */
+  getProperties(...args) {
+    return getProperties(this, ...args);
+  },
+
+  /**
+    Sets the provided key or path to the value.
+       ```javascript
+    record.set("key", value);
+    ```
+       This method is generally very similar to calling `object["key"] = value` or
+    `object.key = value`, except that it provides support for computed
+    properties, the `setUnknownProperty()` method and property observers.
+       ### Computed Properties
+       If you try to set a value on a key that has a computed property handler
+    defined (see the `get()` method for an example), then `set()` will call
+    that method, passing both the value and key instead of simply changing
+    the value itself. This is useful for those times when you need to
+    implement a property that is composed of one or more member
+    properties.
+       ### Unknown Properties
+       If you try to set a value on a key that is undefined in the target
+    object, then the `setUnknownProperty()` handler will be called instead. This
+    gives you an opportunity to implement complex "virtual" properties that
+    are not predefined on the object. If `setUnknownProperty()` returns
+    undefined, then `set()` will simply set the value on the object.
+       ### Property Observers
+       In addition to changing the property, `set()` will also register a property
+    change with the object. Unless you have placed this call inside of a
+    `beginPropertyChanges()` and `endPropertyChanges(),` any "local" observers
+    (i.e. observer methods declared on the same object), will be called
+    immediately. Any "remote" observers (i.e. observer methods declared on
+    another object) will be placed in a queue and called at a later time in a
+    coalesced manner.
+       @method set
+    @param {String} keyName The property to set
+    @param {Object} value The value to set or `null`.
+    @return {Object} The passed value
+    @public
+  */
+  set(keyName, value) {
+    return set(this, keyName, value);
+  },
+
+  /**
+    Sets a list of properties at once. These properties are set inside
+    a single `beginPropertyChanges` and `endPropertyChanges` batch, so
+    observers will be buffered.
+       ```javascript
+    record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
+    ```
+       @method setProperties
+    @param {Object} hash the hash of keys and values to set
+    @return {Object} The passed in hash
+    @public
+  */
+  setProperties(hash) {
+    return setProperties(this, hash);
+  },
+
+  /**
+    Begins a grouping of property changes.
+       You can use this method to group property changes so that notifications
+    will not be sent until the changes are finished. If you plan to make a
+    large number of changes to an object at one time, you should call this
+    method at the beginning of the changes to begin deferring change
+    notifications. When you are done making changes, call
+    `endPropertyChanges()` to deliver the deferred change notifications and end
+    deferring.
+       @method beginPropertyChanges
+    @return {Observable}
+    @private
+  */
+  beginPropertyChanges() {
+    beginPropertyChanges();
+    return this;
+  },
+
+  /**
+    Ends a grouping of property changes.
+       You can use this method to group property changes so that notifications
+    will not be sent until the changes are finished. If you plan to make a
+    large number of changes to an object at one time, you should call
+    `beginPropertyChanges()` at the beginning of the changes to defer change
+    notifications. When you are done making changes, call this method to
+    deliver the deferred change notifications and end deferring.
+       @method endPropertyChanges
+    @return {Observable}
+    @private
+  */
+  endPropertyChanges() {
+    endPropertyChanges();
+    return this;
+  },
+
+  /**
+    Notify the observer system that a property has just changed.
+       Sometimes you need to change a value directly or indirectly without
+    actually calling `get()` or `set()` on it. In this case, you can use this
+    method instead. Calling this method will notify all observers that the
+    property has potentially changed value.
+       @method notifyPropertyChange
+    @param {String} keyName The property key to be notified about.
+    @return {Observable}
+    @public
+  */
+  notifyPropertyChange(keyName) {
+    notifyPropertyChange(this, keyName);
+    return this;
+  },
+
+  /**
+    Adds an observer on a property.
+       This is the core method used to register an observer for a property.
+       Once you call this method, any time the key's value is set, your observer
+    will be notified. Note that the observers are triggered any time the
+    value is set, regardless of whether it has actually changed. Your
+    observer should be prepared to handle that.
+       There are two common invocation patterns for `.addObserver()`:
+       - Passing two arguments:
+      - the name of the property to observe (as a string)
+      - the function to invoke (an actual function)
+    - Passing three arguments:
+      - the name of the property to observe (as a string)
+      - the target object (will be used to look up and invoke a
+        function on)
+      - the name of the function to invoke on the target object
+        (as a string).
+       ```app/components/my-component.js
+    import Component from '@ember/component';
+       export default Component.extend({
+      init() {
+        this._super(...arguments);
+           // the following are equivalent:
+           // using three arguments
+        this.addObserver('foo', this, 'fooDidChange');
+           // using two arguments
+        this.addObserver('foo', (...args) => {
+          this.fooDidChange(...args);
+        });
+      },
+         fooDidChange() {
+        // your custom logic code
+      }
+    });
+    ```
+       ### Observer Methods
+       Observer methods have the following signature:
+       ```app/components/my-component.js
+    import Component from '@ember/component';
+       export default Component.extend({
+      init() {
+        this._super(...arguments);
+        this.addObserver('foo', this, 'fooDidChange');
+      },
+         fooDidChange(sender, key, value, rev) {
+        // your code
+      }
+    });
+    ```
+       The `sender` is the object that changed. The `key` is the property that
+    changes. The `value` property is currently reserved and unused. The `rev`
+    is the last property revision of the object when it changed, which you can
+    use to detect if the key value has really changed or not.
+       Usually you will not need the value or revision parameters at
+    the end. In this case, it is common to write observer methods that take
+    only a sender and key value as parameters or, if you aren't interested in
+    any of these values, to write an observer that has no parameters at all.
+       @method addObserver
+    @param {String} key The key to observe
+    @param {Object} target The target object to invoke
+    @param {String|Function} method The method to invoke
+    @param {Boolean} sync Whether the observer is sync or not
+    @return {Observable}
+    @public
+  */
+  addObserver(key, target, method, sync) {
+    addObserver(this, key, target, method, sync);
+    return this;
+  },
+
+  /**
+    Remove an observer you have previously registered on this object. Pass
+    the same key, target, and method you passed to `addObserver()` and your
+    target will no longer receive notifications.
+       @method removeObserver
+    @param {String} key The key to observe
+    @param {Object} target The target object to invoke
+    @param {String|Function} method The method to invoke
+    @param {Boolean} sync Whether the observer is async or not
+    @return {Observable}
+    @public
+  */
+  removeObserver(key, target, method, sync) {
+    removeObserver(this, key, target, method, sync);
+    return this;
+  },
+
+  /**
+    Returns `true` if the object currently has observers registered for a
+    particular key. You can use this method to potentially defer performing
+    an expensive action until someone begins observing a particular property
+    on the object.
+       @method hasObserverFor
+    @param {String} key Key to check
+    @return {Boolean}
+    @private
+  */
+  hasObserverFor(key) {
+    return hasListeners(this, `${key}:change`);
+  },
+
+  /**
+    Set the value of a property to the current value plus some amount.
+       ```javascript
+    person.incrementProperty('age');
+    team.incrementProperty('score', 2);
+    ```
+       @method incrementProperty
+    @param {String} keyName The name of the property to increment
+    @param {Number} increment The amount to increment by. Defaults to 1
+    @return {Number} The new property value
+    @public
+  */
+  incrementProperty(keyName, increment = 1) {
+    assert('Must pass a numeric value to incrementProperty', !isNaN(parseFloat(String(increment))) && isFinite(increment));
+    return set(this, keyName, (parseFloat(get(this, keyName)) || 0) + increment);
+  },
+
+  /**
+    Set the value of a property to the current value minus some amount.
+       ```javascript
+    player.decrementProperty('lives');
+    orc.decrementProperty('health', 5);
+    ```
+       @method decrementProperty
+    @param {String} keyName The name of the property to decrement
+    @param {Number} decrement The amount to decrement by. Defaults to 1
+    @return {Number} The new property value
+    @public
+  */
+  decrementProperty(keyName, decrement = 1) {
+    assert('Must pass a numeric value to decrementProperty', (typeof decrement === 'number' || !isNaN(parseFloat(decrement))) && isFinite(decrement));
+    return set(this, keyName, (get(this, keyName) || 0) - decrement);
+  },
+
+  /**
+    Set the value of a boolean property to the opposite of its
+    current value.
+       ```javascript
+    starship.toggleProperty('warpDriveEngaged');
+    ```
+       @method toggleProperty
+    @param {String} keyName The name of the property to toggle
+    @return {Boolean} The new property value
+    @public
+  */
+  toggleProperty(keyName) {
+    return set(this, keyName, !get(this, keyName));
+  },
+
+  /**
+    Returns the cached value of a computed property, if it exists.
+    This allows you to inspect the value of a computed property
+    without accidentally invoking it if it is intended to be
+    generated lazily.
+       @method cacheFor
+    @param {String} keyName
+    @return {Object} The cached value of the computed property, if any
+    @public
+  */
+  cacheFor(keyName) {
+    let meta = peekMeta(this);
+
+    if (meta !== null) {
+      return meta.valueFor(keyName);
+    }
+  }
+
+});
+export default Observable;

package/dist/packages/@ember/object/promise-proxy-mixin.js

@@ -1 +1,150 @@
-export { PromiseProxyMixin as default } from '@ember/-internals/runtime';
+import { get, setProperties, computed } from '@ember/object';
+import Mixin from '@ember/object/mixin';
+import EmberError from '@ember/error';
+/**
+  @module @ember/object/promise-proxy-mixin
+*/
+
+function tap(proxy, promise) {
+  setProperties(proxy, {
+    isFulfilled: false,
+    isRejected: false
+  });
+  return promise.then(value => {
+    if (!proxy.isDestroyed && !proxy.isDestroying) {
+      setProperties(proxy, {
+        content: value,
+        isFulfilled: true
+      });
+    }
+
+    return value;
+  }, reason => {
+    if (!proxy.isDestroyed && !proxy.isDestroying) {
+      setProperties(proxy, {
+        reason,
+        isRejected: true
+      });
+    }
+
+    throw reason;
+  }, 'Ember: PromiseProxy');
+}
+
+const PromiseProxyMixin = Mixin.create({
+  /**
+    If the proxied promise is rejected this will contain the reason
+    provided.
+       @property reason
+    @default null
+    @public
+  */
+  reason: null,
+
+  /**
+    Once the proxied promise has settled this will become `false`.
+       @property isPending
+    @default true
+    @public
+  */
+  isPending: computed('isSettled', function () {
+    return !get(this, 'isSettled');
+  }).readOnly(),
+
+  /**
+    Once the proxied promise has settled this will become `true`.
+       @property isSettled
+    @default false
+    @public
+  */
+  isSettled: computed('isRejected', 'isFulfilled', function () {
+    return get(this, 'isRejected') || get(this, 'isFulfilled');
+  }).readOnly(),
+
+  /**
+    Will become `true` if the proxied promise is rejected.
+       @property isRejected
+    @default false
+    @public
+  */
+  isRejected: false,
+
+  /**
+    Will become `true` if the proxied promise is fulfilled.
+       @property isFulfilled
+    @default false
+    @public
+  */
+  isFulfilled: false,
+
+  /**
+    The promise whose fulfillment value is being proxied by this object.
+       This property must be specified upon creation, and should not be
+    changed once created.
+       Example:
+       ```javascript
+    import ObjectProxy from '@ember/object/proxy';
+    import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+       ObjectProxy.extend(PromiseProxyMixin).create({
+      promise: <thenable>
+    });
+    ```
+       @property promise
+    @public
+  */
+  promise: computed({
+    get() {
+      throw new EmberError("PromiseProxy's promise must be set");
+    },
+
+    set(_key, promise) {
+      return tap(this, promise);
+    }
+
+  }),
+
+  /**
+    An alias to the proxied promise's `then`.
+       See RSVP.Promise.then.
+       @method then
+    @param {Function} callback
+    @return {RSVP.Promise}
+    @public
+  */
+  then: promiseAlias('then'),
+
+  /**
+    An alias to the proxied promise's `catch`.
+       See RSVP.Promise.catch.
+       @method catch
+    @param {Function} callback
+    @return {RSVP.Promise}
+    @since 1.3.0
+    @public
+  */
+  catch: promiseAlias('catch'),
+
+  /**
+    An alias to the proxied promise's `finally`.
+       See RSVP.Promise.finally.
+       @method finally
+    @param {Function} callback
+    @return {RSVP.Promise}
+    @since 1.3.0
+    @public
+  */
+  finally: promiseAlias('finally')
+});
+
+function promiseAlias(name) {
+  return function (...args) {
+    let promise = get(this, 'promise'); // 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 promise[name](...args);
+  };
+}
+
+export default PromiseProxyMixin;

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

@@ -1 +1,10 @@
-export { ObjectProxy as default } from '@ember/-internals/runtime';
+/**
+@module @ember/object/proxy
+*/
+import { FrameworkObject } from '@ember/object/-internals';
+import { _ProxyMixin } from '@ember/-internals/runtime';
+
+class ObjectProxy extends FrameworkObject {}
+
+ObjectProxy.PrototypeMixin.reopen(_ProxyMixin);
+export default ObjectProxy;

package/dist/packages/@ember/routing/-internals.js

@@ -0,0 +1,7 @@
+export { default as RouterState } from './lib/router_state';
+export { default as RoutingService } from './lib/routing-service';
+export { deprecateTransitionMethods, prefixRouteNameArg } from './lib/utils';
+export { default as generateController, generateControllerFactory } from './lib/generate_controller';
+export { default as BucketCache } from './lib/cache';
+export { default as DSL } from './lib/dsl';
+export { default as controllerFor } from './lib/controller_for';