discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-runtime/lib/mixins/comparable.js

@@ -1,38 +0,0 @@
-import { Mixin } from 'ember-metal';
-
-/**
-@module ember
-*/
-
-/**
-  Implements some standard methods for comparing objects. Add this mixin to
-  any class you create that can compare its instances.
-
-  You should implement the `compare()` method.
-
-  @class Comparable
-  @namespace Ember
-  @since Ember 0.9
-  @private
-*/
-export default Mixin.create({
-  /**
-    __Required.__ You must implement this method to apply this mixin.
-
-    Override to return the result of the comparison of the two parameters. The
-    compare method should return:
-
-    - `-1` if `a < b`
-    - `0` if `a == b`
-    - `1` if `a > b`
-
-    Default implementation raises an exception.
-
-    @method compare
-    @param a {Object} the first object to compare
-    @param b {Object} the second object to compare
-    @return {Number} the result of the comparison
-    @private
-  */
-  compare: null,
-});

data/dist/es/ember-runtime/lib/mixins/container_proxy.js

@@ -1,154 +0,0 @@
-import { schedule, join } from '@ember/runloop';
-/**
-@module ember
-*/
-import { Mixin } from 'ember-metal';
-
-/**
-  ContainerProxyMixin is used to provide public access to specific
-  container functionality.
-
-  @class ContainerProxyMixin
-  @private
-*/
-let containerProxyMixin = {
-  /**
-   The container stores state.
-
-   @private
-   @property {Ember.Container} __container__
-   */
-  __container__: null,
-
-  /**
-   Returns an object that can be used to provide an owner to a
-   manually created instance.
-
-   Example:
-
-   ```
-   import { getOwner } from '@ember/application';
-
-   let owner = getOwner(this);
-
-   User.create(
-     owner.ownerInjection(),
-     { username: 'rwjblue' }
-   )
-   ```
-
-   @public
-   @method ownerInjection
-   @since 2.3.0
-   @return {Object}
-  */
-  ownerInjection() {
-    return this.__container__.ownerInjection();
-  },
-
-  /**
-   Given a fullName return a corresponding instance.
-
-   The default behavior is for lookup to return a singleton instance.
-   The singleton is scoped to the container, allowing multiple containers
-   to all have their own locally scoped singletons.
-
-   ```javascript
-   let registry = new Registry();
-   let container = registry.container();
-
-   registry.register('api:twitter', Twitter);
-
-   let twitter = container.lookup('api:twitter');
-
-   twitter instanceof Twitter; // => true
-
-   // by default the container will return singletons
-   let twitter2 = container.lookup('api:twitter');
-   twitter2 instanceof Twitter; // => true
-
-   twitter === twitter2; //=> true
-   ```
-
-   If singletons are not wanted an optional flag can be provided at lookup.
-
-   ```javascript
-   let registry = new Registry();
-   let container = registry.container();
-
-   registry.register('api:twitter', Twitter);
-
-   let twitter = container.lookup('api:twitter', { singleton: false });
-   let twitter2 = container.lookup('api:twitter', { singleton: false });
-
-   twitter === twitter2; //=> false
-   ```
-
-   @public
-   @method lookup
-   @param {String} fullName
-   @param {Object} options
-   @return {any}
-   */
-  lookup(fullName, options) {
-    return this.__container__.lookup(fullName, options);
-  },
-
-  destroy() {
-    let container = this.__container__;
-
-    if (container) {
-      join(() => {
-        container.destroy();
-        schedule('destroy', container, 'finalizeDestroy');
-      });
-    }
-
-    this._super();
-  },
-
-  /**
- Given a fullName return a factory manager.
-
-  This method returns a manager which can be used for introspection of the
-  factory's class or for the creation of factory instances with initial
-  properties. The manager is an object with the following properties:
-
-  * `class` - The registered or resolved class.
-  * `create` - A function that will create an instance of the class with
-    any dependencies injected.
-
-  For example:
-
-  ```javascript
-  import { getOwner } from '@ember/application';
-
-  let owner = getOwner(otherInstance);
-  // the owner is commonly the `applicationInstance`, and can be accessed via
-  // an instance initializer.
-
-  let factory = owner.factoryFor('service:bespoke');
-
-  factory.class;
-  // The registered or resolved class. For example when used with an Ember-CLI
-  // app, this would be the default export from `app/services/bespoke.js`.
-
-  let instance = factory.create({
-    someProperty: 'an initial property value'
-  });
-  // Create an instance with any injections and the passed options as
-  // initial properties.
-  ```
-
-  @public
-  @method factoryFor
-  @param {String} fullName
-  @param {Object} options
-  @return {FactoryManager}
-  */
-  factoryFor(fullName, options = {}) {
-    return this.__container__.factoryFor(fullName, options);
-  },
-};
-
-export default Mixin.create(containerProxyMixin);

