discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-glimmer/lib/components/text_area.js

@@ -1,236 +0,0 @@
-/**
-@module @ember/component
-*/
-import { TextSupport } from 'ember-views';
-import Component from '../component';
-import layout from '../templates/empty';
-/**
-  `{{textarea}}` inserts a new instance of `<textarea>` tag into the template.
-  The attributes of `{{textarea}}` match those of the native HTML tags as
-  closely as possible.
-
-  The following HTML attributes can be set:
-
-    * `value`
-    * `name`
-    * `rows`
-    * `cols`
-    * `placeholder`
-    * `disabled`
-    * `maxlength`
-    * `tabindex`
-    * `selectionEnd`
-    * `selectionStart`
-    * `autocomplete`
-    * `selectionDirection`
-    * `wrap`
-    * `readonly`
-    * `autofocus`
-    * `form`
-    * `spellcheck`
-    * `required`
-
-  When set to a quoted string, these value will be directly applied to the HTML
-  element. When left unquoted, these values will be bound to a property on the
-  template's current rendering context (most typically a controller instance).
-
-  Unbound:
-
-  ```handlebars
-  {{textarea value="Lots of static text that ISN'T bound"}}
-  ```
-
-  Would result in the following HTML:
-
-  ```html
-  <textarea class="ember-text-area">
-    Lots of static text that ISN'T bound
-  </textarea>
-  ```
-
-  Bound:
-
-  In the following example, the `writtenWords` property on the application
-  Controller will be updated live as the user types 'Lots of text that IS
-  bound' into the text area of their browser's window.
-
-  ```app/controllers/application.js
-  import Controller from '@ember/controller';
-
-  export default Controller.extend({
-    writtenWords: "Lots of text that IS bound"
-  });
-  ```
-
-  ```handlebars
-  {{textarea value=writtenWords}}
-  ```
-
-  Would result in the following HTML:
-
-  ```html
-  <textarea class="ember-text-area">
-    Lots of text that IS bound
-  </textarea>
-  ```
-
-  If you wanted a one way binding between the text area and a div tag
-  somewhere else on your screen, you could use `oneWay`:
-
-  ```app/controllers/application.js
-  import Controller from '@ember/controller';
-  import { oneWay } from '@ember/object/computed';
-
-  export default Controller.extend({
-    writtenWords: "Lots of text that IS bound",
-
-    outputWrittenWords: oneWay("writtenWords")
-  });
-  ```
-
-  ```handlebars
-  {{textarea value=writtenWords}}
-  <div>
-    {{outputWrittenWords}}
-  </div>
-  ```
-
-  Would result in the following HTML:
-
-  ```html
-  <textarea class="ember-text-area">
-    Lots of text that IS bound
-  </textarea>
-  <-- the following div will be updated in real time as you type -->
-  <div>
-    Lots of text that IS bound
-  </div>
-  ```
-
-  Finally, this example really shows the power and ease of Ember when two
-  properties are bound to eachother via `alias`. Type into
-  either text area box and they'll both stay in sync. Note that
-  `alias` costs more in terms of performance, so only use it when
-  your really binding in both directions:
-
-  ```app/controllers/application.js
-  import Controller from '@ember/controller';
-  import { alias } from '@ember/object/computed';
-
-  export default Controller.extend({
-    writtenWords: "Lots of text that IS bound",
-
-    twoWayWrittenWords: alias("writtenWords")
-  });
-  ```
-
-  ```handlebars
-  {{textarea value=writtenWords}}
-  {{textarea value=twoWayWrittenWords}}
-  ```
-
-  ```html
-  <textarea id="ember1" class="ember-text-area">
-    Lots of text that IS bound
-  </textarea>
-  <-- both updated in real time -->
-  <textarea id="ember2" class="ember-text-area">
-    Lots of text that IS bound
-  </textarea>
-  ```
-
-  ### Actions
-
-  The helper can send multiple actions based on user events.
-  The action property defines the action which is send when
-  the user presses the return key.
-
-  ```handlebars
-  {{input action="submit"}}
-  ```
-
-  The helper allows some user events to send actions.
-
-  * `enter`
-  * `insert-newline`
-  * `escape-press`
-  * `focus-in`
-  * `focus-out`
-  * `key-press`
-
-  For example, if you desire an action to be sent when the input is blurred,
-  you only need to setup the action name to the event name property.
-
-  ```handlebars
-  {{textarea focus-out="alertMessage"}}
-  ```
-
-  See more about [Text Support Actions](/api/ember/release/classes/TextArea)
-
-  ### Extension
-
-  Internally, `{{textarea}}` creates an instance of `TextArea`, passing
-  arguments from the helper to `TextArea`'s `create` method. You can
-  extend the capabilities of text areas in your application by reopening this
-  class. For example, if you are building a Bootstrap project where `data-*`
-  attributes are used, you can globally add support for a `data-*` attribute
-  on all `{{textarea}}`s' in your app by reopening `TextArea` or
-  `TextSupport` and adding it to the `attributeBindings` concatenated
-  property:
-
-  ```javascript
-  import TextArea from '@ember/component/text-area';
-
-  TextArea.reopen({
-    attributeBindings: ['data-error']
-  });
-  ```
-
-  Keep in mind when writing `TextArea` subclasses that `TextArea`
-  itself extends `Component`. Expect isolated component semantics, not
-  legacy 1.x view semantics (like `controller` being present).
-
-  See more about [Ember components](/api/ember/release/classes/Component)
-
-  @method textarea
-  @for Ember.Templates.helpers
-  @param {Hash} options
-  @public
-*/
-/**
-  The internal class used to create textarea element when the `{{textarea}}`
-  helper is used.
-
-  See [Ember.Templates.helpers.textarea](/api/ember/release/classes/Ember.Templates.helpers/methods/textarea?anchor=textarea)  for usage details.
-
-  ## Layout and LayoutName properties
-
-  Because HTML `textarea` elements do not contain inner HTML the `layout` and
-  `layoutName` properties will not be applied.
-
-  @class TextArea
-  @extends Component
-  @uses Ember.TextSupport
-  @public
-*/
-const TextArea = Component.extend(TextSupport, {
-    classNames: ['ember-text-area'],
-    layout,
-    tagName: 'textarea',
-    attributeBindings: [
-        'rows',
-        'cols',
-        'name',
-        'selectionEnd',
-        'selectionStart',
-        'autocomplete',
-        'wrap',
-        'lang',
-        'dir',
-        'value',
-    ],
-    rows: null,
-    cols: null,
-});
-TextArea.toString = () => '@ember/component/text-area';
-export default TextArea;

