` element with class `form-field`: {% code title="my-component.html" %} ```html ``` {% endcode %} The rendered HTML will be: ```html

``` This behavior can be used to switch between different host elements when necessary, all bindings declared on `` will be transferred to the newly created host element if there is one. ## Passing Data Through `model.bind` `activate` method on the view model, regardless of whether a custom element or a plain object is provided, will be called during the first composition and subsequent changes of the `model` property on the `` element. ```html ``` You can also pass an object inline from the template: ```html ``` Inside the component view model being composed, the `activate` method will receive the object as its first argument. ```typescript export class MyComponent { activate(model) { // Model contains the passed-in model object } } ``` ## When to Use Dynamic Composition Over Components Dynamic composition in Aurelia is a powerful feature allowing greater flexibility in rendering components or views dynamically based on runtime conditions. However, it's important to understand when using dynamic composition (``) over standard components is more appropriate. Here are some scenarios where dynamic composition can be particularly advantageous: ### Dynamic Content Based on User Input or State When the content of your application needs to change dynamically based on user interactions or application state, dynamic composition is a great fit. For example, in a dashboard application where different widgets must be displayed based on user preferences, `` can dynamically load these widgets. ### Rendering Unknown Components at Runtime Suppose your application needs to render components unknown at compile time, such as in a plugin-based architecture where plugins are loaded dynamically. In that case, dynamic composition is the way to go. It allows you to render these components without hardcoding them into your application. ### Conditional Rendering of Multiple Views In cases where you need to render one of many possible views or components based on certain conditions, dynamic composition can be more efficient. Instead of using multiple `if.bind` statements or switch cases in your templates, you can use `` to select and render the appropriate view or component. ### Complex Reusable Layouts When creating complex layouts that are reused across different parts of your application with different content, dynamic composition can be used to inject the specific content into these layouts. This approach promotes reusability and keeps your code DRY. ### Simplify Component Interfaces In scenarios where passing numerous parameters to a component could make its interface overly complex, dynamic composition allows for encapsulating these parameters within a model object. This can simplify the interface and make the component easier to use. ### Decoupling of Component Logic Dynamic composition can help decouple the logic of which component to display from the display logic itself. This separation of concerns can make your codebase more maintainable and easier to test. ### Reduce Initial Load Time If your application is large and you want to reduce the initial load time, dynamic composition can be used to load components on demand. This lazy loading of components can significantly improve performance, especially for single-page applications with many features. ## Accessing the view model In some scenarios, you may want to access the view model of the rendered component using ``. We can achieve this by adding the `component.ref`(known as `view-model.ref` in v1) binding to our compose element. ```html ``` This will work as though it were a `component.ref` binding on a standard custom element. ## Passing props through The `` will pass all bindings, except those targeting its bindable properties (`model`/`component`/`template`) declared on it, to the composed view model, assuming it is a custom element. As an example, for the following scenario: {% code title="app.html" %} ```HTML ``` {% endcode %} {% code title="my-input.ts" %} ```ts export class MyInput { @bindable() value } ``` {% endcode %} {% code title="my-input.html" %} ```html ``` {% endcode %} It will work as if you have the following content in `app.html`: {% code title="app.html" %} ```html ``` {% endcode %} ## Migrating from Aurelia 1 \ The composition in Aurelia 2 is fundamentally different from Aurelia 1. The same ease of use is still there, but how some things worked in v1 does not work the same in v2. ### Template and component-breaking changes 1. In Aurelia 2, the `view` and `view-model` properties have been renamed `template` and `component` respectively. If you were having `view.bind` or `view-model.bind`, change them to `template.bind` or `component.bind` respectively. 2. In Aurelia 2, passing a string to the view or view-model properties no longer means module name. In Aurelia 1, the module would be resolved to a file. In v2, the view property only understands string values, and the view-model property only understands objects and classes. If you still want a view supporting a dynamically loaded module, you can create a value converter that achieves this. {% code title="my-component.html" %} ```html ``` {% endcode %} {% code title="load-template.ts" %} ```javascript class LoadTemplateValueConverter { toView(v) { return fetch(v).then(r => r.text()) } } ``` {% endcode %} The above value converter will load the URL and return the text response. For view models, something similar can be achieved where an object or class can be returned. 3. In Aurelia 2, all bindings are transferred to the underlying custom element composition. Therefore, `component.ref` no longer signifies obtaining a reference to the composer but rather to the composed view model. 4. Scope-breaking changes By default, when composing, the outer scope will not be inherited. The parent scope will only be inherited when no custom element is composed. This means the outer scope will be used when composing only a view or plain object as the view model. You can disable this behaviour using the `scope-behavior` attribute. ```html ``` **Possible values are:** * auto: in view only composition: inherit the parent scope * scoped: never inherit parent scope even in view only composition --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.aurelia.io/~/revisions/NShYVVc01DvYc5bgBiwq/getting-to-know-aurelia/dynamic-composition.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.