data/dist/es/ember-runtime/lib/mixins/copyable.js

@@ -1,34 +0,0 @@
-/**
-@module ember
-*/
-
-import { Mixin } from 'ember-metal';
-
-/**
-  Implements some standard methods for copying an object. Add this mixin to
-  any object you create that can create a copy of itself. This mixin is
-  added automatically to the built-in array.
-
-  You should generally implement the `copy()` method to return a copy of the
-  receiver.
-
-  @class Copyable
-  @namespace Ember
-  @since Ember 0.9
-  @deprecated Use 'ember-copy' addon instead
-  @private
-*/
-export default Mixin.create({
-  /**
-    __Required.__ You must implement this method to apply this mixin.
-
-    Override to return a copy of the receiver. Default implementation raises
-    an exception.
-
-    @method copy
-    @param {Boolean} deep if `true`, a deep copy of the object should be made
-    @return {Object} copy of receiver
-    @private
-  */
-  copy: null,
-});

data/dist/es/ember-runtime/lib/mixins/enumerable.js

@@ -1,16 +0,0 @@
-import { Mixin } from 'ember-metal';
-
-/**
-@module @ember/enumerable
-@private
-*/
-
-/**
-  The methods in this mixin have been moved to [MutableArray](https://emberjs.com/api/ember/release/classes/MutableArray). This mixin has
-  been intentionally preserved to avoid breaking Enumerable.detect checks
-  until the community migrates away from them.
-
-  @class Enumerable
-  @private
-*/
-export default Mixin.create();

data/dist/es/ember-runtime/lib/mixins/evented.js

@@ -1,149 +0,0 @@
-import { Mixin, addListener, removeListener, hasListeners, sendEvent } from 'ember-metal';
-
-/**
-@module @ember/object
-*/
-
-/**
-  This mixin allows for Ember objects to subscribe to and emit events.
-
-  ```app/utils/person.js
-  import EmberObject from '@ember/object';
-  import Evented from '@ember/object/evented';
-
-  export default EmberObject.extend(Evented, {
-    greet() {
-      // ...
-      this.trigger('greet');
-    }
-  });
-  ```
-
-  ```javascript
-  var person = Person.create();
-
-  person.on('greet', function() {
-    console.log('Our person has greeted');
-  });
-
-  person.greet();
-
-  // outputs: 'Our person has greeted'
-  ```
-
-  You can also chain multiple event subscriptions:
-
-  ```javascript
-  person.on('greet', function() {
-    console.log('Our person has greeted');
-  }).one('greet', function() {
-    console.log('Offer one-time special');
-  }).off('event', this, forgetThis);
-  ```
-
-  @class Evented
-  @public
- */
-export default 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 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} method The callback to execute
-    @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. If this argument is passed then the 3rd argument
-    becomes the function.
-
-    @method one
-    @param {String} name The name of the event
-    @param {Object} [target] The "this" binding for the callback
-    @param {Function} method The callback to execute
-    @return this
-    @public
-  */
-  one(name, target, method) {
-    if (!method) {
-      method = target;
-      target = null;
-    }
-
-    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} method The 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);
-  },
-});

data/dist/es/ember-runtime/lib/mixins/mutable_enumerable.js

@@ -1,18 +0,0 @@
-import Enumerable from './enumerable';
-import { Mixin } from 'ember-metal';
-
-/**
-@module ember
-*/
-
-/**
-  The methods in this mixin have been moved to MutableArray. This mixin has
-  been intentionally preserved to avoid breaking MutableEnumerable.detect
-  checks until the community migrates away from them.
-
-  @class MutableEnumerable
-  @namespace Ember
-  @uses Enumerable
-  @private
-*/
-export default Mixin.create(Enumerable);