data/dist/es/ember-glimmer/lib/components/text_field.js

@@ -1,145 +0,0 @@
-/**
-@module @ember/component
-*/
-import { hasDOM } from 'ember-browser-environment';
-import { computed } from 'ember-metal';
-import { TextSupport } from 'ember-views';
-import Component from '../component';
-import layout from '../templates/empty';
-const inputTypes = Object.create(null);
-function canSetTypeOfInput(type) {
-    if (type in inputTypes) {
-        return inputTypes[type];
-    }
-    // if running in outside of a browser always return the
-    // original type
-    if (!hasDOM) {
-        inputTypes[type] = type;
-        return type;
-    }
-    let inputTypeTestElement = document.createElement('input');
-    try {
-        inputTypeTestElement.type = type;
-    }
-    catch (e) {
-        // ignored
-    }
-    return (inputTypes[type] = inputTypeTestElement.type === type);
-}
-/**
-
-  The internal class used to create text inputs when the `{{input}}`
-  helper is used with `type` of `text`.
-
-  See [Ember.Templates.helpers.input](/api/ember/release/classes/Ember.Templates.helpers/methods/input?anchor=input)  for usage details.
-
-  ## Layout and LayoutName properties
-
-  Because HTML `input` elements are self closing `layout` and `layoutName`
-  properties will not be applied.
-
-  @class TextField
-  @extends Component
-  @uses Ember.TextSupport
-  @public
-*/
-const TextField = Component.extend(TextSupport, {
-    layout,
-    classNames: ['ember-text-field'],
-    tagName: 'input',
-    attributeBindings: [
-        'accept',
-        'autocomplete',
-        'autosave',
-        'dir',
-        'formaction',
-        'formenctype',
-        'formmethod',
-        'formnovalidate',
-        'formtarget',
-        'height',
-        'inputmode',
-        'lang',
-        'list',
-        'type',
-        'max',
-        'min',
-        'multiple',
-        'name',
-        'pattern',
-        'size',
-        'step',
-        'value',
-        'width',
-    ],
-    /**
-      The `value` attribute of the input element. As the user inputs text, this
-      property is updated live.
-  
-      @property value
-      @type String
-      @default ""
-      @public
-    */
-    value: '',
-    /**
-      The `type` attribute of the input element.
-  
-      @property type
-      @type String
-      @default "text"
-      @public
-    */
-    type: computed({
-        get() {
-            return 'text';
-        },
-        set(_key, value) {
-            let type = 'text';
-            if (canSetTypeOfInput(value)) {
-                type = value;
-            }
-            return type;
-        },
-    }),
-    /**
-      The `size` of the text field in characters.
-  
-      @property size
-      @type String
-      @default null
-      @public
-    */
-    size: null,
-    /**
-      The `pattern` attribute of input element.
-  
-      @property pattern
-      @type String
-      @default null
-      @public
-    */
-    pattern: null,
-    /**
-      The `min` attribute of input element used with `type="number"` or `type="range"`.
-  
-      @property min
-      @type String
-      @default null
-      @since 1.4.0
-      @public
-    */
-    min: null,
-    /**
-      The `max` attribute of input element used with `type="number"` or `type="range"`.
-  
-      @property max
-      @type String
-      @default null
-      @since 1.4.0
-      @public
-    */
-    max: null,
-});
-TextField.toString = () => '@ember/component/text-field';
-export default TextField;

