ember-source 3.28.5 → 4.0.0-beta.10

package/dist/packages/@ember/-internals/runtime/lib/ext/function.js

@@ -1,155 +0,0 @@
-/**
-@module ember
-*/
-import { ENV } from '@ember/-internals/environment';
-import { on, computed, observer } from '@ember/-internals/metal';
-import { deprecate } from '@ember/debug';
-import { FUNCTION_PROTOTYPE_EXTENSIONS } from '@ember/deprecated-features';
-
-if (FUNCTION_PROTOTYPE_EXTENSIONS && ENV.EXTEND_PROTOTYPES.Function) {
-  Object.defineProperties(Function.prototype, {
-    /**
-      The `property` extension of Javascript's Function prototype is available
-      when `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Function` is
-      `true`, which is the default.
-       Computed properties allow you to treat a function like a property:
-       ```app/utils/president.js
-      import EmberObject from '@ember/object';
-       export default EmberObject.extend({
-        firstName: '',
-        lastName:  '',
-         fullName: function() {
-          return this.get('firstName') + ' ' + this.get('lastName');
-        }.property() // Call this flag to mark the function as a property
-      });
-      ```
-       ```javascript
-      let president = President.create({
-        firstName: 'Barack',
-        lastName: 'Obama'
-      });
-       president.get('fullName'); // 'Barack Obama'
-      ```
-       Treating a function like a property is useful because they can work with
-      bindings, just like any other property.
-       Many computed properties have dependencies on other properties. For
-      example, in the above example, the `fullName` property depends on
-      `firstName` and `lastName` to determine its value. You can tell Ember
-      about these dependencies like this:
-       ```app/utils/president.js
-      import EmberObject from '@ember/object';
-       export default EmberObject.extend({
-        firstName: '',
-        lastName:  '',
-         fullName: function() {
-          return this.get('firstName') + ' ' + this.get('lastName');
-           // Tell Ember.js that this computed property depends on firstName
-          // and lastName
-        }.property('firstName', 'lastName')
-      });
-      ```
-       Make sure you list these dependencies so Ember knows when to update
-      bindings that connect to a computed property. Changing a dependency
-      will not immediately trigger an update of the computed property, but
-      will instead clear the cache so that it is updated when the next `get`
-      is called on the property.
-       See [ComputedProperty](/ember/release/classes/ComputedProperty), [@ember/object/computed](/ember/release/classes/@ember%2Fobject%2Fcomputed).
-       @method property
-      @for Function
-      @public
-    */
-    property: {
-      configurable: true,
-      enumerable: false,
-      writable: true,
-      value: function () {
-        deprecate(`Function prototype extensions have been deprecated, please migrate from function(){}.property('bar') to computed('bar', function() {}).`, false, {
-          id: 'function-prototype-extensions.property',
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_function-prototype-extensions-property',
-          for: 'ember-source',
-          since: {
-            enabled: '3.11.0'
-          }
-        });
-        return computed(...arguments, this);
-      }
-    },
-
-    /**
-      The `observes` extension of Javascript's Function prototype is available
-      when `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Function` is
-      true, which is the default.
-       You can observe property changes simply by adding the `observes`
-      call to the end of your method declarations in classes that you write.
-      For example:
-       ```javascript
-      import EmberObject from '@ember/object';
-       EmberObject.extend({
-        valueObserver: function() {
-          // Executes whenever the "value" property changes
-        }.observes('value')
-      });
-      ```
-       In the future this method may become asynchronous.
-       See `observer`.
-       @method observes
-      @for Function
-      @public
-    */
-    observes: {
-      configurable: true,
-      enumerable: false,
-      writable: true,
-      value: function () {
-        deprecate(`Function prototype extensions have been deprecated, please migrate from function(){}.observes('foo') to observer('foo', function() {}).`, false, {
-          id: 'function-prototype-extensions.observes',
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_function-prototype-extensions-observes',
-          for: 'ember-source',
-          since: {
-            enabled: '3.11.0'
-          }
-        });
-        return observer(...arguments, this);
-      }
-    },
-
-    /**
-      The `on` extension of Javascript's Function prototype is available
-      when `EmberENV.EXTEND_PROTOTYPES` or `EmberENV.EXTEND_PROTOTYPES.Function` is
-      true, which is the default.
-       You can listen for events simply by adding the `on` call to the end of
-      your method declarations in classes or mixins that you write. For example:
-       ```javascript
-      import Mixin from '@ember/mixin';
-       Mixin.create({
-        doSomethingWithElement: function() {
-          // Executes whenever the "didInsertElement" event fires
-        }.on('didInsertElement')
-      });
-      ```
-       See `@ember/object/evented/on`.
-       @method on
-      @for Function
-      @public
-    */
-    on: {
-      configurable: true,
-      enumerable: false,
-      writable: true,
-      value: function () {
-        deprecate(`Function prototype extensions have been deprecated, please migrate from function(){}.on('foo') to on('foo', function() {}).`, false, {
-          id: 'function-prototype-extensions.on',
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_function-prototype-extensions-on',
-          for: 'ember-source',
-          since: {
-            enabled: '3.11.0'
-          }
-        });
-        return on(...arguments, this);
-      }
-    }
-  });
-}