data/dist/es/ember-runtime/lib/mixins/observable.js

@@ -1,482 +0,0 @@
-/**
-@module @ember/object
-*/
-
-import {
-  get,
-  getWithDefault,
-  set,
-  getProperties,
-  setProperties,
-  Mixin,
-  hasListeners,
-  beginPropertyChanges,
-  propertyWillChange,
-  propertyDidChange,
-  notifyPropertyChange,
-  endPropertyChanges,
-  addObserver,
-  removeObserver,
-  getCachedValueFor,
-} from 'ember-metal';
-import { assert } from '@ember/debug';
-
-/**
-  ## Overview
-
-  This mixin provides properties and property observing functionality, core
-  features of the Ember object model.
-
-  Properties and observers allow one object to observe changes to a
-  property on another object. This is one of the fundamental ways that
-  models, controllers and views communicate with each other in an Ember
-  application.
-
-  Any object that has this mixin applied can be used in observer
-  operations. That includes `EmberObject` and most objects you will
-  interact with as you write your Ember application.
-
-  Note that you will not generally apply this mixin to classes yourself,
-  but you will use the features provided by this module frequently, so it
-  is important to understand how to use it.
-
-  ## Using `get()` and `set()`
-
-  Because of Ember's support for bindings and observers, you will always
-  access properties using the get method, and set properties using the
-  set method. This allows the observing objects to be notified and
-  computed properties to be handled properly.
-
-  More documentation about `get` and `set` are below.
-
-  ## Observing Property Changes
-
-  You typically observe property changes simply by using the `observer`
-  function in classes that you write.
-
-  For example:
-
-  ```javascript
-  import { observer } from '@ember/object';
-  import EmberObject from '@ember/object';
-
-  EmberObject.extend({
-    valueObserver: observer('value', function(sender, key, value, rev) {
-      // Executes whenever the "value" property changes
-      // See the addObserver method for more information about the callback arguments
-    })
-  });
-  ```
-
-  Although this is the most common way to add an observer, this capability
-  is actually built into the `EmberObject` class on top of two methods
-  defined in this mixin: `addObserver` and `removeObserver`. You can use
-  these two methods to add and remove observers yourself if you need to
-  do so at runtime.
-
-  To add an observer for a property, call:
-
-  ```javascript
-  object.addObserver('propertyKey', targetObject, targetAction)
-  ```
-
-  This will call the `targetAction` method on the `targetObject` whenever
-  the value of the `propertyKey` changes.
-
-  Note that if `propertyKey` is a computed property, the observer will be
-  called when any of the property dependencies are changed, even if the
-  resulting value of the computed property is unchanged. This is necessary
-  because computed properties are not computed until `get` is called.
-
-  @class Observable
-  @public
-*/
-export default 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].concat(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;
-  },
-
-  /**
-    @method propertyWillChange
-    @private
-  */
-  propertyWillChange(keyName) {
-    propertyWillChange(this, keyName);
-    return this;
-  },
-
-  /**
-    @method propertyDidChange
-    @private
-  */
-  propertyDidChange(keyName) {
-    propertyDidChange(this, keyName);
-    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.
-
-    ### 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
-    @return {Observable}
-    @public
-  */
-  addObserver(key, target, method) {
-    addObserver(this, key, target, method);
-    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
-    @return {Observable}
-    @public
-  */
-  removeObserver(key, target, method) {
-    removeObserver(this, key, target, method);
-    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`);
-  },
-
-  /**
-    Retrieves the value of a property, or a default value in the case that the
-    property returns `undefined`.
-
-    ```javascript
-    person.getWithDefault('lastName', 'Doe');
-    ```
-
-    @method getWithDefault
-    @param {String} keyName The name of the property to retrieve
-    @param {Object} defaultValue The value to return if the property value is undefined
-    @return {Object} The property value or the defaultValue.
-    @public
-  */
-  getWithDefault(keyName, defaultValue) {
-    return getWithDefault(this, keyName, defaultValue);
-  },
-
-  /**
-    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(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',
-      !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) {
-    return getCachedValueFor(this, keyName);
-  },
-});