data/dist/es/ember-glimmer/lib/dom.js

@@ -1,3 +0,0 @@
-///<reference path="./simple-dom.d.ts" />
-export { DOMChanges, DOMTreeConstruction, clientBuilder, rehydrationBuilder, } from '@glimmer/runtime';
-export { NodeDOMTreeConstruction, serializeBuilder } from '@glimmer/node';

data/dist/es/ember-glimmer/lib/environment.js

@@ -1,102 +0,0 @@
-import { warn } from '@ember/debug';
-import { DEBUG } from '@glimmer/env';
-import { Environment as GlimmerEnvironment, SimpleDynamicAttribute, } from '@glimmer/runtime';
-import { OWNER } from 'ember-owner';
-import { constructStyleDeprecationMessage, lookupComponent } from 'ember-views';
-import DebugStack from './utils/debug-stack';
-import createIterable from './utils/iterable';
-import { ConditionalReference } from './utils/references';
-import { isHTMLSafe } from './utils/string';
-import installPlatformSpecificProtocolForURL from './protocol-for-url';
-export default class Environment extends GlimmerEnvironment {
-    constructor(injections) {
-        super(injections);
-        this.inTransaction = false;
-        this.owner = injections[OWNER];
-        this.isInteractive = this.owner.lookup('-environment:main').isInteractive;
-        // can be removed once https://github.com/tildeio/glimmer/pull/305 lands
-        this.destroyedComponents = [];
-        installPlatformSpecificProtocolForURL(this);
-        if (DEBUG) {
-            this.debugStack = new DebugStack();
-        }
-    }
-    static create(options) {
-        return new this(options);
-    }
-    // this gets clobbered by installPlatformSpecificProtocolForURL
-    // it really should just delegate to a platform specific injection
-    protocolForURL(s) {
-        return s;
-    }
-    lookupComponent(name, meta) {
-        return lookupComponent(meta.owner, name, meta);
-    }
-    toConditionalReference(reference) {
-        return ConditionalReference.create(reference);
-    }
-    iterableFor(ref, key) {
-        return createIterable(ref, key);
-    }
-    scheduleInstallModifier(modifier, manager) {
-        if (this.isInteractive) {
-            super.scheduleInstallModifier(modifier, manager);
-        }
-    }
-    scheduleUpdateModifier(modifier, manager) {
-        if (this.isInteractive) {
-            super.scheduleUpdateModifier(modifier, manager);
-        }
-    }
-    didDestroy(destroyable) {
-        destroyable.destroy();
-    }
-    begin() {
-        this.inTransaction = true;
-        super.begin();
-    }
-    commit() {
-        let destroyedComponents = this.destroyedComponents;
-        this.destroyedComponents = [];
-        // components queued for destruction must be destroyed before firing
-        // `didCreate` to prevent errors when removing and adding a component
-        // with the same name (would throw an error when added to view registry)
-        for (let i = 0; i < destroyedComponents.length; i++) {
-            destroyedComponents[i].destroy();
-        }
-        try {
-            super.commit();
-        }
-        finally {
-            this.inTransaction = false;
-        }
-    }
-}
-if (DEBUG) {
-    class StyleAttributeManager extends SimpleDynamicAttribute {
-        set(dom, value, env) {
-            warn(constructStyleDeprecationMessage(value), (() => {
-                if (value === null || value === undefined || isHTMLSafe(value)) {
-                    return true;
-                }
-                return false;
-            })(), { id: 'ember-htmlbars.style-xss-warning' });
-            super.set(dom, value, env);
-        }
-        update(value, env) {
-            warn(constructStyleDeprecationMessage(value), (() => {
-                if (value === null || value === undefined || isHTMLSafe(value)) {
-                    return true;
-                }
-                return false;
-            })(), { id: 'ember-htmlbars.style-xss-warning' });
-            super.update(value, env);
-        }
-    }
-    Environment.prototype.attributeFor = function (element, attribute, isTrusting, namespace) {
-        if (attribute === 'style' && !isTrusting) {
-            return new StyleAttributeManager({ element, name: attribute, namespace });
-        }
-        return GlimmerEnvironment.prototype.attributeFor.call(this, element, attribute, isTrusting, namespace);
-    };
-}