discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,172 +0,0 @@
-/**
-@module ember
-*/
-
-import { context } from 'ember-environment';
-import { get, Mixin, computed, descriptor } from 'ember-metal';
-import { assert, deprecate } from '@ember/debug';
-import { TARGET_OBJECT } from '@ember/deprecated-features';
-/**
-`Ember.TargetActionSupport` is a mixin that can be included in a class
-to add a `triggerAction` method with semantics similar to the Handlebars
-`{{action}}` helper. In normal Ember usage, the `{{action}}` helper is
-usually the best choice. This mixin is most often useful when you are
-doing more complex event handling in Components.
-
-@class TargetActionSupport
-@namespace Ember
-@extends Mixin
-@private
-*/
-export default Mixin.create({
-  target: null,
-  targetObject: TARGET_OBJECT
-    ? descriptor({
-        configurable: true,
-        enumerable: false,
-        get() {
-          let message = `${this} Usage of \`targetObject\` is deprecated. Please use \`target\` instead.`;
-          let options = { id: 'ember-runtime.using-targetObject', until: '3.5.0' };
-          deprecate(message, false, options);
-          return this._targetObject;
-        },
-        set(value) {
-          let message = `${this} Usage of \`targetObject\` is deprecated. Please use \`target\` instead.`;
-          let options = { id: 'ember-runtime.using-targetObject', until: '3.5.0' };
-          deprecate(message, false, options);
-          this._targetObject = value;
-        },
-      })
-    : undefined,
-  action: null,
-  actionContext: null,
-
-  actionContextObject: computed('actionContext', function() {
-    let actionContext = get(this, 'actionContext');
-
-    if (typeof actionContext === 'string') {
-      let value = get(this, actionContext);
-      if (value === undefined) {
-        value = get(context.lookup, actionContext);
-      }
-      return value;
-    } else {
-      return actionContext;
-    }
-  }),
-
-  /**
-  Send an `action` with an `actionContext` to a `target`. The action, actionContext
-  and target will be retrieved from properties of the object. For example:
-
-  ```javascript
-  import { alias } from '@ember/object/computed';
-
-  App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
-    target: alias('controller'),
-    action: 'save',
-    actionContext: alias('context'),
-    click() {
-      this.triggerAction(); // Sends the `save` action, along with the current context
-                            // to the current controller
-    }
-  });
-  ```
-
-  The `target`, `action`, and `actionContext` can be provided as properties of
-  an optional object argument to `triggerAction` as well.
-
-  ```javascript
-  App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
-    click() {
-      this.triggerAction({
-        action: 'save',
-        target: this.get('controller'),
-        actionContext: this.get('context')
-      }); // Sends the `save` action, along with the current context
-          // to the current controller
-    }
-  });
-  ```
-
-  The `actionContext` defaults to the object you are mixing `TargetActionSupport` into.
-  But `target` and `action` must be specified either as properties or with the argument
-  to `triggerAction`, or a combination:
-
-  ```javascript
-  import { alias } from '@ember/object/computed';
-
-  App.SaveButtonView = Ember.View.extend(Ember.TargetActionSupport, {
-    target: alias('controller'),
-    click() {
-      this.triggerAction({
-        action: 'save'
-      }); // Sends the `save` action, along with a reference to `this`,
-          // to the current controller
-    }
-  });
-  ```
-
-  @method triggerAction
-  @param opts {Object} (optional, with the optional keys action, target and/or actionContext)
-  @return {Boolean} true if the action was sent successfully and did not return false
-  @private
-  */
-  triggerAction(opts = {}) {
-    let { action, target, actionContext } = opts;
-    action = action || get(this, 'action');
-    target = target || getTarget(this);
-
-    if (actionContext === undefined) {
-      actionContext = get(this, 'actionContextObject') || this;
-    }
-
-    if (target && action) {
-      let ret;
-
-      if (target.send) {
-        ret = target.send(...[action].concat(actionContext));
-      } else {
-        assert(
-          `The action '${action}' did not exist on ${target}`,
-          typeof target[action] === 'function'
-        );
-        ret = target[action](...[].concat(actionContext));
-      }
-
-      if (ret !== false) {
-        return true;
-      }
-    }
-
-    return false;
-  },
-});
-
-function getTarget(instance) {
-  let target = get(instance, 'target');
-  if (target) {
-    if (typeof target === 'string') {
-      let value = get(instance, target);
-      if (value === undefined) {
-        value = get(context.lookup, target);
-      }
-
-      return value;
-    } else {
-      return target;
-    }
-  }
-
-  // if a `targetObject` CP was provided, use it
-  if (target) {
-    return target;
-  }
-
-  // if _targetObject use it
-  if (TARGET_OBJECT && instance._targetObject) {
-    return instance._targetObject;
-  }
-
-  return null;
-}

