> Currently, the Edge browser has a serious performance problem with its Promise implementation. This deficiency can greatly increase startup time of your app. If you are targeting the Edge browser, it is highly recommended that you use the [bluebird promise](http://bluebirdjs.com/docs/getting-started.html) library to replace Edge's native implementation. You can do this by simply referencing the library prior to loading system.js.
UI components consist of two parts: a view-model and a view. Simply create each part in its own file. Use the same file name but different file extensions for the two parts. For example: _hello${context.language.fileExtension}_ and _hello.html_.
1.`constructor()` - The view-model's constructor is called first.
2.`created(owningView: View, myView: View)` - If the view-model implements the `created` callback it is invoked next. At this point in time, the view has also been created and both the view-model and the view are connected to their controller. The created callback will receive the instance of the "owningView". This is the view that the component is declared inside of. If the component itself has a view, this will be passed second.
3.`bind(bindingContext: Object, overrideContext: Object)` - Databinding is then activated on the view and view-model. If the view-model has a `bind` callback, it will be invoked at this time. The "binding context" to which the component is being bound will be passed first. An "override context" will be passed second. The override context contains information used to traverse the parent hierarchy and can also be used to add any contextual properties that the component wants to add. It should be noted that when the view-model has implemented the `bind` callback, the databinding framework will not invoke the changed handlers for the view-model's bindable properties until the "next" time those properties are updated. If you need to perform specific post-processing on your bindable properties, when implementing the `bind` callback, you should do so manually within the callback itself.
4.`attached()` - Next, the component is attached to the DOM (in document). If the view-model has an `attached` callback, it will be invoked at this time.
5.`detached()` - At some point in the future, the component may be removed from the DOM. If/When this happens, and if the view-model has a `detached` callback, this is when it will be invoked.
6.`unbind()` - After a component is detached, it's usually unbound. If your view-model has the `unbind` callback, it will be invoked during this process.
> Info: Invalid Table Structure When Dynamically Creating Tables
> When the browser loads in the template it very helpfully validates the structure of the HTML, notices that you have an invalid tag inside your table definition, and very unhelpfully removes it for you before Aurelia even has a chance to examine your template.
Use of the `as-element` attribute ensures we have a valid HTML table structure at load time, yet we tell Aurelia to treat its contents as though it were a different tag.
<code-listingheading="Compose an existing object instance with a view.">
<source-codelang="HTML">
<template>
<table>
<trrepeat.for="r of ['A','B','A','B']"as-element="compose"view='./template_${r}.html'>
</table>
<template>
</source-code>
</code-listing>
For the above example we can then programmatically choose the embedded template based on an element of our data:
<code-listingheading="template_A.html">
<source-codelang="HTML">
<template>
<td>I'm an A Row</td><td>Col 2A</td><td>Col 3A</td>
</template>
</source-code>
</code-listing>
<code-listingheading="template_B.html">
<source-codelang="HTML">
<template>
<td>I'm an B Row</td><td>Col 2B</td><td>Col 3B</td>
</template>
</source-code>
</code-listing>
Note that when a `containerless` attribute is used, the container is stripped *after* the browser has loaded the DOM elements, and as such this method cannot be used to transform non-HTML compliant structures into compliant ones!
<code-listingheading="Illegal Table Code">
<source-codelang="HTML">
<template>
<table>
<templaterepeat.for="customer of customers">
<tr>
<td>${customer.fullName}</td>
</tr>
</template>
</table>
</template>
</source-code>
</code-listing>
<code-listingheading="Correct Table Code">
<source-codelang="HTML">
<template>
<table>
<trrepeat.for="customer of customers">
<td>${customer.fullName}</td>
</tr>
</table>
</template>
</source-code>
</code-listing>
<code-listingheading="Illegal Select Code">
<source-codelang="HTML">
<template>
<select>
<templaterepeat.for="customer of customers">
<option>...</option>
</template>
</select>
</template>
</source-code>
</code-listing>
<code-listingheading="Correct Select Code">
<source-codelang="HTML">
<template>
<select>
<optionrepeat.for="customer of customers">...</option>
*`.bind` - Uses the default binding. One-way binding for everything but form controls, which use two-way binding.
*`.one-way` - Flows data one direction: from the view-model to the view.
*`.two-way` - Flows data both ways: from view-model to view and from view to view-model.
*`.one-time` - Renders data once, but does not synchronize changes after the initial render.
<code-listingheading="Data Binding Examples">
<source-codelang="HTML">
<template>
<inputtype="text"value.bind="firstName">
<inputtype="text"value.two-way="lastName">
<ahref.one-way="profileUrl">View Profile</a>
</template>
</source-code>
</code-listing>
> Info
> At the moment inheritance of bindables is not supported. For use cases where `class B extends A` and `B` is used as custom Element/Attribute `@bindable` properties cannot be defined only on `class A`. If inheritance is used, `@bindable` properties should be defined on the instantiated class.
### delegate, trigger
Use on any native or custom DOM event. (Do not include the "on" prefix in the event name.)
*`.trigger` - Attaches an event handler directly to the element. When the event fires, the expression will be invoked.
*`.delegate` - Attaches a single event handler to the document (or nearest shadow DOM boundary) which handles all events of the specified type, properly dispatching them back to their original targets for invocation of the associated expression.
> Info
> The `$event` value can be passed as an argument to a `delegate` or `trigger` function call if you need to access the event object.
A typical select element is rendered using a combination of `value.bind` and `repeat`. You can also bind to arrays of objects and synchronize based on an id (or similar) property.
<code-listingheading="Basic Select">
<source-codelang="HTML">
<template>
<selectvalue.bind="favoriteColor">
<option>Select A Color</option>
<optionrepeat.for="color of colors"value.bind="color">${color}</option>
</select>
</template>
</source-code>
</code-listing>
<code-listingheading="Select with Object Array">
<source-codelang="HTML">
<template>
<selectvalue.bind="employeeOfTheMonth">
<option>Select An Employee</option>
<optionrepeat.for="employee of employees"model.bind="employee">${employee.fullName}</option>
</select>
</template>
</source-code>
</code-listing>
<code-listingheading="Select with Object Id Sync">
<source-codelang="HTML">
<template>
<selectvalue.bind="employeeOfTheMonthId">
<option>Select An Employee</option>
<optionrepeat.for="employee of employees"model.bind="employee.id">${employee.fullName}</option>
</select>
</template>
</source-code>
</code-listing>
<code-listingheading="Basic Multi-Select">
<source-codelang="HTML">
<template>
<selectvalue.bind="favoriteColors"multiple>
<optionrepeat.for="color of colors"value.bind="color">${color}</option>
</select>
</template>
</source-code>
</code-listing>
<code-listingheading="Multi-Select with Object Array">
<source-codelang="HTML">
<template>
<selectvalue.bind="favoriteEmployees"multiple>
<optionrepeat.for="employee of employees"model.bind="employee">${employee.fullName}</option>
> Always use HTML sanitization. We provide a simple converter that can be used. You are encouraged to use a more complete HTML sanitizer such as [sanitize-html](https://www.npmjs.com/package/sanitize-html).
> Warning
> Binding using the `innerhtml` attribute simply sets the element's `innerHTML` property. The markup does not pass through Aurelia's templating system. Binding expressions and require elements will not be evaluated.
You can bind a css string or object to an element's `style` attribute. Use the `style` attribute's alias, `css` when doing string interpolation to ensure your application is compatible with Internet Explorer.
<code-listingheading="Conditionally displays an HTML element.">
<source-codelang="HTML">
<template>
<divshow.bind="isSaving"class="spinner"></div>
</template>
</source-code>
</code-listing>
<code-listingheading="Conditionally add/remove an HTML element.">
<source-codelang="HTML">
<template>
<divif.bind="isSaving"class="spinner"></div>
</template>
</source-code>
</code-listing>
<code-listingheading="Conditionally add/remove a group of elements.">
<source-codelang="HTML">
<template>
<inputvalue.bind="firstName">
<templateif.bind="hasErrors">
<iclass="icon error"></i>
${errorMessage}
</template>
</template>
</source-code>
</code-listing>
<code-listingheading="Render an array with a template.">
<source-codelang="HTML">
<template>
<ul>
<lirepeat.for="customer of customers">${customer.fullName}</li>
</ul>
</template>
</source-code>
</code-listing>
<code-listingheading="Render a map with a template.">
<source-codelang="HTML">
<template>
<ul>
<lirepeat.for="[id, customer] of customers">${id} ${customer.fullName}</li>
</ul>
</template>
</source-code>
</code-listing>
<code-listingheading="Render a template N times.">
<source-codelang="HTML">
<template>
<ul>
<lirepeat.for="i of rating">*</li>
</ul>
</template>
</source-code>
</code-listing>
Contextual items available inside a repeat template:
*`$index` - The index of the item in the array.
*`$first` - True if the item is the first item in the array.
*`$last` - True if the item is the last item in the array.
*`$even` - True if the item has an even numbered index.
*`$odd` - True if the item has an odd numbered index.
> Info: Containerless Template Controllers
> The `if` and `repeat` attributes are usually placed on the HTML elements that they affect. However, you can also use a `template` tag to group a collection of elements that don't have a parent element and place the `if` or `repeat` on the `template` element instead.
<code-listingheading="Dynamically render UI into the DOM based on data.">
- ie 'users/:id/detail' - Matches the string and then parses an `id` parameter. Your view-model's `activate` callback will be called with an object that has an `id` property set to the value that was extracted from the url.
* wildcard routes
- ie 'files*path' - Matches the string and then anything that follows it. Your view-model's `activate` callback will be called with an object that has a `path` property set to the wildcard's value.
### The Route Screen Activation Lifecycle
*`canActivate(params, routeConfig, navigationInstruction)` - Implement this hook if you want to control whether or not your view-model _can be navigated to_. Return a boolean value, a promise for a boolean value, or a navigation command.
*`activate(params, routeConfig, navigationInstruction)` - Implement this hook if you want to perform custom logic just before your view-model is displayed. You can optionally return a promise to tell the router to wait to bind and attach the view until after you finish your work.
*`canDeactivate()` - Implement this hook if you want to control whether or not the router _can navigate away_ from your view-model when moving to a new route. Return a boolean value, a promise for a boolean value, or a navigation command.
*`deactivate()` - Implement this hook if you want to perform custom logic when your view-model is being navigated away from. You can optionally return a promise to tell the router to wait until after you finish your work.
> Warning: Root Screen Activation
> Unlike the mapped routes, the root's view-model only has access to the `activate()` hook.
> However this can also be used to implement logic for _attaching the component_ by returning a promise for a boolean value.
The `params` object will have a property for each parameter of the route that was parsed, as well as a property for each query string value. `routeConfig` will be the original route configuration object that you set up. `routeConfig` will also have a new `navModel` property, which can be used to change the document title for data loaded by your view-model. For example:
if (navigationInstruction.getAllInstructions().some(i => i.config.auth)) {
var isLoggedIn = /* insert magic here */false;
if (!isLoggedIn) {
return next.cancel(new Redirect('login'));
}
}
return next();
}
}
</source-code>
</code-listing>
### Configuring PushState
Add [a base tag](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base) to the head of your html document. If you're using JSPM, you will also need to configure it with a `baseURL` corresponding to your base tag's `href`. Finally, be sure to set the `config.options.root` to match your base tag's setting.
> PushState requires server-side support. Don't forget to configure your server appropriately.
### Reusing an existing VM
Since the VM's navigation life-cycle is called only once you may have problems recognizing that the user switched the route from `Product A` to `Product B` (see below). To work around this issue implement the method `determineActivationStrategy` in your VM and return hints for the router about what you'd like to happen.
> Info
> Additionally, you can add an `activationStrategy` property to your route config if the strategy is always the same and you don't want that to be in your view-model code. Available values are `replace` and `invoke-lifecycle`. Remember, "lifecycle" refers to the navigation lifecycle.
<code-listingheading="Router VM Activation Control">
It's worth noting that when binding variables to custom elements, use camelCase inside the custom element's View-Model, and dash-case on the html element. See the following example:
<code-listingheading="Custom Element View-Model Declaration">
*`@children(selector)` - Decorates a property to create an array on your class that has its items automatically synchronized based on a query selector against the element's immediate child content.
*`@child(selector)` - Decorates a property to create a reference to a single immediate child content element.
*`@processContent(false|Function)` - Tells the compiler that the element's content requires special processing. If you provide `false` to the decorator, the compiler will not process the content of your custom element. It is expected that you will do custom processing yourself. But, you can also supply a custom function that lets you process the content during the view's compilation. That function can then return true/false to indicate whether or not the compiler should also process the content. The function takes the following form `function(compiler, resources, node, instruction):boolean`
*`@useView(path)` - Specifies a different view to use.
*`@noView()` - Indicates that this custom element does not have a view and that the author intends for the element to handle its own rendering internally.
*`@inlineView(markup, dependencies?)` - Allows the developer to provide a string that will be compiled into the view.
*`@useShadowDOM()` - Causes the view to be rendered in the ShadowDOM. When an element is rendered to ShadowDOM, a special `DOMBoundary` instance can optionally be injected into the constructor. This represents the shadow root.
*`@containerless()` - Causes the element's view to be rendered without the custom element container wrapping it. This cannot be used in conjunction with `@child`, `@children` or `@useShadowDOM` decorators. It also cannot be uses with surrogate behaviors. Use sparingly.
### SVG Elements
SVG (scalable vector graphic) tags can support Aurelia's custom element `<template>` tags by nesting the templated code inside a second `<svg>` tag. For example if you had a base `<svg>` element and wanted to add a templated `<rect>` inside it, you would first put your custom tag inside the main `<svg>` tag. Also, make sure the custom element class uses the `@containerless()` decorator.
<code-listingheading="SVG Custom Element View-Model Declaration">
Aurelia exposes a decorator named observable to allow watching for changes to a property and reacting to them. By convention it will look for a matching method name `${name}Changed` -
<code-listingheading="Correct observable usage">
<source-codelang="ES 2016">
import {observable} from 'aurelia-framework';
export class MyCustomViewModel {
@observable name = 'Hello world';
nameChanged(newValue, oldValue) {
// react to change
}
}
</source-code>
<source-codelang="ES 2015">
import {decorators, observable} from 'aurelia-framework';
export let MyCustomViewModel = decorators(
observable('name')
).on(class {
nameChanged(newValue, oldValue) {
// react to change
}
});
</source-code>
<source-codelang="TypeScript">
import {observable} from 'aurelia-framework';
export class MyCustomViewModel {
@observable name = 'Hello world';
nameChanged(newValue, oldValue) {
// react to change
}
}
</source-code>
</code-listing>
The developer can also specify a different method name to use -
<code-listingheading="Correct observable usage with configured change handler">
<source-codelang="ES 2016">
import {observable} from 'aurelia-framework';
export class MyCustomViewModel {
@observable({changeHandler: 'nameChanged'}) name = 'Hello world';
nameChanged(newValue, oldValue) {
// react to change
}
}
</source-code>
<source-codelang="ES 2015">
import {decorators, observable} from 'aurelia-framework';
If you include the `aurelia-event-aggregator` plugin using "basicConfiguration" or "standardConfiguration" then the singleton EventAggregator's API will be also present on the `Aurelia` object. You can also create additional instances of the EventAggregator, if needed, and "merge" them into any object. To do this, import `includeEventsIn` and invoke it with the object you wish to turn into an event aggregator. For example `includeEventsIn(myObject)`. Now my object has `publish` and `subscribe` methods and can be used in the same way as the global event aggregator, detailed below.
<code-listingheading="Publishing on a Channel">
<source-codelang="ES 2016">
import {inject} from 'aurelia-framework';
import {EventAggregator} from 'aurelia-event-aggregator';
@inject(EventAggregator)
export class APublisher {
constructor(eventAggregator) {
this.eventAggregator = eventAggregator;
}
publish(){
var payload = {};
this.eventAggregator.publish('channel name here', payload);
}
}
</source-code>
<source-codelang="ES 2015">
import {EventAggregator} from 'aurelia-event-aggregator';
export class APublisher{
static inject() { return [EventAggregator]; }
constructor(eventAggregator){
this.eventAggregator = eventAggregator;
}
publish(){
var payload = {};
this.eventAggregator.publish('channel name here', payload);
}
}
</source-code>
<source-codelang="TypeScript">
import {autoinject} from 'aurelia-framework';
import {EventAggregator} from 'aurelia-event-aggregator';
