Class Component

public
import Component from '@ember/component';

A component is a reusable UI element that consists of a .hbs template and an optional JavaScript class that defines its behavior. For example, someone might make a button in the template and handle the click behavior in the JavaScript file that shares the same name as the template.

Components are broken down into two categories:

  • Components without JavaScript, that are based only on a template. These are called Template-only or TO components.
  • Components with JavaScript, which consist of a template and a backing class.

Ember ships with two types of JavaScript classes for components:

  1. Glimmer components, imported from @glimmer/component, which are the default component's for Ember Octane (3.15) and more recent editions.
  2. Classic components, imported from @ember/component, which were the default for older editions of Ember (pre 3.15).

Below is the documentation for Classic components. If you are looking for the API documentation for Template-only or Glimmer components, it is available here.

Defining a Classic Component

If you want to customize the component in order to handle events, transform arguments or maintain internal state, you implement a subclass of Component.

One example is to add computed properties to your component:

app/components/person-profile.js
import Component from '@ember/component';

export default Component.extend({
  displayName: computed('person.title', 'person.firstName', 'person.lastName', function() {
    let { title, firstName, lastName } = this.person;

    if (title) {
      return `${title} ${lastName}`;
    } else {
      return `${firstName} ${lastName}`;
    }
  })
});

And then use it in the component's template:

app/templates/components/person-profile.hbs
<h1>{{this.displayName}}</h1>
{{yield}}

Customizing a Classic Component's HTML Element in JavaScript

HTML Tag

The default HTML tag name used for a component's HTML representation is div. This can be customized by setting the tagName property.

Consider the following component class:

app/components/emphasized-paragraph.js
import Component from '@ember/component';

export default Component.extend({
  tagName: 'em'
});

When invoked, this component would produce output that looks something like this:

<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']
});

Invoking this component will produce output that looks like this:

<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({
  classNames: ['my-class', 'my-other-class'],
  classNameBindings: ['propertyA', 'propertyB'],

  propertyA: 'from-a',
  propertyB: computed(function() {
    if (someLogic) { return 'from-b'; }
  })
});

Invoking this component will produce HTML that looks like:

<div id="ember1" class="ember-view my-class my-other-class from-a from-b"></div>

Note that classNames and classNameBindings is in addition to the class attribute passed with the angle bracket invocation syntax. Therefore, if this component was invoked like so:

<MyWidget class="from-invocation" />

The resulting HTML will look similar to this:

<div id="ember1" class="from-invocation ember-view my-class my-other-class 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
});

Invoking this component will produce HTML that looks like:

<div id="ember1" class="ember-view hovered"></div>

Custom Class Names for Boolean Values

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
});

Invoking this component will produce HTML that looks like:

<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
});

Invoking this component will produce HTML that looks like:

<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
  })
});

Invoking this component will produce HTML that looks like:

<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
});

Invoking this component will produce HTML that looks like:

<div id="ember1" class="ember-view enabled"></div>

When isEnabled is false, the resulting HTML representation looks like this:

<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
});

Invoking this component when the isEnabled property is true will produce HTML that looks like:

<div id="ember1" class="ember-view"></div>

Invoking it when the isEnabled property on the component is false will produce HTML that looks like:

<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 documentation for more information about concatenated properties.

Other 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'
});

Invoking this component will produce HTML that looks like:

<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'
});

Invoking this component will produce HTML that looks like:

<a id="ember1" class="ember-view" href="http://google.com"></a>

HTML attributes passed with angle bracket invocations will take precedence over those specified in attributeBindings. Therefore, if this component was invoked like so:

<MyAnchor href="http://bing.com" @url="http://google.com" />

The resulting HTML will looks like this:

<a id="ember1" class="ember-view" href="http://bing.com"></a>

Note that the href attribute is ultimately set to http://bing.com, despite it having attribute binidng to the url property, which was set to http://google.com.

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'
});