package/dist/packages/@ember/-internals/runtime/lib/mixins/copyable.js

@@ -1,31 +0,0 @@
-/**
-@module ember
-*/
-import { Mixin } from '@ember/-internals/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
-});

package/dist/packages/@ember/-internals/views/lib/mixins/text_support.js

@@ -1,357 +0,0 @@
-/**
-@module ember
-*/
-import { get, set, Mixin } from '@ember/-internals/metal';
-import { deprecate } from '@ember/debug';
-import { SEND_ACTION } from '@ember/deprecated-features';
-import { MUTABLE_CELL } from '@ember/-internals/views';
-import { DEBUG } from '@glimmer/env';
-
-if (DEBUG && true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
-  Mixin._disableDebugSeal = true;
-}
-
-const KEY_EVENTS = {
-  Enter: 'insertNewline',
-  Escape: 'cancel'
-};
-/**
-  `TextSupport` is a shared mixin used by both `TextField` and
-  `TextArea`. `TextSupport` adds a number of methods that allow you to
-  specify a controller action to invoke when a certain event is fired on your
-  text field or textarea. The specified controller action would get the current
-  value of the field passed in as the only argument unless the value of
-  the field is empty. In that case, the instance of the field itself is passed
-  in as the only argument.
-
-  Let's use the pressing of the escape key as an example. If you wanted to
-  invoke a controller action when a user presses the escape key while on your
-  field, you would use the `escape-press` attribute on your field like so:
-
-  ```handlebars
-    {{! application.hbs}}
-
-    {{input escape-press='alertUser'}}
-  ```
-
-  ```javascript
-      import Application from '@ember/application';
-      import Controller from '@ember/controller';
-      App = Application.create();
-
-      App.ApplicationController = Controller.extend({
-        actions: {
-          alertUser: function ( currentValue ) {
-            alert( 'escape pressed, current value: ' + currentValue );
-          }
-        }
-      });
-  ```
-
-  The following chart is a visual representation of what takes place when the
-  escape key is pressed in this scenario:
-
-  ```
-  The Template
-  +---------------------------+
-  |                           |
-  | escape-press='alertUser'  |
-  |                           |          TextSupport Mixin
-  +----+----------------------+          +-------------------------------+
-       |                                 | cancel method                 |
-       |      escape button pressed      |                               |
-       +-------------------------------> | checks for the `escape-press` |
-                                         | attribute and pulls out the   |
-       +-------------------------------+ | `alertUser` value             |
-       |     action name 'alertUser'     +-------------------------------+
-       |     sent to controller
-       v
-  Controller
-  +------------------------------------------ +
-  |                                           |
-  |  actions: {                               |
-  |     alertUser: function( currentValue ){  |
-  |       alert( 'the esc key was pressed!' ) |
-  |     }                                     |
-  |  }                                        |
-  |                                           |
-  +-------------------------------------------+
-  ```
-
-  Here are the events that we currently support along with the name of the
-  attribute you would need to use on your field. To reiterate, you would use the
-  attribute name like so:
-
-  ```handlebars
-    {{input attribute-name='controllerAction'}}
-  ```
-
-  ```
-  +--------------------+----------------+
-  |                    |                |
-  | event              | attribute name |
-  +--------------------+----------------+
-  | new line inserted  | insert-newline |
-  |                    |                |
-  | enter key pressed  | enter          |
-  |                    |                |
-  | cancel key pressed | escape-press   |
-  |                    |                |
-  | focusin            | focus-in       |
-  |                    |                |
-  | focusout           | focus-out      |
-  |                    |                |
-  | keypress           | key-press      |
-  |                    |                |
-  | keyup              | key-up         |
-  |                    |                |
-  | keydown            | key-down       |
-  +--------------------+----------------+
-  ```
-
-  @class TextSupport
-  @namespace Ember
-  @uses Ember.TargetActionSupport
-  @extends Mixin
-  @private
-*/
-
-const TextSupport = Mixin.create({
-  value: '',
-  attributeBindings: ['autocapitalize', 'autocorrect', 'autofocus', 'disabled', 'form', 'maxlength', 'minlength', 'placeholder', 'readonly', 'required', 'selectionDirection', 'spellcheck', 'tabindex', 'title'],
-  placeholder: null,
-  disabled: false,
-  maxlength: null,
-
-  init() {
-    this._super(...arguments);
-
-    this.on('paste', this, this._elementValueDidChange);
-    this.on('cut', this, this._elementValueDidChange);
-    this.on('input', this, this._elementValueDidChange);
-  },
-
-  /**
-    Whether the `keyUp` event that triggers an `action` to be sent continues
-    propagating to other views.
-     By default, when the user presses the return key on their keyboard and
-    the text field has an `action` set, the action will be sent to the view's
-    controller and the key event will stop propagating.
-     If you would like parent views to receive the `keyUp` event even after an
-    action has been dispatched, set `bubbles` to true.
-     @property bubbles
-    @type Boolean
-    @default false
-    @private
-  */
-  bubbles: false,
-
-  interpretKeyEvents(event) {
-    let method = KEY_EVENTS[event.key];
-
-    this._elementValueDidChange();
-
-    if (method) {
-      return this[method](event);
-    }
-  },
-
-  _elementValueDidChange() {
-    set(this, 'value', this.element.value);
-  },
-
-  change(event) {
-    this._elementValueDidChange(event);
-  },
-
-  /**
-    Allows you to specify a controller action to invoke when either the `enter`
-    key is pressed or, in the case of the field being a textarea, when a newline
-    is inserted. To use this method, give your field an `insert-newline`
-    attribute. The value of that attribute should be the name of the action
-    in your controller that you wish to invoke.
-     For an example on how to use the `insert-newline` attribute, please
-    reference the example near the top of this file.
-     @method insertNewline
-    @param {Event} event
-    @private
-  */
-  insertNewline(event) {
-    sendAction('enter', this, event);
-    sendAction('insert-newline', this, event);
-  },
-
-  /**
-    Allows you to specify a controller action to invoke when the escape button
-    is pressed. To use this method, give your field an `escape-press`
-    attribute. The value of that attribute should be the name of the action
-    in your controller that you wish to invoke.
-     For an example on how to use the `escape-press` attribute, please reference
-    the example near the top of this file.
-     @method cancel
-    @param {Event} event
-    @private
-  */
-  cancel(event) {
-    sendAction('escape-press', this, event);
-  },
-
-  /**
-    Allows you to specify a controller action to invoke when a field receives
-    focus. To use this method, give your field a `focus-in` attribute. The value
-    of that attribute should be the name of the action in your controller
-    that you wish to invoke.
-     For an example on how to use the `focus-in` attribute, please reference the
-    example near the top of this file.
-     @method focusIn
-    @param {Event} event
-    @private
-  */
-  focusIn(event) {
-    sendAction('focus-in', this, event);
-  },
-
-  /**
-    Allows you to specify a controller action to invoke when a field loses
-    focus. To use this method, give your field a `focus-out` attribute. The value
-    of that attribute should be the name of the action in your controller
-    that you wish to invoke.
-     For an example on how to use the `focus-out` attribute, please reference the
-    example near the top of this file.
-     @method focusOut
-    @param {Event} event
-    @private
-  */
-  focusOut(event) {
-    this._elementValueDidChange(event);
-
-    sendAction('focus-out', this, event);
-  },
-
-  /**
-    Allows you to specify a controller action to invoke when a key is pressed.
-    To use this method, give your field a `key-press` attribute. The value of
-    that attribute should be the name of the action in your controller you
-    that wish to invoke.
-     For an example on how to use the `key-press` attribute, please reference the
-    example near the top of this file.
-     @method keyPress
-    @param {Event} event
-    @private
-  */
-  keyPress(event) {
-    sendAction('key-press', this, event);
-  },
-
-  /**
-    Allows you to specify a controller action to invoke when a key-up event is
-    fired. To use this method, give your field a `key-up` attribute. The value
-    of that attribute should be the name of the action in your controller
-    that you wish to invoke.
-     For an example on how to use the `key-up` attribute, please reference the
-    example near the top of this file.
-     @method keyUp
-    @param {Event} event
-    @private
-  */
-  keyUp(event) {
-    this.interpretKeyEvents(event);
-    sendAction('key-up', this, event);
-  },
-
-  /**
-    Allows you to specify a controller action to invoke when a key-down event is
-    fired. To use this method, give your field a `key-down` attribute. The value
-    of that attribute should be the name of the action in your controller that
-    you wish to invoke.
-     For an example on how to use the `key-down` attribute, please reference the
-    example near the top of this file.
-     @method keyDown
-    @param {Event} event
-    @private
-  */
-  keyDown(event) {
-    sendAction('key-down', this, event);
-  }
-
-}); // In principle, this shouldn't be necessary, but the legacy
-// sendAction semantics for TextField are different from
-// the component semantics so this method normalizes them.
-
-function sendAction(eventName, view, event) {
-  let action = get(view, `attrs.${eventName}`);
-
-  if (action !== null && typeof action === 'object' && action[MUTABLE_CELL] === true) {
-    action = action.value;
-  }
-
-  if (action === undefined) {
-    action = get(view, eventName);
-  }
-
-  let value = get(view, 'value');
-
-  if (SEND_ACTION && typeof action === 'string') {
-    let message = `Passing actions to components as strings (like \`<Input @${eventName}="${action}" />\`) is deprecated. Please use closure actions instead (\`<Input @${eventName}={{action "${action}"}} />\`).`;
-    deprecate(message, false, {
-      id: 'ember-component.send-action',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_ember-component-send-action',
-      for: 'ember-source',
-      since: {
-        enabled: '3.4.0'
-      }
-    });
-    view.triggerAction({
-      action: action,
-      actionContext: [value, event]
-    });
-  } else if (typeof action === 'function') {
-    action(value, event);
-  }
-
-  if (action && !get(view, 'bubbles')) {
-    event.stopPropagation();
-  }
-}
-
-if (true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
-  Object.defineProperty(TextSupport, '_wasReopened', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: false
-  });
-  Object.defineProperty(TextSupport, 'reopen', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: function reopen(...args) {
-      if (this === TextSupport) {
-        deprecate('Reopening Ember.TextSupport is deprecated.', false, {
-          id: 'ember.built-in-components.reopen',
-          for: 'ember-source',
-          since: {
-            enabled: '3.27.0'
-          },
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_ember-built-in-components-reopen'
-        });
-        TextSupport._wasReopened = true;
-      }
-
-      return Mixin.prototype.reopen.call(this, ...args);
-    }
-  });
-
-  if (DEBUG) {
-    Object.seal(TextSupport);
-    Mixin._disableDebugSeal = false;
-  }
-}
-
-export default TextSupport;

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

