discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-glimmer/lib/component-managers/root.js

@@ -1,74 +0,0 @@
-import { _instrumentStart } from '@ember/instrumentation';
-import { DEBUG } from '@glimmer/env';
-import { FACTORY_FOR } from 'container';
-import { DIRTY_TAG } from '../component';
-import ComponentStateBucket from '../utils/curly-component-state-bucket';
-import CurlyComponentManager, { initialRenderInstrumentDetails, processComponentInitializationAssertions, } from './curly';
-class RootComponentManager extends CurlyComponentManager {
-    constructor(component) {
-        super();
-        this.component = component;
-    }
-    getLayout(_state, resolver) {
-        const template = this.templateFor(this.component, resolver);
-        const layout = template.asWrappedLayout();
-        return {
-            handle: layout.compile(),
-            symbolTable: layout.symbolTable,
-        };
-    }
-    create(environment, _state, _args, dynamicScope) {
-        let component = this.component;
-        if (DEBUG) {
-            this._pushToDebugStack(component._debugContainerKey, environment);
-        }
-        let finalizer = _instrumentStart('render.component', initialRenderInstrumentDetails, component);
-        dynamicScope.view = component;
-        let hasWrappedElement = component.tagName !== '';
-        // We usually do this in the `didCreateElement`, but that hook doesn't fire for tagless components
-        if (!hasWrappedElement) {
-            if (environment.isInteractive) {
-                component.trigger('willRender');
-            }
-            component._transitionTo('hasElement');
-            if (environment.isInteractive) {
-                component.trigger('willInsertElement');
-            }
-        }
-        if (DEBUG) {
-            processComponentInitializationAssertions(component, {});
-        }
-        return new ComponentStateBucket(environment, component, null, finalizer, hasWrappedElement);
-    }
-}
-// ROOT is the top-level template it has nothing but one yield.
-// it is supposed to have a dummy element
-export const ROOT_CAPABILITIES = {
-    dynamicLayout: false,
-    dynamicTag: true,
-    prepareArgs: false,
-    createArgs: false,
-    attributeHook: true,
-    elementHook: true,
-    createCaller: true,
-    dynamicScope: true,
-    updateHook: true,
-    createInstance: false,
-};
-export class RootComponentDefinition {
-    constructor(component) {
-        this.component = component;
-        let manager = new RootComponentManager(component);
-        this.manager = manager;
-        let factory = FACTORY_FOR.get(component);
-        this.state = {
-            name: factory.fullName.slice(10),
-            capabilities: ROOT_CAPABILITIES,
-            ComponentClass: factory,
-            handle: null,
-        };
-    }
-    getTag({ component }) {
-        return component[DIRTY_TAG];
-    }
-}

data/dist/es/ember-glimmer/lib/component-managers/template-only.js

@@ -1,46 +0,0 @@
-import { CONSTANT_TAG } from '@glimmer/reference';
-import { NULL_REFERENCE, } from '@glimmer/runtime';
-import AbstractManager from './abstract';
-const CAPABILITIES = {
-    dynamicLayout: false,
-    dynamicTag: false,
-    prepareArgs: false,
-    createArgs: false,
-    attributeHook: false,
-    elementHook: false,
-    createCaller: true,
-    dynamicScope: true,
-    updateHook: true,
-    createInstance: true,
-};
-export default class TemplateOnlyComponentManager extends AbstractManager {
-    getLayout(template) {
-        const layout = template.asLayout();
-        return {
-            handle: layout.compile(),
-            symbolTable: layout.symbolTable,
-        };
-    }
-    getCapabilities() {
-        return CAPABILITIES;
-    }
-    create() {
-        return null;
-    }
-    getSelf() {
-        return NULL_REFERENCE;
-    }
-    getTag() {
-        return CONSTANT_TAG;
-    }
-    getDestructor() {
-        return null;
-    }
-}
-const MANAGER = new TemplateOnlyComponentManager();
-export class TemplateOnlyComponentDefinition {
-    constructor(state) {
-        this.state = state;
-        this.manager = MANAGER;
-    }
-}

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

