discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-views/lib/mixins/text_support.js

@@ -1,333 +0,0 @@
-/**
-@module ember
-*/
-
-import { get, set, Mixin } from 'ember-metal';
-import { TargetActionSupport } from 'ember-runtime';
-import { deprecate } from '@ember/debug';
-import { SEND_ACTION } from '@ember/deprecated-features';
-
-const KEY_EVENTS = {
-  13: 'insertNewline',
-  27: '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
-*/
-export default Mixin.create(TargetActionSupport, {
-  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 map = KEY_EVENTS;
-    let method = map[event.keyCode];
-
-    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 actionName = get(view, `attrs.${eventName}`) || get(view, eventName);
-  let value = get(view, 'value');
-
-  if (SEND_ACTION && typeof actionName === 'string') {
-    deprecate(
-      `Passing actions to components as strings (like {{input ${eventName}="${actionName}"}}) is deprecated. Please use closure actions instead ({{input ${eventName}=(action "${actionName}")}})`,
-      false,
-      {
-        id: 'ember-component.send-action',
-        until: '4.0.0',
-        url: 'https://emberjs.com/deprecations/v3.x#toc_ember-component-send-action',
-      }
-    );
-    view.triggerAction({
-      action: actionName,
-      actionContext: [value, event],
-    });
-  } else if (typeof actionName === 'function') {
-    actionName(value, event);
-  }
-
-  if (actionName && !get(view, 'bubbles')) {
-    event.stopPropagation();
-  }
-}

data/dist/es/ember-views/lib/mixins/view_state_support.js

@@ -1,19 +0,0 @@
-/**
-@module ember
-*/
-import { Mixin } from 'ember-metal';
-
-export default Mixin.create({
-  _transitionTo(state) {
-    let priorState = this._currentState;
-    let currentState = (this._currentState = this._states[state]);
-    this._state = state;
-
-    if (priorState && priorState.exit) {
-      priorState.exit(this);
-    }
-    if (currentState.enter) {
-      currentState.enter(this);
-    }
-  },
-});

data/dist/es/ember-views/lib/mixins/view_support.js

@@ -1,452 +0,0 @@
-import { guidFor } from 'ember-utils';
-import { descriptorFor } from 'ember-meta';
-import { descriptor, Mixin } from 'ember-metal';
-import { assert } from '@ember/debug';
-import { hasDOM } from 'ember-browser-environment';
-import { matches } from '../system/utils';
-import { default as jQuery, jQueryDisabled } from '../system/jquery';
-
-function K() {
-  return this;
-}
-
-/**
- @class ViewMixin
- @namespace Ember
- @private
-*/
-export default Mixin.create({
-  /**
-    A list of properties of the view to apply as attributes. If the property
-    is a string value, the value of that string will be applied as the value
-    for an attribute of the property's name.
-
-    The following example creates a tag like `<div priority="high" />`.
-
-    ```app/components/my-component.js
-    import Component from '@ember/component';
-
-    export default Component.extend({
-      attributeBindings: ['priority'],
-      priority: 'high'
-    });
-    ```
-
-    If the value of the property is a Boolean, the attribute is treated as
-    an HTML Boolean attribute. It will be present if the property is `true`
-    and omitted if the property is `false`.
-
-    The following example creates markup like `<div visible />`.
-
-    ```app/components/my-component.js
-    import Component from '@ember/component';
-
-    export default Component.extend({
-      attributeBindings: ['visible'],
-      visible: true
-    });
-    ```
-
-    If you would prefer to use a custom value instead of the property name,
-    you can create the same markup as the last example with a binding like
-    this:
-
-    ```app/components/my-component.js
-    import Component from '@ember/component';
-
-    export default Component.extend({
-      attributeBindings: ['isVisible:visible'],
-      isVisible: true
-    });
-    ```
-
-    This list of attributes is inherited from the component's superclasses,
-    as well.
-
-    @property attributeBindings
-    @type Array
-    @default []
-    @public
-   */
-  concatenatedProperties: ['attributeBindings'],
-
-  // ..........................................................
-  // TEMPLATE SUPPORT
-  //
-
-  /**
-    Return the nearest ancestor that is an instance of the provided
-    class or mixin.
-
-    @method nearestOfType
-    @param {Class,Mixin} klass Subclass of Ember.View (or Ember.View itself),
-           or an instance of Mixin.
-    @return Ember.View
-    @deprecated use `yield` and contextual components for composition instead.
-    @private
-  */
-  nearestOfType(klass) {
-    let view = this.parentView;
-    let isOfType =
-      klass instanceof Mixin ? view => klass.detect(view) : view => klass.detect(view.constructor);
-
-    while (view) {
-      if (isOfType(view)) {
-        return view;
-      }
-      view = view.parentView;
-    }
-  },
-
-  /**
-    Return the nearest ancestor that has a given property.
-
-    @method nearestWithProperty
-    @param {String} property A property name
-    @return Ember.View
-    @deprecated use `yield` and contextual components for composition instead.
-    @private
-  */
-  nearestWithProperty(property) {
-    let view = this.parentView;
-
-    while (view) {
-      if (property in view) {
-        return view;
-      }
-      view = view.parentView;
-    }
-  },
-
-  /**
-    Renders the view again. This will work regardless of whether the
-    view is already in the DOM or not. If the view is in the DOM, the
-    rendering process will be deferred to give bindings a chance
-    to synchronize.
-
-    If children were added during the rendering process using `appendChild`,
-    `rerender` will remove them, because they will be added again
-    if needed by the next `render`.
-
-    In general, if the display of your view changes, you should modify
-    the DOM element directly instead of manually calling `rerender`, which can
-    be slow.
-
-    @method rerender
-    @public
-  */
-  rerender() {
-    return this._currentState.rerender(this);
-  },
-
-  // ..........................................................
-  // ELEMENT SUPPORT
-  //
-
-  /**
-    Returns the current DOM element for the view.
-
-    @property element
-    @type DOMElement
-    @public
-  */
-  element: descriptor({
-    configurable: false,
-    enumerable: false,
-    get() {
-      return this.renderer.getElement(this);
-    },
-  }),
-
-  /**
-    Returns a jQuery object for this view's element. If you pass in a selector
-    string, this method will return a jQuery object, using the current element
-    as its buffer.
-
-    For example, calling `view.$('li')` will return a jQuery object containing
-    all of the `li` elements inside the DOM element of this view.
-
-    @method $
-    @param {String} [selector] a jQuery-compatible selector string
-    @return {jQuery} the jQuery object for the DOM node
-    @public
-  */
-  $(sel) {
-    assert(
-      "You cannot access this.$() on a component with `tagName: ''` specified.",
-      this.tagName !== ''
-    );
-    assert('You cannot access this.$() with `jQuery` disabled.', !jQueryDisabled);
-    if (this.element) {
-      return sel ? jQuery(sel, this.element) : jQuery(this.element);
-    }
-  },
-
-  /**
-    Appends the view's element to the specified parent element.
-
-    Note that this method just schedules the view to be appended; the DOM
-    element will not be appended to the given element until all bindings have
-    finished synchronizing.
-
-    This is not typically a function that you will need to call directly when
-    building your application. If you do need to use `appendTo`, be sure that
-    the target element you are providing is associated with an `Application`
-    and does not have an ancestor element that is associated with an Ember view.
-
-    @method appendTo
-    @param {String|DOMElement|jQuery} A selector, element, HTML string, or jQuery object
-    @return {Ember.View} receiver
-    @private
-  */
-  appendTo(selector) {
-    let target;
-
-    if (hasDOM) {
-      target = typeof selector === 'string' ? document.querySelector(selector) : selector;
-
-      assert(`You tried to append to (${selector}) but that isn't in the DOM`, target);
-      assert('You cannot append to an existing Ember.View.', !matches(target, '.ember-view'));
-      assert(
-        'You cannot append to an existing Ember.View.',
-        (() => {
-          let node = target.parentNode;
-          while (node) {
-            if (node.nodeType !== 9 && matches(node, '.ember-view')) {
-              return false;
-            }
-
-            node = node.parentNode;
-          }
-
-          return true;
-        })()
-      );
-    } else {
-      target = selector;
-
-      assert(
-        `You tried to append to a selector string (${selector}) in an environment without jQuery`,
-        typeof target !== 'string'
-      );
-      assert(
-        `You tried to append to a non-Element (${selector}) in an environment without jQuery`,
-        typeof selector.appendChild === 'function'
-      );
-    }
-
-    this.renderer.appendTo(this, target);
-
-    return this;
-  },
-
-  /**
-    Appends the view's element to the document body. If the view does
-    not have an HTML representation yet
-    the element will be generated automatically.
-
-    If your application uses the `rootElement` property, you must append
-    the view within that element. Rendering views outside of the `rootElement`
-    is not supported.
-
-    Note that this method just schedules the view to be appended; the DOM
-    element will not be appended to the document body until all bindings have
-    finished synchronizing.
-
-    @method append
-    @return {Ember.View} receiver
-    @private
-  */
-  append() {
-    return this.appendTo(document.body);
-  },
-
-  /**
-    The HTML `id` of the view's element in the DOM. You can provide this
-    value yourself but it must be unique (just as in HTML):
-
-    ```handlebars
-      {{my-component elementId="a-really-cool-id"}}
-    ```
-
-    If not manually set a default value will be provided by the framework.
-
-    Once rendered an element's `elementId` is considered immutable and you
-    should never change it. If you need to compute a dynamic value for the
-    `elementId`, you should do this when the component or element is being
-    instantiated:
-
-    ```app/components/my-component.js
-    import Component from '@ember/component';
-
-    export default Component.extend({
-      init() {
-        this._super(...arguments);
-        let index = this.get('index');
-        this.set('elementId', 'component-id' + index);
-      }
-    });
-    ```
-
-    @property elementId
-    @type String
-    @public
-  */
-  elementId: null,
-
-  /**
-    Attempts to discover the element in the parent element. The default
-    implementation looks for an element with an ID of `elementId` (or the
-    view's guid if `elementId` is null). You can override this method to
-    provide your own form of lookup. For example, if you want to discover your
-    element using a CSS class name instead of an ID.
-
-    @method findElementInParentElement
-    @param {DOMElement} parentElement The parent's DOM element
-    @return {DOMElement} The discovered element
-    @private
-  */
-  findElementInParentElement(parentElem) {
-    let id = `#${this.elementId}`;
-    return jQuery(id)[0] || jQuery(id, parentElem)[0];
-  },
-
-  /**
-    Called when a view is going to insert an element into the DOM.
-
-    @event willInsertElement
-    @public
-  */
-  willInsertElement: K,
-
-  /**
-    Called when the element of the view has been inserted into the DOM.
-    Override this function to do any set up that requires an element
-    in the document body.
-
-    When a view has children, didInsertElement will be called on the
-    child view(s) first and on itself afterwards.
-
-    @event didInsertElement
-    @public
-  */
-  didInsertElement: K,
-
-  /**
-    Called when the view is about to rerender, but before anything has
-    been torn down. This is a good opportunity to tear down any manual
-    observers you have installed based on the DOM state
-
-    @event willClearRender
-    @public
-  */
-  willClearRender: K,
-
-  /**
-    You must call `destroy` on a view to destroy the view (and all of its
-    child views). This will remove the view from any parent node, then make
-    sure that the DOM element managed by the view can be released by the
-    memory manager.
-
-    @method destroy
-    @private
-  */
-  destroy() {
-    this._super(...arguments);
-    this._currentState.destroy(this);
-  },
-
-  /**
-    Called when the element of the view is going to be destroyed. Override
-    this function to do any teardown that requires an element, like removing
-    event listeners.
-
-    Please note: any property changes made during this event will have no
-    effect on object observers.
-
-    @event willDestroyElement
-    @public
-  */
-  willDestroyElement: K,
-
-  /**
-    Called when the parentView property has changed.
-
-    @event parentViewDidChange
-    @private
-  */
-  parentViewDidChange: K,
-
-  // ..........................................................
-  // STANDARD RENDER PROPERTIES
-  //
-
-  /**
-    Tag name for the view's outer element. The tag name is only used when an
-    element is first created. If you change the `tagName` for an element, you
-    must destroy and recreate the view element.
-
-    By default, the render buffer will use a `<div>` tag for views.
-
-    @property tagName
-    @type String
-    @default null
-    @public
-  */
-
-  // We leave this null by default so we can tell the difference between
-  // the default case and a user-specified tag.
-  tagName: null,
-
-  // .......................................................
-  // CORE DISPLAY METHODS
-  //
-
-  /**
-    Setup a view, but do not finish waking it up.
-
-    * configure `childViews`
-    * register the view with the global views hash, which is used for event
-      dispatch
-
-    @method init
-    @private
-  */
-  init() {
-    this._super(...arguments);
-
-    // tslint:disable-next-line:max-line-length
-    assert(
-      `You cannot use a computed property for the component's \`elementId\` (${this}).`,
-      descriptorFor(this, 'elementId') === undefined
-    );
-
-    // tslint:disable-next-line:max-line-length
-    assert(
-      `You cannot use a computed property for the component's \`tagName\` (${this}).`,
-      descriptorFor(this, 'tagName') === undefined
-    );
-
-    if (!this.elementId && this.tagName !== '') {
-      this.elementId = guidFor(this);
-    }
-
-    assert('Using a custom `.render` function is no longer supported.', !this.render);
-  },
-
-  // .......................................................
-  // EVENT HANDLING
-  //
-
-  /**
-    Handle events from `EventDispatcher`
-
-    @method handleEvent
-    @param eventName {String}
-    @param evt {Event}
-    @private
-  */
-  handleEvent(eventName, evt) {
-    return this._currentState.handleEvent(this, eventName, evt);
-  },
-});