@@ -1,26 +0,0 @@
-import { context } from '@ember/-internals/environment';
-import { hasDOM } from '@ember/-internals/browser-environment';
-import { ENV } from '@ember/-internals/environment';
-import { JQUERY_INTEGRATION } from '@ember/deprecated-features';
-export let jQuery;
-export let jQueryDisabled = !JQUERY_INTEGRATION || ENV._JQUERY_INTEGRATION === false;
-
-if (JQUERY_INTEGRATION && hasDOM) {
-  jQuery = context.imports.jQuery;
-
-  if (!jQueryDisabled && jQuery) {
-    if (jQuery.event.addProp) {
-      jQuery.event.addProp('dataTransfer');
-    } else {
-      // http://www.whatwg.org/specs/web-apps/current-work/multipage/dnd.html#dndevents
-      ['dragstart', 'drag', 'dragenter', 'dragleave', 'dragover', 'drop', 'dragend'].forEach(eventName => {
-        jQuery.event.fixHooks[eventName] = {
-          props: ['dataTransfer']
-        };
-      });
-    }
-  } else {
-    jQuery = undefined;
-    jQueryDisabled = true;
-  }
-}

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

@@ -1,60 +0,0 @@
-/* global Proxy */
-import { deprecate } from '@ember/debug';
-import { global } from '@ember/-internals/environment';
-import { HAS_NATIVE_PROXY } from '@ember/-internals/utils';
-import { DEBUG } from '@glimmer/env';
-import { JQUERY_INTEGRATION } from '@ember/deprecated-features';
-export default function addJQueryEventDeprecation(jqEvent) {
-  if (DEBUG && JQUERY_INTEGRATION && HAS_NATIVE_PROXY) {
-    let boundFunctions = new Map(); // wrap the jQuery event in a Proxy to add the deprecation message for originalEvent, according to RFC#294
-    // we need a native Proxy here, so we can make sure that the internal use of originalEvent in jQuery itself does
-    // not trigger a deprecation
-
-    return new Proxy(jqEvent, {
-      get(target, name) {
-        switch (name) {
-          case 'originalEvent':
-            deprecate('Accessing jQuery.Event specific properties is deprecated. Either use the ember-jquery-legacy addon to normalize events to native events, or explicitly opt into jQuery integration using @ember/optional-features.', (EmberENV => {
-              // this deprecation is intentionally checking `global.EmberENV` so
-              // that we can ensure we _only_ deprecate in the case where jQuery
-              // integration is enabled implicitly (e.g. "defaulted" to enabled)
-              // as opposed to when the user explicitly opts in to using jQuery
-              if (typeof EmberENV !== 'object' || EmberENV === null) return false;
-              return EmberENV._JQUERY_INTEGRATION === true;
-            })(global.EmberENV), {
-              id: 'ember-views.event-dispatcher.jquery-event',
-              until: '4.0.0',
-              url: 'https://deprecations.emberjs.com/v3.x#toc_jquery-event',
-              for: 'ember-source',
-              since: {
-                enabled: '3.9.0'
-              }
-            });
-            return target[name];
-          // provide an escape hatch for ember-jquery-legacy to access originalEvent without a deprecation
-
-          case '__originalEvent':
-            return target.originalEvent;
-
-          default:
-            if (typeof target[name] === 'function') {
-              // cache functions for reuse
-              if (!boundFunctions.has(name)) {
-                // for jQuery.Event methods call them with `target` as the `this` context, so they will access
-                // `originalEvent` from the original jQuery event, not our proxy, thus not trigger the deprecation
-                boundFunctions.set(name, target[name].bind(target));
-              }
-
-              return boundFunctions.get(name);
-            } // same for jQuery's getter functions for simple properties
-
-
-            return target[name];
-        }
-      }
-
-    });
-  }
-
-  return jqEvent;
-}

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

@@ -1,25 +0,0 @@
-import { deprecate as _deprecate, deprecateFunc as _deprecateFunc } from '@ember/debug';
-export function deprecate(message, condition, options) {
-  _deprecate("`import { deprecate } from '@ember/application/deprecations';` has been deprecated, please update to `import { deprecate } from '@ember/debug';`", false, {
-    id: 'old-deprecate-method-paths',
-    until: '4.0.0',
-    for: 'ember-source',
-    since: {
-      enabled: '3.0.0'
-    }
-  });
-
-  _deprecate(message, condition, options);
-}
-export function deprecateFunc(message, options, func) {
-  _deprecate("`import { deprecateFunc } from '@ember/application/deprecations';` has been deprecated, please update to `import { deprecateFunc } from '@ember/debug';`", false, {
-    id: 'old-deprecate-method-paths',
-    until: '4.0.0',
-    for: 'ember-source',
-    since: {
-      enabled: '3.0.0'
-    }
-  });
-
-  _deprecateFunc(message, options, func);
-}