data/dist/es/ember-runtime/lib/system/array_proxy.js

@@ -1,298 +0,0 @@
-/**
-@module @ember/array
-*/
-
-import {
-  get,
-  objectAt,
-  alias,
-  PROPERTY_DID_CHANGE,
-  addArrayObserver,
-  removeArrayObserver,
-  replace,
-} from 'ember-metal';
-import EmberObject from './object';
-import { isArray, MutableArray } from '../mixins/array';
-import { assert } from '@ember/debug';
-
-const ARRAY_OBSERVER_MAPPING = {
-  willChange: '_arrangedContentArrayWillChange',
-  didChange: '_arrangedContentArrayDidChange',
-};
-
-/**
-  An ArrayProxy wraps any other object that implements `Array` and/or
-  `MutableArray,` forwarding all requests. This makes it very useful for
-  a number of binding use cases or other cases where being able to swap
-  out the underlying array is useful.
-
-  A simple example of usage:
-
-  ```javascript
-  import { A } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-
-  let pets = ['dog', 'cat', 'fish'];
-  let ap = ArrayProxy.create({ content: A(pets) });
-
-  ap.get('firstObject');                        // 'dog'
-  ap.set('content', ['amoeba', 'paramecium']);
-  ap.get('firstObject');                        // 'amoeba'
-  ```
-
-  This class can also be useful as a layer to transform the contents of
-  an array, as they are accessed. This can be done by overriding
-  `objectAtContent`:
-
-  ```javascript
-  import { A } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-
-  let pets = ['dog', 'cat', 'fish'];
-  let ap = ArrayProxy.create({
-      content: A(pets),
-      objectAtContent: function(idx) {
-          return this.get('content').objectAt(idx).toUpperCase();
-      }
-  });
-
-  ap.get('firstObject'); // . 'DOG'
-  ```
-
-  When overriding this class, it is important to place the call to
-  `_super` *after* setting `content` so the internal observers have
-  a chance to fire properly:
-
-  ```javascript
-  import { A } from '@ember/array';
-  import ArrayProxy from '@ember/array/proxy';
-
-  export default ArrayProxy.extend({
-    init() {
-      this.set('content', A(['dog', 'cat', 'fish']));
-      this._super(...arguments);
-    }
-  });
-  ```
-
-  @class ArrayProxy
-  @extends EmberObject
-  @uses MutableArray
-  @public
-*/
-export default class ArrayProxy extends EmberObject {
-  init() {
-    super.init(...arguments);
-
-    /*
-      `this._objectsDirtyIndex` determines which indexes in the `this._objects`
-      cache are dirty.
-
-      If `this._objectsDirtyIndex === -1` then no indexes are dirty.
-      Otherwise, an index `i` is dirty if `i >= this._objectsDirtyIndex`.
-
-      Calling `objectAt` with a dirty index will cause the `this._objects`
-      cache to be recomputed.
-    */
-    this._objectsDirtyIndex = 0;
-    this._objects = null;
-
-    this._lengthDirty = true;
-    this._length = 0;
-
-    this._arrangedContent = null;
-    this._addArrangedContentArrayObsever();
-  }
-
-  willDestroy() {
-    this._removeArrangedContentArrayObsever();
-  }
-
-  /**
-    The content array. Must be an object that implements `Array` and/or
-    `MutableArray.`
-
-    @property content
-    @type EmberArray
-    @public
-  */
-
-  /**
-    Should actually retrieve the object at the specified index from the
-    content. You can override this method in subclasses to transform the
-    content item to something new.
-
-    This method will only be called if content is non-`null`.
-
-    @method objectAtContent
-    @param {Number} idx The index to retrieve.
-    @return {Object} the value or undefined if none found
-    @public
-  */
-  objectAtContent(idx) {
-    return objectAt(get(this, 'arrangedContent'), idx);
-  }
-
-  // See additional docs for `replace` from `MutableArray`:
-  // https://www.emberjs.com/api/ember/3.3/classes/MutableArray/methods/replace?anchor=replace
-  replace(idx, amt, objects) {
-    assert(
-      'Mutating an arranged ArrayProxy is not allowed',
-      get(this, 'arrangedContent') === get(this, 'content')
-    );
-    this.replaceContent(idx, amt, objects);
-  }
-
-  /**
-    Should actually replace the specified objects on the content array.
-    You can override this method in subclasses to transform the content item
-    into something new.
-
-    This method will only be called if content is non-`null`.
-
-    @method replaceContent
-    @param {Number} idx The starting index
-    @param {Number} amt The number of items to remove from the content.
-    @param {EmberArray} objects Optional array of objects to insert or null if no
-      objects.
-    @return {void}
-    @public
-  */
-  replaceContent(idx, amt, objects) {
-    get(this, 'content').replace(idx, amt, objects);
-  }
-
-  // Overriding objectAt is not supported.
-  objectAt(idx) {
-    if (this._objects === null) {
-      this._objects = [];
-    }
-
-    if (this._objectsDirtyIndex !== -1 && idx >= this._objectsDirtyIndex) {
-      let arrangedContent = get(this, 'arrangedContent');
-      if (arrangedContent) {
-        let length = (this._objects.length = get(arrangedContent, 'length'));
-
-        for (let i = this._objectsDirtyIndex; i < length; i++) {
-          this._objects[i] = this.objectAtContent(i);
-        }
-      } else {
-        this._objects.length = 0;
-      }
-      this._objectsDirtyIndex = -1;
-    }
-
-    return this._objects[idx];
-  }
-
-  // Overriding length is not supported.
-  get length() {
-    if (this._lengthDirty) {
-      let arrangedContent = get(this, 'arrangedContent');
-      this._length = arrangedContent ? get(arrangedContent, 'length') : 0;
-      this._lengthDirty = false;
-    }
-
-    return this._length;
-  }
-
-  set length(value) {
-    let length = this.length;
-    let removedCount = length - value;
-    let added;
-
-    if (removedCount === 0) {
-      return;
-    } else if (removedCount < 0) {
-      added = new Array(-removedCount);
-      removedCount = 0;
-    }
-
-    let content = get(this, 'content');
-    if (content) {
-      replace(content, value, removedCount, added);
-
-      this._invalidate();
-    }
-  }
-
-  [PROPERTY_DID_CHANGE](key) {
-    if (key === 'arrangedContent') {
-      let oldLength = this._objects === null ? 0 : this._objects.length;
-      let arrangedContent = get(this, 'arrangedContent');
-      let newLength = arrangedContent ? get(arrangedContent, 'length') : 0;
-
-      this._removeArrangedContentArrayObsever();
-      this.arrayContentWillChange(0, oldLength, newLength);
-
-      this._invalidate();
-
-      this.arrayContentDidChange(0, oldLength, newLength);
-      this._addArrangedContentArrayObsever();
-    } else if (key === 'content') {
-      this._invalidate();
-    }
-  }
-
-  _addArrangedContentArrayObsever() {
-    let arrangedContent = get(this, 'arrangedContent');
-    if (arrangedContent) {
-      assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
-      assert(
-        `ArrayProxy expects an Array or ArrayProxy, but you passed ${typeof arrangedContent}`,
-        isArray(arrangedContent) || arrangedContent.isDestroyed
-      );
-
-      addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING);
-
-      this._arrangedContent = arrangedContent;
-    }
-  }
-
-  _removeArrangedContentArrayObsever() {
-    if (this._arrangedContent) {
-      removeArrayObserver(this._arrangedContent, this, ARRAY_OBSERVER_MAPPING);
-    }
-  }
-
-  _arrangedContentArrayWillChange() {}
-
-  _arrangedContentArrayDidChange(proxy, idx, removedCnt, addedCnt) {
-    this.arrayContentWillChange(idx, removedCnt, addedCnt);
-
-    let dirtyIndex = idx;
-    if (dirtyIndex < 0) {
-      let length = get(this._arrangedContent, 'length');
-      dirtyIndex += length + removedCnt - addedCnt;
-    }
-
-    if (this._objectsDirtyIndex === -1) {
-      this._objectsDirtyIndex = dirtyIndex;
-    } else {
-      if (this._objectsDirtyIndex > dirtyIndex) {
-        this._objectsDirtyIndex = dirtyIndex;
-      }
-    }
-
-    this._lengthDirty = true;
-
-    this.arrayContentDidChange(idx, removedCnt, addedCnt);
-  }
-
-  _invalidate() {
-    this._objectsDirtyIndex = 0;
-    this._lengthDirty = true;
-  }
-}
-
-ArrayProxy.reopen(MutableArray, {
-  /**
-    The array that the proxy pretends to be. In the default `ArrayProxy`
-    implementation, this and `content` are the same. Subclasses of `ArrayProxy`
-    can override this property to provide things like sorting and filtering.
-
-    @property arrangedContent
-    @public
-  */
-  arrangedContent: alias('content'),
-});