Invoking this component will produce HTML that looks like:

<use xlink:href="#triangle"></use>

If the value of a property monitored by attributeBindings 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
});

Invoking this component will produce HTML that looks like:

<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 value of the property used in attributeBindings:

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 HTML output.

attributeBindings is a concatenated property. See EmberObject documentation for more information about concatenated properties.

Layouts

The layout property can be used to dynamically specify a template associated with a component class, instead of relying on Ember to link together a component class and a template based on file names.

In general, applications should not use this feature, but it's commonly used in addons for historical reasons.

The layout property should be set to the default export of a template module, which is the name of a template file without the .hbs extension.

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
  });

If you invoke the component:

<PersonProfile>
  <h2>Chief Basket Weaver</h2>
  <h3>Fisherman Industries</h3>
</PersonProfile>

or

{{#person-profile}}
  <h2>Chief Basket Weaver</h2>
  <h3>Fisherman Industries</h3>
{{/person-profile}}

It will result in the following HTML output:

<h1>Person's Title</h1>
  <div class="details">
  <h2>Chief Basket Weaver</h2>
  <h3>Fisherman Industries</h3>
</div>

Handling Browser Events

There are two ways to handle user-initiated events:

Using the on modifier to capture browser events

In a component's template, you can attach an event handler to any element with the on modifier:

<button {{on 'click' this.doSomething}} />

This will call the function on your component:

import Component from '@ember/component';

export default class ExampleComponent extends Component {
  doSomething = (event) => {
    // `event` is the native click Event
    console.log('clicked on the button');
  };
});

See the Guide on Component event handlers and the API docs for on for more details.

Event Handler Methods

Components can also respond to user-initiated events by implementing a method that matches the event name. This approach is appropriate when the same event should be handled by all instances of the same component.

An event object will be passed as the argument to the event handler method.

app/components/my-widget.js
import Component from '@ember/component';

export default Component.extend({
  click(event) {
    // `event.target` is either the component's element or one of its children
    let tag = event.target.tagName.toLowerCase();
    console.log('clicked on a `<${tag}>` HTML element!');
  }
});

In this example, whenever the user clicked anywhere inside the component, it will log a message to the console.

It is possible to handle event types other than click by implementing the following event handler methods. In addition, 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
  • focusIn
  • focusOut

Form events:

  • submit
  • change
  • focusIn
  • focusOut
  • input

Drag and drop events:

  • dragStart
  • drag
  • dragEnter
  • dragLeave
  • dragOver
  • dragEnd
  • drop

Show:

The collection of functions, keyed by name, available on this ActionHandler as action targets.

These functions will be invoked when a matching {{action}} is triggered from within a template and the application's current route is this route.

Actions can also be invoked from other parts of your application via ActionHandler#send.

The actions hash will inherit action handlers from the actions hash defined on extended parent classes or mixins rather than just replace the entire hash, e.g.:

app/mixins/can-display-banner.js
import Mixin from '@ember/object/mixin';

export default Mixin.create({
  actions: {
    displayBanner(msg) {
      // ...
    }
  }
});
app/routes/welcome.js
import Route from '@ember/routing/route';
import CanDisplayBanner from '../mixins/can-display-banner';

export default Route.extend(CanDisplayBanner, {
  actions: {
    playMusic() {
      // ...
    }
  }
});

// `WelcomeRoute`, when active, will be able to respond
// to both actions, since the actions hash is merged rather
// then replaced when extending mixins / parent classes.
this.send('displayBanner');
this.send('playMusic');

Within a Controller, Route or Component's action handler, the value of the this context is the Controller, Route or Component object:

app/routes/song.js
import Route from '@ember/routing/route';

export default Route.extend({
  actions: {
    myAction() {
      this.controllerFor("song");
      this.transitionTo("other.route");
      ...
    }
  }
});

It is also possible to call this._super(...arguments) from within an action handler if it overrides a handler defined on a parent class or mixin:

Take for example the following routes:

app/mixins/debug-route.js
import Mixin from '@ember/object/mixin';

export default Mixin.create({
  actions: {
    debugRouteInformation() {
      console.debug("It's a-me, console.debug!");
    }
  }
});
app/routes/annoying-debug.js
import Route from '@ember/routing/route';
import DebugRoute from '../mixins/debug-route';

export default Route.extend(DebugRoute, {
  actions: {
    debugRouteInformation() {
      // also call the debugRouteInformation of mixed in DebugRoute
      this._super(...arguments);

      // show additional annoyance
      window.alert(...);
    }
  }
});

Bubbling

By default, an action will stop bubbling once a handler defined on the actions hash handles it. To continue bubbling the action, you must return true from the handler:

app/router.js
Router.map(function() {
  this.route("album", function() {
    this.route("song");
  });
});
app/routes/album.js
import Route from '@ember/routing/route';

export default Route.extend({
  actions: {
    startPlaying: function() {
    }
  }
});
app/routes/album-song.js
import Route from '@ember/routing/route';

export default Route.extend({
  actions: {
    startPlaying() {
      // ...

      if (actionShouldAlsoBeTriggeredOnParentRoute) {
        return true;
      }
    }
  }
});

The WAI-ARIA role of the control represented by this view. For example, a button may have a role of type 'button', or a pane may have a role of type 'alertdialog'. This property is used by assistive software to help visually challenged users navigate rich web applications.

The full list of valid WAI-ARIA roles is available at: https://www.w3.org/TR/wai-aria/#roles_categorization

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.

A list of properties of the view to apply as class names. If the property is a string value, the value of that string will be applied as a class name.

// Applies the 'high' class to the view element
import Component from '@ember/component';
Component.extend({
  classNameBindings: ['priority'],
  priority: 'high'
});

If the value of the property is a Boolean, the name of that property is added as a dasherized class name.

// Applies the 'is-urgent' class to the view element
import Component from '@ember/component';
Component.extend({
  classNameBindings: ['isUrgent'],
  isUrgent: true
});

If you would prefer to use a custom value instead of the dasherized property name, you can pass a binding like this:

// Applies the 'urgent' class to the view element
import Component from '@ember/component';
Component.extend({
  classNameBindings: ['isUrgent:urgent'],
  isUrgent: true
});

If you would like to specify a class that should only be added when the property is false, you can declare a binding like this:

// Applies the 'disabled' class to the view element
import Component from '@ember/component';
Component.extend({
  classNameBindings: ['isEnabled::disabled'],
  isEnabled: false
});

This list of properties is inherited from the component's superclasses as well.

Standard CSS class names to apply to the view's outer element. This property automatically inherits any class names defined by the view's superclasses as well.

Defines the properties that will be concatenated from the superclass (instead of overridden).

By default, when you extend an Ember class a property defined in the subclass overrides a property with the same name that is defined in the superclass. However, there are some cases where it is preferable to build up a property's value by combining the superclass' property value with the subclass' value. An example of this in use within Ember is the classNames property of Component from @ember/component.

Here is some sample code showing the difference between a concatenated property and a normal one:

import EmberObject from '@ember/object';

const Bar = EmberObject.extend({
  // Configure which properties to concatenate
  concatenatedProperties: ['concatenatedProperty'],

  someNonConcatenatedProperty: ['bar'],
  concatenatedProperty: ['bar']
});

const FooBar = Bar.extend({
  someNonConcatenatedProperty: ['foo'],
  concatenatedProperty: ['foo']
});

let fooBar = FooBar.create();
fooBar.get('someNonConcatenatedProperty'); // ['foo']
fooBar.get('concatenatedProperty'); // ['bar', 'foo']

This behavior extends to object creation as well. Continuing the above example:

let fooBar = FooBar.create({
  someNonConcatenatedProperty: ['baz'],
  concatenatedProperty: ['baz']
})
fooBar.get('someNonConcatenatedProperty'); // ['baz']
fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']

Adding a single property that is not an array will just add it in the array:

let fooBar = FooBar.create({
  concatenatedProperty: 'baz'
})
view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']

Using the concatenatedProperties property, we can tell Ember to mix the content of the properties.

In Component the classNames, classNameBindings and attributeBindings properties are concatenated.

This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual concatenated property (to not mislead your users to think they can override the property in a subclass).

Returns the current DOM element for the view.

The HTML id of the component's element in the DOM. You can provide this value yourself but it must be unique (just as in HTML):

{{my-component elementId="a-really-cool-id"}}
<MyComponent @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:

export default Component.extend({
  init() {
    this._super(...arguments);

    var index = this.get('index');
    this.set('elementId', `component-id${index}`);
  }
});

Destroyed object property flag.

if this property is true the observers and bindings were already removed by the effect of calling the destroy() method.

Destruction scheduled flag. The destroy() method has been called.

The object stays intact until the end of the run loop at which point the isDestroyed flag is set.

Layout can be used to wrap content in a component.

Defines the properties that will be merged from the superclass (instead of overridden).

By default, when you extend an Ember class a property defined in the subclass overrides a property with the same name that is defined in the superclass. However, there are some cases where it is preferable to build up a property's value by merging the superclass property value with the subclass property's value. An example of this in use within Ember is the queryParams property of routes.

Here is some sample code showing the difference between a merged property and a normal one:

import EmberObject from '@ember/object';

const Bar = EmberObject.extend({
  // Configure which properties are to be merged
  mergedProperties: ['mergedProperty'],

  someNonMergedProperty: {
    nonMerged: 'superclass value of nonMerged'
  },
  mergedProperty: {
    page: { replace: false },
    limit: { replace: true }
  }
});

const FooBar = Bar.extend({
  someNonMergedProperty: {
    completelyNonMerged: 'subclass value of nonMerged'
  },
  mergedProperty: {
    limit: { replace: false }
  }
});

let fooBar = FooBar.create();

fooBar.get('someNonMergedProperty');
// => { completelyNonMerged: 'subclass value of nonMerged' }
//
// Note the entire object, including the nonMerged property of
// the superclass object, has been replaced

fooBar.get('mergedProperty');
// => {
//   page: {replace: false},
//   limit: {replace: false}
// }
//
// Note the page remains from the superclass, and the
// `limit` property's value of `false` has been merged from
// the subclass.

This behavior is not available during object create calls. It is only available at extend time.

In Route the queryParams property is merged.

This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual merged property (to not mislead your users to think they can override the property in a subclass).

Available since v1.13.0

Enables components to take a list of parameters as arguments. For example, a component that takes two parameters with the names name and age:

app/components/my-component.js
 import Component from '@ember/component';

 let MyComponent = Component.extend();

 MyComponent.reopenClass({
   positionalParams: ['name', 'age']
 });

 export default MyComponent;

It can then be invoked like this:

 {{my-component "John" 38}}

The parameters can be referred to just like named parameters:

 Name: {{name}}, Age: {{age}}.

Using a string instead of an array allows for an arbitrary number of parameters:

app/components/my-component.js
 import Component from '@ember/component';

 let MyComponent = Component.extend();

 MyComponent.reopenClass({
   positionalParams: 'names'
 });

 export default MyComponent;

It can then be invoked like this:

 {{my-component "John" "Michael" "Scott"}}

The parameters can then be referred to by enumerating over the list:

 {{#each names as |name|}}{{name}}{{/each}}

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.

If the tagName is '', the view will be tagless, with no outer element. Component properties that depend on the presence of an outer element, such as classNameBindings and attributeBindings, do not work with tagless components. Tagless components cannot implement methods to handle events, and their element property has a null value.