@@ -1,633 +0,0 @@
-import { assert } from '@ember/debug';
-import { DirtyableTag } from '@glimmer/reference';
-import { normalizeProperty, SVG_NAMESPACE } from '@glimmer/runtime';
-import { get, PROPERTY_DID_CHANGE } from 'ember-metal';
-import { getOwner } from 'ember-owner';
-import { TargetActionSupport } from 'ember-runtime';
-import { symbol } from 'ember-utils';
-import { ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, getViewElement, ViewMixin, ViewStateSupport, } from 'ember-views';
-import { RootReference, UPDATE } from './utils/references';
-export const DIRTY_TAG = symbol('DIRTY_TAG');
-export const ARGS = symbol('ARGS');
-export const ROOT_REF = symbol('ROOT_REF');
-export const IS_DISPATCHING_ATTRS = symbol('IS_DISPATCHING_ATTRS');
-export const HAS_BLOCK = symbol('HAS_BLOCK');
-export const BOUNDS = symbol('BOUNDS');
-/**
-@module @ember/component
-*/
-/**
-  A `Component` is a view that is completely
-  isolated. Properties accessed in its templates go
-  to the view object and actions are targeted at
-  the view object. There is no access to the
-  surrounding context or outer controller; all
-  contextual information must be passed in.
-
-  The easiest way to create a `Component` is via
-  a template. If you name a template
-  `app/components/my-foo.hbs`, you will be able to use
-  `{{my-foo}}` in other templates, which will make
-  an instance of the isolated component.
-
-  ```app/components/my-foo.hbs
-  {{person-profile person=currentUser}}
-  ```
-
-  ```app/components/person-profile.hbs
-  <h1>{{person.title}}</h1>
-  <img src={{person.avatar}}>
-  <p class='signature'>{{person.signature}}</p>
-  ```
-
-  You can use `yield` inside a template to
-  include the **contents** of any block attached to
-  the component. The block will be executed in the
-  context of the surrounding context or outer controller:
-
-  ```handlebars
-  {{#person-profile person=currentUser}}
-    <p>Admin mode</p>
-    {{! Executed in the controller's context. }}
-  {{/person-profile}}
-  ```
-
-  ```app/components/person-profile.hbs
-  <h1>{{person.title}}</h1>
-  {{! Executed in the component's context. }}
-  {{yield}} {{! block contents }}
-  ```
-
-  If you want to customize the component, in order to
-  handle events or actions, you implement a subclass
-  of `Component` named after the name of the
-  component.
-
-  For example, you could implement the action
-  `hello` for the `person-profile` component:
-
-  ```app/components/person-profile.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    actions: {
-      hello(name) {
-        console.log("Hello", name);
-      }
-    }
-  });
-  ```
-
-  And then use it in the component's template:
-
-  ```app/templates/components/person-profile.hbs
-  <h1>{{person.title}}</h1>
-  {{yield}} <!-- block contents -->
-  <button {{action 'hello' person.name}}>
-    Say Hello to {{person.name}}
-  </button>
-  ```
-
-  Components must have a `-` in their name to avoid
-  conflicts with built-in controls that wrap HTML
-  elements. This is consistent with the same
-  requirement in web components.
-
-  ## HTML Tag
-
-  The default HTML tag name used for a component's DOM representation is `div`.
-  This can be customized by setting the `tagName` property.
-  The following component class:
-
-  ```app/components/emphasized-paragraph.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'em'
-  });
-  ```
-
-  Would result in instances with the following HTML:
-
-  ```html
-  <em id="ember1" class="ember-view"></em>
-  ```
-
-  ## HTML `class` Attribute
-
-  The HTML `class` attribute of a component's tag can be set by providing a
-  `classNames` property that is set to an array of strings:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNames: ['my-class', 'my-other-class']
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view my-class my-other-class"></div>
-  ```
-
-  `class` attribute values can also be set by providing a `classNameBindings`
-  property set to an array of properties names for the component. The return value
-  of these properties will be added as part of the value for the components's `class`
-  attribute. These properties can be computed properties:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-  import { computed } from '@ember/object';
-
-  export default Component.extend({
-    classNameBindings: ['propertyA', 'propertyB'],
-
-    propertyA: 'from-a',
-    propertyB: computed(function() {
-      if (someLogic) { return 'from-b'; }
-    })
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view from-a from-b"></div>
-  ```
-
-  If the value of a class name binding returns a boolean the property name
-  itself will be used as the class name if the property is true.
-  The class name will not be added if the value is `false` or `undefined`.
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNameBindings: ['hovered'],
-
-    hovered: true
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view hovered"></div>
-  ```
-
-  When using boolean class name bindings you can supply a string value other
-  than the property name for use as the `class` HTML attribute by appending the
-  preferred value after a ":" character when defining the binding:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNameBindings: ['awesome:so-very-cool'],
-
-    awesome: true
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view so-very-cool"></div>
-  ```
-
-  Boolean value class name bindings whose property names are in a
-  camelCase-style format will be converted to a dasherized format:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNameBindings: ['isUrgent'],
-
-    isUrgent: true
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view is-urgent"></div>
-  ```
-
-  Class name bindings can also refer to object values that are found by
-  traversing a path relative to the component itself:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-  import EmberObject from '@ember/object';
-
-  export default Component.extend({
-    classNameBindings: ['messages.empty'],
-
-    messages: EmberObject.create({
-      empty: true
-    })
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view empty"></div>
-  ```
-
-  If you want to add a class name for a property which evaluates to true and
-  and a different class name if it evaluates to false, you can pass a binding
-  like this:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    classNameBindings: ['isEnabled:enabled:disabled'],
-    isEnabled: true
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view enabled"></div>
-  ```
-
-  When isEnabled is `false`, the resulting HTML representation looks like
-  this:
-
-  ```html
-  <div id="ember1" class="ember-view disabled"></div>
-  ```
-
-  This syntax offers the convenience to add a class if a property is `false`:
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  // Applies no class when isEnabled is true and class 'disabled' when isEnabled is false
-  export default Component.extend({
-    classNameBindings: ['isEnabled::disabled'],
-    isEnabled: true
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view"></div>
-  ```
-
-  When the `isEnabled` property on the component is set to `false`, it will result
-  in component instances with an HTML representation of:
-
-  ```html
-  <div id="ember1" class="ember-view disabled"></div>
-  ```
-
-  Updates to the value of a class name binding will result in automatic
-  update of the  HTML `class` attribute in the component's rendered HTML
-  representation. If the value becomes `false` or `undefined` the class name
-  will be removed.
-  Both `classNames` and `classNameBindings` are concatenated properties. See
-  [EmberObject](/api/ember/release/classes/EmberObject) documentation for more
-  information about concatenated properties.
-
-  ## HTML Attributes
-
-  The HTML attribute section of a component's tag can be set by providing an
-  `attributeBindings` property set to an array of property names on the component.
-  The return value of these properties will be used as the value of the component's
-  HTML associated attribute:
-
-  ```app/components/my-anchor.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'a',
-    attributeBindings: ['href'],
-
-    href: 'http://google.com'
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <a id="ember1" class="ember-view" href="http://google.com"></a>
-  ```
-
-  One property can be mapped on to another by placing a ":" between
-  the source property and the destination property:
-
-  ```app/components/my-anchor.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'a',
-    attributeBindings: ['url:href'],
-
-    url: 'http://google.com'
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <a id="ember1" class="ember-view" href="http://google.com"></a>
-  ```
-
-  Namespaced attributes (e.g. `xlink:href`) are supported, but have to be
-  mapped, since `:` is not a valid character for properties in Javascript:
-
-  ```app/components/my-use.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'use',
-    attributeBindings: ['xlinkHref:xlink:href'],
-
-    xlinkHref: '#triangle'
-  });
-  ```
-
-  Will result in component instances with an HTML representation of:
-
-  ```html
-  <use xlink:href="#triangle"></use>
-  ```
-
-  If the return value of an `attributeBindings` monitored property is a boolean
-  the attribute will be present or absent depending on the value:
-
-  ```app/components/my-text-input.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'input',
-    attributeBindings: ['disabled'],
-
-    disabled: false
-  });
-  ```
-
-  Will result in a component instance with an HTML representation of:
-
-  ```html
-  <input id="ember1" class="ember-view" />
-  ```
-
-  `attributeBindings` can refer to computed properties:
-
-  ```app/components/my-text-input.js
-  import Component from '@ember/component';
-  import { computed } from '@ember/object';
-
-  export default Component.extend({
-    tagName: 'input',
-    attributeBindings: ['disabled'],
-
-    disabled: computed(function() {
-      if (someLogic) {
-        return true;
-      } else {
-        return false;
-      }
-    })
-  });
-  ```
-
-  To prevent setting an attribute altogether, use `null` or `undefined` as the
-  return value of the `attributeBindings` monitored property:
-
-  ```app/components/my-text-input.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    tagName: 'form',
-    attributeBindings: ['novalidate'],
-    novalidate: null
-  });
-  ```
-
-  Updates to the property of an attribute binding will result in automatic
-  update of the  HTML attribute in the component's rendered HTML representation.
-  `attributeBindings` is a concatenated property. See [EmberObject](/api/ember/release/classes/EmberObject)
-  documentation for more information about concatenated properties.
-
-  ## Layouts
-
-  See [Ember.Templates.helpers.yield](/api/ember/release/classes/Ember.Templates.helpers/methods/yield?anchor=yield)
-  for more information.
-
-  Layout can be used to wrap content in a component. In addition
-  to wrapping content in a Component's template, you can also use
-  the public layout API in your Component JavaScript.
-
-  ```app/templates/components/person-profile.hbs
-    <h1>Person's Title</h1>
-    <div class='details'>{{yield}}</div>
-  ```
-
-  ```app/components/person-profile.js
-    import Component from '@ember/component';
-    import layout from '../templates/components/person-profile';
-
-    export default Component.extend({
-      layout
-    });
-  ```
-
-  The above will result in the following HTML output:
-
-  ```html
-    <h1>Person's Title</h1>
-    <div class="details">
-      <h2>Chief Basket Weaver</h2>
-      <h3>Fisherman Industries</h3>
-    </div>
-  ```
-
-  ## Responding to Browser Events
-
-  Components can respond to user-initiated events in one of three ways: method
-  implementation, through an event manager, and through `{{action}}` helper use
-  in their template or layout.
-
-  ### Method Implementation
-
-  Components can respond to user-initiated events by implementing a method that
-  matches the event name. A `jQuery.Event` object will be passed as the
-  argument to this method.
-
-  ```app/components/my-widget.js
-  import Component from '@ember/component';
-
-  export default Component.extend({
-    click(event) {
-      // will be called when an instance's
-      // rendered element is clicked
-    }
-  });
-  ```
-
-  ### `{{action}}` Helper
-
-  See [Ember.Templates.helpers.action](/api/ember/release/classes/Ember.Templates.helpers/methods/yield?anchor=yield).
-
-  ### Event Names
-
-  All of the event handling approaches described above respond to the same set
-  of events. The names of the built-in events are listed below. (The hash of
-  built-in events exists in `Ember.EventDispatcher`.) Additional, custom events
-  can be registered by using `Application.customEvents`.
-
-  Touch events:
-
-  * `touchStart`
-  * `touchMove`
-  * `touchEnd`
-  * `touchCancel`
-
-  Keyboard events:
-
-  * `keyDown`
-  * `keyUp`
-  * `keyPress`
-
-  Mouse events:
-
-  * `mouseDown`
-  * `mouseUp`
-  * `contextMenu`
-  * `click`
-  * `doubleClick`
-  * `mouseMove`
-  * `focusIn`
-  * `focusOut`
-  * `mouseEnter`
-  * `mouseLeave`
-
-  Form events:
-
-  * `submit`
-  * `change`
-  * `focusIn`
-  * `focusOut`
-  * `input`
-
-  HTML5 drag and drop events:
-
-  * `dragStart`
-  * `drag`
-  * `dragEnter`
-  * `dragLeave`
-  * `dragOver`
-  * `dragEnd`
-  * `drop`
-
-  @class Component
-  @extends Ember.CoreView
-  @uses Ember.TargetActionSupport
-  @uses Ember.ClassNamesSupport
-  @uses Ember.ActionSupport
-  @uses Ember.ViewMixin
-  @uses Ember.ViewStateSupport
-  @public
-*/
-const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassNamesSupport, TargetActionSupport, ActionSupport, ViewMixin, {
-    isComponent: true,
-    init() {
-        this._super(...arguments);
-        this[IS_DISPATCHING_ATTRS] = false;
-        this[DIRTY_TAG] = DirtyableTag.create();
-        this[ROOT_REF] = new RootReference(this);
-        this[BOUNDS] = null;
-        // If in a tagless component, assert that no event handlers are defined
-        assert(
-        // tslint:disable-next-line:max-line-length
-        `You can not define a function that handles DOM events in the \`${this}\` tagless component since it doesn't have any DOM element.`, this.tagName !== '' ||
-            !this.renderer._destinedForDOM ||
-            !(() => {
-                let eventDispatcher = getOwner(this).lookup('event_dispatcher:main');
-                let events = (eventDispatcher && eventDispatcher._finalEvents) || {};
-                // tslint:disable-next-line:forin
-                for (let key in events) {
-                    let methodName = events[key];
-                    if (typeof this[methodName] === 'function') {
-                        return true; // indicate that the assertion should be triggered
-                    }
-                }
-                return false;
-            })());
-    },
-    rerender() {
-        this[DIRTY_TAG].inner.dirty();
-        this._super();
-    },
-    [PROPERTY_DID_CHANGE](key) {
-        if (this[IS_DISPATCHING_ATTRS]) {
-            return;
-        }
-        let args = this[ARGS];
-        let reference = args !== undefined ? args[key] : undefined;
-        if (reference !== undefined && reference[UPDATE] !== undefined) {
-            reference[UPDATE](get(this, key));
-        }
-    },
-    getAttr(key) {
-        // TODO Intimate API should be deprecated
-        return this.get(key);
-    },
-    /**
-      Normally, Ember's component model is "write-only". The component takes a
-      bunch of attributes that it got passed in, and uses them to render its
-      template.
-
-      One nice thing about this model is that if you try to set a value to the
-      same thing as last time, Ember (through HTMLBars) will avoid doing any
-      work on the DOM.
-
-      This is not just a performance optimization. If an attribute has not
-      changed, it is important not to clobber the element's "hidden state".
-      For example, if you set an input's `value` to the same value as before,
-      it will clobber selection state and cursor position. In other words,
-      setting an attribute is not **always** idempotent.
-
-      This method provides a way to read an element's attribute and also
-      update the last value Ember knows about at the same time. This makes
-      setting an attribute idempotent.
-
-      In particular, what this means is that if you get an `<input>` element's
-      `value` attribute and then re-render the template with the same value,
-      it will avoid clobbering the cursor and selection position.
-      Since most attribute sets are idempotent in the browser, you typically
-      can get away with reading attributes using jQuery, but the most reliable
-      way to do so is through this method.
-      @method readDOMAttr
-
-      @param {String} name the name of the attribute
-      @return String
-      @public
-     */
-    readDOMAttr(name) {
-        // TODO revisit this
-        let element = getViewElement(this);
-        let isSVG = element.namespaceURI === SVG_NAMESPACE;
-        let { type, normalized } = normalizeProperty(element, name);
-        if (isSVG || type === 'attr') {
-            return element.getAttribute(normalized);
-        }
-        return element[normalized];
-    },
-});
-Component.toString = () => '@ember/component';
-Component.reopenClass({
-    isComponentFactory: true,
-    positionalParams: [],
-});
-export default Component;