wiip

This is useful to prevent interactions with other testing code.

.github/workflows/deploy.yml

@@ -25,3 +25,4 @@ jobs:
     - run: npm install
     - run: npm run test
     - run: npm run check-formatting
+    - run: npm run build

CHANGELOG.md

@@ -8,13 +8,16 @@ patching the `setup` method of `Component` to auto register all the lifecycle
 methods as hooks). This will be done for the transition period, but will be
 removed after.
 
-## Changes
+## From Owl 1.x to Owl 2.0
+
+All changes are documented here in no particular order.
 
 **Components**
 
 - components can now have empty content or multiple root nodes (htmlelement or text) ([details](#31-components-can-now-have-arbitrary-content))
-- new `useEffect` hook
+- breaking: component.el is removed ([details](#9-componentel-is-removed))
-- new `onDestroyed`, `onWillRender` and `onRendered` hooks
+- new `useEffect` hook ([doc](doc/reference/hooks.md#useeffect))
+- new `onWillDestroy`, `onWillRender` and `onRendered` hooks ([doc](doc/reference/component.md#lifecycle))
 - breaking: lifecycle methods are removed ([details](#1-component-lifecycle-methods-are-removed))
 - breaking: can no longer be mounted on detached DOM ([details](#2-components-can-no-longer-be-mounted-in-a-detached-dom-element))
 - breaking: standalone `mount` method API is simpler ([details](#4-mount-method-api-is-simpler))
@@ -22,21 +25,42 @@ removed after.
 - breaking: components can no longer be unmounted/remounted ([details](#6-components-can-no-longer-be-unmountedremounted))
 - breaking: template name is no longer inferred from the class name ([details](#7-template-name-is-no-longer-inferred-from-the-class-name))
 - breaking: components no longer have a `shouldUpdate` method ([details](#8-components-no-longer-have-a-shouldupdate-method))
-- breaking: component.el may be a text node, and is no longer `null` ([details](#9-componentel-may-be-a-text-node-and-is-no-longer-null))
-- breaking: style/class on components are now regular props ([details](#10-styleclass-on-components-are-now-regular-props))
 - breaking: components can no longer be mounted with position=self ([details](#11-components-can-no-longer-be-mounted-with-positionself))
+- breaking: `render` method does not return a promise anymore ([details](#35-render-method-does-not-return-a-promise-anymore))
+- breaking: `catchError` method is replaced by `onError` hook ([details](#36-catcherror-method-is-replaced-by-onerror-hook))
+- breaking: Support for inline css (`css` tag and static `style`) has been removed ([details](#37-support-for-inline-css-css-tag-and-static-style-has-been-removed))
+- new: prop validation system can now describe that additional props are allowed (with `*`) ([doc](doc/reference/props.md#props-validation))
+
+
+**Templates**
+
+- breaking: `t-foreach` should always have a corresponding `t-key` ([details](#20-t-foreach-should-always-have-a-corresponding-t-key))
+- breaking: `t-ref` does not work on components ([details](#29-t-ref-does-not-work-on-component))
+- breaking: `t-on` does not accept expressions, only functions ([details](#30-t-on-does-not-accept-expressions-only-functions))
+- breaking: `t-raw` directive has been removed (replaced by `t-out`) ([details](#38-t-raw-directive-has-been-removed-replaced-by-t-out))
+- new: add support for synthetic events ([doc](doc/reference/event_handling.md#synthetic-events))
+- breaking: style/class on components are now regular props ([details](#10-styleclass-on-components-are-now-regular-props))
+- new: components can use the `.bind` suffix to bind function props ([doc](doc/reference/props.md#binding-function-props))
 - breaking: `t-on` does not work on components any more ([details](#12-t-on-does-not-work-on-components-any-more))
 - breaking: `t-component` no longer accepts strings ([details](#17-t-component-no-longer-accepts-strings))
 
-**Portal**
-
-- portals can now have arbitrary content (no longer restricted to one single child)
-- breaking: does no longer transfer dom events ([details](#13-portal-does-no-longer-transfer-dom-events))
-- breaking: does render as an empty text node instead of `<portal/>` ([details](#14-portal-does-render-as-an-empty-text-node-instead-of-portal))
 
 **Slots**
 
 - breaking: `t-set` does not define a slot any more ([details](#3-t-set-will-no-longer-work-to-define-a-slot))
+- slots capabilities have been improved ([doc](doc/reference/slots.md))
+  - params can be give to slot content (to pass information from slot owner to slot user)
+  - slots are given as a `prop` (and can be manipulated/propagated to sub components )
+  - slots can define scopes (to pass information from slot user to slot owner)
+
+
+**Portal**
+
+- Portal are now defined with `t-portal` ([details](#33-portal-are-now-defined-with-t-portal))
+- portals can now have arbitrary content (no longer restricted to one single child)
+- breaking: does no longer transfer dom events ([details](#13-portal-does-no-longer-transfer-dom-events))
+- breaking: does render as an empty text node instead of `<portal/>` ([details](#14-portal-does-render-as-an-empty-text-node-instead-of-portal))
+
 
 **Miscellaneous**
 
@@ -44,13 +68,13 @@ removed after.
 - much simpler code 
 - finer grained reactivity: owl 2 tracks change per key/component
 - finer grained reactivity: sub components can reobserve state
-- new App class to encapsulate a root Owl component (with the config for that application)
+- new App class to encapsulate a root Owl component (with the config for that application) ([doc](doc/reference/app.md))
 - new `Memo` component
+- new `useEffect` hook ([doc](doc/reference/hooks.md#useeffect))
 - breaking: `Context` is removed ([details](#15-context-is-removed))
 - breaking: `env` is now totally empty ([details](#16-env-is-now-totally-empty))
 - breaking: most exports are exported at top level ([details](#18-most-exports-are-exported-at-top-level))
 - breaking: properties are no longer set as attributes ([details](#19-properties-are-no-longer-set-as-attributes))
-- breaking: `t-foreach` should always have a corresponding `t-key` ([details](#20-t-foreach-should-always-have-a-corresponding-t-key))
 - breaking: `EventBus` api changed: it is now an `EventTarget` ([details](#21-eventbus-api-changed-it-is-now-an-eventtarget))
 - breaking: `Store` is removed ([details](#22-store-is-removed))
 - breaking: `Router` is removed ([details](#23-router-is-removed))
@@ -59,10 +83,9 @@ removed after.
 - breaking: `AsyncRoot` utility component is removed ([details](#26-asyncroot-utility-component-is-removed))
 - breaking: `useSubEnv` only applies to child components ([details](#27-usesubenv-only-applies-to-child-components))
 - breaking: `env` is now frozen ([details](#28-env-is-now-frozen))
-- breaking: `t-ref` does not work on components ([details](#29-t-ref-does-not-work-on-component))
-- breaking: `t-on` does not accept expressions, only functions ([details](#30-t-on-does-not-accept-expressions-only-functions))
 - breaking: `renderToString` function on qweb has been removed ([details](#32-rendertostring-on-qweb-has-been-removed))
-
+- breaking: `debounce` utility function has been removed ([details](#34-debounce-utility-function-has-been-removed))
+- breaking: `browser` object has been removed ([details](#39-browser-object-has-been-removed))
 
 ## Details/Rationale/Migration
 
@@ -96,6 +119,8 @@ class MyComponent extends Component {
 }
 ```
 
+Documentation: [Component Lifecycle](doc/reference/component.md#lifecycle)
+
 ### 2. components can no longer be mounted in a detached dom element
 
 Nor document fragment.
@@ -147,6 +172,8 @@ because real applications will need to configure the templates, the translations
 and other stuff. All complex usecases need to go through the new `App` class,
 that encapsulates the root of an owl application.
 
+Documentation: [Mounting a component](doc/reference/app.md#mount-helper)
+
 ### 5. components can no longer be instantiated and mounted by hand
 
 In Owl 1, it was possible to instantiate a component by hand:
@@ -240,10 +267,14 @@ ideas may help:
     </Memo>
   ```
 
-### 9. component.el may be a text node, and is no longer `null`
+### 9. component.el is removed
 
-This comes from the fact that Owl 2 supports fragments (arbitrary content). When
+This comes from the fact that Owl 2 supports fragments (arbitrary content).
-it is not defined, it was `null` in Owl 1 and is `undefined` in owl 2.
+
+Migration: if one need a reference to the root htmlelement of a template, it is
+suggested to simply add a `ref` on it, and access the reference as needed.
+
+Documentation: [Refs](doc/reference/refs.md)
 
 ### 10. style/class on components are now regular props
 
@@ -286,7 +317,13 @@ compatible with the fact that a component can have a root `<div>` then later,
 change it to something else, or even a text node.
 
 Migration: no real way to do the same. Owl application needs to be appended or
-prepended in something, maybe a `div`.
+prepended in something, maybe a `div`. Remember that you the root component
+can have multiple roots
+
+Documentation:
+- [Fragments](doc/reference/templates.md#fragments)
+- [Mounting a component](doc/reference/app.md#mount-helper)
+
 
 ### 12. `t-on` does not work on components any more
 
@@ -313,8 +350,16 @@ the component API to accept explicitely a callback as props.
 
 ```xml
 <SomeComponent onSomeEvent="doSomething"/>
+<!-- or alternatively: -->
+<SomeComponent onSomeEvent.bind="doSomething"/>
 ```
 
+Note that one of the example above uses the `.bind` suffix, to bind the function
+prop to the component.  Most of the time, binding the function is necessary, and
+using the `.bind` suffix is very helpful in that case.
+
+Documentation: [Binding function props](doc/reference/props.md#binding-function-props)
+
 ### 13. Portal does no longer transfer DOM events
 
 In Owl 1, a Portal component would listen to events emitted on its portalled
@@ -372,6 +417,8 @@ Migration: there is no proper way to get an equivalent. The closest is to get
 a reference to the root App using `this.__owl__.app`. If you need to do this,
 let us know. If this is a legitimate usecase, we may add a `useApp` hook.
 
+Documentation: [Environment](doc/reference/environment.md)
+
 ### 17. `t-component` no longer accepts strings
 
 In owl 1, we could write this:
@@ -397,6 +444,8 @@ the implementation is slightly simpler.
 Migration: simply using `constructor.components.Coucou` instead of `Coucou` will
 do the trick.
 
+Documentation: [Component](doc/reference/component.md#dynamic-sub-components)
+
 ### 18. most exports are exported at top level
 
 Most exports are flattened: for ex, `onMounted` is in owl, not in `owl.hooks`.
@@ -453,6 +502,8 @@ rewritten like this: `bus.addEventListener("event-type", (({detail: info}) => {.
 
 Do not forget to similarly replace `bus.off(...)` by `bus.removeEventListener(...)`
 
+Documentation: [EventBus](doc/reference/utils.md#eventbus)
+
 ### 22. `Store` is removed
 
 The Store system had been abandoned in owl 2.
@@ -522,6 +573,7 @@ AND the component. It now only defines an environment for the children.
 Rationale: This was a subtle cause for bugs: some code had to be rrun
 before the call to `useSubEnv`, otherwise it could interfere with the sub environment.
 
+Documentation: [Hooks](doc/reference/hooks.md#usesubenv)
 
 ### 28. `env` is now frozen
 
@@ -536,6 +588,8 @@ components. This use case still works with `useSubEnv`.
 Migration: use `useSubEnv` instead of writing directly to the env.  Also, note
 that the environment given to the App can initially contain anything.
 
+Documentation: [Environment](doc/reference/environment.md)
+
 ### 29. `t-ref` does not work on component
 
 Before, `t-ref` could be used to get a reference to a child component. It no
@@ -576,6 +630,8 @@ adapted like this:
 <button t-on-click="() => this.someFunction(someVar)">blabla</button>
 ```
 
+Documentation: [Event Handling](doc/reference/event_handling.md)
+
 ### 31. components can now have arbitrary content
 
 Before Owl 2, components had to limit themselves to one single htmlelement as
@@ -588,6 +644,8 @@ So, the following template works for components:
   hello
 ```
 
+Documentation: [Fragments](doc/reference/templates.md#fragments)
+
 ### 32. `renderToString` on QWeb has been removed
 
 Rationale: the `renderToString` function was a qweb method, which made sense because
@@ -609,4 +667,99 @@ export async function renderToString(template, context) {
   app.destroy();
   div.remove();
   return result;
-}
+}
+```
+
+### 33. Portal are now defined with `t-portal`
+
+Before Owl 2, one could use the `Portal` component by importing it and using it.
+Now, it is no longer available. Instead, we can simply use the `t-portal` directive:
+
+```xml
+<div>
+  some content
+  <span t-portal="'body'">
+    portalled content
+  </span>
+<div>
+```
+
+Rationale: it makes it slightly simpler to use (just need the directive, instead
+of having to import and use a sub component), it makes the implementation slightly
+simpler as well. Also, it prevents subclassing the Portal component, which could
+be dangerous, since it is really doing weird stuff under the hood, and could
+easily be broken inadvertendly.
+
+### 34. `debounce` utility function has been removed
+
+Rationale: it did not really help that much, is available as utility function
+elsewhere, so, we decided to have a smaller footprint by focusing Owl on what
+it does best.
+
+### 35. `render` method does not return a promise anymore
+
+Rationale: using the `render` method directly and waiting for it to complete
+was slightly un-declarative. Also, it can be done using the lifecycle hooks
+any way.
+
+Migration: if necessary, one can use the lifecycle hooks to execute code after
+the next mounted/patched operation.
+
+### 36. `catchError` method is replaced by `onError` hook
+
+The `catchError` method was used to provide a way to components to handle errors
+occurring during the component lifecycle. This has been replaced by a `onError`
+hook, with a similar API.
+
+Rationale: `catchError` felt a little big awkward, when most of the way we
+interact with componentss is via hooks.  Using hooks felt more natural and
+consistent.
+
+Migration: mostly replace all `catchError` methods by `onError` hooks in the
+`setup` method.
+
+Documentation: [Error Handling](doc/reference/error_handling.md)
+
+
+## 37. Support for inline css (`css` tag and static `style`) has been removed
+
+Rationale: Owl tries to focus on what it does best, and supporting inline css
+was not a priority.  It used to support some simplified scss language, but it
+was feared that it would cause more trouble than it was worth. Also, it seems
+like it can be done in userspace.
+
+Migration: it seems possible to implement an equivalent solution using hooks. A
+simple implementation could look like this:
+
+```js
+let cache = {};
+
+function useStyle(css) {
+  if (!css in cache) {
+    const sheet = document.createElement("style");
+    sheet.innerHTML = css;
+    cache[css] = sheet;
+    document.head.appendChild(sheet);
+  }
+}
+```
+
+## 38. `t-raw` directive has been removed (replaced by `t-out`)
+
+To match the Odoo qweb server implementation, Owl does no longer implement `t-raw`.
+It is replaced by the `t-out` directive, which is safer: it requires the data
+to be marked explicitely as markup if it is to be inserted without escaping.
+Otherwise, it will be escaped (just like `t-esc`).
+
+Migration: replace all `t-raw` uses by `t-out`, and uses the `markup` function
+to mark all the js values.
+
+Documentation: [Outputting data](doc/reference/templates.md#outputting-data)
+
+## 39. `browser` object has been removed
+
+Rationale: the `browser` object caused more trouble than it was worth. Also, it
+seems like this should be done in user space, not at the framework level.  
+
+Migration: code should just be adapted to either use another browser object,
+or to use native browser function (and then, just mock them directly).

README.md

@@ -16,8 +16,10 @@ framework, written in Typescript, taking the best ideas from React and Vue in a
 simple and consistent way. Owl's main features are:
 
 - a declarative component system,
-- a reactivity system based on hooks,
+- a fine grained reactivity system similar to Vue,
-- concurrent mode by default,
+- hooks
+- fragments
+- asynchronous rendering
 
 Owl components are defined with ES6 classes and xml templates, uses an
 underlying virtual DOM, integrates beautifully with hooks, and the rendering is
@@ -38,28 +40,26 @@ const { Component, useState, mount, xml } = owl;
 
 class Counter extends Component {
   static template = xml`
-    <button t-on-click="() => state.value++">
+    <button t-on-click="() => state.value = state.value + props.increment">
       Click Me! [<t t-esc="state.value"/>]
     </button>`;
 
   state = useState({ value: 0 });
 }
 
-class App extends Component {
+class Root extends Component {
   static template = xml`
-    <div>
+    <span>Hello Owl</span>
-      <span>Hello Owl</span>
+    <Counter increment="2"/>`;
-      <Counter />
-    </div>`;
 
   static components = { Counter };
 }
 
-mount(App, document.body);
+mount(Root, document.body);
 ```
 
 Note that the counter component is made reactive with the [`useState` hook](doc/reference/hooks.md#usestate).
-Also, all examples here uses the [`xml` helper](doc/reference/tags.md#xml-tag) to define inline templates.
+Also, all examples here uses the [`xml` helper](doc/reference/templates.md#inline-templates) to define inline templates.
 But this is not mandatory, many applications will load templates separately.
 
 More interesting examples can be found on the
@@ -74,47 +74,42 @@ Are you new to Owl? This is the place to start!
 - [Tutorial: create a TodoList application](doc/learning/tutorial_todoapp.md)
 - [How to start an Owl project](doc/learning/quick_start.md)
 - [How to test Components](doc/learning/how_to_test.md)
-- [How to write Single File Components](doc/learning/how_to_write_sfc.md)
 
 ### Reference
 
-You will find here a complete reference of every feature, class or object
+- [Overview](doc/readme.md)
-provided by Owl.
+- [App](doc/reference/app.md)
-
-- [Animations](doc/reference/animations.md)
-- [Browser](doc/reference/browser.md)
 - [Component](doc/reference/component.md)
-- [Content](doc/reference/content.md)
+- [Component Lifecycle](doc/reference/component.md#lifecycle)
 - [Concurrency Model](doc/reference/concurrency_model.md)
-- [Configuration](doc/reference/config.md)
+- [Dynamic sub components](doc/reference/component.md#dynamic-sub-components)
-- [Context](doc/reference/context.md)
 - [Environment](doc/reference/environment.md)
-- [Event Bus](doc/reference/event_bus.md)
-- [Event Handling](doc/reference/event_handling.md)
 - [Error Handling](doc/reference/error_handling.md)
+- [Event Handling](doc/reference/event_handling.md)
+- [Form Input Bindings](doc/reference/input_bindings.md)
+- [Fragments](doc/reference/templates.md#fragments)
 - [Hooks](doc/reference/hooks.md)
-- [Mounting a component](doc/reference/mounting.md)
+- [Loading Templates](doc/reference/app.md#loading-templates)
-- [Miscellaneous Components](doc/reference/misc.md)
+- [Mounting a component](doc/reference/app.md#mount-helper)
-- [Observer](doc/reference/observer.md)
+- [Portal](doc/reference/portal.md)
 - [Props](doc/reference/props.md)
-- [Props Validation](doc/reference/props_validation.md)
+- [Props Validation](doc/reference/props.md#props-validation)
-- [QWeb Templating Language](doc/reference/qweb_templating_language.md)
+- [Reactivity](doc/reference/reactivity.md)
-- [QWeb Engine](doc/reference/qweb_engine.md)
+- [Rendering SVG](doc/reference/templates.md#rendering-svg)
+- [Refs](doc/reference/refs.md)
 - [Slots](doc/reference/slots.md)
-- [Tags](doc/reference/tags.md)
+- [Sub components](doc/reference/component.md#sub-components)
+- [Sub templates](doc/reference/templates.md#sub-templates)
+- [Templates (Qweb)](doc/reference/templates.md)
+- [Translations](doc/reference/translations.md)
 - [Utils](doc/reference/utils.md)
 
 ### Other Topics
 
-This section provides miscellaneous document that explains some topics
+- [Notes On Owl Architecture](doc/miscellaneous/architecture.md)
-which cannot be considered either a tutorial, or reference documentation.
-
-- [Owl architecture: the Virtual DOM](doc/miscellaneous/vdom.md)
-- [Owl architecture: the rendering pipeline](doc/miscellaneous/rendering.md)
 - [Comparison with React/Vue](doc/miscellaneous/comparison.md)
-- [Why did Odoo built Owl?](doc/miscellaneous/why_owl.md)
+- [Why did Odoo build Owl?](doc/miscellaneous/why_owl.md)
-
+- [Changelog (from owl 1.x to 2.x)](CHANGELOG.md)
-
 
 ## Installing Owl
 

doc/learning/how_to_write_sfc.md

@@ -1,52 +0,0 @@
-# 🦉 How to write Single File Components 🦉
-
-It is very useful to group code by feature instead of by type of file. It makes
-it easier to scale application to larger size.
-
-To do so, Owl has two small helpers that make it easy to define a
-template or a stylesheet inside a javascript (or typescript) file: the
-[`xml`](../reference/tags.md#xml-tag) and [`css`](../reference/tags.md#css-tag)
-helper.
-
-This means that the template, the style and the javascript code can be defined in
-the same file. For example:
-
-```js
-const { Component } = owl;
-const { xml, css } = owl.tags;
-
-// -----------------------------------------------------------------------------
-// TEMPLATE
-// -----------------------------------------------------------------------------
-const TEMPLATE = xml/* xml */ `
-	<div class="main">
-		<Sidebar/>
-		<Content />
-	</div>`;
-
-// -----------------------------------------------------------------------------
-// STYLE
-// -----------------------------------------------------------------------------
-const STYLE = css/* css */ `
-  .main {
-    display: grid;
-    grid-template-columns: 200px auto;
-  }
-`;
-
-// -----------------------------------------------------------------------------
-// CODE
-// -----------------------------------------------------------------------------
-class Main extends Component {
-  static template = TEMPLATE;
-  static style = STYLE;
-  static components = { Sidebar, Content };
-
-  // rest of component...
-}
-```
-
-Note that the above example has an inline xml comment, just after the `xml` call.
-This is useful for some editor plugins, such as the VS Code addon
-`Comment tagged template`, which, if installed, add syntax highlighting to the
-content of the template string.

doc/learning/tutorial_todoapp.md

@@ -116,7 +116,7 @@ class App extends Component {}
 App.template = xml`<div>todo app</div>`;
 ```
 
-Note 3: writing inline templates with the [`xml` helper](../reference/tags.md#xml-tag)
+Note 3: writing inline templates with the [`xml` helper](../reference/templates.md#inline-templates)
 is nice, but there is no syntax highlighting, and this makes it very easy to
 have malformed xml. Some editors support syntax highlighting for this situation.
 For example, VS Code has an addon `Comment tagged template`, which, if installed,
@@ -173,14 +173,14 @@ class Root extends Component {
 }
 ```
 
-The template contains a [`t-foreach`](../reference/qweb_templating_language.md#loops) loop to iterate
+The template contains a [`t-foreach`](../reference/templates.md#loops) loop to iterate
 through the tasks. It can find the `tasks` list from the component, since the
 component is the rendering context. Note that we use the `id` of each task as a
 `t-key`, which is very common. There are two css classes: `task-list` and `task`,
 that we will use in the next section.
 
 Finally, notice the use of the `t-att-checked` attribute:
-prefixing an attribute by [`t-att`](../reference/qweb_templating_language.md#dynamic-attributes) makes
+prefixing an attribute by [`t-att`](../reference/templates.md#dynamic-attributes) makes
 it dynamic. Owl will evaluate the expression and set it as the value of the
 attribute.
 
@@ -277,10 +277,10 @@ A lot of stuff happened here:
 - the `Task` component has a `props` key: this is only useful for validation
   purpose. It says that each `Task` should be given exactly one prop, named
   `task`. If this is not the case, Owl will throw an
-  [error](../reference/props_validation.md). This is extremely
+  [error](../reference/props.md#props-validation). This is extremely
   useful when refactoring components
 - finally, to activate the props validation, we need to set Owl's
-  [mode](../reference/config.md#mode) to `dev`. This is done in the last argument
+  [mode](../reference/app.md#configuration) to `dev`. This is done in the last argument
   of the `mount` function. Note that this should be removed when an app is used in a real
   production environment, since `dev` mode is slightly slower, due to extra
   checks and validations.

doc/miscellaneous/architecture.md

@@ -0,0 +1,68 @@
+# 🦉 Notes On Owl Architecture 🦉
+
+We explain here how Owl is designed
+
+Warning: these notes are technical by nature, and intended for people working
+on Owl (or interested in understanding its design).
+
+## Overview
+
+Roughly speaking, Owl has 5 main parts:
+
+- a virtual dom system (in `src/blockdom`)
+- a component system (in `src/component`)
+- a template compiler (located in the `src/compiler` folder)
+- a small runtime code to tie them together (in `src/app`)
+- a reactivity system (in `src/reactivity.ts`)
+
+There are some other files, but the core of Owl can be understood with these
+five main parts.
+
+The virtual dom is an optimized virtual dom based on blocks, which supports
+multi blocks (for fragments). Everything that owl renders is internally
+represented by a virtual node. The job of the virtual dom is to efficiently
+represent the current state of the application, and to build an actual DOM
+representation when needed, or update the DOM whenever it is needed.
+
+- some other helpers/smaller scale stuff
+  A rendering occurs in two phases:
+
+- virtual rendering: this generates the virtual dom in memory, asynchronously
+- patch: applies a virtual tree to the screen (synchronously)
+
+There are several classes involved in a rendering:
+
+- components
+- a scheduler
+- fibers: small objects containing some metadata, associated with a rendering of
+  a specific component
+
+Components are organized in a dynamic component tree, visible in the user
+interface. Whenever a rendering is initiated in a component `C`:
+
+- a fiber is created on `C` with the rendering props information
+- the virtual rendering phase starts on C (will asynchronously render all the
+  child components)
+- the fiber is added to the scheduler, which will poll continuously, every
+  animation frame, if the fiber is done
+- once it is done, the scheduler will call the task callback, which will apply
+  the patch (if it was not cancelled in the meantime).
+
+# 🦉 VDom 🦉
+
+Owl is a declarative component system: we declare the structure of the component
+tree, and Owl will translate that to a list of imperative operations. This
+translation is done by a virtual dom. This is the low level layer of Owl, most
+developer will not need to call directly the virtual dom functions.
+
+The main idea behind a virtual dom is to keep a in-memory representation of the
+DOM (called a virtual node), and whenever some change is needed, to regenerate
+a new representation, compute the difference between the old and the new, then
+apply the changes.
+
+`vdom` exports two functions:
+
+- `h`: create a new virtual node
+- `patch`: compare two virtual nodes, and apply the difference.
+
+Note: Owl's virtual dom is a fork of [snabbdom](https://github.com/snabbdom/snabbdom).

doc/miscellaneous/comparison.md

@@ -78,7 +78,7 @@ additional tools, we made a lot of effort to make the most of the web platform.
 
 For example, Owl uses the standard `xml` parser that comes with every browser.
 Because of that, Owl did not have to write its own template parser. Another
-example is the [`xml`](../reference/tags.md#xml-tag) tag helper function, which makes use of
+example is the [`xml`](../reference/templates.md#inline-templates) tag helper function, which makes use of
 native template literals to allow in a natural way to write `xml` templates
 directly in the javascript code. This can be easily integrated with editor
 plugins to have autocompletion inside the template.
@@ -126,7 +126,7 @@ structured than a template language. Note that the tooling is quite impressive:
 there is a syntax highlighter for jsx here on github!
 
 By comparison, here is the equivalent Owl component, written with the
-[`xml`](../reference/tags.md#xml-tag) tag helper:
+[`xml`](../reference/templates.md#inline-templates) tag helper:
 
 ```js
 class Clock extends Component {

doc/miscellaneous/rendering.md

@@ -1,32 +0,0 @@
-# 🦉 Rendering Pipeline 🦉
-
-We explain here how Owl is designed, from the perspective of its rendering
-pipeline.
-
-Warning: these notes are technical by nature, and intended for people working
-on Owl (or interested in understanding its design).
-
-## Overview
-
-A rendering occurs in two phases:
-
-- virtual rendering: this generates the virtual dom in memory, asynchronously
-- patch: applies a virtual tree to the screen (synchronously)
-
-There are several classes involved in a rendering:
-
-- components
-- a scheduler
-- fibers: small objects containing some metadata, associated with a rendering of
-  a specific component
-
-Components are organized in a dynamic component tree, visible in the user
-interface. Whenever a rendering is initiated in a component `C`:
-
-- a fiber is created on `C` with the rendering props information
-- the virtual rendering phase starts on C (will asynchronously render all the
-  child components)
-- the fiber is added to the scheduler, which will poll continuously, every
-  animation frame, if the fiber is done
-- once it is done, the scheduler will call the task callback, which will apply
-  the patch (if it was not cancelled in the meantime).

doc/miscellaneous/vdom.md

@@ -1,18 +0,0 @@
-# 🦉 VDom 🦉
-
-Owl is a declarative component system: we declare the structure of the component
-tree, and Owl will translate that to a list of imperative operations. This
-translation is done by a virtual dom. This is the low level layer of Owl, most
-developer will not need to call directly the virtual dom functions.
-
-The main idea behind a virtual dom is to keep a in-memory representation of the
-DOM (called a virtual node), and whenever some change is needed, to regenerate
-a new representation, compute the difference between the old and the new, then
-apply the changes.
-
-`vdom` exports two functions:
-
-- `h`: create a new virtual node
-- `patch`: compare two virtual nodes, and apply the difference.
-
-Note: Owl's virtual dom is a fork of [snabbdom](https://github.com/snabbdom/snabbdom).

doc/readme.md

@@ -0,0 +1,42 @@
+# 🦉 Owl overview 🦉
+
+Here is a list of everything exported by the Owl library:
+
+Main entities:
+
+- [`App`](reference/app.md): represent an Owl application (mainly a root component,a set of templates, and a config)
+- [`Component`](reference/component.md): the main class to define a concrete Owl component
+- [`mount`](reference/app.md#mount-helper): main entry point for most application: mount a component to a target
+- [`useState`](reference/reactivity.md#usestate): create a reactive object (hook, linked to a specific component)
+- [`reactive`](reference/reactivity.md#reactive): create a reactive object (not linked to any component)
+- [`xml`](reference/templates.md#inline-templates): helper to define an inline template
+
+Lifecycle hooks:
+
+- [`onWillStart`](reference/component.md#willstart): hook to define asynchronous code that should be executed before component is rendered
+- [`onMounted`](reference/component.md#mounted): hook to define code that should be executed when component is mounted
+- [`onWillPatch`](reference/component.md#willpatch): hook to define code that should be executed before component is patched
+- [`onWillUpdateProps`](reference/component.md#willupdateprops): hook to define code that should be executed before component is updated
+- [`onPatched`](reference/component.md#patched): hook to define code that should be executed when component is patched
+- [`onWillRender`](reference/component.md#willrender): hook to define code that should be executed before component is rendered
+- [`onRendered`](reference/component.md#rendered): hook to define code that should be executed after component is rendered
+- [`onWillUnmount`](reference/component.md#willunmount): hook to define code that should be executed before component is unmounted
+- [`onWillDestroy`](reference/component.md#willdestroy): hook to define code that should be executed before component is destroyed
+- [`onError`](reference/component.md#onerror): hook to define a Owl error handler
+
+Other hooks:
+
+- [`useComponent`](reference/hooks.md#usecomponent): return a reference to the current component (useful to create derived hooks)
+- [`useEffect`](reference/hooks.md#useeffect): define an effect with its dependencies
+- [`useEnv`](reference/hooks.md#useenv): return a reference to the current env
+- [`useExternalListener`](reference/hooks.md#useexternallistener): add a listener outside of a component DOM
+- [`useRef`](reference/hooks.md#useref): get an object representing a reference (`t-ref`)
+- [`useSubEnv`](reference/hooks.md#usesubenv): extend the current env with additional information for child components
+
+Utility/helpers:
+
+- [`EventBus`](reference/utils.md#eventbus): a simple event bus
+- [`loadFile`](reference/utils.md#loadfile): an helper to load a file from the server
+- [`markup`](reference/templates.md#outputting-data): utility function to define strings that represent html (should not be escaped)
+- [`status`](reference/component.md#status-helper): utility function to get the status of a component (new, mounted or destroyed)
+- [`whenReady`](reference/utils.md#whenready): utility function to execute code when DOM is ready

doc/reference/animations.md

@@ -1,127 +0,0 @@
-# 🦉 Animations 🦉
-
-Animation is a complex topic. There are many different use cases, and many
-solutions and technologies. Owl only supports some basic use cases.
-
-## Simple CSS effects
-
-Sometimes, using pure CSS is enough. For these use cases, Owl is not really
-necessary: it just needs to render a DOM element with a specific class. For
-example:
-
-```xml
-<a class="btn flash" t-on-click="doSomething">Click</a>
-```
-
-with the following CSS:
-
-```css
-btn {
-  background-color: gray;
-}
-
-.flash {
-  transition: background 0.5s;
-}
-
-.flash:active {
-  background-color: #41454a;
-  transition: background 0s;
-}
-```
-
-will produce a nice flash effect whenever the user clicks (or activates with the
-keyboard) the button.
-
-## CSS Transitions
-
-A more complex situation occurs when we want to transition an element in or out
-of the page. For example, we may want a fade-in and fade-out effect.
-
-The `t-transition` directive is here to help us. It works on html elements and
-on components, by adding and removing some css classes.
-
-To perform useful transition effects, whenever an element appears or disappears,
-it is necessary to add/remove some css style or class at some precise moment in
-the lifetime of a node. Since this is not easy to do by hand, Owl `t-transition`
-directive is there to help.
-
-Whenever a node has a `t-transition` directive, with a `name` value, the following
-sequence of events will happen:
-
-At node insertion:
-
-- the css classes `name-enter` and `name-enter-active` will be added directly
-  when the node is inserted into the DOM.
-- on the next animation frame: the css class `name-enter` will be removed and the
-  class `name-enter-to` will be added (so they can be used to trigger css
-  transition effects).
-- at the end of the transition, `name-enter-to` and `name-enter-active` will be removed.
-
-At node destruction:
-
-- the css classes `name-leave` and `name-leave-active` will be added before the
-  node is removed to the DOM.
-- on the next animation frame: the css class `name-leave` will be removed and the
-  class `name-leave-to` will be added (so they can be used to trigger css
-  transition effects).
-- at the end of the transition, `name-leave-to` and `name-leave-active` will be removed.
-
-For example, a simple fade in/out effect can be done with this:
-
-```xml
-<div>
-    <div t-if="state.flag" class="square" t-transition="fade">Hello</div>
-</div>
-```
-
-```css
-.fade-enter-active,
-.fade-leave-active {
-  transition: opacity 0.5s;
-}
-.fade-enter,
-.fade-leave-to {
-  opacity: 0;
-}
-```
-
-The `t-transition` directive can be applied on a node element or on a component.
-
-Notes:
-
-Owl does not support more than one transition on a single node, so the
-`t-transition` expression must be a single value (i.e. no space allowed).
-
-## SCSS Mixins
-
-If you use SCSS, you can use mixins to make generic animations. Here is an exemple with a fade in / fade out animation:
-
-```scss
-@mixin animation-fade($time, $name) {
-  .#{$name}_fade-enter-active,
-  .#{$name}_fade-active {
-    transition: all $time;
-  }
-
-  .#{$name}_fade-enter {
-    opacity: 0;
-  }
-
-  .#{$name}_fade-leave-to {
-    opacity: 0;
-  }
-}
-```
-
-Usage:
-
-```scss
-@include animation-fade(0.5s, "o_notification");
-```
-
-You can now have in your template:
-
-```xml
-<SomeTag  t-transition="o_notification_fade"/>
-```

doc/reference/app.md

@@ -0,0 +1,107 @@
+# 🦉 App 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Configuration](#configuration)
+- [`mount` helper](#mount-helper)
+- [Loading templates](#loading-templates)
+
+## Overview
+
+Every Owl application has a root element, a set of templates, an environment and
+possibly a few other settings. The `App` class is a simple class that represents
+all of these elements. Here is an example:
+
+```js
+const {Component, App } = owl;
+
+class MyComponent extends Component { ... }
+
+const app = new App(MyComponent, { props: {...}, templates: "..."});
+app.mount(document.body);
+```
+
+The basic workflow is: create an `App` instance configured with the root
+component, the templates, and possibly other settings. Then, we mount that
+instance somewhere in the DOM.
+
+## Configuration
+
+- **`constructor(Root[, config])`**: first argument should be a component class (not
+  an instance), and the optional second argument is a configuration object.
+
+  The `config` object is an object with some of the following keys:
+
+  - **`env (object)`**: if given, this will be the shared `env` given to each component
+  - **`props (object)`**: the props given to the root component
+  - **`dev (boolean, default=false)`**: if `true`, the application is rendered in `dev`
+    mode, which activates some additional checks (in particular, the props validation
+    code is only performed in dev mode)
+  - **`translatableAttributes (string[])`**: a list of additional attributes that should
+    be translated (see [translations](translations.md))
+  - **`translateFn (function)`**: a function that will be called by owl to translate
+    templates (see [translations](translations.md))
+  - **`templates (string | xml document)`**: all the templates that will be used by
+    the components created by the application.
+
+- **`mount(target, options)`**: first argument is an html element, and the optional
+  second argument is an object with mounting options (see below). Mount the app
+  to a target in the DOM. Note that this is an asynchronous operation: the `mount`
+  method returns a promise that resolves to the component instance whenever it
+  is complete.
+
+  The `option` object is an object with the following keys:
+
+  - **`position (string)`**: either `first-child` or `last-child`. This option determines
+    the position of the application in the target: either first or last child.
+
+- **`destroy()`**: destroys the application
+
+## `mount` helper
+
+Note that there is a `mount` helper to do that in just a line:
+
+```js
+const { mount, Component } = owl;
+
+class MyComponent extends Component {
+    ...
+}
+
+mount(MyComponent, document.body, { props: {...}, templates: "..."});
+```
+
+Here is the `mount` function signature:
+
+**`mount(Component, target, config)`** with the following arguments:
+
+- **`Component`**: a component class (Root component of the app)
+- **`target`**: an html element, where the component will be mounted as last child
+- **`config (optional)`**: a config object (the same as the App config object)
+
+Most of the time, the `mount` helper is more convenient, but whenever one needs
+a reference to the actual Owl App, then using the `App` class directly is
+possible.
+
+## Loading templates
+
+Most applications will need to load templates whenever they start. Here is
+what it could look like in practice:
+
+```js
+// in the main js file:
+const { loadFile, mount } = owl;
+
+// async, so we can use async/await
+(async function setup() {
+  const templates = await loadFile(`/some/endpoint/that/return/templates`);
+  const env = {
+    _t: someTranslateFn,
+    templates,
+    // possibly other stuff
+  };
+
+  mount(Root, document.body, { env });
+})();
+```

doc/reference/browser.md

@@ -1,33 +0,0 @@
-# 🦉 Browser 🦉
-
-## Content
-
-- [Overview](#overview)
-- [Browser Content](#browser-content)
-
-## Overview
-
-The browser object contains some browser native APIs, such as `setTimeout`, that
-are used by Owl and its utility functions. They are exposed with the intent of
-making them mockable if necessary.
-
-```js
-owl.browser.setTimeout === window.setTimeout; // return true
-```
-
-For now, this object contains some functions that are not used by Owl. They
-will eventually be removed in Owl 2.0.
-
-## Browser Content
-
-More specifically, the `browser` object contains the following methods and objects:
-
-- `setTimeout`
-- `clearTimeout`
-- `setInterval`
-- `clearInterval`
-- `requestAnimationFrame`
-- `random`
-- `Date`
-- `fetch`
-- `localStorage`

doc/reference/concurrency_model.md

@@ -11,7 +11,7 @@
 
 Owl was designed from the very beginning with asynchronous components. This comes
 from the `willStart` and the `willUpdateProps` lifecycle hooks. With these
-methods, it is possible to build complex highly concurrent applications.
+asynchronous hooks, it is possible to build complex highly concurrent applications.
 
 Owl concurrent mode has several benefits: it makes it possible to delay the
 rendering until some asynchronous operation is complete, it makes it possible
@@ -35,7 +35,8 @@ two phases: _virtual rendering_ and _patching_.
 
 ### Virtual rendering
 
-This phase represent the process of rendering a template, in memory, which create a virtual representation of the desired component html). The output of this phase is a
+This phase represent the process of rendering a template, in memory, which creates
+a virtual representation of the desired component html). The output of this phase is a
 virtual DOM.
 
 It is asynchronous: each subcomponents needs to either be created (so, `willStart`
@@ -94,7 +95,7 @@ component (with some code like `app.mount(document.body)`).
 5. The method `mounted` is called recursively on all components in the following
    order: `E`, `D`, `C`, `B`, `A`.
 
-**Scenario 2: rerendering a component**. Now, let's assume that the user clicked on some
+**Scenario 2: updating a component**. Now, let's assume that the user clicked on some
 button in `C`, and this results in a state update, which is supposed to:
 
 - update `D`,
@@ -136,8 +137,7 @@ Here is what Owl will do:
 6. `mounted` hook is called on `F`, `patched` hooks are called on `D`, `C`
 
 Tags are very small helpers to make it easy to write inline templates. There is
-only one currently available tag: `xml`, but we plan to add other tags later,
+only one currently available tag: `xml`.
-such as a `css` tag, which will be used to write [single file components](../learning/how_to_write_sfc.md).
 
 ### Asynchronous Rendering
 
@@ -160,22 +160,4 @@ Here are a few tips on how to work with asynchronous components:
 1. Minimize the use of asynchronous components!
 2. Lazy loading external libraries is a good use case for async rendering. This
    is mostly fine, because we can assume that it will only takes a fraction of a
-   second, and only once (see [`owl.utils.loadJS`](utils.md#loadjs))
+   second, and only once.
-3. For all the other cases, the [`AsyncRoot`](misc.md#asyncroot) component is there to help you. When
-   this component is met, a new rendering
-   sub tree is created, such that the rendering of that component (and its
-   children) is not tied to the rendering of the rest of the interface. It can
-   be used on an asynchronous component, to prevent it from delaying the
-   rendering of the whole interface, or on a synchronous one, such that its
-   rendering isn't delayed by other (asynchronous) components. Note that this
-   directive has no effect on the first rendering, but only on subsequent ones
-   (triggered by state or props changes).
-
-   ```xml
-   <div t-name="ParentComponent">
-     <SyncChild />
-     <AsyncRoot>
-        <AsyncChild/>
-     </AsyncRoot>
-   </div>
-   ```

doc/reference/config.md

@@ -1,44 +0,0 @@
-# 🦉 Config 🦉
-
-The Owl framework is designed to work in many situations. However, it is
-sometimes necessary to customize some behaviour. This is done by using the
-global `config` object. It provides two settings:
-
-- [`mode`](#mode) (default value: `prod`),
-- [`enableTransitions`](#enabletransitions) (default value: `true`).
-
-## Mode
-
-By default, Owl is in _production_ mode, this means that it will try to do its
-job fast, and skip some expensive operations. However, it is sometimes necessary
-to have better information on what is going on, this is the purpose
-of the `dev` mode.
-
-Owl has a mode flag, in `owl.config.mode`. Its default value is `prod`, but
-it can be set to `dev`:
-
-```js
-owl.config.mode = "dev";
-```
-
-Note that templates compiled with the `prod` settings will not be recompiled.
-So, changing this setting is best done at startup.
-
-An important job done by the `dev` mode is to validate props for each component
-creation and update. Also, extra props will cause an error.
-
-## `enableTransitions`
-
-Transitions are usually nice, but they can cause issues in some specific cases,
-such as automated tests. It is uncomfortable having to wait for a transition
-to end before moving to the next step.
-
-To solve this issue, Owl can be configured to ignore the `t-transition` directive.
-To do that, one only needs to set the `enableTransitions` flag to false:
-
-```js
-owl.config.enableTransitions = false;
-```
-
-Note that it suffers from the same drawback as the "dev" mode: all compiled
-templates, if any, will keep their current behaviours.

doc/reference/content.md

@@ -1,36 +0,0 @@
-# 🦉 Owl Content 🦉
-
-Here is a complete visual representation of everything exported by the `owl`
-global object.
-
-For example, `Component` is available at `owl.Component` and `EventBus` is
-exported as `owl.core.EventBus`.
-
-```
-browser
-Component                               misc
-Context                                     AsyncRoot
-QWeb                                        Portal
-mount
-useState                                tags
-config                                      css
-    mode                                    xml
-core                                    utils
-    EventBus                                debounce
-    Observer                                escape
-hooks                                       loadJS
-    onWillStart                             loadFile
-    onMounted                               shallowEqual
-    onWillUpdateProps                       whenReady
-    onWillPatch
-    onPatched
-    onWillUnmount
-    useContext
-    useState
-    useRef
-    useComponent
-    useEnv
-    useSubEnv
-```
-
-Note that for convenience, the `useState` hook is also exported at the root of the `owl` object.

doc/reference/environment.md

@@ -6,15 +6,15 @@
 - [Setting an Environment](#setting-an-environment)
 - [Using a sub environment](#using-a-sub-environment)
 - [Content of an Environment](#content-of-an-environment)
-- [Special keys](#special-keys)
 
 ## Overview
 
-An environment is an object which contains a [`QWeb` instance](qweb_engine.md). Whenever
+An environment is a shared object given to all components in a tree. It is not
-a root component is created, it is assigned an environment (see
+used by Owl itself, but it is useful for application developers to provide a
-[below](#setting-an-environment) for more info on this). This environment is
+simple communication channel between components (in addition to the props).
-then automatically given to each sub component (and accessible in the `this.env`
+
-property).
+The `env` given to the [`App`](app.md) is assigned to the `env` component
+property.
 
 ```
     Root
@@ -22,31 +22,14 @@ property).
    A    B
 ```
 
-This way, all components share the same `QWeb` instance. Owl internally requires
+Also, the `env` object is frozen when the application is started. This is done
-that the environment has a `qweb` key which maps to a
+to ensure a simpler mental model of what's happening in runtime. Note that it
-[`QWeb`](qweb_engine.md) instance. This is the QWeb instance that will be used to
+is only shallowly frozen, so sub objects can be modified.
-render each templates in this specific component tree. Note that if no `QWeb`
-instance is provided, Owl will simply generate it on the fly.
-
-The environment is mostly static. Each application is free to add anything to
-the environment, which is very useful, since this can be accessed by each sub
-component.
 
 ## Setting an environment
 
-An Owl application needs an [environment](environment.md) to be executed. The
+The correct way to customize an environment is to simply give it to the `App`,
-environment has an important key: the [QWeb](qweb_engine.md) instance, which will render
+whenever it is created.
-all templates.
-
-Whenever a root component `App` is mounted, Owl will setup a valid environment by
-following the next steps:
-
-- take the `env` object defined on `App.env` (if no `env` was explicitly setup,
-  this will return the empty `env` object defined on `Component`)
-- if `env.qweb` is not set, then Owl will create a `QWeb` instance.
-
-The correct way to customize an environment is to simply set it up on the root
-component class, before the first component is created:
 
 ```js
 const env = {
@@ -56,20 +39,13 @@ const env = {
         ...
     },
 };
-mount(App, { target: document.body, env });
+
+new App(Root, { env }).mount(document.body);
+
+// or alternatively
+mount(App, document.body, { env });
 ```
 
-It is also possible to simply share an environment between all root components,
-by simply doing this:
-
-```js
-Component.env = myEnv; // will be the default env for all components
-```
-
-Note that this environment is the global owl environment for an application. The
-next section explains how to extend an environment for a specific sub component
-and its children.
-
 ## Using a sub environment
 
 It is sometimes useful to add one (or more) specific keys to the environment,
@@ -79,58 +55,22 @@ solution presented above will not work, since it sets the global environment.
 There is a hook for this situation: [`useSubEnv`](hooks.md#usesubenv).
 
 ```js
-class FormComponent extends Component {
+class SomeComponent extends Component {
-  constructor(parent, props) {
+  setup() {
-    super(parent, props);
+    useSubEnv({ myKey: someValue }); // myKey is now available for all child components
-    useSubEnv({ myKey: someValue });
   }
 }
 ```
 
 ## Content of an Environment
 
-Some good use cases for additional keys in the environment are:
+The `env` object content is totally up to the application developer. However,
+some good use cases for additional keys in the environment are:
 
 - some configuration keys,
 - session information,
 - generic services (such as doing rpcs).
+- other utility functions that one want to inject, such as a translation function.
 
 Doing it this way means that components are easily testable: we can simply
 create a test environment with mock services.
-
-For example:
-
-```js
-async function myEnv() {
-  const templates = await loadTemplates();
-  const qweb = new QWeb({ templates });
-  const session = getSession();
-
-  return {
-    _t: myTranslateFunction,
-    session: session,
-    qweb: qweb,
-    services: {
-      localStorage: localStorage,
-      rpc: rpc,
-    },
-    debug: false,
-    inMobileMode: true,
-  };
-}
-
-async function start() {
-  const env = await myEnv();
-  mount(App, { target: document.body, env });
-}
-```
-
-## Special Keys
-
-There are two special key/value added by Owl if not provided in the environment:
-the `QWeb` instance and a `browser` object:
-
-- `qweb` will be set to an empty `QWeb` instance. This is absolutely necessary
-  for Owl to be able to render anything
-- `browser`: this is an object that contains some common access points to the
-  browser methods with a side effect. See [browser](browser.md) for more information. Note that the browser object will be removed from the environment in Owl 2.0.

doc/reference/error_handling.md

@@ -3,60 +3,30 @@
 ## Content
 
 - [Overview](#overview)
+- [Managing Errors](#managing-errors)
 - [Example](#example)
-- [Reference](#reference)
 
 ## Overview
 
 By default, whenever an error occurs in the rendering of an Owl application, we
 destroy the whole application. Otherwise, we cannot offer any guarantee on the
 state of the resulting component tree. It might be hopelessly corrupted, but
-without any user-visible state.
+without any user-visible feedback.
 
-Clearly, it sometimes is a little bit extreme to destroy the application. This
+Clearly, it is usually a little bit extreme to destroy the application. This
-is why we have a builtin mechanism to handle rendering errors (and errors coming
+is why we need a mechanism to handle rendering errors (and errors coming
-from lifecycle hooks): the `catchError` hook.
+from lifecycle hooks): the `onError` hook.
 
-## Example
+The main idea is that the `onError` hook register a function that will be called
+with the error. This function need to handle the situation, most of the time by
+updating some state and rerendering itself, so the application can return to a
+normal state.
 
-For example, here is how we could implement an `ErrorBoundary` component:
+## Managing Errors
 
-```xml
+Whenever the `onError` lifecycle hook is used, all errors coming from
-<div t-name="ErrorBoundary">
-    <t t-if="state.error">
-        Error handled
-    </t>
-    <t t-else="">
-        <t t-slot="default" />
-    </t>
-</div>
-```
-
-```js
-class ErrorBoundary extends Component {
-  state = useState({ error: false });
-
-  catchError() {
-    this.state.error = true;
-  }
-}
-```
-
-Using the `ErrorBoundary` is then extremely simple:
-
-```xml
-<ErrorBoundary><SomeOtherComponent/></ErrorBoundary>
-```
-
-Note that we need to be careful here: the fallback UI should not throw any
-error, otherwise we risk going into an infinite loop (also, see the page on
-[slots](slots.md) for more information on the `t-slot` directive).
-
-## Reference
-
-Whenever the `catchError` lifecycle hook is implemented, all errors coming from
 sub components rendering and/or lifecycle method calls will be caught and given
-to the `catchError` method. This allows us to properly handle the error, and to
+to the `onError` method. This allows us to properly handle the error, and to
 not break the application.
 
 There are important things to know:
@@ -65,17 +35,41 @@ There are important things to know:
   Owl will destroy the full application. This is done on purpose, because Owl
   cannot guarantee that the state is not corrupted from this point on.
 
-- errors coming from event handlers are NOT managed by `catchError` or any other
+- errors coming from event handlers are NOT managed by `onError` or any other
   owl mechanism. This is up to the application developer to properly recover
   from an error
 
-Also, it may be useful to know that whenever an error is caught, it is then
+- if an error handler is unable to properly handle an error, it can just rethrow
-broadcasted to the application by an event on the `qweb` instance. It may be
+  an error, and Owl will try looking for another error handler up the component
-useful, for example, to log the error somewhere.
+  tree.
+
+## Example
+
+For example, here is how we could implement a generic component `ErrorBoundary`
+that render its content, and a fallback if an error happened.
 
 ```js
-env.qweb.on("error", null, function (error) {
+class ErrorBoundary extends Component {
-  // do something
+  static template = xml`
-  // react to the error
+    <t t-if="error" t-slot="fallback">An error occurred</t>
-});
+    <t t-else="" t-slot="content"`;
+
+  setup() {
+    this.state = useState({ error: false });
+    onError(() => (this.state.error = true));
+  }
+}
 ```
+
+Using the `ErrorBoundary` is then simple simple:
+
+```xml
+<ErrorBoundary>
+  <SomeOtherComponent/>
+  <t t-set-slot="fallback">Some specific error message</t>
+</ErrorBoundary>
+```
+
+Note that we need to be careful here: the fallback UI should not throw any
+error, otherwise we risk going into an infinite loop (also, see the page on
+[slots](slots.md) for more information on the `t-slot` directive).

doc/reference/event_handling.md

@@ -3,22 +3,14 @@
 ## Content
 
 - [Event Handling](#event-handling)
-- [Business DOM Events](#business-dom-events)
-- [Inline Event Handlers](#inline-event-handlers)
 - [Modifiers](#modifiers)
+- [Synthetic Events](#synthetic-events)
 
 ## Event Handling
 
 In a component's template, it is useful to be able to register handlers on DOM
-elements to some specific events. This is what makes a template _alive_. There
+elements to some specific events. This is what makes a template _alive_. This
-are four different use cases.
+is done with the `t-on` directive. For example:
-
-1. Register an event handler on a DOM node (_pure_ DOM event)
-2. Register an event handler on a component (_pure_ DOM event)
-3. Register an event handler on a DOM node (_business_ DOM event)
-4. Register an event handler on a component (_business_ DOM event)
-
-A _pure_ DOM event is directly triggered by a user interaction (e.g. a `click`).
 
 ```xml
 <button t-on-click="someMethod">Do something</button>
@@ -31,93 +23,28 @@ button.addEventListener("click", component.someMethod.bind(component));
 ```
 
 The suffix (`click` in this example) is simply the name of the actual DOM
-event.
+event. The value of the `t-on` expression should be a valid javascript expression
-
+that evaluates to a function in the context of the current component. So, one
-## Business DOM Events
+can get a reference to the event, or pass some additional arguments. For example,
-
+all the following expressions are valid:
-A _business_ DOM event is triggered by a call to `trigger` on a component.
 
 ```xml
-<MyComponent t-on-menu-loaded="someMethod" />
+<button t-on-click="someMethod">Do something</button>
+<button t-on-click="() => this.increment(3)">Add 3</button>
+<button t-on-click="ev => this.doStuff(ev, 'value')">Do something</button>
 ```
 
-```js
+Notice the use of the `this` keyword in the lambda function: this is the
- class MyComponent {
+correct way to call a method on the component in a lambda function.
-     someWhere() {
-         const payload = ...;
-         this.trigger('menu-loaded', payload);
-     }
- }
-```
 
-The call to `trigger` generates an `OwlEvent`, a subclass of [_CustomEvent_](https://developer.mozilla.org/docs/Web/Guide/Events/Creating_and_triggering_events)
+One could use the following expression:
-with an additional attribute `originalComponent` (the component that triggered
-the event). The generated event is of type `menu-loaded` and dispatches it on
-the component's DOM element (`this.el`). The event bubbles and is cancelable.
-The parent component listening to event `menu-loaded` will receive the payload
-in its `someMethod` handler (in the `detail` property of the event), whenever
-the event is triggered.
-
-```js
- class ParentComponent {
-     someMethod(ev) {
-         const payload = ev.detail;
-         ...
-     }
- }
-```
-
-By convention, we use KebabCase for the name of _business_ events.
-
-The `t-on` directive allows to prebind its arguments. For example,
 
 ```xml
-<button t-on-click="someMethod(expr)">Do something</button>
+<button t-on-click="() => increment(3)">Add 3</button>
 ```
 
-Here, `expr` is a valid Owl expression, so it could be `true` or some variable
+But then, the increment function may be unbound (unless the component binds it
-from the rendering context.
+in its setup function, for example).
-
-### Type Hinting
-
-Note that if you work with Typescript, the `trigger` method is generic on the type of the payload.
-
-You can then describe the type of the event, so you will see typing errors...
-
-```typescript
-this.trigger<MyCustomPayload>("my-custom-event", payload);
-```
-
-```typescript
-myCustomEventHandler(ev: OwlEvent<MyCustomPayload>) { ... }
-```
-
-## Inline Event Handlers
-
-One can also directly specify inline statements. For example,
-
-```xml
-<button t-on-click="state.counter++">Increment counter</button>
-```
-
-Here, `state` must be defined in the rendering context (typically the component)
-as it will be translated to:
-
-```js
-button.addEventListener("click", () => {
-  context.state.counter++;
-});
-```
-
-Warning: inline expressions are evaluated in the context of the template. This
-means that they can access the component methods and properties. But if they set
-a key, the inline statement will actually not modify the component, but a key in
-a sub scope.
-
-```xml
-<button t-on-click="value = 1">Set value to 1 (does not work!!!)</button>
-<button t-on-click="state.value = 1">Set state.value to 1 (work as expected)</button>
-```
 
 ## Modifiers
 
@@ -125,12 +52,13 @@ In order to remove the DOM event details from the event handlers (like calls to
 `event.preventDefault`) and let them focus on data logic, _modifiers_ can be
 specified as additional suffixes of the `t-on` directive.
 
-| Modifier   | Description                                                                                                              |
+| Modifier     | Description                                                                                                              |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------ |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------ |
-| `.stop`    | calls `event.stopPropagation()` before calling the method                                                                |
+| `.stop`      | calls `event.stopPropagation()` before calling the method                                                                |
-| `.prevent` | calls `event.preventDefault()` before calling the method                                                                 |
+| `.prevent`   | calls `event.preventDefault()` before calling the method                                                                 |
-| `.self`    | calls the method only if the `event.target` is the element itself                                                        |
+| `.self`      | calls the method only if the `event.target` is the element itself                                                        |
-| `.capture` | bind the event handler in [capture](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener) mode. |
+| `.capture`   | bind the event handler in [capture](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener) mode. |
+| `.synthetic` | define a synthetic event handler (see below)                                                                             |
 
 ```xml
 <button t-on-click.stop="someMethod">Do something</button>
@@ -149,3 +77,26 @@ modifiers. For example,
 ```
 
 This will simply stop the propagation of the event.
+
+## Synthetic Events
+
+In some cases, attaching an event handler for each element of large lists has
+a non trivial cost. Owl provides a way to efficiently improve the performance:
+with synthetic event, it actually adds only one handler on the document body,
+and will properly call the handler, just as expected.
+
+The only difference with regular events is that the event is caught at the document
+body, so it cannot be stopped before it actually gets there. Since it may be
+surprising in some cases, it is not enabled by default.
+
+To enable it, one can just use the `.synthetic` suffix:
+
+```xml
+<div>
+    <t t-foreach="largeList" t-as="elem" t-key="elem.id">
+        <button t-on-click.synthetic="doSomething" ...>
+            <!-- some content -->
+        </button>
+    </t>
+</div>
+```

doc/reference/hooks.md

@@ -3,24 +3,17 @@
 ## Content
 
 - [Overview](#overview)
-- [Example: Mouse Position](#example-mouse-position)
+- [The Hook Rule](#the-hook-rule)
-- [Example: Autofocus](#example-autofocus)
+- [Lifecycle hooks](#lifecycle-hooks)
-- [Reference](#reference)
+- [Other hooks](#other-hooks)
-  - [One Rule](#one-rule)
   - [`useState`](#usestate)
-  - [`onMounted`](#onmounted)
-  - [`onWillUnmount`](#onwillunmount)
-  - [`onWillPatch`](#onwillpatch)
-  - [`onPatched`](#onpatched)
-  - [`onWillStart`](#onwillstart)
-  - [`onWillUpdateProps`](#onwillupdateprops)
-  - [`useContext`](#usecontext)
   - [`useRef`](#useref)
   - [`useSubEnv`](#usesubenv)
   - [`useExternalListener`](#useexternallistener)
   - [`useComponent`](#usecomponent)
   - [`useEnv`](#useenv)
-  - [Making customized hooks](#making-customized-hooks)
+  - [`useEffect`](#useeffect)
+- [Example: Mouse Position](#example-mouse-position)
 
 ## Overview
 
@@ -39,96 +32,9 @@ Hooks work beautifully with Owl components: they solve the problems mentioned
 above, and in particular, they are the perfect way to make your component
 reactive.
 
-## Example: mouse position
+## The Hook Rule
 
-Here is the classical example of a non trivial hook to track the mouse position.
+There is only one rule: every hook for a component has to be called in the _setup_ method, or in class fields:
-
-```js
-const { useState, onMounted, onWillUnmount } = owl.hooks;
-
-// We define here a custom behaviour: this hook tracks the state of the mouse
-// position
-function useMouse() {
-  const position = useState({ x: 0, y: 0 });
-
-  function update(e) {
-    position.x = e.clientX;
-    position.y = e.clientY;
-  }
-  onMounted(() => {
-    window.addEventListener("mousemove", update);
-  });
-  onWillUnmount(() => {
-    window.removeEventListener("mousemove", update);
-  });
-
-  return position;
-}
-
-// Main root component
-class App extends owl.Component {
-  static template = xml`
-    <div t-name="App">
-      <div>Mouse: <t t-esc="mouse.x"/>, <t t-esc="mouse.y"/></div>
-    </div>`;
-
-  // this hooks is bound to the 'mouse' property.
-  mouse = useMouse();
-}
-```
-
-Note that we use the prefix `use` for hooks, just like in React. This is just
-a convention.
-
-## Example: autofocus
-
-Hooks can be combined to create the desired effect. For example, the following
-hook combines the `useRef` hook with the `onPatched` and `onMounted` functions
-to create an easy way to focus an input whenever it appears in the DOM:
-
-```js
-function useAutofocus(name) {
-  let ref = useRef(name);
-  let isInDom = false;
-  function updateFocus() {
-    if (!isInDom && ref.el) {
-      isInDom = true;
-      ref.el.focus();
-    } else if (isInDom && !ref.el) {
-      isInDom = false;
-    }
-  }
-  onPatched(updateFocus);
-  onMounted(updateFocus);
-}
-```
-
-This hook takes the name of a valid `t-ref` directive, which should be present
-in the template. It then checks whenever the component is mounted or patched if
-the reference is not valid, and in this case, it will focus the node element.
-This hook can be used like this:
-
-```js
-class SomeComponent extends Component {
-  static template = xml`
-    <div>
-        <input />
-        <input t-ref="myinput"/>
-    </div>`;
-
-  constructor(...args) {
-    super(...args);
-    useAutofocus("myinput");
-  }
-}
-```
-
-## Reference
-
-### One rule
-
-There is only one rule: every hook for a component has to be called in the
-constructor, in the _setup_ method, or in class fields:
 
 ```js
 // ok
@@ -136,14 +42,6 @@ class SomeComponent extends Component {
   state = useState({ value: 0 });
 }
 
-// also ok
-class SomeComponent extends Component {
-  constructor(...args) {
-    super(...args);
-    this.state = useState({ value: 0 });
-  }
-}
-
 // also ok
 class SomeComponent extends Component {
   setup() {
@@ -159,15 +57,24 @@ class SomeComponent extends Component {
 }
 ```
 
-As you can see, the `useState` hook does not need to be given a reference to
+## Lifecycle Hooks
-the component. This is possible because there is a way to get a reference to the
-current component: the `Component.current` static property is the reference to the
-component instance that is currently being created.
 
-Hooks need to be called in the constructor to ensure that this reference is
+All lifecycle hooks are documented in detail in their specific [section](component.md#lifecycle).
-properly set. This is also a good thing for performance reasons (Owl can use
+
-this to optimize its implementation), and for a clean architecture (this makes
+| Hook                                                  | Description                                                            |
-it easier for developers to understand what is really happening in a component).
+| ----------------------------------------------------- | ---------------------------------------------------------------------- |
+| **[onWillStart](component.md#willstart)**             | async, before first rendering                                          |
+| **[onWillRender](component.md#willrender)**           | just before component is rendered                                      |
+| **[onRendered](component.md#rendered)**               | just after component is rendered                                       |
+| **[onMounted](component.md#mounted)**                 | just after component is rendered and added to the DOM                  |
+| **[onWillUpdateProps](component.md#willupdateprops)** | async, before props update                                             |
+| **[onWillPatch](component.md#willpatch)**             | just before the DOM is patched                                         |
+| **[onPatched](component.md#patched)**                 | just after the DOM is patched                                          |
+| **[onWillUnmount](component.md#willunmount)**         | just before removing component from DOM                                |
+| **[onWillDestroy](component.md#willdestroy)**         | just before component is destroyed                                     |
+| **[onError](component.md#onerror)**                   | catch and handle errors (see [error handling page](error_handling.md)) |
+
+## Other Hooks
 
 ### `useState`
 
@@ -178,9 +85,9 @@ The `useState` hook has to be given an object or an array, and will return
 an observed version of it (using a `Proxy`).
 
 ```javascript
-const { useState } = owl.hooks;
+const { useState, Component } = owl;
 
-class Counter extends owl.Component {
+class Counter extends Component {
   static template = xml`
     <button t-on-click="increment">
         Click Me! [<t t-esc="state.value"/>]
@@ -197,128 +104,38 @@ class Counter extends owl.Component {
 It is important to remember that `useState` only works with objects or arrays. It
 is necessary, since Owl needs to react to a change in state.
 
-### `onMounted`
-
-`onMounted` is not a user hook, but is a building block designed to help make useful
-abstractions. `onMounted` registers a callback, which will be called when the component
-is mounted (see example on top of this page).
-
-### `onWillUnmount`
-
-`onWillUnmount` is not a user hook, but is a building block designed to help make useful
-abstractions. `onWillUnmount` registers a callback, which will be called when the component
-is unmounted (see example on top of this page).
-
-### `onWillPatch`
-
-`onWillPatch` is not a user hook, but is a building block designed to help make useful
-abstractions. `onWillPatch` registers a callback, which will be called just
-before the component patched.
-
-### `onPatched`
-
-`onPatched` is not a user hook, but is a building block designed to help make useful
-abstractions. `onPatched` registers a callback, which will be called just
-after the component patched.
-
-### `onWillStart`
-
-`onWillStart` is an asynchronous hook. This means that the function registered
-in the hook will be run just before the component is first rendered and can return a
-promise, to express the fact that it is an asynchronous operation.
-
-Note that if there are more than one `onWillStart` registered callback, then they
-will all be run in parallel.
-
-It can be used to load some initial data. For example, the following hook will
-automatically load some data from the server, and return an object that will
-be ready whenever the component is rendered:
-
-```js
-function useLoader() {
-  const component = Component.current;
-  const record = useState({});
-  onWillStart(async () => {
-    const recordId = component.props.id;
-    Object.assign(record, await fetchSomeRecord(recordId));
-  });
-  return record;
-}
-```
-
-Note that this example does not update the record value whenever props are
-updated. For that situation, we need to use the `onWillUpdateProps` hook.
-
-### `onWillUpdateProps`
-
-Just like `onWillStart`, `onWillUpdateProps` is an asynchronous hook. It is
-designed to be run whenever the component props are updated. This could be
-useful to perform some asynchronous task such as fetching updated data.
-
-```js
-function useLoader() {
-  const component = Component.current;
-  const record = useState({});
-
-  async function updateRecord(id) {
-    Object.assign(record, await fetchSomeRecord(id));
-  }
-
-  onWillStart(() => updateRecord(component.props.id));
-  onWillUpdateProps((nextProps) => updateRecord(nextProps.id));
-
-  return record;
-}
-```
-
-Note that if there are more than one `onWillUpdateProps` registered callback,
-then they will all be run in parallel.
-
-### `useContext`
-
-See [`useContext`](context.md#usecontext) for reference documentation.
-
 ### `useRef`
 
 The `useRef` hook is useful when we need a way to interact with some inside part
-of a component, rendered by Owl. It can work either on a DOM node, or on a component,
+of a component, rendered by Owl. It only work on a html element tagged by the
-tagged by the `t-ref` directive:
+`t-ref` directive:
 
 ```xml
 <div>
-    <div t-ref="someDiv"/>
+    <input t-ref="someDiv"/>
-    <SubComponent t-ref="someComponent"/>
+    <span>hello</span>
 </div>
 ```
 
 In this example, the component will be able to access the `div` and the component
-`SubComponent` using the `useRef` hook:
+`SubComponent` with the `useRef` hook:
 
 ```js
 class Parent extends Component {
-  subRef = useRef("someComponent");
+  inputRef = useRef("someComponent");
-  divRef = useRef("someDiv");
 
   someMethod() {
     // here, if component is mounted, refs are active:
-    // - this.divRef.el is the div HTMLElement
+    // - this.inputRef.el is the input HTMLElement
-    // - this.subRef.comp is the instance of the sub component
-    // - this.subRef.el is the root HTML node of the sub component (i.e. this.subRef.comp.el)
   }
 }
 ```
 
-As shown by the example above, html elements are accessed by using the `el`
+As shown by the example above, the actual HTMLElement instance is accessed with
-key, and components references are accessed with `comp`.
+the `el` key.
-
-Notes:
-
-- if used on a component, the reference will be set in the `refs`
-  variable between `willPatch` and `patched`,
-- on a component, accessing `ref.el` will get the root node of the component.
 
 The `t-ref` directive also accepts dynamic values with string interpolation
-(like the [`t-attf-`](qweb_templating_language.md#dynamic-attributes) and
+(like the [`t-attf-`](templates.md#dynamic-attributes) and
 `t-component` directives). For example,
 
 ```xml
@@ -343,13 +160,12 @@ all components. But sometimes, we want to _scope_ that knowledge to a subtree.
 For example, if we have a form view component, maybe we would like to make some
 `model` object available to all sub components, but not to the whole application.
 This is where the `useSubEnv` hook may be useful: it lets a component add some
-information to the environment in a way that only the component and its children
+information to the environment in a way that only its children
 can access it:
 
 ```js
 class FormComponent extends Component {
-  constructor(...args) {
+  setup() {
-    super(...args);
     const model = makeModel();
     useSubEnv({ model });
   }
@@ -377,70 +193,121 @@ useExternalListener(window, "click", this.closeMenu);
 The `useComponent` hook is useful as a building block for some customized hooks,
 that may need a reference to the component calling them.
 
+```js
+function useSomething() {
+  const component = useComponent();
+  // now, component is bound to the instance of the current component
+}
+```
+
 ### `useEnv`
 
 The `useEnv` hook is useful as a building block for some customized hooks,
 that may need a reference to the env of the component calling them.
 
-### Making customized hooks
+```js
+function useSomething() {
+  const env = useEnv();
+  // now, env is bound to the env of the current component
+}
+```
 
-Hooks are a wonderful way to organize the code of a complex component by feature
+### `useEffect`
-instead of by lifecycle methods. They are like mixins, except that they can be
-easily composed together.
 
-But, like every good things in life, hooks should be used with moderation. They are
+This hook will run a callback when a component is mounted and patched, and
-not the solution to every problem.
+will run a cleanup function before patching and before unmounting the
+the component (only if some dependencies have changed).
 
-- they may be overkill: if your component needs to perform some action specific
+It has almost the same API as the React `useEffect` hook, except that the dependencies
-  to itself (so, the specific code does not need to be shared), there is nothing
+are defined by a function instead of just the dependencies.
-  wrong with a simple class method:
 
-  ```js
+The `useEffect` hook takes two function: the effect function and the dependency
-  // maybe overkill
+function. The effect function perform some task and return (optionally) a cleanup
-  class A extends Component {
+function. The dependency function returns a list of dependencies. If any of these
-    constructor(...args) {
+dependencies changes, then the current effect will be cleaned up and reexecuted.
-      super(...args);
+
-      useMySpecificHook();
+Here is an example without any dependencies:
-    }
+
+```js
+useEffect(
+  () => {
+    window.addEventListener("mousemove", someHandler);
+    return () => window.removeEventListener("mousemove", someHandler);
+  },
+  () => []
+);
+```
+
+In the example above, the dependency list is empty, so the effect is only cleaned
+up when the component is unmounted.
+
+If the dependency function is skipped, then the effect will be cleaned up and
+rerun at every patch.
+
+Here is another example, of how one could implement a `useAutofocus` hook with
+the `useEffect` hook:
+
+```js
+function useAutofocus(name) {
+  let ref = useRef(name);
+  useEffect(
+    (el) => el && el.focus(),
+    () => [ref.el]
+  );
+}
+```
+
+This hook takes the name of a valid `t-ref` directive, which should be present
+in the template. It then checks whenever the component is mounted or patched if
+the reference is not valid, and in this case, it will focus the node element.
+This hook can be used like this:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+    <div>
+        <input />
+        <input t-ref="myinput"/>
+    </div>`;
+
+  setup() {
+    useAutofocus("myinput");
   }
+}
+```
 
-  // ok
+## Example: mouse position
-  class B extends Component {
+
-    constructor(...args) {
+Here is the classical example of a non trivial hook to track the mouse position.
-      super(...args);
+
-      this.performSpecificTask();
+```js
-    }
+const { useState, onWillDestroy, Component } = owl;
+
+// We define here a custom behaviour: this hook tracks the state of the mouse
+// position
+function useMouse() {
+  const position = useState({ x: 0, y: 0 });
+
+  function update(e) {
+    position.x = e.clientX;
+    position.y = e.clientY;
   }
-  ```
+  window.addEventListener("mousemove", update);
+  onWillDestroy(() => {
+    window.removeEventListener("mousemove", update);
+  });
 
-  Note that the second solution is easier to extend in sub components.
+  return position;
+}
 
-- they may be harder to test: if a customized hook injects some external side
+// Main root component
-  effect dependency, then it is harder to test without doing some non obvious
+class Root extends Component {
-  manipulation. For example, assume that we want to give a reference to a
+  static template = xml`<div>Mouse: <t t-esc="mouse.x"/>, <t t-esc="mouse.y"/></div>`;
-  router in a `useRouter` hook. We could do this:
 
-  ```js
+  // this hooks is bound to the 'mouse' property.
-  const router = new Router(...);
+  mouse = useMouse();
+}
+```
 
-  function useRouter() {
+Note that we use the prefix `use` for hooks, just like in React. This is just
-      return router;
+a convention.
-  }
-  ```
-
-  As you can see, this does not _hook_ into the internal of the component. It
-  simply returns a global object, which is difficult to mock.
-
-  A better way would be to do something like this: get the reference from the
-  environment.
-
-  ```js
-  function useRouter() {
-    const env = useEnv();
-    return env.router;
-  }
-  ```
-
-  This means that we give control to the application developer to create the
-  router, which is good, so they can set it up, subclass it, ... And then, to
-  test our components, we can just add a mock router in the environment.

doc/reference/input_bindings.md

@@ -0,0 +1,92 @@
+# 🦉 Form Input Bindings 🦉
+
+It is very common to need to be able to read the value out of an html `input` (or
+`textarea`, or `select`) in order to use it (note: it does not need to be in a
+form!). A possible way to do this is to do it by hand:
+
+```js
+class Form extends owl.Component {
+  state = useState({ text: "" });
+
+  _updateInputValue(event) {
+    this.state.text = event.target.value;
+  }
+}
+```
+
+```xml
+<div>
+  <input t-on-input="_updateInputValue" />
+  <span t-esc="state.text" />
+</div>
+```
+
+This works. However, this requires a little bit of _plumbing_ code. Also, the
+plumbing code is slightly different if you need to interact with a checkbox,
+or with radio buttons, or with select tags.
+
+To help with this situation, Owl has a builtin directive `t-model`: its value
+should be an observed value in the component (usually `state.someValue`). With
+the `t-model` directive, we can write a shorter code, equivalent to the previous
+example:
+
+```js
+class Form extends owl.Component {
+  state = { text: "" };
+}
+```
+
+```xml
+<div>
+  <input t-model="state.text" />
+  <span t-esc="state.text" />
+</div>
+```
+
+The `t-model` directive works with `<input>`, `<input type="checkbox">`,
+`<input type="radio">`, `<textarea>` and `<select>`:
+
+```xml
+<div>
+    <div>Text in an input: <input t-model="state.someVal"/></div>
+    <div>Textarea: <textarea t-model="state.otherVal"/></div>
+    <div>Boolean value: <input type="checkbox" t-model="state.someFlag"/></div>
+    <div>Selection:
+        <select t-model="state.color">
+            <option value="">Select a color</option>
+            <option value="red">Red</option>
+            <option value="blue">Blue</option>
+        </select>
+    </div>
+    <div>
+        Selection with radio buttons:
+        <span>
+            <input type="radio" name="color" id="red" value="red" t-model="state.color"/>
+            <label for="red">Red</label>
+        </span>
+        <span>
+            <input type="radio" name="color" id="blue" value="blue" t-model="state.color" />
+            <label for="blue">Blue</label>
+        </span>
+    </div>
+</div>
+```
+
+Like event handling, the `t-model` directive accepts the following modifiers:
+
+| Modifier  | Description                                                          |
+| --------- | -------------------------------------------------------------------- |
+| `.lazy`   | update the value on the `change` event (default is on `input` event) |
+| `.number` | try to parse the value to a number (using `parseFloat`)              |
+| `.trim`   | trim the resulting value                                             |
+
+For example:
+
+```xml
+<input t-model.lazy="state.someVal" />
+```
+
+These modifiers can be combined. For instance, `t-model.lazy.number` will only
+update a number whenever the change is done.
+
+Note: the online playground has an example to show how it works.

doc/reference/misc.md

@@ -1,133 +0,0 @@
-# 🦉 Miscellaneous 🦉
-
-## Content
-
-- [Portal](#portal)
-- [AsyncRoot](#asyncroot)
-
-## `Portal`
-
-### Overview
-
-The component `Portal` is meant to be used as a transparent way to 'teleport' a piece
-of DOM to the node represented by its sole `target` props.
-
-This component aims at helping the implementation of the needed infrastructure
-for modals (as in `bootstrap-modal`).
-
-### Usage
-
-The content it will teleport is defined within the `<Portal>` node and
-internally uses the `default` [Slot](slots.md).
-
-This slot must contain only **one** node, which in turn can have as many children as necessary.
-
-The element under which the content will be teleported is represented as a selector
-by the `target` props which only accepts a string as value.
-
-The `target` props only supports static selector, and is not meant to be passed to `Portal`
-as a variable. Namely, `<Portal target="'body'" />` is the intended use.
-By contrast, `<Portal target="state.target" />` is not supported.
-
-The component `Portal` has no particular state, rather it is meant to be a slave to its parent,
-and ultimately just a way for the parent to teleport a piece of its own DOM elsewhere.
-
-The `Portal`'s root node is always `<portal/>` and is placed where the teleported content
-_would have_ been. It is this element that the [teleported events](#expected-behaviors) are re-directed on.
-
-### Example
-
-The canonic use-case is to implement a Dialog, where a Component may choose to break the natural
-workflow to help the user put in some data, which it could use later on.
-
-JavaScript:
-
-```js
-const { Component, mount } = owl;
-const { Portal } = owl.misc;
-
-class TeleportedComponent extends Component {}
-class App extends Component {
-  static components = { Portal, TeleportedComponent };
-}
-
-mount(App, { target: document.body });
-```
-
-XML:
-
-```xml
-<templates>
-    <div t-name="TeleportedComponent">
-        <span>I will move soon enough</span>
-    </div>
-
-    <div t-name="App">
-        <span>I am like the rest of us</span>
-        <Portal target="'body'">
-            <TeleportedComponent />
-        </Portal>
-    </div>
-</templates>
-```
-
-In this example, the `Portal` component will teleport the `TeleportedComponent`'s `div` as a child of the `body`.
-`TeleportedComponent` is acting as a Dialog here.
-
-The resulting DOM will look like:
-
-```xml
-<body>
-    <div>
-        <span>I am like the rest of us</span>
-        <portal></portal>
-    </div>
-    <div>
-        <span>I will move soon enough</span>
-    </div>
-</body>
-```
-
-### Expected Behaviors
-
-The teleported piece is updated as any other `Component`'s DOM and in the same sequence.
-Namely the teleported piece will be updated in function of its parents components, and patched as
-a normal child.
-
-The [_business_ events](event_handling.md#business-dom-events) triggered by a child component will be stopped
-to not bubble outside of the `target`. They will, on the other hand, be re-directed onto the
-`Portal`'s root node and bubble up the DOM as if it were triggered by a regular child component.
-
-Beware that those re-directed events are copies of the original event.
-They have:
-
-- The same payload.
-- The same `originalComponent` than their original counterpart,
-  that is the actual Component that triggered it.
-- A **different** `target` property than their original counterpart.
-  The `target` of a re-directed event is necessarily the `Portal`'s root node.
-
-Pure DOM events do not follow this pattern and are free to bubble their natural, unaltered way
-up to the `body`.
-
-## `AsyncRoot`
-
-When this component is used, a new rendering sub tree is created, such that the
-rendering of that component (and its children) is not tied to the rendering of
-the rest of the interface. It can be used on an asynchronous component, to
-prevent it from delaying the rendering of the whole interface, or on a
-synchronous one, such that its rendering isn't delayed by other (asynchronous)
-components. Note that this directive has no effect on the first rendering, but
-only on subsequent ones (triggered by state or props changes).
-
-```xml
-<div t-name="ParentComponent">
-  <SyncChild />
-  <AsyncRoot>
-     <AsyncChild/>
-  </AsyncRoot>
-</div>
-```
-
-The `AsyncRoot` assumes that there is exactly one root node inside it. It can
-be a dom node or a component.

doc/reference/mounting.md

@@ -1,60 +0,0 @@
-# 🦉 Mounting an application 🦉
-
-## Content
-
-- [Overview](#overview)
-- [API](#api)
-
-## Overview
-
-Mounting an Owl application is done by using the `mount` method (available in
-`owl.mount` if you are using the iife build, or it can be directly imported
-from `owl` if you are using a module system):
-
-```js
-const mount = { owl }; // if owl is available as an object
-
-const env = { ... };
-const app = await mount(MyComponent, { target: document.body, env });
-```
-
-Another example:
-
-```js
-const config = {
-  env: ...,
-  props: ...,
-  target: document.body,
-  position: "self",
-};
-const app = await mount(App, config);
-```
-
-A common way to initialize an application is to first setup an environment,
-then to call the `mount` method.
-
-## API
-
-Mount takes two parameters:
-
-- `C`, which should be a component class (NOT instance),
-- `params`, which is an object with the following keys:
-  - `target (HTMLElement | DocumentFragment)`: the target of the mount operation
-  - `env (optional, Env)` an environment
-  - `position (optional, "first-child" | "last-child" | "self")` the position
-    where it should be mounted (see below for more informations)
-  - `props (optional, any)`: some initial values that are given as props. Useful
-    when the root component is configurable, or when testing sub components
-
-Here are the various positions supported by Owl:
-
-- `first-child`: with this option, the component will be prepended inside the target,
-- `last-child` (default value): with this option, the component will be
-  appended in the target element,
-- `self`: the target will be used as the root element for the component. This
-  means that the target has to be an HTMLElement (and not a document fragment).
-  In this situation, it is possible that the component cannot be unmounted. For
-  example, if its target is `document.body`.
-
-The `mount` method returns a promise that resolves to the instance of the created
-component.

doc/reference/observer.md

@@ -1,52 +0,0 @@
-# 🦉 Observer 🦉
-
-Owl needs to be able to react to state changes. For example, whenever the state
-of a component is changed, Owl needs to rerender it. To help with that, there is
-an Observer class. Its job is to observe the state of an object (or array), and
-to react to any change. The observer is implemented with the native `Proxy`
-object. Note that this means that it will not work on older browsers.
-
-Note that the `Observer` is used by the `useState` and `useContext` hooks. This
-is the way most Owl applications will create observers. For the majority of
-use cases, there is no need to directly instantiate an observer.
-
-## Example
-
-For example, this code will display `update` in the console:
-
-```javascript
-const observer = new owl.core.Observer();
-observer.notifyCB = () => console.log("update");
-const obj = observer.observe({ a: { b: 1 } });
-
-obj.a.b = 2;
-```
-
-This example shows that an observer can observe nested properties.
-
-## Reference
-
-**observe** An observer can observe multiple values with the `observe` method.
-This method takes an object or an array as its argument and will return a proxy
-(which is mapped to the initial object/array). With this proxy, the observer
-can detect whenever any internal value is changed.
-
-**Registering a callback** Whenever an observer sees a state change, it will
-call its `notifyCB` method. No additional information is given to the callback.
-
-**deepRevNumber** Each observed value has an internal revision number, which
-is incremented every time the value is observed. Sometimes, it can be useful
-to obtain that number:
-
-```js
-const observer = new owl.core.Observer();
-const obj = observer.observe({ a: { b: 1 } });
-
-observer.revNumber(obj.a); // 1
-obj.a.b = 2;
-
-observer.revNumber(obj.a); // 2
-```
-
-The `revNumber` can also return 0, which indicates that the value is not
-observed.

doc/reference/portal.md

@@ -0,0 +1,17 @@
+# 🦉 Portal 🦉
+
+It is sometimes useful to be able to render some content outside the boundaries
+of a component. To do that, Owl provides a special directive: `t-portal`:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+      <div>this is inside the component</div>
+      <div t-portal="'body'">and this is outside</div>
+    `;
+}
+```
+
+The `t-portal` directive takes a valid css selector as argument. The content of
+the portalled template will be mounted at the corresponding location. Note that
+Owl need to insert an empty text node at the location of the portalled content.

doc/reference/props.md

@@ -4,8 +4,11 @@
 
 - [Overview](#overview)
 - [Definition](#definition)
-- [Good Practices](#good-practices)
+- [Binding function props](#binding-function-props)
 - [Dynamic Props](#dynamic-props)
+- [Default Props](#default-props)
+- [Props validation](#props-validation)
+- [Good Practices](#good-practices)
 
 ## Overview
 
@@ -38,8 +41,6 @@ The `props` object is made of every attributes defined on the template, with the
 following exceptions:
 
 - every attribute starting with `t-` are not props (they are QWeb directives),
-- `style` and `class` attributes are excluded as well (they are applied by Owl on
-  the root element of the component).
 
 In the following example:
 
@@ -47,7 +48,6 @@ In the following example:
 <div>
     <ComponentA a="state.a" b="'string'"/>
     <ComponentB t-if="state.flag" model="model"/>
-    <ComponentC style="color:red;" class="left-pane" />
 </div>
 ```
 
@@ -55,7 +55,188 @@ the `props` object contains the following keys:
 
 - for `ComponentA`: `a` and `b`,
 - for `ComponentB`: `model`,
-- for `ComponentC`: empty object
+
+## Binding function props
+
+It is common to have the need to pass a callback as a prop. Since Owl components
+are class based, the callback frequently needs to be bound to its owner component.
+So, one can do this:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+    <div>
+      <Child callback="doSomething"/>
+    </div>`;
+
+  setup() {
+    this.doSomething = this.doSomething.bind(this);
+  }
+
+  doSomething() {
+    // ...
+  }
+}
+```
+
+However, this is such a common use case that Owl provides a special suffix to do
+just that: `.bind`. This looks like this:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+    <div>
+      <Child callback.bind="doSomething"/>
+    </div>`;
+
+  doSomething() {
+    // ...
+  }
+}
+```
+
+## Dynamic Props
+
+The `t-props` directive can be used to specify totally dynamic props:
+
+```xml
+<div t-name="ParentComponent">
+    <Child t-props="some.obj"/>
+</div>
+```
+
+```js
+class ParentComponent {
+  static components = { Child };
+  some = { obj: { a: 1, b: 2 } };
+}
+```
+
+## Default Props
+
+If the static `defaultProps` property is defined, it will be used to complete
+props received by the parent, if missing.
+
+```js
+class Counter extends owl.Component {
+  static defaultProps = {
+    initialValue: 0,
+  };
+  ...
+}
+```
+
+In the example above, the `initialValue` props is now by default set to 0.
+
+## Props Validation
+
+As an application becomes complex, it may be quite unsafe to define props in an informal way. This leads to two issues:
+
+- hard to tell how a component should be used, by looking at its code.
+- unsafe, it is easy to send wrong props into a component, either by refactoring a component, or one of its parents.
+
+A props type system solves both issues, by describing the types and shapes
+of the props. Here is how it works in Owl:
+
+- `props` key is a static key (so, different from `this.props` in a component instance)
+- it is optional: it is ok for a component to not define a `props` key.
+- props are validated whenever a component is created/updated
+- props are only validated in `dev` mode (see [how to configure an app](app.md#configuration))
+- if a key does not match the description, an error is thrown
+- it validates keys defined in (static) `props`. Additional keys given by the
+  parent will cause an error (unless the special prop `*` is present).
+- it is an object or a list of strings
+- a list of strings is a simplified props definition, which only lists the name
+  of the props. Also, if the name ends with `?`, it is considered optional.
+- all props are by default required, unless they are defined with `optional: true`
+  (in that case, it is only done if there is a value)
+- valid types are: `Number, String, Boolean, Object, Array, Date, Function`, and all
+  constructor functions (so, if you have a `Person` class, it can be used as a type)
+- arrays are homogeneous (all elements have the same type/shape)
+
+For each key, a `prop` definition is either a boolean, a constructor, a list of constructors, or an object:
+
+- a boolean: indicate that the props exists, and is mandatory.
+- a constructor: this should describe the type, for example: `id: Number` describe
+  the props `id` as a number
+- a list of constructors. In that case, this means that we allow more than one
+  type. For example, `id: [Number, String]` means that `id` can be either a string
+  or a number.
+- an object. This makes it possible to have more expressive definition. The following sub keys are then allowed (but not mandatory):
+  - `type`: the main type of the prop being validated
+  - `element`: if the type was `Array`, then the `element` key describes the type of each element in the array. If it is not set, then we only validate the array, not its elements,
+  - `shape`: if the type was `Object`, then the `shape` key describes the interface of the object. If it is not set, then we only validate the object, not its elements,
+  - `validate`: this is a function which should return a boolean to determine if
+    the value is valid or not. Useful for custom validation logic.
+
+There is a special `*` prop that means that additional prop are allowed. This is
+sometimes useful for generic components that will propagate some or all their
+props to their child components.
+
+Examples:
+
+```js
+class ComponentA extends owl.Component {
+    static props = ['id', 'url'];
+
+    ...
+}
+
+class ComponentB extends owl.Component {
+  static props = {
+    count: {type: Number},
+    messages: {
+      type: Array,
+      element: {type: Object, shape: {id: Boolean, text: String }
+    },
+   date: Date,
+   combinedVal: [Number, Boolean]
+  };
+
+  ...
+}
+```
+
+```js
+  // only the existence of those 3 keys is documented
+  static props = ['message', 'id', 'date'];
+```
+
+```js
+  // only the existence of those 3 keys is documented. any other key is allowed.
+  static props = ['message', 'id', 'date', '*'];
+```
+
+```js
+  // size is optional
+  static props = ['message', 'size?'];
+```
+
+```js
+  static props = {
+    messageIds: {type: Array, element: Number},  // list of number
+    otherArr: {type: Array},   // just array. no validation is made on sub elements
+    otherArr2: Array,   // same as otherArr
+    someObj: {type: Object},  // just an object, no internal validation
+    someObj2: {
+      type: Object,
+      shape: {
+        id: Number,
+        name: {type: String, optional: true},
+        url: String
+      ]},    // object, with keys id (number), name (string, optional) and url (string)
+    someFlag: Boolean,     // a boolean, mandatory (even if `false`)
+    someVal: [Boolean, Date],   // either a boolean or a date
+    otherValue: true,     // indicates that it is a prop
+    kindofsmallnumber: {
+      type: Number,
+      validate: n => (0 <= n && n <= 10)
+    },
+    size: {
+      validate:  e => ["small", "medium", "large"].includes(e)
+    },
+  };
+```
 
 ## Good Practices
 
@@ -78,20 +259,3 @@ sent to the parent (for example, with an event).
 Any value can go in a props. Strings, objects, classes, or even callbacks could
 be given to a child component (but then, in the case of callbacks, communicating
 with events seems more appropriate).
-
-## Dynamic Props
-
-The `t-props` directive can be used to specify totally dynamic props:
-
-```xml
-<div t-name="ParentComponent">
-    <Child t-props="some.obj"/>
-</div>
-```
-
-```js
-class ParentComponent {
-  static components = { Child };
-  some = { obj: { a: 1, b: 2 } };
-}
-```

doc/reference/props_validation.md

@@ -1,103 +0,0 @@
-# 🦉 Props Validation 🦉
-
-As an application becomes complex, it may be quite unsafe to define props in an informal way. This leads to two issues:
-
-- hard to tell how a component should be used, by looking at its code.
-- unsafe, it is easy to send wrong props into a component, either by refactoring a component, or one of its parents.
-
-A props type system solves both issues, by describing the types and shapes
-of the props. Here is how it works in Owl:
-
-- `props` key is a static key (so, different from `this.props` in a component instance)
-- it is optional: it is ok for a component to not define a `props` key.
-- props are validated whenever a component is created/updated
-- props are only validated in `dev` mode (see [config page](config.md#mode))
-- if a key does not match the description, an error is thrown
-- it validates keys defined in (static) `props`. Additional keys given by the
-  parent will cause an error.
-
-For example:
-
-```js
-class ComponentA extends owl.Component {
-    static props = ['id', 'url'];
-
-    ...
-}
-
-class ComponentB extends owl.Component {
-  static props = {
-    count: {type: Number},
-    messages: {
-      type: Array,
-      element: {type: Object, shape: {id: Boolean, text: String }
-    },
-   date: Date,
-   combinedVal: [Number, Boolean]
-  };
-
-  ...
-}
-```
-
-- it is an object or a list of strings
-- a list of strings is a simplified props definition, which only lists the name
-  of the props. Also, if the name ends with `?`, it is considered optional.
-- all props are by default required, unless they are defined with `optional: true`
-  (in that case, validation is only done if there is a value)
-- valid types are: `Number, String, Boolean, Object, Array, Date, Function`, and all
-  constructor functions (so, if you have a `Person` class, it can be used as a type)
-- arrays are homogeneous (all elements have the same type/shape)
-
-For each key, a `prop` definition is either a boolean, a constructor, a list of constructors, or an object:
-
-- a boolean: indicate that the props exists, and is mandatory.
-- a constructor: this should describe the type, for example: `id: Number` describe
-  the props `id` as a number
-- a list of constructors. In that case, this means that we allow more than one
-  type. For example, `id: [Number, String]` means that `id` can be either a string
-  or a number.
-- an object. This makes it possible to have more expressive definition. The following sub keys are then allowed (but not mandatory):
-  - `type`: the main type of the prop being validated
-  - `element`: if the type was `Array`, then the `element` key describes the type of each element in the array. If it is not set, then we only validate the array, not its elements,
-  - `shape`: if the type was `Object`, then the `shape` key describes the interface of the object. If it is not set, then we only validate the object, not its elements,
-  - `validate`: this is a function which should return a boolean to determine if
-    the value is valid or not. Useful for custom validation logic.
-
-Examples:
-
-```js
-  // only the existence of those 3 keys is documented
-  static props = ['message', 'id', 'date'];
-```
-
-```js
-  // size is optional
-  static props = ['message', 'size?'];
-```
-
-```js
-  static props = {
-    messageIds: {type: Array, element: Number},  // list of number
-    otherArr: {type: Array},   // just array. no validation is made on sub elements
-    otherArr2: Array,   // same as otherArr
-    someObj: {type: Object},  // just an object, no internal validation
-    someObj2: {
-      type: Object,
-      shape: {
-        id: Number,
-        name: {type: String, optional: true},
-        url: String
-      ]},    // object, with keys id (number), name (string, optional) and url (string)
-    someFlag: Boolean,     // a boolean, mandatory (even if `false`)
-    someVal: [Boolean, Date],   // either a boolean or a date
-    otherValue: true,     // indicates that it is a prop
-    kindofsmallnumber: {
-      type: Number,
-      validate: n => (0 <= n && n <= 10)
-    },
-    size: {
-      validate:  e => ["small", "medium", "large"].includes(e)
-    },
-  };
-```

doc/reference/qweb_engine.md

@@ -1,153 +0,0 @@
-# 🦉 QWeb Engine 🦉
-
-## Content
-
-- [Overview](#overview)
-- [Reference](#reference)
-
-## Overview
-
-[QWeb](https://www.odoo.com/documentation/13.0/reference/qweb.html) is the primary
-templating engine used by Odoo. The QWeb class in the OWL project is an
-implementation of that specification with a few interesting points:
-
-- it compiles templates into functions that output a virtual DOM instead of a
-  string. This is necessary for the component system.
-- it has a few extra directives: `t-component`, `t-on`, ...
-
-We present in this section the engine, not the templating language.
-
-## Reference
-
-This section is about the javascript code that implements the `QWeb` specification.
-Owl exports a `QWeb` class in `owl.QWeb`. To use it, it just needs to be
-instantiated:
-
-```js
-const qweb = new owl.QWeb();
-```
-
-Its API is quite simple:
-
-- **`constructor(config)`**: constructor. Takes an optional configuration object
-  with an optional `templates` string to add initial
-  templates (see `addTemplates` for more information on format of the string)
-  and an optional `translateFn` translate function (see the section on
-  [translations](#translations)).
-
-  ```js
-  const qweb = new owl.QWeb({ templates: TEMPLATES, translateFn: _t });
-  ```
-
-- **`addTemplate(name, xmlStr, allowDuplicate)`**: add a specific template.
-
-  ```js
-  qweb.addTemplate("mytemplate", "<div>hello</div>");
-  ```
-
-  If the optional `allowDuplicate` is set to `true`, then `QWeb` will simply
-  ignore templates added for a second time. Otherwise, `QWeb` will crash.
-
-- **`addTemplates(xmlStr)`**: add a list of templates (identified by `t-name`
-  attribute).
-
-  ```js
-  const TEMPLATES = `
-    <templates>
-      <div t-name="App" class="main">main</div>
-      <div t-name="OtherComponent">other component</div>
-    </templates>`;
-  qweb.addTemplates(TEMPLATES);
-  ```
-
-- **`render(name, context, extra)`**: renders a template. This returns a `vnode`,
-  which is a virtual representation of the DOM (see [vdom doc](../miscellaneous/vdom.md)).
-
-  ```js
-  const vnode = qweb.render("App", component);
-  ```
-
-- **`renderToString(name, context)`**: renders a template, but returns an html
-  string.
-
-  ```js
-  const str = qweb.renderToString("someTemplate", somecontext);
-  ```
-
-- **`registerTemplate(name, template)`**: static function to register a global
-  QWeb template. This is useful for commonly used components accross the
-  application, and for making a template available to an application without
-  having a reference to the actual QWeb instance.
-
-  ```js
-  QWeb.registerTemplate("mytemplate", `<div>some template</div>`);
-  ```
-
-- **`registerComponent(name, Component)`**: static function to register an OWL Component
-  to QWeb's global registry. Globally registered Components can be used in
-  templates (see the `t-component` directive). This is useful for commonly used
-  components accross the application.
-
-  ```js
-  class Dialog extends owl.Component { ... }
-  QWeb.registerComponent("Dialog", Dialog);
-
-  ...
-
-  class ParentComponent extends owl.Component { ... }
-  qweb.addTemplate("ParentComponent", "<div><Dialog/></div>");
-  ```
-
-In some way, a `QWeb` instance is the core of an Owl application. It is the only
-mandatory element of an [environment](environment.md). As such, it
-has an extra responsibility: it can act as an event bus for internal communication
-between Owl classes. This is the reason why `QWeb` actually extends [EventBus](event_bus.md).
-
-### Translations
-
-take care of this and "cherry-pick" 8464a1b04e7469434f9dcb3d68a543f58cb61b8e
-
-If properly setup, Owl QWeb engine can translate all rendered templates. To do
-so, it needs a translate function, which takes a string and returns a string.
-
-For example:
-
-```js
-const translations = {
-  hello: "bonjour",
-  yes: "oui",
-  no: "non",
-};
-const translateFn = (str) => translations[str] || str;
-
-const qweb = new QWeb({ translateFn });
-```
-
-Once setup, all rendered templates will be translated using `translateFn`:
-
-- each text node will be replaced with its translation,
-- each of the following attribute values will be translated as well: `title`,
-  `placeholder`, `label` and `alt`,
-- translating text nodes can be disabled with the special attribute `t-translation`,
-  if its value is `off`.
-
-So, with the above `translateFn`, the following templates:
-
-```xml
-<div>hello</div>
-<div t-translation="off">hello</div>
-<div>Are you sure?</div>
-<input placeholder="hello" other="yes"/>
-```
-
-will be rendered as:
-
-```xml
-<div>bonjour</div>
-<div>hello</div>
-<div>Are you sure?</div>
-<input placeholder="bonjour" other="yes"/>
-```
-
-Note that the translation is done during the compilation of the template, not
-when it is rendered.

doc/reference/reactivity.md

@@ -0,0 +1,80 @@
+# 🦉 Reactivity 🦉
+
+## Content
+
+- [Overview](#overview)
+- [`useState`](#usestate)
+- [`reactive`](#reactive)
+
+## Overview
+
+Reactivity is a big topic in javascript frameworks. The goal is to provide a
+simple way to manipulate state, in such a way that the interface automatically
+update accordingly to state changes. Also, we obviously want this to happen in
+a performant way.
+
+To solve this issue, Owl provides two reactivity primitives:
+
+- `reactive`, which returns a proxy to its first argument, and tracks all read/update
+  operation going through it,
+- `useState`: a hook, that internally uses `reactive`, and is linked to its
+  owner component: any read operation will be tracked (key by key), and any
+  updates to these tracked values will cause the component to be rerendered.
+
+Most of the time, the `useState` hook is the best solution.
+
+## `useState`
+
+Let us start by an example of how `useState` could be used:
+
+```js
+class Counter extends Component {
+  static template = xml`
+    <div t-on-click="increment">
+      <t t-esc="state.value"/>
+    </div>`;
+
+  setup() {
+    this.state = useState({ value: 0 });
+  }
+
+  increment() {
+    this.state.value++;
+  }
+}
+```
+
+If one were to use a simple state object, Owl would not be aware that the value
+was changed and that the component should be rerendered. With the `useState`
+hook, `this.state` is now a reactive object, so this component works as expected.
+
+## `reactive`
+
+The `reactive` function is the basic reactivity primitive. It takes an object
+or an array as first argument, and optionally, a function as the second argument.
+The function will be called whenever any tracked value is updated.
+
+```js
+const obj = reactive({ a: 1 }, () => console.log("changed"));
+
+obj.a = 2; // does not log anything: the 'a' key was not read
+console.log(obj.a); // log 2, and reads the 'a' key => it is now tracked
+obj.a = 3; // log 'changed' because we updated a tracked value
+```
+
+An important property of reactive objects is that they can be reobserved: this
+will create an independant proxy that tracks another set of keys:
+
+```js
+const obj1 = reactive({ a: 1, b: 2 }, () => console.log("observer 1"));
+const obj2 = reactive(obj1, () => console.log("observer 2"));
+
+console.log(obj1.a); // log 1, and reads the 'a' key => it is now tracked by observer 1
+console.log(obj1.b); // log 2, and 'b' is now tracked by observer 1
+console.log(obj2.b); // log 2, and 'b' is now tracked by observer 1
+obj2.a = 3; // log 'observer1', because observer2 does not track a
+obj2.b = 3; // log 'observer1' and 'observer2'
+```
+
+Obviously, one can use `reactive` on the result of a `useState` if wanted, this
+is the proper way to watch for some state changes.

doc/reference/refs.md

@@ -0,0 +1,37 @@
+# 🦉 References 🦉
+
+The `useRef` hook is useful when we need a way to interact with some inside part
+of a component, rendered by Owl. It can work either on a DOM node, or on a component,
+targeted by the `t-ref` directive. See the [hooks section](hooks.md#useref) for
+more detail.
+
+As a short example, here is how we could set the focus on a given input:
+
+```xml
+<div>
+    <input t-ref="input"/>
+    <button t-on-click="focusInput">Click</button>
+</div>
+```
+
+```js
+import { useRef } from "owl/hooks";
+
+class SomeComponent extends Component {
+  inputRef = useRef("input");
+
+  focusInput() {
+    this.inputRef.el.focus();
+  }
+}
+```
+
+Be aware that the `el` property will only be set when the target of the `t-ref`
+directive is mounted in the DOM. Otherwise, it will be set to `null`.
+
+The `useRef` hook cannot be used to get a reference to an instance of a sub
+component.
+
+Note that this example uses the suffix `ref` to name the reference. This
+is not mandatory, but it is a useful convention, so we do not forget that it is
+a reference object.

doc/reference/slots.md

@@ -3,68 +3,89 @@
 ## Content
 
 - [Overview](#overview)
-- [Example](#example)
+- [Named slots](#named-slots)
-- [Reference](#reference)
+- [Rendering Context](#rendering-context)
+- [Default Slot](#default-slot)
+- [Default Content](#default-content)
+- [Dynamic slots](#dynamic-slots)
+- [Slots and props](#slots-and-props)
+- [Slot params](#slot-params)
+- [Slot scopes](#slot-scopes)
 
 ## Overview
 
 Owl is a template based component system. There is therefore a need to be able
-to make generic components. For example, imagine a generic `Dialog`
+to make generic components. For example, imagine a generic `Navbar`
-component, which is able to display some arbitrary content.
+component, which displays a navbar, but with some customizable content. Since
-
+the specific content is only known to the user of the `Navbar`, it would be nice
-Obviously, we want to use this component everywhere in our application, to
+to specify it in the template where `Navbar` is used:
-display various different content. The `Dialog` component is technically the
-owner of its content, but is only a container. The user of the `Dialog` is
-the component that want to _inject_ something inside the `Dialog`. This is
-exactly what slots are for.
-
-## Example
-
-To make generic components, it is useful to be able for a parent component to _inject_
-some sub template, but still be the owner. For example, a generic dialog component
-will need to render some content, some footer, but with the parent as the
-rendering context.
-
-Slots are inserted with the `t-slot` directive:
 
 ```xml
-<div t-name="Dialog" class="modal">
+  <div>
-  <div class="modal-title"><t t-esc="props.title"/></div>
+    <Navbar>
-  <div class="modal-content">
+      <span>Hello Owl</span>
+    </Navbar>
+  </div>
+```
+
+This is exactly the way slots work! In the example above, the user of the `Navbar`
+component specify some content (here, in the default slot). The `Navbar`
+component can insert that content in its own template at the appropriate location.
+An important information to notice is that the content of the slot is rendered in
+the parent context, not in the navbar. As such, it can access values and methods
+from the parent component.
+
+Here is how the `Navbar` component could be defined, with the `t-slot` directive:
+
+```xml
+<div class="navbar">
+  <t t-slot="default"/>
+  <ul>
+    <!-- rest of the navbar here -->
+  </ul>
+</div>
+```
+
+## Named slots
+
+Default slots are very useful, but sometimes, we may need more than one slot.
+This is what named slots are for! For example, suppose we implement a component
+`InfoBox` that display a title and some specific content. Its template could look
+like this:
+
+```xml
+<div class="info-box">
+  <div class="info-box-title">
+    <t t-slot="title"/>
+    <span class="info-box-close-button" t-on-click="close">X</span>
+  </div>
+  <div class="info-box-content">
     <t t-slot="content"/>
   </div>
-  <div class="modal-footer">
-    <t t-slot="footer"/>
-  </div>
 </div>
 ```
 
-Slots are defined by the caller, with the `t-set-slot` directive:
+And one could use it with the `t-set-slot` directive:
 
 ```xml
-<div t-name="SomeComponent">
+<InfoBox>
-  <div>some component</div>
+  <t t-set-slot="title">
-  <Dialog title="'Some Dialog'">
+    Specific Title. It could be html also.
-    <t t-set-slot="content">
+  </t>
-      <div>hey</div>
+  <t t-set-slot="content">
-    </t>
+    <!-- some template here, with html, events, whatever -->
-    <t t-set-slot="footer">
+  </t>
-      <button t-on-click="doSomething">ok</button>
+</InfoBox>
-    </t>
-  </Dialog>
-</div>
 ```
 
-In this example, the component `Dialog` will render the slots `content` and `footer`
+## Rendering context
-with its parent as rendering context. This means that clicking on the button
-will execute the `doSomething` method on the parent, not on the dialog.
 
-Note: Owl previously used the `t-set` directive to define the content of a slot.
+The content of the slots is actually rendered with the rendering context corresponding
-This is deprecated and should no longer be used in new code.
+to where it was defined, not where it is positioned. This allows the user to define
+event handlers that will be bound to the correct component (usually, the
+grandparent of the slot content).
 
-## Reference
+## Default Slot
-
-### Default Slot
 
 The first element inside the component which is not a named slot will
 be considered the `default` slot. For example:
@@ -81,7 +102,19 @@ be considered the `default` slot. For example:
 </div>
 ```
 
-### Default content
+One can mix default slot and named slots:
+
+```xml
+<div>
+  <Child>
+    default content
+    <t t-set-slot="footer">
+      content for footer slot here
+  </Child>
+</div>
+```
+
+## Default content
 
 Slots can define a default content, in case the parent did not define them:
 
@@ -96,12 +129,7 @@ Slots can define a default content, in case the parent did not define them:
 <!-- will be rendered as: <div><span>default content</span></div> -->
 ```
 
-Rendering context: the content of the slots is actually rendered with the
+## Dynamic Slots
-rendering context corresponding to where it was defined, not where it is
-positioned. This allows the user to define event handlers that will be bound
-to the correct component (usually, the grandparent of the slot content).
-
-### Dynamic Slots
 
 The `t-slot` directive is actually able to use any expressions, using string
 interplolation:
@@ -109,3 +137,102 @@ interplolation:
 ```xml
  <t t-slot="{{current}}" />
 ```
+
+This will evaluate the `current` expression, and insert the corresponding slot
+at the place of the `t-slot` directive.
+
+## Slots and props
+
+In a sense, slots are almost the same as a prop: they define some information
+to pass to the child component. To make it possible to use it, and to pass it
+down to sub component, Owl actually define a special prop `slots` that contains
+all slot information given to the component. It looks like this:
+
+```js
+{ slotName_1: slotInfo_1, ..., slotName_m: slotInfo_m }
+```
+
+So, a component can pass its slots to a subcomponent like this:
+
+```xml
+<Child slots="props.slots"/>
+```
+
+## Slot params
+
+For advanced usecases, it may be necessary to pass additional information to a
+slot. This can be done by providing extra key/value pairs to the `t-set-slot`
+directive. Then, the generic component can read them in its prop `slots`.
+
+For example, here is how a Notebook component could be implemented (a component
+with multiple page, and a tab bar, which only render the current active page,
+and each page has a title).
+
+```js
+class Notebook extends Component {
+  static template = xml`
+    <div class="notebook">
+      <div class="tabs">
+        <t t-foreach="tabNames" t-as="tab" t-key="tab_index">
+          <span t-att-class="{active:tab_index === activeTab}" t-on-click="() => state.activeTab=tab">
+            <t t-esc="props.slots[tab].title"/>
+          </span>
+        </t>
+      </div>
+      <div class="page">
+        <t t-slot="{{currentSlot}}"/>
+      </div>
+    </div>`;
+
+  setup() {
+    this.state = useState({ activeTab: 0 });
+    this.tabNames = Object.keys(this.props.slots);
+  }
+
+  get currentSlot() {
+    return this.tabNames[this.state.activeTab];
+  }
+}
+```
+
+Notice how one can read the `title` value for each slots. Here is how one could
+use this `Notebook` component:
+
+```xml
+<Notebook>
+  <t t-set-slot="page1" title="'Page 1'">
+    <div>this is in the page 1</div>
+  </t>
+  <t t-set-slot="page2" title="'Page 2'" hidden="somevalue">
+    <div>this is in the page 2</div>
+  </t>
+</Notebook>
+```
+
+## Slot scopes
+
+For other kind of advanced use cases, the content of a slot may depends on some
+specific information specific to the generic component. This is the opposite
+of the slot params.
+
+To solve this kind of problems, one can use the `t-set-scope` directive along
+with the `t-set-slot`. This defines the name of a variable that can access
+everything given by the child component:
+
+```xml
+<div>
+    <t t-set-slot="foo" t-set-scope="scope">
+        content
+        <t t-esc="scope.bool"/>
+        <t t-esc="scope.num"/>
+    </t>
+</div>
+```
+
+And the child component that includes the slot can provide values like this:
+
+```xml
+<div>
+    <t t-slot="foo" bool="other_var" num="5">
+</div>
+```

doc/reference/tags.md

@@ -1,184 +0,0 @@
-# 🦉 Tags 🦉
-
-## Content
-
-- [Overview](#overview)
-- [`xml` tag](#xml-tag)
-- [`css` tag](#css-tag)
-
-## Overview
-
-Tags are very small helpers intended to make it easy to write inline templates
-or styles. There are currently two tags: `css` and `xml`. With these functions,
-it is possible to write [single file components](../learning/how_to_write_sfc.md).
-
-## XML tag
-
-The `xml` tag is certainly the most useful tag. It is used to define an inline
-QWeb template for a component. Without tags, creating a standalone component
-would look like this:
-
-```js
-import { Component } from 'owl'
-
-const name = 'some-unique-name';
-const template = `
-    <div>
-        <span t-if="somecondition">text</span>
-        <button t-on-click="someMethod">Click</button>
-    </div>
-`;
-QWeb.registerTemplate(name, template);
-
-class MyComponent extends Component {
-    static template = name;
-
-    ...
-}
-```
-
-With tags, this process is slightly simplified. The name is uniquely generated,
-and the template is automatically registered:
-
-```js
-const { Component } = owl;
-const { xml } = owl.tags;
-
-class MyComponent extends Component {
-    static template = xml`
-        <div>
-            <span t-if="somecondition">text</span>
-            <button t-on-click="someMethod">Click</button>
-        </div>
-    `;
-
-    ...
-}
-```
-
-## CSS tag
-
-The CSS tag is useful to define a css stylesheet in the javascript file:
-
-```js
-class MyComponent extends Component {
-  static template = xml`
-        <div class="my-component">some template</div>
-    `;
-  static style = css`
-    .my-component {
-      color: red;
-    }
-  `;
-}
-```
-
-The `css` tag registers internally the css information. Then, whenever the first
-instance of the component is created, will add a `<style>` tag to the document
-`<head>`.
-
-Note that to make it more useful, like other css preprocessors, the `css` tag
-accepts a small extension of the css specification: css scopes can be nested,
-and the rules will then be expanded by the `css` helper:
-
-```scss
-.my-component {
-  display: block;
-  .sub-component h {
-    color: red;
-  }
-}
-```
-
-will be formatted as:
-
-```css
-.my-component {
-  display: block;
-}
-.my-component .sub-component h {
-  color: red;
-}
-```
-
-This extension brings another useful feature: the `&` selector which refers to
-the parent selector. For example, we want our component to be red when hovered.
-We would like to write something like:
-
-```scss
-.my-component {
-  display: block;
-  :hover {
-    color: red;
-  }
-}
-```
-
-but it will be formatted as:
-
-```css
-.my-component {
-  display: block;
-}
-.my-component :hover {
-  color: red;
-}
-```
-
-The `&` selector can be used to solve this problem:
-
-```scss
-.my-component {
-  display: block;
-  &:hover {
-    color: red;
-  }
-}
-```
-
-will be formatted as:
-
-```css
-.my-component {
-  display: block;
-}
-.my-component:hover {
-  color: red;
-}
-```
-
-Now, there is no additional processing done by the `css` tag. However, since it
-is done in javascript at runtime, we actually have more power. For example:
-
-1. sharing values between javascript and css:
-
-```js
-import { theme } from "./theme";
-
-class MyComponent extends Component {
-  static template = xml`<div class="my-component">...</div>`;
-  static style = css`
-    .my-component {
-      color: ${theme.MAIN_COLOR};
-      background-color: ${theme.SECONDARY_color};
-    }
-  `;
-}
-```
-
-2. scoping rules to the current component:
-
-```js
-import { generateUUID } from "./utils";
-
-const uuid = generateUUID();
-
-class MyComponent extends Component {
-  static template = xml`<div data-o-${uuid}="">...</div>`;
-  static style = css`
-    [data-o-${uuid}] {
-      color: red;
-    }
-  `;
-}
-```

doc/reference/templates.md

@@ -1,12 +1,11 @@
-# 🦉 QWeb Templating Language🦉
+# 🦉 Templates 🦉
 
 ## Content
 
 - [Overview](#overview)
 - [Directives](#directives)
-- [Reference](#reference)
+- [QWeb Template reference](#qweb-template-reference)
   - [White Spaces](#white-spaces)
-  - [Root Nodes](#root-nodes)
   - [Expression Evaluation](#expression-evaluation)
   - [Static html Nodes](#static-html-nodes)
   - [Outputting Data](#outputting-data)
@@ -16,17 +15,19 @@
   - [Dynamic Class Attribute](#dynamic-class-attribute)
   - [Dynamic Tag Names](#dynamic-tag-names)
   - [Loops](#loops)
-  - [Rendering Sub Templates](#rendering-sub-templates)
+  - [Sub Templates](#sub-templates)
   - [Dynamic Sub Templates](#dynamic-sub-templates)
-  - [Translations](#translations)
   - [Debugging](#debugging)
+- [Fragments](#fragments)
+- [Inline templates](#inline-templates)
+- [Rendering svg](#rendering-svg)
 
 ## Overview
 
-[QWeb](https://www.odoo.com/documentation/13.0/reference/qweb.html) is the primary
+Owl templates are describe using the [QWeb](https://www.odoo.com/documentation/13.0/reference/qweb.html) specification. It is based on the XML format, and used
-templating engine used by Odoo. It is based on the XML format, and used
 mostly to generate HTML. In OWL, QWeb templates are compiled into functions that
-generate a virtual dom representation of the HTML.
+generate a virtual dom representation of the HTML. Also, since Owl is a live
+component system, there are additional directives specific to Owl (such as `t-on`).
 
 ```xml
 <div>
@@ -53,34 +54,33 @@ extensions.
 
 For reference, here is a list of all standard QWeb directives:
 
-| Name                           | Description                                                    |
+| Name                           | Description                                                     |
-| ------------------------------ | -------------------------------------------------------------- |
+| ------------------------------ | --------------------------------------------------------------- |
-| `t-esc`                        | [Outputting safely a value](#outputting-data)                  |
+| `t-esc`                        | [Outputting safely a value](#outputting-data)                   |
-| `t-raw`                        | [Outputting value, without escaping](#outputting-data)         |
+| `t-out`                        | [Outputting value, possibly without escaping](#outputting-data) |
-| `t-set`, `t-value`             | [Setting variables](#setting-variables)                        |
+| `t-set`, `t-value`             | [Setting variables](#setting-variables)                         |
-| `t-if`, `t-elif`, `t-else`,    | [conditionally rendering](#conditionals)                       |
+| `t-if`, `t-elif`, `t-else`,    | [conditionally rendering](#conditionals)                        |
-| `t-foreach`, `t-as`            | [Loops](#loops)                                                |
+| `t-foreach`, `t-as`            | [Loops](#loops)                                                 |
-| `t-att`, `t-attf-*`, `t-att-*` | [Dynamic attributes](#dynamic-attributes)                      |
+| `t-att`, `t-attf-*`, `t-att-*` | [Dynamic attributes](#dynamic-attributes)                       |
-| `t-call`                       | [Rendering sub templates](#rendering-sub-templates)            |
+| `t-call`                       | [Rendering sub templates](#sub-templates)                       |
-| `t-debug`, `t-log`             | [Debugging](#debugging)                                        |
+| `t-debug`, `t-log`             | [Debugging](#debugging)                                         |
-| `t-translation`                | [Disabling the translation of a node](#translations)           |
+| `t-translation`                | [Disabling the translation of a node](translations.md)          |
-| `t-name`                       | [Defining a template (not really a directive)](qweb_engine.md) |
 
 The component system in Owl requires additional directives, to express various
 needs. Here is a list of all Owl specific directives:
 
-| Name                     | Description                                                                     |
+| Name                                   | Description                                                     |
-| ------------------------ | ------------------------------------------------------------------------------- |
+| -------------------------------------- | --------------------------------------------------------------- |
-| `t-component`, `t-props` | [Defining a sub component](component.md#composition)                            |
+| `t-component`, `t-props`               | [Defining a sub component](component.md#sub-components)         |
-| `t-ref`                  | [Setting a reference to a dom node or a sub component](component.md#references) |
+| `t-ref`                                | [Setting a reference to a dom node or a sub component](refs.md) |
-| `t-key`                  | [Defining a key (to help virtual dom reconciliation)](#loops)                   |
+| `t-key`                                | [Defining a key (to help virtual dom reconciliation)](#loops)   |
-| `t-on-*`                 | [Event handling](event_handling.md)                                             |
+| `t-on-*`                               | [Event handling](event_handling.md)                             |
-| `t-transition`           | [Defining an animation](animations.md#css-transitions)                          |
+| `t-portal`                             | [Portal](portal.md)                                             |
-| `t-slot`                 | [Rendering a slot](slots.md)                                                    |
+| `t-slot`, `t-set-slot`, `t-slot-scope` | [Rendering a slot](slots.md)                                    |
-| `t-model`                | [Form input bindings](component.md#form-input-bindings)                         |
+| `t-model`                              | [Form input bindings](input_bindings.md)                        |
-| `t-tag`                  | [Rendering nodes with dynamic tag name](#dynamic-tag-names)                     |
+| `t-tag`                                | [Rendering nodes with dynamic tag name](#dynamic-tag-names)     |
 
-## Reference
+## QWeb Template Reference
 
 ### White Spaces
 
@@ -90,32 +90,6 @@ White spaces in a template are handled in a special way:
 - if a whitespace-only text node contains a linebreak, it is ignored
 - the previous rules do not apply if we are in a `<pre>` tag
 
-### Root Nodes
-
-For many reasons, Owl QWeb templates should have a single root node. More
-precisely, the result of a template rendering should have a single root node:
-
-```xml
-<!–– not ok: two root nodes ––>
-<t>
-    <div>foo</div>
-    <div>bar</div>
-</t>
-
-<!–– ok: result has one single root node ––>
-<t>
-    <div t-if="someCondition">foo</div>
-    <span t-else="">bar</span>
-</t>
-```
-
-Extra root nodes will actually be ignored (even though they will be rendered
-in memory).
-
-Note: this does not apply to subtemplates (see the `t-call` directive). In that
-case, they will be inlined in the main template, and can actually have many
-root nodes.
-
 ### Expression Evaluation
 
 QWeb expressions are strings that will be processed at compile time. Each variable in
@@ -190,24 +164,29 @@ rendered with the value `value` set to `42` in the rendering context yields:
 <p>42</p>
 ```
 
-The `t-raw` directive is almost the same as `t-esc`, but without the escaping.
+The `t-out` directive is almost the same as `t-esc`, but possibly without the
-This is mostly useful to inject a raw html string somewhere. Obviously, this
+escaping. The difference is that the value received by the `t-out` directive
-is unsafe to do in general, and should only be used for strings known to be safe.
+will only be not-escaped if it has been marked as such, using the `markup`
+utility function:
 
-```xml
+For example, in the following component:
-<p><t t-raw="value"/></p>
+
+```js
+const { markup, Component, xml } = owl;
+
+class SomeComponent extends Component {
+  static template = xml`
+    <t t-out="value1"/>
+    <t t-out="value2"/>`;
+
+  value1 = "<div>some text 1</div>";
+  value2 = markup("<div>some text 2</div>");
+}
 ```
 
-rendered with the value `value` set to `<span>foo</span>` in the rendering context yields:
+The first `t-out` will act as a `t-esc` directive, which means that the content
-
+of `value1` will be escaped. However, since `value2` has been tagged as a markup,
-```html
+this will be injected as html.
-<p><span>foo</span></p>
-```
-
-Note that since the content of the expression is not known beforehand, the `t-raw`
-directive has to parse the html (and convert it to a virtual dom structure) for
-each rendering. So, it will be much slower than a regular template. It is
-therefore advised to limit the use of `t-raw` whenever possible.
 
 ### Setting Variables
 
@@ -368,7 +347,7 @@ collection to iterate on, and a second parameter `t-as` providing the name to us
 for the current item of the iteration:
 
 ```xml
-<t t-foreach="[1, 2, 3]" t-as="i">
+<t t-foreach="[1, 2, 3]" t-as="i" t-key="i">
     <p><t t-esc="i"/></p>
 </t>
 ```
@@ -384,13 +363,17 @@ will be rendered as:
 Like conditions, `t-foreach` applies to the element bearing the directive’s attribute, and
 
 ```xml
-<p t-foreach="[1, 2, 3]" t-as="i">
+<p t-foreach="[1, 2, 3]" t-as="i" t-key="i">
     <t t-esc="i"/>
 </p>
 ```
 
 is equivalent to the previous example.
 
+An important difference should be made with the usual `QWeb` behaviour: Owl
+requires the presence of a `t-key` directive, to be able to properly reconcile
+renderings.
+
 `t-foreach` can iterate on an array (the current item will be the current value)
 or an object (the current item will be the current key).
 
@@ -416,7 +399,7 @@ into the global context.
 <t t-set="existing_variable" t-value="false"/>
 <!-- existing_variable now False -->
 
-<p t-foreach="Array(3)" t-as="i">
+<p t-foreach="Array(3)" t-as="i" t-key="i">
     <t t-set="existing_variable" t-value="true"/>
     <t t-set="new_variable" t-value="true"/>
     <!-- existing_variable and new_variable now true -->
@@ -430,17 +413,14 @@ Even though Owl tries to be as declarative as possible, the DOM does not fully
 expose its state declaratively in the DOM tree. For example, the scrolling state,
 the current user selection, the focused element or the state of an input are not
 set as attribute in the DOM tree. This is why we use a virtual dom
-algorithm to keep the actual DOM node as much as possible.
+algorithm to make sure we keep the actual DOM node instead of replacing it with
-
+a new one.
-However, in some situations, this is not enough, and we need to help Owl decide
-if an element is actually the same, or is a different element with the same
-properties.
 
 Consider the following situation: we have a list of two items `[{text: "a"}, {text: "b"}]`
 and we render them in this template:
 
 ```xml
-<p t-foreach="items" t-as="item"><t t-esc="item.text"/></p>
+<p t-foreach="items" t-as="item" t-key="item_index"><t t-esc="item.text"/></p>
 ```
 
 The result will be two `<p>` tags with text `a` and `b`. Now, if we swap them,
@@ -501,7 +481,7 @@ using the `...` javascript operator. For example:
 The `...` operator will convert the `Set` (or any other iterables) into a list,
 which will work with Owl QWeb.
 
-### Rendering Sub Templates
+### Sub Templates
 
 QWeb templates can be used for top level rendering, but they can also be used
 from within another template (to avoid duplication or give names to parts of
@@ -574,21 +554,6 @@ using string interpolation. For example:
 Here, the name of the template is obtained from the `template` value in the
 template rendering context.
 
-### Translations
-
-By default, QWeb specify that templates should be translated. If this behaviour
-is not wanted, there is a `t-translation` directive which can turn off
-translations (if it is set to the `off` value), with the following rules:
-
-- each text node will be replaced with its translation,
-- each of the following attribute values will be translated as well: `title`,
-  `placeholder`, `label` and `alt`,
-- translating text nodes can be disabled with the special attribute `t-translation`,
-  if its value is `off`.
-
-See [here](qweb_engine.md#translations) for more information on how to setup a
-translate function in Owl QWeb.
-
 ### Debugging
 
 The javascript QWeb implementation provides two useful debugging directives:
@@ -611,3 +576,105 @@ will stop execution if the browser dev tools are open.
 ```
 
 will print 42 to the console.
+
+## Fragments
+
+Owl 2 supports templates with an arbitrary number of root elements, or even just
+a text node. So, the following templates are all valid:
+
+```xml
+hello owl. This is just a text node!
+```
+
+```xml
+<div>hello</div>
+```
+
+```xml
+<div>hello</div>
+<div>ola</div>
+```
+
+```xml
+<div t-if="someCondition"><SomeChildComponent/></div>
+```
+
+```xml
+<t t-if="someCondition"><SomeChildComponent/></t>
+```
+
+## Inline templates
+
+Most real applications will define their templates in a XML file, to benefit
+from the XML ecosystem, and to do some additional processing, such as translating
+them. However, in some cases, it is convenient to be able to define a template
+inline. To do so, one can use the `xml` helper function:
+
+```js
+const { Component, xml } = owl;
+
+class MyComponent extends Component {
+  static template = xml`
+      <div>
+          <span t-if="somecondition">text</span>
+          <button t-on-click="someMethod">Click</button>
+      </div>
+  `;
+
+    ...
+}
+
+mount(MyComponent, document.body);
+```
+
+This function simply generates an unique string id, and register the template
+under that id in the internals of Owl, then return the id.
+
+## Rendering svg
+
+Owl components can be used to generate dynamic SVG graphs:
+
+```js
+class Node extends Component {
+  static template = xml`
+        <g>
+            <circle t-att-cx="props.x" t-att-cy="props.y" r="4" fill="black"/>
+            <text t-att-x="props.x - 5" t-att-y="props.y + 18"><t t-esc="props.node.label"/></text>
+            <t t-set="childx" t-value="props.x + 100"/>
+            <t t-set="height" t-value="props.height/(props.node.children || []).length"/>
+            <t t-foreach="props.node.children || []" t-as="child">
+                <t t-set="childy" t-value="props.y + child_index*height"/>
+                <line t-att-x1="props.x" t-att-y1="props.y" t-att-x2="childx" t-att-y2="childy" stroke="black" />
+                <Node x="childx" y="childy" node="child" height="height"/>
+            </t>
+        </g>
+    `;
+  static components = { Node };
+}
+
+class RootNode extends Component {
+  static template = xml`
+        <svg height="180">
+            <Node node="graph" x="10" y="20" height="180"/>
+        </svg>
+    `;
+  static components = { Node };
+  graph = {
+    label: "a",
+    children: [
+      { label: "b" },
+      { label: "c", children: [{ label: "d" }, { label: "e" }] },
+      { label: "f", children: [{ label: "g" }] },
+    ],
+  };
+}
+```
+
+This `RootNode` component will then display a live SVG representation of the
+graph described by the `graph` property. Note that there is a recursive structure
+here: the `Node` component uses itself as a subcomponent.
+
+Note that since SVG needs to be handled in a specific way (its namespace needs
+to be properly set), there is a small constraint for Owl components: if an owl
+component is supposed to be a part of an svg graph, then its root node needs to
+be a `g` tag, so Owl can properly set the namespace.

doc/reference/translations.md

@@ -0,0 +1,59 @@
+# 🦉 Translations 🦉
+
+If properly setup, Owl can translate all rendered templates. To do
+so, it needs a translate function, which takes a string and returns a string.
+
+For example:
+
+```js
+const translations = {
+  hello: "bonjour",
+  yes: "oui",
+  no: "non",
+};
+const translateFn = (str) => translations[str] || str;
+
+const app = new App(Root, { templates, tranaslateFn });
+// ...
+```
+
+See the [app configuration page](app.md#configuration) for more info on how to
+configure an Owl application.
+
+Once setup, all rendered templates will be translated using `translateFn`:
+
+- each text node will be replaced with its translation,
+- each of the following attribute values will be translated as well: `title`,
+  `placeholder`, `label` and `alt`,
+- translating text nodes can be disabled with the special attribute `t-translation`,
+  if its value is `off`.
+
+So, with the above `translateFn`, the following templates:
+
+```xml
+<div>hello</div>
+<div t-translation="off">hello</div>
+<div>Are you sure?</div>
+<input placeholder="hello" other="yes"/>
+```
+
+will be rendered as:
+
+```xml
+<div>bonjour</div>
+<div>hello</div>
+<div>Are you sure?</div>
+<input placeholder="bonjour" other="yes"/>
+```
+
+Note that the translation is done during the compilation of the template, not
+when it is rendered.
+
+In some case, it is useful to be able to extend the list of translatable attributes.
+For example, one may want to also translate `data-title` attributes. To do that,
+we can define additional attributes with the `translatableAttributes` option:
+
+```js
+const app = new App(Root, { templates, tranaslateFn, translatalbeAttributes: ["data-title"] });
+// ...
+```

doc/reference/utils.md

@@ -6,11 +6,8 @@ functions are all available in the `owl.utils` namespace.
 ## Content
 
 - [`whenReady`](#whenready): executing code when DOM is ready
-- [`loadJS`](#loadjs): loading script files
 - [`loadFile`](#loadfile): loading a file (useful for templates)
-- [`escape`](#escape): sanitizing strings
+- [`EventBus`](#eventbus): a simple EventBus
-- [`debounce`](#debounce): limiting rate of function calls
-- [`shallowEqual`](#shallowequal): shallow object comparison
 
 ## `whenReady`
 
@@ -19,40 +16,20 @@ not ready yet, resolved directly otherwise). If called with a callback as
 argument, it executes it as soon as the DOM ready (or directly).
 
 ```js
-Promise.all([loadFile("templates.xml"), owl.utils.whenReady()]).then(function ([templates]) {
+const { whenReady } = owl;
-  const qweb = new owl.QWeb({ templates });
+
-  const env = { qweb };
+await whenReady();
-  await mount(App, { env, target: document.body });
+// do something
-});
 ```
 
 or alternatively:
 
 ```js
-owl.utils.whenReady(function () {
+whenReady(function () {
-  const qweb = new owl.QWeb();
+  // do something
-  const env = { qweb };
-  await mount(App, { env, target: document.body });
 });
 ```
 
-## `loadJS`
-
-`loadJS` takes a url (string) for a javascript resource, and loads it (by adding
-a script tag in the document head). It returns a promise, so the caller can
-properly reacts when it is ready. Also, it is smart: it maintains a list of urls
-previously loaded (or currently being loaded), and prevent doing twice the work.
-
-For example, it is useful for lazy loading external libraries:
-
-```js
-class MyComponent extends owl.Component {
-  willStart() {
-    return owl.utils.loadJS("/static/libs/someLib.js");
-  }
-}
-```
-
 ## `loadFile`
 
 `loadFile` is a helper function to fetch a file. It simply
@@ -60,89 +37,22 @@ performs a `GET` request and returns the resulting string in a promise. The
 initial usecase for this function is to load a template file. For example:
 
 ```js
+const { loadFile } = owl;
+
 async function makeEnv() {
-  const templates = await owl.utils.loadFile("templates.xml");
+  const templates = await loadFile("templates.xml");
-  const qweb = new owl.QWeb({ templates });
+  // do something
-  return { qweb };
 }
 ```
 
-Note that unlike `loadJS`, this function returns the content of the file as a
+## `EventBus`
-string. It does not add a `script` tag or any other side effect.
 
-## `escape`
+It is a simple `EventBus`, with the same API as usual DOM elements, and an
-
+additional `trigger` method to dispatch events:
-Sometimes, we need to display dynamic data (for example user-generated data) in
-the user interface. If this is done by a `QWeb` template, it is not an issue:
-
-```xml
-    <div><t t-esc="user.data"/></div>
-```
-
-The `QWeb` engine will create a `div` node and add the content of the `user.data`
-string as a text node, so the web browser will not parse it as html. However,
-it may be a problem if this is done with some javascript code like this:
 
 ```js
-class BadComponent extends Component {
+const bus = new EventBus();
-  // some template with a ref to a div
+bus.addEventListener("event", () => console.log("something happened"));
-  // some code ...
 
-  mounted() {
+bus.trigger("event"); // 'something happened' is logged
-    this.divRef.el.innerHTML = this.state.value;
-  }
-}
-```
-
-In this case, the content of the `div` will be parsed as html, which may inject
-unwanted behaviour. To fix this, the `escape` function will simply transform a
-string into an escaped version of the same string, which will be properly displayed
-by the browser, but which will not be parsed as html (for example, `"<ok>"` is
-escaped to the string: `"&lt;ok&gt;"`). So, the bad example above can be fixed
-with the following change:
-
-```js
-this.divRef.el.innerHTML = owl.utils.escape(this.state.value);
-```
-
-## `debounce`
-
-The `debounce` function is useful when we want to limit the number of times some
-function/action is perfomed. For example, this may be useful to prevent issue
-with people double clicking on a button.
-
-It takes three arguments:
-
-- `func` (function): this is the function that will be rate limited
-- `wait` (number): this is the number of milliseconds that we want to use to
-  rate limit the function `func`
-- `immediate` (optional, boolean, default=false): if `immediate` is true, the
-  function will be triggered immediately (leading edge of the interval). If false,
-  the function will be triggered at the end (trailing edge).
-
-It returns a function. For example:
-
-```js
-const debounce = owl.utils.debounce;
-window.addEventListener("mousemove", debounce(doSomething, 100));
-```
-
-As this example shows, it is usualy useful for event handlers which are triggered
-very quickly, such as `scroll` or `mousemove` events.
-
-## `shallowEqual`
-
-This function checks if two objects have the same values assigned to each keys:
-
-```js
-shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2 }); // true
-shallowEqual({ a: 1, b: 2 }, { a: 1, b: 3 }); // false
-```
-
-However, for performance reasons, it assumes that the two objects have the same
-keys. If we are in a situation where this is not guaranteed, the following code
-will work:
-
-```js
-const completeShallowEqual = (a, b) => shallowEqual(a, b) && shallowEqual(b, a);
 ```

package.json

@@ -13,10 +13,10 @@
     "node": ">=12.18.3"
   },
   "scripts": {
-    "build:bundle": "rollup -c",
+    "build:bundle": "rollup -c --failAfterWarnings",
     "build": "npm run build:bundle",
     "test": "jest",
-    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --watch",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --watch --testTimeout=5000000",
     "test:watch": "jest --watch",
     "playground:serve": "python3 tools/server.py || python tools/server.py",
     "playground": "npm run build && npm run playground:serve",

src/app/app.ts

@@ -25,7 +25,7 @@ export class App<T extends typeof Component = any> extends TemplateSet {
   Root: T;
   props: any;
   env: Env;
-  scheduler = new Scheduler(window.requestAnimationFrame.bind(window));
+  scheduler = new Scheduler();
   root: ComponentNode | null = null;
 
   constructor(Root: T, config: AppConfig = {}) {

src/app/template_helpers.ts

@@ -2,7 +2,6 @@ import { BDom, multi, text, toggler } from "../blockdom";
 import { validateProps } from "../component/props_validation";
 import { Markup } from "../utils";
 import { html } from "../blockdom/index";
-
 /**
  * This file contains utility functions that will be injected in each template,
  * to perform various useful tasks in the compiled code.
@@ -21,6 +20,7 @@ function callSlot(
   extra: any,
   defaultContent?: (ctx: any, node: any, key: string) => BDom
 ): BDom {
+  key = key + "__slot_" + name;
   const slots = (ctx.props && ctx.props.slots) || {};
   const { __render, __ctx, __scope } = slots[name] || {};
   const slotScope = Object.create(__ctx || {});

src/app/template_set.ts

@@ -55,7 +55,7 @@ export class TemplateSet {
       const template = this.getTemplate(subTemplate);
       return toggler(subTemplate, template.call(owner, ctx, parent, key));
     },
-    getTemplate: (name: string) => this.getTemplate(name),
+    getTemplate: (name: string, nameSpace?: string) => this.getTemplate(name, nameSpace),
   });
 
   constructor(config: TemplateSetConfig = {}) {
@@ -87,28 +87,35 @@ export class TemplateSet {
     }
   }
 
-  getTemplate(name: string): Template {
+  getTemplate(name: string, nameSpace?: string): Template {
+
     if (!(name in this.templates)) {
       const rawTemplate = this.rawTemplates[name];
       if (rawTemplate === undefined) {
         throw new Error(`Missing template: "${name}"`);
       }
-      const templateFn = this._compileTemplate(name, rawTemplate);
+          console.log("getTemplate", nameSpace);
+      const templateFn = this._compileTemplate(name, rawTemplate, nameSpace);
       // first add a function to lazily get the template, in case there is a
       // recursive call to the template name
-      this.templates[name] = (context, parent) => this.templates[name](context, parent);
+      const templates = this.templates;
+      this.templates[name] = function (context, parent) {
+        return templates[name].call(this, context, parent);
+      };
       const template = templateFn(bdom, this.utils);
       this.templates[name] = template;
     }
     return this.templates[name];
   }
 
-  _compileTemplate(name: string, template: string | Node) {
+  _compileTemplate(name: string, template: string | Node, nameSpace?: string) {
+    console.log("CompileTpm", nameSpace)
     return compile(template, {
       name,
       dev: this.dev,
       translateFn: this.translateFn,
       translatableAttributes: this.translatableAttributes,
+      nameSpace: nameSpace,
     });
   }
 }

src/blockdom/list.ts

@@ -98,7 +98,6 @@ class VList {
     let endVn2 = ch2[endIdx2];
 
     let mapping: any = undefined;
-    // let noFullRemove = this.hasNoComponent;
 
     while (startIdx1 <= endIdx1 && startIdx2 <= endIdx2) {
       // -------------------------------------------------------------------

src/blockdom/multi.ts

@@ -125,7 +125,7 @@ export class VMulti {
   }
 
   toString(): string {
-    return this.children.map((c) => c!.toString()).join("");
+    return this.children.map((c) => (c ? c!.toString() : "")).join("");
   }
 }
 

src/compiler/code_generator.ts

@@ -19,6 +19,7 @@ import {
   ASTTSet,
   ASTTranslation,
   ASTType,
+  ASTTPortal,
 } from "./parser";
 
 type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
@@ -32,12 +33,14 @@ export interface Config {
 export interface CodeGenOptions extends Config {
   hasSafeContext?: boolean;
   name?: string;
+  nameSpace?: string;
 }
 
 // using a non-html document so that <inner/outer>HTML serializes as XML instead
 // of HTML (as we will parse it as xml later)
 const xmlDoc = document.implementation.createDocument(null, null, null);
 
+const MODS = new Set(["stop", "capture", "prevent", "self", "synthetic"]);
 // -----------------------------------------------------------------------------
 // BlockDescription
 // -----------------------------------------------------------------------------
@@ -125,6 +128,7 @@ interface Context {
   isLast?: boolean;
   translate: boolean;
   tKeyExpr: string | null;
+  nameSpace?: string;
 }
 
 function createContext(parentCtx: Context, params?: Partial<Context>) {
@@ -135,6 +139,7 @@ function createContext(parentCtx: Context, params?: Partial<Context>) {
       forceNewBlock: true,
       translate: parentCtx.translate,
       tKeyExpr: null,
+      nameSpace: parentCtx.nameSpace,
     },
     params
   );
@@ -210,8 +215,9 @@ export class CodeGenerator {
   translateFn: (s: string) => string;
   translatableAttributes: string[];
   ast: AST;
-  staticCalls: { id: string; template: string }[] = [];
+  staticCalls: { id: string; template: string, nameSpace?: string }[] = [];
   helpers: Set<string> = new Set();
+  nameSpace?: string;
 
   constructor(ast: AST, options: CodeGenOptions) {
     this.translateFn = options.translateFn || ((s: string) => s);
@@ -220,6 +226,8 @@ export class CodeGenerator {
     this.dev = options.dev || false;
     this.ast = ast;
     this.templateName = options.name;
+    this.nameSpace = options.nameSpace;
+    console.log('ThisNS', this.nameSpace)
   }
 
   generateCode(): string {
@@ -234,6 +242,7 @@ export class CodeGenerator {
       isLast: true,
       translate: true,
       tKeyExpr: null,
+      nameSpace: this.nameSpace,
     });
     // define blocks and utility functions
     let mainCode = [
@@ -246,8 +255,12 @@ export class CodeGenerator {
       mainCode.push(`// Template name: "${this.templateName}"`);
     }
 
-    for (let { id, template } of this.staticCalls) {
+    for (let { id, template, nameSpace } of this.staticCalls) {
-      mainCode.push(`const ${id} = getTemplate(${template});`);
+      let ns;
+      if (nameSpace) {
+        ns = `, "${nameSpace}"`;
+      }
+      mainCode.push(`const ${id} = getTemplate(${template}${ns});`);
     }
 
     // define all blocks
@@ -445,6 +458,8 @@ export class CodeGenerator {
       case ASTType.TTranslation:
         this.compileTTranslation(ast, ctx);
         break;
+      case ASTType.TPortal:
+        this.compileTPortal(ast, ctx);
     }
   }
 
@@ -501,7 +516,12 @@ export class CodeGenerator {
     const modifiers = rawEvent
       .split(".")
       .slice(1)
-      .map((m) => `"${m}"`);
+      .map((m) => {
+        if (!MODS.has(m)) {
+          throw new Error(`Unknown event modifier: '${m}'`);
+        }
+        return `"${m}"`;
+      });
     let modifiersCode = "";
     if (modifiers.length) {
       modifiersCode = `${modifiers.join(",")}, `;
@@ -514,7 +534,7 @@ export class CodeGenerator {
     const isNewBlock = !block || forceNewBlock || ast.dynamicTag !== null;
     let codeIdx = this.target.code.length;
     if (isNewBlock) {
-      if (ast.dynamicTag && ctx.block) {
+      if ((ast.dynamicTag || ctx.tKeyExpr) && ctx.block) {
         this.insertAnchor(ctx.block!);
       }
       block = this.createBlock(block, "block", ctx);
@@ -527,9 +547,11 @@ export class CodeGenerator {
     }
     // attributes
     const attrs: { [key: string]: string } = {};
-    if (ast.ns) {
+    const nameSpace = ast.ns || ctx.nameSpace;
+    console.log(nameSpace)
+    if (nameSpace && isNewBlock) {
       // specific namespace uri
-      attrs["block-ns"] = ast.ns;
+      attrs["block-ns"] = nameSpace;
     }
     for (let key in ast.attrs) {
       if (key.startsWith("t-attf")) {
@@ -644,6 +666,8 @@ export class CodeGenerator {
           index: block!.childNumber,
           forceNewBlock: false,
           isLast: ctx.isLast && i === children.length - 1,
+          tKeyExpr: ctx.tKeyExpr,
+          nameSpace,
         });
         this.compileAST(child, subCtx);
       }
@@ -658,7 +682,7 @@ export class CodeGenerator {
         const children = block!.children.slice();
         let current = children.shift();
         for (let i = codeIdx; i < code.length; i++) {
-          if (code[i].trimStart().startsWith(`let ${current!.varName}`)) {
+          if (code[i].trimStart().startsWith(`let ${current!.varName} `)) {
             code[i] = code[i].replace(`let ${current!.varName}`, current!.varName);
             current = children.shift();
             if (!current) break;
@@ -753,7 +777,7 @@ export class CodeGenerator {
         const children = block!.children.slice();
         let current = children.shift();
         for (let i = codeIdx; i < code.length; i++) {
-          if (code[i].trimStart().startsWith(`let ${current!.varName}`)) {
+          if (code[i].trimStart().startsWith(`let ${current!.varName} `)) {
             code[i] = code[i].replace(`let ${current!.varName}`, current!.varName);
             current = children.shift();
             if (!current) break;
@@ -897,7 +921,7 @@ export class CodeGenerator {
           const children = block!.children.slice();
           let current = children.shift();
           for (let i = codeIdx; i < code.length; i++) {
-            if (code[i].trimStart().startsWith(`let ${current!.varName}`)) {
+            if (code[i].trimStart().startsWith(`let ${current!.varName} `)) {
               code[i] = code[i].replace(`let ${current!.varName}`, current!.varName);
               current = children.shift();
               if (!current) break;
@@ -946,7 +970,7 @@ export class CodeGenerator {
     } else {
       const id = this.generateId(`callTemplate_`);
       this.helpers.add("getTemplate");
-      this.staticCalls.push({ id, template: subTemplate });
+      this.staticCalls.push({ id, template: subTemplate, nameSpace: ctx.nameSpace });
       block = this.createBlock(block, "multi", ctx);
       this.insertBlock(`${id}.call(this, ctx, node, ${key})`, block!, {
         ...ctx,
@@ -1018,6 +1042,8 @@ export class CodeGenerator {
           this.helpers.add("bind");
           propName = name;
           propValue = `bind(ctx, ${propValue})`;
+        } else {
+          throw new Error("Invalid prop suffix");
         }
       }
       propName = /^[a-z_]+$/i.test(propName) ? propName : `'${propName}'`;
@@ -1102,7 +1128,10 @@ export class CodeGenerator {
       this.insertAnchor(block);
     }
 
-    const keyArg = `key+\`${key}\`,${ctx.tKeyExpr}`;
+    let keyArg = `key + \`${key}\``;
+    if (ctx.tKeyExpr) {
+      keyArg = `${ctx.tKeyExpr} + ${keyArg}`;
+    }
     const blockArgs = `${expr}, ${propString}, ${keyArg}, node, ctx`;
     let blockExpr = `component(${blockArgs})`;
     if (ast.isDynamic) {
@@ -1158,4 +1187,23 @@ export class CodeGenerator {
       this.compileAST(ast.content, Object.assign({}, ctx, { translate: false }));
     }
   }
+  compileTPortal(ast: ASTTPortal, ctx: Context) {
+    this.helpers.add("Portal");
+
+    let { block } = ctx;
+    const name = this.compileInNewTarget("slot", ast.content, ctx);
+    const key = this.generateComponentKey();
+    let ctxStr = "ctx";
+    if (this.target.loopLevel || !this.hasSafeContext) {
+      ctxStr = this.generateId("ctx");
+      this.helpers.add("capture");
+      this.addLine(`const ${ctxStr} = capture(ctx);`);
+    }
+    const blockString = `component(Portal, {target: ${ast.target},slots: {'default': {__render: ${name}, __ctx: ${ctxStr}}}}, key + \`${key}\`, node, ctx)`;
+    if (block) {
+      this.insertAnchor(block);
+    }
+    block = this.createBlock(block, "multi", ctx);
+    this.insertBlock(blockString, block, { ...ctx, forceNewBlock: false });
+  }
 }

src/compiler/index.ts

@@ -8,6 +8,7 @@ export type TemplateFunction = (blocks: any, utils: any) => Template;
 
 interface CompileOptions extends Config {
   name?: string;
+  nameSpace?: string,
 }
 export function compile(template: string | Node, options: CompileOptions = {}): TemplateFunction {
   // parsing
@@ -20,8 +21,10 @@ export function compile(template: string | Node, options: CompileOptions = {}):
       : !template.includes("t-set") && !template.includes("t-call");
 
   // code generation
+  console.log("compile", options)
   const codeGenerator = new CodeGenerator(ast, { ...options, hasSafeContext });
   const code = codeGenerator.generateCode();
+  console.log(code)
   // template function
   return new Function("bdom, helpers", code) as TemplateFunction;
 }

src/compiler/parser.ts

@@ -20,6 +20,7 @@ export const enum ASTType {
   TSlot,
   TCallBlock,
   TTranslation,
+  TPortal,
 }
 
 export interface ASTText {
@@ -92,8 +93,6 @@ export interface ASTTForEach {
   key: string | null;
   body: AST;
   memo: string;
-  isOnlyChild: boolean;
-  hasNoComponent: boolean;
   hasNoFirst: boolean;
   hasNoLast: boolean;
   hasNoIndex: boolean;
@@ -149,6 +148,12 @@ export interface ASTTranslation {
   content: AST | null;
 }
 
+export interface ASTTPortal {
+  type: ASTType.TPortal;
+  target: string;
+  content: AST;
+}
+
 export type AST =
   | ASTText
   | ASTComment
@@ -166,7 +171,8 @@ export type AST =
   | ASTTCallBlock
   | ASTLog
   | ASTDebug
-  | ASTTranslation;
+  | ASTTranslation
+  | ASTTPortal;
 
 // -----------------------------------------------------------------------------
 // Parser
@@ -195,6 +201,7 @@ function parseNode(node: ChildNode, ctx: ParsingContext): AST | null {
     parseTDebugLog(node, ctx) ||
     parseTForEach(node, ctx) ||
     parseTIf(node, ctx) ||
+    parseTPortal(node, ctx) ||
     parseTCall(node, ctx) ||
     parseTCallBlock(node, ctx) ||
     parseTEscNode(node, ctx) ||
@@ -351,9 +358,6 @@ function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
       attrs[attr] = value;
     }
   }
-  if (children.length === 1 && children[0].type === ASTType.TForEach) {
-    children[0].isOnlyChild = true;
-  }
   return {
     type: ASTType.DomNode,
     tag: tagName,
@@ -478,8 +482,6 @@ function parseTForEach(node: Element, ctx: ParsingContext): AST | null {
     body,
     memo,
     key,
-    isOnlyChild: false,
-    hasNoComponent: hasNoComponent(body),
     hasNoFirst,
     hasNoLast,
     hasNoIndex,
@@ -487,58 +489,6 @@ function parseTForEach(node: Element, ctx: ParsingContext): AST | null {
   };
 }
 
-/**
- * @returns true if we are sure the ast does not contain any component
- */
-function hasNoComponent(ast: AST): boolean {
-  switch (ast.type) {
-    case ASTType.TComponent:
-    case ASTType.TOut:
-    case ASTType.TCall:
-    case ASTType.TCallBlock:
-    case ASTType.TSlot:
-      return false;
-    case ASTType.TSet:
-    case ASTType.Text:
-    case ASTType.Comment:
-    case ASTType.TEsc:
-      return true;
-    case ASTType.TKey:
-      return hasNoComponent(ast.content);
-    case ASTType.TDebug:
-    case ASTType.TLog:
-    case ASTType.TTranslation:
-      return ast.content ? hasNoComponent(ast.content) : true;
-    case ASTType.TForEach:
-      return ast.hasNoComponent;
-    case ASTType.Multi:
-    case ASTType.DomNode: {
-      for (let elem of ast.content) {
-        if (!hasNoComponent(elem)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    case ASTType.TIf: {
-      if (!hasNoComponent(ast.content)) {
-        return false;
-      }
-      if (ast.tElif) {
-        for (let elem of ast.tElif) {
-          if (!hasNoComponent(elem.content)) {
-            return false;
-          }
-        }
-      }
-      if (ast.tElse && !hasNoComponent(ast.tElse)) {
-        return false;
-      }
-      return true;
-    }
-  }
-}
-
 function parseTKey(node: Element, ctx: ParsingContext): AST | null {
   if (!node.hasAttribute("t-key")) {
     return null;
@@ -805,6 +755,30 @@ function parseTTranslation(node: Element, ctx: ParsingContext): AST | null {
   };
 }
 
+// -----------------------------------------------------------------------------
+// Portal
+// -----------------------------------------------------------------------------
+
+function parseTPortal(node: Element, ctx: ParsingContext): AST | null {
+  if (!node.hasAttribute("t-portal")) {
+    return null;
+  }
+  const target = node.getAttribute("t-portal")!;
+  node.removeAttribute("t-portal");
+  const content = parseNode(node, ctx);
+  if (!content) {
+    return {
+      type: ASTType.Text,
+      value: "",
+    };
+  }
+  return {
+    type: ASTType.TPortal,
+    target,
+    content,
+  };
+}
+
 // -----------------------------------------------------------------------------
 // helpers
 // -----------------------------------------------------------------------------

src/component/component.ts

@@ -1,19 +1,18 @@
-import type { Env } from "../app/app";
 import type { ComponentNode } from "./component_node";
 
 // -----------------------------------------------------------------------------
 //  Component Class
 // -----------------------------------------------------------------------------
 
-export class Component {
+export class Component<Props = any, Env = any> {
   static template: string = "";
   static props?: any;
 
-  props: any;
+  props: Props;
   env: Env;
   __owl__: ComponentNode;
 
-  constructor(props: any, env: Env, node: ComponentNode) {
+  constructor(props: Props, env: Env, node: ComponentNode) {
     this.props = props;
     this.env = env;
     this.__owl__ = node;

src/component/component_node.ts

@@ -27,34 +27,15 @@ export function component(
   name: string | typeof Component,
   props: any,
   key: string,
-  tKey: null | string,
   ctx: ComponentNode,
   parent: any
 ): ComponentNode {
-  const parentChildren = ctx.children;
+  let node: any = ctx.children[key];
-  const destroy = ComponentNode.prototype.destroy;
-
-  if (tKey) {
-    const parentMap = ctx.keyToTkey;
-    const oldTkey = parentMap[key];
-    if (oldTkey && oldTkey !== tKey) {
-      const oldKey = key + oldTkey;
-      const node = parentChildren[oldKey];
-      if (node && node.status < STATUS.MOUNTED) {
-        destroy.call(node);
-        delete parentChildren[oldKey];
-      }
-    }
-    parentMap[key] = tKey;
-    key = key + tKey;
-  }
-
-  let node: any = parentChildren[key];
   let isDynamic = typeof name !== "string";
 
   if (node) {
     if (node.status < STATUS.MOUNTED) {
-      destroy.call(node);
+      node.destroy();
       node = undefined;
     } else if (node.status === STATUS.DESTROYED) {
       node = undefined;
@@ -79,7 +60,7 @@ export function component(
       }
     }
     node = new ComponentNode(C, props, ctx.app, ctx);
-    parentChildren[key] = node;
+    ctx.children[key] = node;
 
     const fiber = makeChildFiber(node, parentFiber);
     node.initiateRender(fiber);
@@ -109,7 +90,6 @@ export class ComponentNode<T extends typeof Component = typeof Component>
   childEnv: Env;
   children: { [key: string]: ComponentNode } = Object.create(null);
   refs: any = {};
-  keyToTkey: any = {};
 
   willStart: LifecycleHook[] = [];
   willUpdateProps: LifecycleHook[] = [];
@@ -141,7 +121,7 @@ export class ComponentNode<T extends typeof Component = typeof Component>
   async initiateRender(fiber: Fiber | MountFiber) {
     this.fiber = fiber;
     if (this.mounted.length) {
-      fiber.root.mounted.push(fiber);
+      fiber.root!.mounted.push(fiber);
     }
     const component = this.component;
     try {
@@ -157,7 +137,7 @@ export class ComponentNode<T extends typeof Component = typeof Component>
 
   async render() {
     let current = this.fiber;
-    if (current && current.root.locked) {
+    if (current && current.root!.locked) {
       await Promise.resolve();
       // situation may have changed after the microtask tick
       current = this.fiber;
@@ -187,7 +167,7 @@ export class ComponentNode<T extends typeof Component = typeof Component>
     //   a root fiber to a child fiber in the previous microtick, because it was
     //   embedded in a rendering coming from above, so the fiber will be rendered
     //   in the next microtick anyway, so we should not render it again.
-    if (this.fiber && (current || !fiber.parent)) {
+    if (this.fiber === fiber && (current || !fiber.parent)) {
       this._render(fiber);
     }
   }
@@ -195,7 +175,7 @@ export class ComponentNode<T extends typeof Component = typeof Component>
   _render(fiber: Fiber | RootFiber) {
     try {
       fiber.bdom = this.renderFn();
-      fiber.root.counter--;
+      fiber.root!.counter--;
     } catch (e) {
       handleError({ node: this, error: e });
     }
@@ -238,7 +218,7 @@ export class ComponentNode<T extends typeof Component = typeof Component>
     }
     component.props = props;
     this._render(fiber);
-    const parentRoot = parentFiber.root;
+    const parentRoot = parentFiber.root!;
     if (this.willPatch.length) {
       parentRoot.willPatch.push(fiber);
     }
@@ -295,7 +275,11 @@ export class ComponentNode<T extends typeof Component = typeof Component>
   }
 
   patch() {
-    this.bdom!.patch(this!.fiber!.bdom!, false);
+    const hasChildren = Object.keys(this.children).length > 0;
+    this.bdom!.patch(this!.fiber!.bdom!, hasChildren);
+    if (hasChildren) {
+      this.cleanOutdatedChildren();
+    }
     this.fiber!.appliedToDom = true;
     this.fiber = null;
   }
@@ -307,4 +291,18 @@ export class ComponentNode<T extends typeof Component = typeof Component>
   remove() {
     this.bdom!.remove();
   }
+
+  cleanOutdatedChildren() {
+    const children = this.children;
+    for (const key in children) {
+      const node = children[key];
+      const status = node.status;
+      if (status !== STATUS.MOUNTED) {
+        delete children[key];
+        if (status !== STATUS.DESTROYED) {
+          node.destroy();
+        }
+      }
+    }
+  }
 }

src/component/error_handling.ts

@@ -29,8 +29,8 @@ function _handleError(node: ComponentNode | null, error: any, isFirstRound = fal
     }
 
     if (stopped) {
-      if (isFirstRound && fiber) {
+      if (isFirstRound && fiber && fiber.node.fiber) {
-        fiber.root.counter--;
+        fiber.root!.counter--;
       }
       return true;
     }
@@ -52,7 +52,7 @@ export function handleError(params: ErrorParams) {
     current = current.parent;
   } while (current);
 
-  fibersInError.set(fiber.root, error);
+  fibersInError.set(fiber.root!, error);
 
   const handled = _handleError(node, error, true);
   if (!handled) {

src/component/fibers.ts

@@ -3,46 +3,12 @@ import type { ComponentNode } from "./component_node";
 import { fibersInError, handleError } from "./error_handling";
 import { STATUS } from "./status";
 
-/**
- * Cleans on the root fiber the patch and willPatch fiber lists
- * It is typically needed when the same root fiber needs to recycle on
- * of its children or grandchildren's fiber.
- */
-function cleanPatchableFiber(child: Fiber, root: RootFiber) {
-  const { willPatch, patched } = root;
-  let i = willPatch.indexOf(child);
-  if (i > -1) {
-    willPatch.splice(i, 1);
-  }
-  i = patched.indexOf(child);
-  if (i > -1) {
-    patched.splice(i, 1);
-  }
-}
-
 export function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber {
   let current = node.fiber;
   if (current) {
-    // current is necessarily a rootfiber here
     let root = parent.root;
-    const isSameRoot = current.root === root;
     cancelFibers(root, current.children);
-    current.children = [];
+    current.root = null;
-    current.parent = parent;
-    // only increment our rendering if we were not
-    // already accounted for, or that we have been rendered
-    // already (in which case our fiber was removed from the root rendering)
-    if (!isSameRoot || current.bdom) {
-      root.counter++;
-    }
-
-    if (isSameRoot) {
-      cleanPatchableFiber(current, root);
-    }
-
-    current.bdom = null;
-    current.root = root;
-    return current;
   }
   return new Fiber(node, parent);
 }
@@ -50,7 +16,7 @@ export function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber {
 export function makeRootFiber(node: ComponentNode): Fiber {
   let current = node.fiber;
   if (current) {
-    let root = current.root;
+    let root = current.root!;
     root.counter -= cancelFibers(root, current.children);
     current.children = [];
     root.counter++;
@@ -92,7 +58,7 @@ function cancelFibers(root: any, fibers: Fiber[]): number {
 export class Fiber {
   node: ComponentNode;
   bdom: BDom | null = null;
-  root: RootFiber;
+  root: RootFiber | null; // A Fiber that has been replaced by another has no root
   parent: Fiber | null;
   children: Fiber[] = [];
   appliedToDom = false;
@@ -101,7 +67,7 @@ export class Fiber {
     this.node = node;
     this.parent = parent;
     if (parent) {
-      const root = parent.root;
+      const root = parent.root!;
       root.counter++;
       this.root = root;
       parent.children.push(this);
@@ -143,13 +109,8 @@ export class RootFiber extends Fiber {
       current = undefined;
 
       // Step 2: patching the dom
-      node.bdom!.patch(this.bdom!, Object.keys(node.children).length > 0);
+      node.patch();
-      this.appliedToDom = true;
-
       this.locked = false;
-      // unregistering the fiber before mounted since it can do another render
-      // and that the current rendering is obviously completed
-      node.fiber = null;
 
       // Step 4: calling all mounted lifecycle hooks
       let mountedFibers = this.mounted;

src/component/handler.ts

@@ -1,4 +1,5 @@
 import { filterOutModifiersFromData } from "../blockdom/config";
+import { STATUS } from "./status";
 
 export const mainEventHandler = (data: any, ev: Event, currentTarget?: EventTarget | null) => {
   const { data: _data, modifiers } = filterOutModifiersFromData(data);
@@ -30,7 +31,14 @@ export const mainEventHandler = (data: any, ev: Event, currentTarget?: EventTarg
   // We check this rather than data[0] being truthy (or typeof function) so that it crashes
   // as expected when there is a handler expression that evaluates to a falsy value
   if (Object.hasOwnProperty.call(data, 0)) {
-    data[0].call(data[1] ? data[1].__owl__.component : null, ev);
+    const handler = data[0];
+    if (typeof handler !== "function") {
+      throw new Error(`Invalid handler (expected a function, received: '${handler}')`);
+    }
+    let node = data[1] ? data[1].__owl__ : null;
+    if (node ? node.status === STATUS.MOUNTED : true) {
+      handler.call(node ? node.component : null, ev);
+    }
   }
   return stopped;
 };

src/component/lifecycle_hooks.ts

@@ -7,44 +7,44 @@ import { nodeErrorHandlers } from "./error_handling";
 
 export function onWillStart(fn: () => Promise<void> | void | any) {
   const node = getCurrent()!;
-  node.willStart.push(fn);
+  node.willStart.push(fn.bind(node.component));
 }
 
 export function onWillUpdateProps(fn: (nextProps: any) => Promise<void> | void | any) {
   const node = getCurrent()!;
-  node.willUpdateProps.push(fn);
+  node.willUpdateProps.push(fn.bind(node.component));
 }
 
 export function onMounted(fn: () => void | any) {
   const node = getCurrent()!;
-  node.mounted.push(fn);
+  node.mounted.push(fn.bind(node.component));
 }
 
 export function onWillPatch(fn: () => Promise<void> | any | void) {
   const node = getCurrent()!;
-  node.willPatch.unshift(fn);
+  node.willPatch.unshift(fn.bind(node.component));
 }
 
 export function onPatched(fn: () => void | any) {
   const node = getCurrent()!;
-  node.patched.push(fn);
+  node.patched.push(fn.bind(node.component));
 }
 
 export function onWillUnmount(fn: () => Promise<void> | void | any) {
   const node = getCurrent()!;
-  node.willUnmount.unshift(fn);
+  node.willUnmount.unshift(fn.bind(node.component));
 }
 
 export function onWillDestroy(fn: () => Promise<void> | void | any) {
   const node = getCurrent()!;
-  node.willDestroy.push(fn);
+  node.willDestroy.push(fn.bind(node.component));
 }
 
 export function onWillRender(fn: () => void | any) {
   const node = getCurrent()!;
   const renderFn = node.renderFn;
   node.renderFn = () => {
-    fn();
+    fn.call(node.component);
     return renderFn();
   };
 }
@@ -54,7 +54,7 @@ export function onRendered(fn: () => void | any) {
   const renderFn = node.renderFn;
   node.renderFn = () => {
     const result = renderFn();
-    fn();
+    fn.call(node.component);
     return result;
   };
 }
@@ -67,5 +67,5 @@ export function onError(callback: OnErrorCallback) {
     handlers = [];
     nodeErrorHandlers.set(node, handlers);
   }
-  handlers.push(callback);
+  handlers.push(callback.bind(node.component));
 }

src/component/scheduler.ts

@@ -7,12 +7,15 @@ import { STATUS } from "./status";
 // -----------------------------------------------------------------------------
 
 export class Scheduler {
+  // capture the value of requestAnimationFrame as soon as possible, to avoid
+  // interactions with other code, such as test frameworks that override them
+  static requestAnimationFrame = window.requestAnimationFrame.bind(window);
   tasks: Set<RootFiber> = new Set();
   isRunning: boolean = false;
   requestAnimationFrame: Window["requestAnimationFrame"];
 
-  constructor(requestAnimationFrame: Window["requestAnimationFrame"]) {
+  constructor() {
-    this.requestAnimationFrame = requestAnimationFrame;
+    this.requestAnimationFrame = Scheduler.requestAnimationFrame;
   }
 
   start() {
@@ -25,7 +28,7 @@ export class Scheduler {
   }
 
   addFiber(fiber: Fiber) {
-    this.tasks.add(fiber.root);
+    this.tasks.add(fiber.root!);
     if (!this.isRunning) {
       this.start();
     }

src/index.ts

@@ -1,3 +1,4 @@
+import { UTILS } from "./app/template_helpers";
 import {
   config,
   createBlock,
@@ -12,9 +13,12 @@ import {
   comment,
 } from "./blockdom";
 import { mainEventHandler } from "./component/handler";
+import { Portal } from "./portal";
+export type { Reactive } from "./reactivity";
 
 config.shouldNormalizeDom = false;
 config.mainEventHandler = mainEventHandler;
+(UTILS as any).Portal = Portal;
 
 export const blockDom = {
   config,
@@ -36,7 +40,6 @@ export { App, mount } from "./app/app";
 export { Component } from "./component/component";
 export { useComponent } from "./component/component_node";
 export { status } from "./component/status";
-export { Portal } from "./portal";
 export { Memo } from "./memo";
 export { xml } from "./app/template_set";
 export { useState, reactive } from "./reactivity";

src/portal.ts

@@ -1,7 +1,7 @@
-import type { ComponentNode } from "./component/component_node";
+import { onWillUnmount } from "./component/lifecycle_hooks";
-import { Component } from "./component/component";
 import { xml } from "./app/template_set";
 import { BDom, text, VNode } from "./blockdom";
+import { Component } from "./component/component";
 
 const VText: any = text("").constructor;
 
@@ -35,9 +35,11 @@ class VPortal extends VText implements Partial<VNode<VPortal>> {
     this.realBDom!.beforeRemove();
   }
   remove() {
-    super.remove();
+    if (this.realBDom) {
-    this.realBDom!.remove();
+      super.remove();
-    this.realBDom = null;
+      this.realBDom!.remove();
+      this.realBDom = null;
+    }
   }
 
   patch(other: VPortal) {
@@ -60,12 +62,14 @@ export class Portal extends Component {
     slots: true,
   };
 
-  constructor(props: any, env: any, node: ComponentNode) {
+  setup() {
-    super(props, env, node);
+    const node = this.__owl__;
-    node._render = function (fiber: any) {
+    const renderFn = node.renderFn;
-      const bdom = new VPortal(props.target, this.renderFn());
+    node.renderFn = () => new VPortal(this.props.target, renderFn());
-      fiber.bdom = bdom;
+    onWillUnmount(() => {
-      fiber.root.counter--;
+      if (node.bdom) {
-    };
+        node.bdom.remove();
+      }
+    });
   }
 }

src/reactivity.ts

@@ -1,5 +1,6 @@
 import { onWillUnmount } from "./component/lifecycle_hooks";
 import { ComponentNode, getCurrent } from "./component/component_node";
+import { batched, Callback } from "./utils";
 
 // Allows to get the target of a Reactive (used for making a new Reactive from the underlying object)
 const TARGET = Symbol("Target");
@@ -8,8 +9,7 @@ const KEYCHANGES = Symbol("Key changes");
 
 type ObjectKey = string | number | symbol;
 type Target = object;
-type Callback = () => void;
+export type Reactive<T extends Target = Target> = T & {
-type Reactive<T extends Target = Target> = T & {
   [TARGET]: any;
 };
 
@@ -191,30 +191,6 @@ export function reactive<T extends Target>(target: T, callback: Callback = () =>
   return reactivesForTarget.get(callback) as Reactive<T>;
 }
 
-/**
- * Creates a batched version of a callback so that all calls to it in the same
- * microtick will only call the original callback once.
- *
- * @param callback the callback to batch
- * @returns a batched version of the original callback
- */
-export function batched(callback: Callback): Callback {
-  let called = false;
-  return async () => {
-    // This await blocks all calls to the callback here, then releases them sequentially
-    // in the next microtick. This line decides the granularity of the batch.
-    await Promise.resolve();
-    if (!called) {
-      called = true;
-      callback();
-      // wait for all calls in this microtick to fall through before resetting "called"
-      // so that only the first call to the batched function calls the original callback
-      await Promise.resolve();
-      called = false;
-    }
-  };
-}
-
 const batchedRenderFunctions = new WeakMap<ComponentNode, Callback>();
 /**
  * Creates a reactive object that will be observed by the current component.

src/utils.ts

@@ -1,3 +1,29 @@
+export type Callback = () => void;
+
+/**
+ * Creates a batched version of a callback so that all calls to it in the same
+ * microtick will only call the original callback once.
+ *
+ * @param callback the callback to batch
+ * @returns a batched version of the original callback
+ */
+export function batched(callback: Callback): Callback {
+  let called = false;
+  return async () => {
+    // This await blocks all calls to the callback here, then releases them sequentially
+    // in the next microtick. This line decides the granularity of the batch.
+    await Promise.resolve();
+    if (!called) {
+      called = true;
+      callback();
+      // wait for all calls in this microtick to fall through before resetting "called"
+      // so that only the first call to the batched function calls the original callback
+      await Promise.resolve();
+      called = false;
+    }
+  };
+}
+
 export class EventBus extends EventTarget {
   trigger(name: string, payload?: any) {
     this.dispatchEvent(new CustomEvent(name, { detail: payload }));

tests/__snapshots__/reactivity.test.ts.snap

@@ -56,7 +56,7 @@ exports[`Reactivity: useState destroyed component before being mounted is inacti
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }
@@ -87,7 +87,7 @@ exports[`Reactivity: useState destroyed component is inactive 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }
@@ -131,7 +131,7 @@ exports[`Reactivity: useState parent and children subscribed to same context 1`]
   let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     let txt1 = ctx['contextObj'].b;
     return block1([txt1], [b2]);
   }
@@ -223,8 +223,8 @@ exports[`Reactivity: useState two components are updated in parallel 1`] = `
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    let b3 = component(\`Child\`, {}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -252,8 +252,8 @@ exports[`Reactivity: useState two components can subscribe to same context 1`] =
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    let b3 = component(\`Child\`, {}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -281,8 +281,8 @@ exports[`Reactivity: useState two independent components on different levels are
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    let b3 = component(\`Parent\`, {}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Parent\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -310,7 +310,7 @@ exports[`Reactivity: useState two independent components on different levels are
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -344,7 +344,7 @@ exports[`Reactivity: useState useless atoms should be deleted 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`id\`] = v_block2[i1];
       let key1 = ctx['id'];
-      c_block2[i1] = withKey(component(\`Quantity\`, {id: ctx['id']}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block2[i1] = withKey(component(\`Quantity\`, {id: ctx['id']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);

tests/blockdom/multi.test.ts

@@ -77,6 +77,11 @@ describe("multi blocks", () => {
     expect(fixture.innerHTML).toBe("ab");
   });
 
+  test("multi vnode can be used as text", () => {
+    mount(text(multi([text("a"), undefined]) as any), fixture);
+    expect(fixture.innerHTML).toBe("a");
+  });
+
   test("multi inside a block", async () => {
     const block = createBlock("<div><block-child-0/></div>");
     const tree = block([], [multi([text("foo"), text("bar")])]);

tests/compiler/__snapshots__/misc.test.ts.snap

@@ -34,7 +34,7 @@ exports[`misc complex template 1`] = `
     for (let i1 = 0; i1 < l_block4; i1++) {
       ctx[\`slot\`] = v_block4[i1];
       let key1 = ctx['slot'].id;
-      c_block4[i1] = withKey(component(\`SlotButton\`, {class: ctx['slot_container'],slot: ctx['slot']}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block4[i1] = withKey(component(\`SlotButton\`, {class: ctx['slot_container'],slot: ctx['slot']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     ctx = ctx.__proto__;
     b4 = list(c_block4);
@@ -316,8 +316,8 @@ exports[`misc other complex template 1`] = `
     if (!ctx['project']) {
       b24 = block24();
     } else {
-      let b26 = component(\`BundlesList\`, {bundles: ctx['bundles'].sticky,category_custom_views: ctx['category_custom_views'],search: ctx['search']}, key+\`__2\`,null, node, ctx);
+      let b26 = component(\`BundlesList\`, {bundles: ctx['bundles'].sticky,category_custom_views: ctx['category_custom_views'],search: ctx['search']}, key + \`__2\`, node, ctx);
-      let b27 = component(\`BundlesList\`, {bundles: ctx['bundles'].dev,search: ctx['search']}, key+\`__3\`,null, node, ctx);
+      let b27 = component(\`BundlesList\`, {bundles: ctx['bundles'].dev,search: ctx['search']}, key + \`__3\`, node, ctx);
       b25 = block25([], [b26, b27]);
     }
     return block1([attr1, txt1, hdlr2, hdlr3, attr8, hdlr4, hdlr5, ref1, hdlr6, ref2], [b2, b4, b14, b17, b22, b23, b24, b25]);

tests/compiler/__snapshots__/svg.test.ts.snap

@@ -44,10 +44,57 @@ exports[`properly support svg namespace to svg tags added even if already in svg
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
-  let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><svg block-ns=\\"http://www.w3.org/2000/svg\\"/></svg>\`);
+  let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><svg/></svg>\`);
   
   return function template(ctx, node, key = \\"\\") {
     return block1();
   }
 }"
 `;
+
+exports[`properly support svg svg namespace added to sub-blocks (t-call) 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { getTemplate } = helpers;
+  const callTemplate_1 = getTemplate(\`path\`, \\"http://www.w3.org/2000/svg\\");
+  
+  let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><block-child-0/></svg>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`properly support svg svg namespace added to sub-blocks (t-call) 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<path/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`properly support svg svg namespace added to sub-blocks 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><block-child-0/></svg>\`);
+  let block2 = createBlock(\`<path block-ns=\\"http://www.w3.org/2000/svg\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['path']) {
+      b2 = block2();
+    }
+    return block1([], [b2]);
+  }
+}"
+`;

tests/compiler/__snapshots__/t_key.test.ts.snap

@@ -68,3 +68,38 @@ exports[`t-key t-key directive in a list 1`] = `
   }
 }"
 `;
+
+exports[`t-key t-key on sub dom node pushes a child block in its parent 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
+  let block2 = createBlock(\`<span/>\`);
+  let block3 = createBlock(\`<div><h1/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2,b3;
+    if (ctx['hasSpan']) {
+      b2 = block2();
+    }
+    const tKey_1 = ctx['key'];
+    b3 = toggler(tKey_1, block3());
+    return block1([], [b2, b3]);
+  }
+}"
+`;
+
+exports[`t-key t-key on sub dom node pushes a child block in its parent 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><h1/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const tKey_1 = ctx['key'];
+    return toggler(tKey_1, block1());
+  }
+}"
+`;

tests/compiler/__snapshots__/t_set.test.ts.snap

@@ -87,6 +87,31 @@ exports[`t-set set from attribute lookup 1`] = `
 }"
 `;
 
+exports[`t-set set from body literal (with t-if/t-else 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { isBoundary, withDefault, LazyValue } = helpers;
+  
+  function value1(ctx, node, key = \\"\\") {
+    let b2,b3;
+    if (ctx['condition']) {
+      b2 = text(\`true\`);
+    } else {
+      b3 = text(\`false\`);
+    }
+    return multi([b2, b3]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    ctx[\`value\`] = new LazyValue(value1, ctx, node);
+    return text(ctx['value']);
+  }
+}"
+`;
+
 exports[`t-set set from body literal 1`] = `
 "function anonymous(bdom, helpers
 ) {

tests/compiler/event_handling.test.ts

@@ -2,6 +2,7 @@ import { TemplateSet } from "../../src/app/template_set";
 import { mount } from "../../src/blockdom";
 import { makeTestFixture, renderToBdom, renderToString, snapshotEverything } from "../helpers";
 import { markup } from "../../src/utils";
+import { STATUS } from "../../src/component/status";
 
 snapshotEverything();
 // -----------------------------------------------------------------------------
@@ -11,7 +12,7 @@ snapshotEverything();
 describe("t-on", () => {
   function mountToFixture(template: string, ctx: any = {}, node?: any): HTMLDivElement {
     if (!node) {
-      node = { component: ctx };
+      node = { component: ctx, status: STATUS.MOUNTED };
       ctx.__owl__ = node;
     }
     const block = renderToBdom(template, ctx, node);
@@ -156,7 +157,7 @@ describe("t-on", () => {
         expect(this).toBe(owner);
       },
     };
-    const node = { component: owner };
+    const node = { component: owner, status: STATUS.MOUNTED };
     owner.__owl__ = node;
     const fixture = makeTestFixture();
     const render = context.getTemplate("main");
@@ -181,7 +182,7 @@ describe("t-on", () => {
         expect(this).toBe(owner);
       },
     };
-    const node = { component: owner };
+    const node = { component: owner, status: STATUS.MOUNTED };
     owner.__owl__ = node;
     const fixture = makeTestFixture();
     const render = context.getTemplate("main");
@@ -260,7 +261,7 @@ describe("t-on", () => {
         expect(this).toBe(owner);
       },
     };
-    const node = { component: owner };
+    const node = { component: owner, status: STATUS.MOUNTED };
     owner.__owl__ = node;
 
     const fixture = makeTestFixture();
@@ -286,7 +287,7 @@ describe("t-on", () => {
       value: 444,
     };
 
-    const node = { component: owner };
+    const node = { component: owner, status: STATUS.MOUNTED };
     owner.__owl__ = node;
 
     const fixture = makeTestFixture();
@@ -479,6 +480,14 @@ describe("t-on", () => {
       button.click();
     });
 
+    test("t-on crashes when used with unknown modifier", async () => {
+      const template = `<div t-on-click.somemodifier="onClick" />`;
+
+      let owner = { onClick(e: Event) {} };
+
+      expect(() => mountToFixture(template, owner)).toThrowError("Unknown event modifier");
+    });
+
     test("t-on combined with t-esc", async () => {
       expect.assertions(3);
       const template = `<div><button t-on-click="onClick" t-esc="text"/></div>`;

tests/compiler/parser.test.ts

@@ -776,8 +776,6 @@ describe("qweb parser", () => {
       collection: "list",
       elem: "item",
       key: "item_index",
-      hasNoComponent: true,
-      isOnlyChild: false,
       body: { type: ASTType.TEsc, expr: "item", defaultValue: "" },
       memo: "",
       hasNoFirst: true,
@@ -793,8 +791,6 @@ describe("qweb parser", () => {
       collection: "list",
       elem: "item",
       key: "item_index",
-      hasNoComponent: true,
-      isOnlyChild: false,
       body: { type: ASTType.TEsc, expr: "item", defaultValue: "" },
       memo: "",
       hasNoFirst: true,
@@ -809,8 +805,6 @@ describe("qweb parser", () => {
       type: ASTType.TForEach,
       collection: "list",
       elem: "item",
-      hasNoComponent: true,
-      isOnlyChild: false,
       key: "item_index",
       body: {
         type: ASTType.DomNode,
@@ -836,8 +830,6 @@ describe("qweb parser", () => {
       type: ASTType.TForEach,
       collection: "list",
       elem: "item",
-      hasNoComponent: true,
-      isOnlyChild: false,
       key: "item.id",
       body: { type: ASTType.TEsc, expr: "item", defaultValue: "" },
       memo: "",
@@ -856,8 +848,6 @@ describe("qweb parser", () => {
       collection: "list",
       elem: "item",
       key: "item_index",
-      hasNoComponent: true,
-      isOnlyChild: false,
       body: {
         type: ASTType.DomNode,
         tag: "span",
@@ -887,8 +877,6 @@ describe("qweb parser", () => {
       collection: "list",
       elem: "item",
       key: "item_index",
-      hasNoComponent: true,
-      isOnlyChild: false,
       body: {
         type: ASTType.TIf,
         condition: "condition",
@@ -924,8 +912,6 @@ describe("qweb parser", () => {
       collection: "categories",
       elem: "category",
       key: "category_index",
-      hasNoComponent: true,
-      isOnlyChild: false,
       body: {
         type: ASTType.DomNode,
         tag: "option",
@@ -966,8 +952,6 @@ describe("qweb parser", () => {
           collection: "list",
           elem: "item",
           key: "item_index",
-          hasNoComponent: true,
-          isOnlyChild: true,
           body: { type: ASTType.TEsc, expr: "item", defaultValue: "" },
           memo: "",
           hasNoFirst: true,
@@ -995,8 +979,6 @@ describe("qweb parser", () => {
       collection: "list",
       elem: "item",
       key: "item_index",
-      hasNoComponent: true,
-      isOnlyChild: false,
       body: {
         type: ASTType.DomNode,
         tag: "span",
@@ -1022,8 +1004,6 @@ describe("qweb parser", () => {
       collection: "list",
       elem: "item",
       key: "item_index",
-      hasNoComponent: false,
-      isOnlyChild: false,
       body: {
         type: ASTType.TComponent,
         isDynamic: false,
@@ -1048,8 +1028,6 @@ describe("qweb parser", () => {
       collection: "list",
       elem: "item",
       key: "item_index",
-      hasNoComponent: false,
-      isOnlyChild: false,
       body: {
         type: ASTType.TCall,
         name: "blap",
@@ -1073,8 +1051,6 @@ describe("qweb parser", () => {
       collection: "list",
       elem: "item",
       key: "item_index",
-      hasNoComponent: true,
-      isOnlyChild: false,
       body: { type: ASTType.TEsc, expr: "item", defaultValue: "" },
       memo: "[row.x]",
       hasNoFirst: true,
@@ -1604,7 +1580,7 @@ describe("qweb parser", () => {
           attrs: {},
           content: [
             {
-              type: 0,
+              type: ASTType.Text,
               value: "word",
             },
           ],
@@ -1616,19 +1592,17 @@ describe("qweb parser", () => {
           type: ASTType.DomNode,
           ns: null,
         },
-        type: 16,
+        type: ASTType.TTranslation,
       },
       collection: "list",
       elem: "item",
-      hasNoComponent: true,
       hasNoFirst: true,
       hasNoIndex: false,
       hasNoLast: true,
       hasNoValue: true,
-      isOnlyChild: false,
       key: "item_index",
       memo: "",
-      type: 9,
+      type: ASTType.TForEach,
     });
   });
 
@@ -1787,4 +1761,29 @@ describe("qweb parser", () => {
       ns: null,
     });
   });
+
+  // ---------------------------------------------------------------------------
+  // t-portal
+  // ---------------------------------------------------------------------------
+  test("t-portal", async () => {
+    expect(parse(`<t t-portal="target">Content</t>`)).toEqual({
+      type: ASTType.TPortal,
+      target: "target",
+      content: { type: ASTType.Text, value: "Content" },
+    });
+  });
+
+  test("t-portal with t-if", async () => {
+    expect(parse(`<t t-portal="target" t-if="condition">Content</t>`)).toEqual({
+      condition: "condition",
+      content: {
+        content: { type: ASTType.Text, value: "Content" },
+        target: "target",
+        type: ASTType.TPortal,
+      },
+      tElif: null,
+      tElse: null,
+      type: ASTType.TIf,
+    });
+  });
 });

tests/compiler/svg.test.ts

@@ -1,4 +1,6 @@
-import { renderToString, snapshotEverything } from "../helpers";
+import { renderToString, renderToBdom, snapshotEverything, makeTestFixture } from "../helpers";
+import { mount } from "../../src/blockdom";
+import { mount as mountComponent, Component } from "../../src/index"
 
 // NB: check the snapshots to see where the SVG namespaces are added
 snapshotEverything();
@@ -25,6 +27,51 @@ describe("properly support svg", () => {
 
   test("namespace to svg tags added even if already in svg namespace", () => {
     const template = `<svg><svg/></svg>`;
-    expect(renderToString(template)).toBe(`<svg><svg></svg></svg>`);
+    const bdom = renderToBdom(template);
+    const fixture = makeTestFixture();
+
+    mount(bdom, fixture);
+    const elems = fixture.querySelectorAll("svg");
+    expect(elems.length).toEqual(2);
+    for (const el of elems) {
+      expect(el.namespaceURI).toBe("http://www.w3.org/2000/svg");
+    }
+  });
+
+  test("svg namespace added to sub-blocks", () => {
+    const template = `<svg><path t-if="path"/></svg>`;
+
+    expect(renderToString(template, { path: false })).toBe(`<svg></svg>`);
+    expect(renderToString(template, { path: true })).toBe(`<svg><path></path></svg>`);
+
+    const bdom = renderToBdom(template, { path: true });
+    const fixture = makeTestFixture();
+
+    mount(bdom, fixture);
+    const elems = fixture.querySelectorAll("svg, path");
+    expect(elems.length).toEqual(2);
+    for (const el of elems) {
+      expect(el.namespaceURI).toBe("http://www.w3.org/2000/svg");
+    }
+  });
+
+  test.only("svg namespace added to sub-blocks (t-call)", async () => {
+    const templates = `<t>
+      <t t-name="svg"><svg><t t-call="path" /></svg></t>
+      <t t-name="path"><path /></t>
+    </t>
+    `
+    const fixture = makeTestFixture();
+
+    class Svg extends Component {
+      static template = "svg";
+    }
+
+    await mountComponent(Svg, fixture, {templates})
+    const elems = fixture.querySelectorAll("svg, path");
+    expect(elems.length).toEqual(2);
+    for (const el of elems) {
+      expect(el.namespaceURI).toBe("http://www.w3.org/2000/svg");
+    }
   });
 });

tests/compiler/t_key.test.ts

@@ -43,4 +43,24 @@ describe("t-key", () => {
       })
     ).toBe("<ul><li>Chimay Rouge</li></ul>");
   });
+
+  test("t-key on sub dom node pushes a child block in its parent", async () => {
+    const template = `
+      <div>
+        <t t-if="hasSpan"><span /></t>
+        <div t-key="key"><h1 /></div>
+      </div>
+    `;
+
+    expect(renderToString(template, { key: "1" })).toBe("<div><div><h1></h1></div></div>");
+    expect(renderToString(template, { hasSpan: true, key: "1" })).toBe(
+      "<div><span></span><div><h1></h1></div></div>"
+    );
+
+    const template2 = `
+        <div t-key="key"><h1 /></div>
+    `;
+
+    expect(renderToString(template2, { key: "1" })).toBe("<div><h1></h1></div>");
+  });
 });

tests/compiler/t_set.test.ts

@@ -38,6 +38,19 @@ describe("t-set", () => {
     expect(renderToString(template)).toBe("ok");
   });
 
+  test("set from body literal (with t-if/t-else", () => {
+    const template = `
+      <t>
+        <t t-set="value">
+          <t t-if="condition">true</t>
+          <t t-else="">false</t>
+        </t>
+        <t t-esc="value"/>
+      </t>`;
+    expect(renderToString(template, { condition: true })).toBe("true");
+    expect(renderToString(template, { condition: false })).toBe("false");
+  });
+
   test("set from attribute lookup", () => {
     const template = `<div><t t-set="stuff" t-value="value"/><t t-esc="stuff"/></div>`;
     expect(renderToString(template, { value: "ok" })).toBe("<div>ok</div>");

tests/components/__snapshots__/basics.test.ts.snap

@@ -1,5 +1,45 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`basics GrandChild display is controlled by its GrandParent 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    let Comp1 = ctx['myComp'];
+    return toggler(Comp1, component(Comp1, {displayGrandChild: ctx['displayGrandChild']}, key + \`__1\`, node, ctx));
+  }
+}"
+`;
+
+exports[`basics GrandChild display is controlled by its GrandParent 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['props'].displayGrandChild) {
+      b2 = component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
+    }
+    return multi([b2]);
+  }
+}"
+`;
+
+exports[`basics GrandChild display is controlled by its GrandParent 3`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
 exports[`basics Multi root component 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -23,7 +63,7 @@ exports[`basics a class component inside a class component, no external dom 1`]
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -49,7 +89,7 @@ exports[`basics a component inside a component 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -92,7 +132,7 @@ exports[`basics can handle empty props 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {val: undefined}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {val: undefined}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -210,7 +250,7 @@ exports[`basics child can be updated 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: ctx['state'].counter}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {value: ctx['state'].counter}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -246,7 +286,7 @@ exports[`basics class parent, class child component with props 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: 42}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {value: 42}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -265,6 +305,59 @@ exports[`basics class parent, class child component with props 2`] = `
 }"
 `;
 
+exports[`basics component children doesn't leak (if case) 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['ifVar']) {
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    }
+    return multi([b2]);
+  }
+}"
+`;
+
+exports[`basics component children doesn't leak (if case) 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`basics component children doesn't leak (t-key case) 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    const tKey_1 = ctx['keyVar'];
+    return toggler(tKey_1, component(\`Child\`, {}, tKey_1 + key + \`__1\`, node, ctx));
+  }
+}"
+`;
+
+exports[`basics component children doesn't leak (t-key case) 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
 exports[`basics component with dynamic content can be updated 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -312,7 +405,7 @@ exports[`basics higher order components parent and child 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {child: ctx['state'].child}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {child: ctx['state'].child}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -325,9 +418,9 @@ exports[`basics higher order components parent and child 2`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     if (ctx['props'].child==='a') {
-      b2 = component(\`ChildA\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`ChildA\`, {}, key + \`__1\`, node, ctx);
     } else {
-      b3 = component(\`ChildB\`, {}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`ChildB\`, {}, key + \`__2\`, node, ctx);
     }
     return multi([b2, b3]);
   }
@@ -375,8 +468,8 @@ exports[`basics list of two sub components inside other nodes 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`blip\`] = v_block2[i1];
       let key1 = ctx['blip'].id;
-      let b4 = component(\`SubWidget\`, {}, key+\`__1__\${key1}\`,null, node, ctx);
+      let b4 = component(\`SubWidget\`, {}, key + \`__1__\${key1}\`, node, ctx);
-      let b5 = component(\`SubWidget\`, {}, key+\`__2__\${key1}\`,null, node, ctx);
+      let b5 = component(\`SubWidget\`, {}, key + \`__2__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([], [b4, b5]), key1);
     }
     let b2 = list(c_block2);
@@ -404,7 +497,7 @@ exports[`basics parent, child and grandchild 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -415,7 +508,7 @@ exports[`basics parent, child and grandchild 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`GrandChild\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -454,9 +547,9 @@ exports[`basics reconciliation alg is not confused in some specific situation 1`
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     const tKey_1 = 4;
-    let b3 = toggler(tKey_1, component(\`Child\`, {}, key+\`__2\`,tKey_1, node, ctx));
+    let b3 = toggler(tKey_1, component(\`Child\`, {}, tKey_1 + key + \`__2\`, node, ctx));
     return block1([], [b2, b3]);
   }
 }"
@@ -481,7 +574,7 @@ exports[`basics rerendering a widget with a sub widget 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Counter\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Counter\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -511,9 +604,9 @@ exports[`basics same t-keys in two different places 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = 1;
-    let b2 = toggler(tKey_1, component(\`Child\`, {blip: '1'}, key+\`__1\`,tKey_1, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, {blip: '1'}, tKey_1 + key + \`__1\`, node, ctx));
     const tKey_2 = 1;
-    let b3 = toggler(tKey_2, component(\`Child\`, {blip: '2'}, key+\`__2\`,tKey_2, node, ctx));
+    let b3 = toggler(tKey_2, component(\`Child\`, {blip: '2'}, tKey_2 + key + \`__2\`, node, ctx));
     return block1([], [b2, b3]);
   }
 }"
@@ -591,7 +684,7 @@ exports[`basics sub components between t-ifs 1`] = `
     } else {
       b3 = block3();
     }
-    b4 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    b4 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     if (ctx['state'].flag) {
       b5 = block5();
     }
@@ -626,7 +719,7 @@ exports[`basics t-elif works with t-component 1`] = `
     if (ctx['state'].flag) {
       b2 = block2();
     } else if (!ctx['state'].flag) {
-      b3 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -659,7 +752,7 @@ exports[`basics t-else with empty string works with t-component 1`] = `
     if (ctx['state'].flag) {
       b2 = block2();
     } else {
-      b3 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -692,7 +785,7 @@ exports[`basics t-else works with t-component 1`] = `
     if (ctx['state'].flag) {
       b2 = block2();
     } else {
-      b3 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -722,7 +815,7 @@ exports[`basics t-if works with t-component 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }
@@ -753,9 +846,9 @@ exports[`basics t-key on a component with t-if, and a sibling component 1`] = `
     let b2,b3;
     if (false) {
       const tKey_1 = 'str';
-      b2 = toggler(tKey_1, component(\`Child\`, {}, key+\`__1\`,tKey_1, node, ctx));
+      b2 = toggler(tKey_1, component(\`Child\`, {}, tKey_1 + key + \`__1\`, node, ctx));
     }
-    b3 = component(\`Child\`, {}, key+\`__2\`,null, node, ctx);
+    b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -784,7 +877,7 @@ exports[`basics text after a conditional component 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasChild) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     let txt1 = ctx['state'].text;
     return block1([txt1], [b2]);
@@ -811,7 +904,7 @@ exports[`basics three level of components with collapsing root nodes 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -822,7 +915,7 @@ exports[`basics three level of components with collapsing root nodes 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`GrandChild\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -846,8 +939,8 @@ exports[`basics two child components 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    let b3 = component(\`Child\`, {}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
     return multi([b2, b3]);
   }
 }"
@@ -875,7 +968,7 @@ exports[`basics update props of component without concrete own node 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['childProps'].key;
-    let b2 = toggler(tKey_1, component(\`Child\`, ctx['childProps'], key+\`__1\`,tKey_1, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, ctx['childProps'], tKey_1 + key + \`__1\`, node, ctx));
     return block1([], [b2]);
   }
 }"
@@ -888,7 +981,7 @@ exports[`basics update props of component without concrete own node 2`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['props'].subKey;
-    return toggler(tKey_1, component(\`Custom\`, {key: ctx['props'].key,subKey: ctx['props'].subKey}, key+\`__1\`,tKey_1, node, ctx));
+    return toggler(tKey_1, component(\`Custom\`, {key: ctx['props'].key,subKey: ctx['props'].subKey}, tKey_1 + key + \`__1\`, node, ctx));
   }
 }"
 `;
@@ -933,7 +1026,7 @@ exports[`basics updating widget immediately 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {flag: ctx['state'].flag}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {flag: ctx['state'].flag}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -974,7 +1067,7 @@ exports[`basics widget after a t-foreach 1`] = `
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);
-    let b4 = component(\`SomeComponent\`, {}, key+\`__1\`,null, node, ctx);
+    let b4 = component(\`SomeComponent\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2, b4]);
   }
 }"
@@ -1001,7 +1094,7 @@ exports[`basics zero or one child components 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasChild) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }
@@ -1081,7 +1174,7 @@ exports[`support svg components add proper namespace to svg 1`] = `
   let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><block-child-0/></svg>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`GComp\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`GComp\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

tests/components/__snapshots__/concurrency.test.ts.snap

@@ -1,5 +1,57 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`Cascading renders after microtaskTick 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, withKey } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b3 = text(\` _ \`);
+    ctx = Object.create(ctx);
+    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['state']);
+    for (let i1 = 0; i1 < l_block4; i1++) {
+      ctx[\`elem\`] = v_block4[i1];
+      let key1 = ctx['elem'].id;
+      c_block4[i1] = withKey(text(ctx['elem'].id), key1);
+    }
+    let b4 = list(c_block4);
+    return multi([b2, b3, b4]);
+  }
+}"
+`;
+
+exports[`Cascading renders after microtaskTick 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, withKey } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['state']);
+    for (let i1 = 0; i1 < l_block1; i1++) {
+      ctx[\`elem\`] = v_block1[i1];
+      let key1 = ctx['elem'].id;
+      c_block1[i1] = withKey(component(\`Element\`, {id: ctx['elem'].id}, key + \`__1__\${key1}\`, node, ctx), key1);
+    }
+    return list(c_block1);
+  }
+}"
+`;
+
+exports[`Cascading renders after microtaskTick 3`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(ctx['props'].id);
+  }
+}"
+`;
+
 exports[`async rendering destroying a widget before start is over 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -20,7 +72,7 @@ exports[`calling render in destroy 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key'];
-    return toggler(tKey_1, component(\`B\`, {fromA: ctx['state']}, key+\`__1\`,tKey_1, node, ctx));
+    return toggler(tKey_1, component(\`B\`, {fromA: ctx['state']}, tKey_1 + key + \`__1\`, node, ctx));
   }
 }"
 `;
@@ -31,7 +83,7 @@ exports[`calling render in destroy 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`C\`, {fromA: ctx['props'].fromA}, key+\`__1\`,null, node, ctx);
+    return component(\`C\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -74,7 +126,7 @@ exports[`changing state before first render does not trigger a render (with pare
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`TestW\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`TestW\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }
@@ -117,7 +169,7 @@ exports[`concurrent renderings scenario 1 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -131,7 +183,7 @@ exports[`concurrent renderings scenario 1 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA,fromB: ctx['state'].fromB}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA,fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -161,7 +213,7 @@ exports[`concurrent renderings scenario 2 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].fromA;
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([txt1], [b2]);
   }
 }"
@@ -175,7 +227,7 @@ exports[`concurrent renderings scenario 2 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA,fromB: ctx['state'].fromB}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA,fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -204,7 +256,7 @@ exports[`concurrent renderings scenario 2bis 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -218,7 +270,7 @@ exports[`concurrent renderings scenario 2bis 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA,fromB: ctx['state'].fromB}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA,fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -247,7 +299,7 @@ exports[`concurrent renderings scenario 3 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -261,7 +313,7 @@ exports[`concurrent renderings scenario 3 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -275,7 +327,7 @@ exports[`concurrent renderings scenario 3 3`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA,fromC: ctx['state'].fromC}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA,fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -304,7 +356,7 @@ exports[`concurrent renderings scenario 4 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -318,7 +370,7 @@ exports[`concurrent renderings scenario 4 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -332,7 +384,7 @@ exports[`concurrent renderings scenario 4 3`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA,fromC: ctx['state'].fromC}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA,fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -361,7 +413,7 @@ exports[`concurrent renderings scenario 5 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -389,7 +441,7 @@ exports[`concurrent renderings scenario 6 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -417,7 +469,7 @@ exports[`concurrent renderings scenario 7 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -446,7 +498,7 @@ exports[`concurrent renderings scenario 8 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -476,8 +528,8 @@ exports[`concurrent renderings scenario 9 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].fromA;
-    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
-    let b3 = component(\`ComponentC\`, {fromA: ctx['state'].fromA}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`ComponentC\`, {fromA: ctx['state'].fromA}, key + \`__2\`, node, ctx);
     return block1([txt1], [b2, b3]);
   }
 }"
@@ -505,7 +557,7 @@ exports[`concurrent renderings scenario 9 3`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA,fromC: ctx['state'].fromC}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA,fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -534,7 +586,7 @@ exports[`concurrent renderings scenario 10 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {value: ctx['state'].value}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -550,7 +602,7 @@ exports[`concurrent renderings scenario 10 2`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasChild) {
-      b2 = component(\`ComponentC\`, {value: ctx['props'].value}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`ComponentC\`, {value: ctx['props'].value}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }
@@ -579,7 +631,7 @@ exports[`concurrent renderings scenario 11 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {val: ctx['state'].valA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -608,7 +660,7 @@ exports[`concurrent renderings scenario 12 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {val: ctx['val']}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -637,9 +689,9 @@ exports[`concurrent renderings scenario 13 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
-    b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     if (ctx['state'].bool) {
-      b3 = component(\`Child\`, {}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -668,7 +720,7 @@ exports[`concurrent renderings scenario 14 1`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -682,7 +734,7 @@ exports[`concurrent renderings scenario 14 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`C\`, {fromB: ctx['state'].fromB,fromA: ctx['props'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`C\`, {fromB: ctx['state'].fromB,fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -712,7 +764,7 @@ exports[`concurrent renderings scenario 15 1`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -726,7 +778,7 @@ exports[`concurrent renderings scenario 15 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`C\`, {fromB: ctx['state'].fromB,fromA: ctx['props'].fromA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`C\`, {fromB: ctx['state'].fromB,fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -754,7 +806,7 @@ exports[`concurrent renderings scenario 16 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`B\`, {fromA: ctx['state'].fromA}, key+\`__1\`,null, node, ctx);
+    return component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -765,7 +817,7 @@ exports[`concurrent renderings scenario 16 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`C\`, {fromB: ctx['state'].fromB,fromA: ctx['props'].fromA}, key+\`__1\`,null, node, ctx);
+    return component(\`C\`, {fromB: ctx['state'].fromB,fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -784,7 +836,7 @@ exports[`concurrent renderings scenario 16 3`] = `
     b6 = text(ctx['state'].fromC);
     b7 = text(\`: \`);
     if (ctx['state'].fromC===13) {
-      b8 = component(\`D\`, {}, key+\`__1\`,null, node, ctx);
+      b8 = component(\`D\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2, b3, b4, b5, b6, b7, b8]);
   }
@@ -810,10 +862,10 @@ exports[`creating two async components, scenario 1 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     if (ctx['state'].flagA) {
-      b2 = component(\`ChildA\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`ChildA\`, {}, key + \`__1\`, node, ctx);
     }
     if (ctx['state'].flagB) {
-      b3 = component(\`ChildB\`, {}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`ChildB\`, {}, key + \`__2\`, node, ctx);
     }
     return multi([b2, b3]);
   }
@@ -856,9 +908,9 @@ exports[`creating two async components, scenario 2 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
-    b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key+\`__1\`,null, node, ctx);
+    b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
     if (ctx['state'].flagB) {
-      b3 = component(\`ChildB\`, {val: ctx['state'].valB}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`ChildB\`, {val: ctx['state'].valB}, key + \`__2\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -902,9 +954,9 @@ exports[`creating two async components, scenario 3 (patching in the same frame)
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
-    b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key+\`__1\`,null, node, ctx);
+    b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
     if (ctx['state'].flagB) {
-      b3 = component(\`ChildB\`, {val: ctx['state'].valB}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`ChildB\`, {val: ctx['state'].valB}, key + \`__2\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -945,7 +997,7 @@ exports[`delay willUpdateProps 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: ctx['state'].value}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -970,7 +1022,7 @@ exports[`delay willUpdateProps with rendering grandchild 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Parent\`, {state: ctx['state']}, key+\`__1\`,null, node, ctx);
+    return component(\`Parent\`, {state: ctx['state']}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -981,8 +1033,8 @@ exports[`delay willUpdateProps with rendering grandchild 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`DelayedChild\`, {value: ctx['props'].state.value}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`DelayedChild\`, {value: ctx['props'].state.value}, key + \`__1\`, node, ctx);
-    let b3 = component(\`ReactiveChild\`, {}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`ReactiveChild\`, {}, key + \`__2\`, node, ctx);
     return multi([b2, b3]);
   }
 }"
@@ -1025,7 +1077,7 @@ exports[`destroying/recreating a subwidget with different props (if start is not
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].val>1) {
-      b2 = component(\`Child\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }
@@ -1052,7 +1104,7 @@ exports[`parent and child rendered at exact same time 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: ctx['state'].value}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1078,7 +1130,7 @@ exports[`properly behave when destroyed/unmounted while rendering  1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }
@@ -1093,7 +1145,7 @@ exports[`properly behave when destroyed/unmounted while rendering  2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`SubChild\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubChild\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1123,7 +1175,7 @@ exports[`rendering component again in next microtick 1`] = `
     let b2;
     let hdlr1 = [ctx['onClick'], ctx];
     if (ctx['env'].config.flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([hdlr1], [b2]);
   }
@@ -1143,6 +1195,72 @@ exports[`rendering component again in next microtick 2`] = `
 }"
 `;
 
+exports[`t-foreach with dynamic async component 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, withKey } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['list']);
+    for (let i1 = 0; i1 < l_block1; i1++) {
+      ctx[\`arr\`] = v_block1[i1];
+      ctx[\`arr_index\`] = i1;
+      let key1 = ctx['arr_index'];
+      let b3;
+      if (ctx['arr']) {
+        let Comp1 = ctx['myComp'];
+        b3 = toggler(Comp1, component(Comp1, {key: ctx['arr'][0]}, key + \`__1__\${key1}\`, node, ctx));
+      }
+      c_block1[i1] = withKey(multi([b3]), key1);
+    }
+    return list(c_block1);
+  }
+}"
+`;
+
+exports[`t-foreach with dynamic async component 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><block-text-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['props'].key;
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-key on dom node having a component 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const tKey_1 = ctx['key'];
+    let Comp1 = ctx['myComp'];
+    let b2 = toggler(tKey_1, toggler(Comp1, component(Comp1, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx)));
+    return toggler(tKey_1, block1([], [b2]));
+  }
+}"
+`;
+
+exports[`t-key on dom node having a component 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(ctx['props'].key);
+  }
+}"
+`;
+
 exports[`t-key on dynamic async component (toggler is never patched) 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -1151,7 +1269,7 @@ exports[`t-key on dynamic async component (toggler is never patched) 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key'];
     let Comp1 = ctx['myComp'];
-    return toggler(tKey_1, toggler(Comp1, component(Comp1, {key: ctx['key']}, key+\`__1\`,tKey_1, node, ctx)));
+    return toggler(tKey_1, toggler(Comp1, component(Comp1, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx)));
   }
 }"
 `;
@@ -1181,7 +1299,7 @@ exports[`two renderings initiated between willPatch and patched 1`] = `
     let b2;
     if (ctx['state'].flag) {
       const tKey_1 = 'panel_'+ctx['state'].panel;
-      b2 = toggler(tKey_1, component(\`Panel\`, {val: ctx['state'].panel}, key+\`__1\`,tKey_1, node, ctx));
+      b2 = toggler(tKey_1, component(\`Panel\`, {val: ctx['state'].panel}, tKey_1 + key + \`__1\`, node, ctx));
     }
     return block1([], [b2]);
   }
@@ -1209,7 +1327,7 @@ exports[`two sequential renderings before an animation frame 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: ctx['state'].value}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1233,7 +1351,7 @@ exports[`update a sub-component twice in the same frame 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1261,7 +1379,7 @@ exports[`update a sub-component twice in the same frame, 2 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

tests/components/__snapshots__/error_handling.test.ts.snap

@@ -6,7 +6,7 @@ exports[`basics display a nice error if it cannot find component 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`SomeMispelledComponent\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`SomeMispelledComponent\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -19,7 +19,7 @@ exports[`basics no component catching error lead to full app destruction 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ErrorComponent\`, {flag: ctx['state'].flag}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ErrorComponent\`, {flag: ctx['state'].flag}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -51,7 +51,7 @@ exports[`basics simple catchError 1`] = `
     if (ctx['error']) {
       b2 = text(\`Error\`);
     } else {
-      b3 = component(\`Boom\`, {}, key+\`__1\`,null, node, ctx);
+      b3 = component(\`Boom\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -80,11 +80,11 @@ exports[`can catch errors can catch an error in a component render function 1`]
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {flag: ctx['state'].flag}, key+\`__1\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {flag: ctx['state'].flag}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -132,11 +132,11 @@ exports[`can catch errors can catch an error in the constructor call of a compon
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -170,13 +170,13 @@ exports[`can catch errors can catch an error in the constructor call of a compon
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    let b3 = component(\`ClassicCompoent\`, {}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`ClassicCompoent\`, {}, key + \`__1\`, node, ctx);
-    let b4 = component(\`ErrorComponent\`, {}, key+\`__2\`,null, node, ctx);
+    let b4 = component(\`ErrorComponent\`, {}, key + \`__2\`, node, ctx);
     return multi([b3, b4]);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b5 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__3\`,null, node, ctx);
+    let b5 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -249,11 +249,11 @@ exports[`can catch errors can catch an error in the initial call of a component
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -301,13 +301,13 @@ exports[`can catch errors can catch an error in the initial call of a component
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
     let b3;
     if (ctx['state'].flag) {
-      b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     }
     return block1([], [b3]);
   }
@@ -354,7 +354,7 @@ exports[`can catch errors can catch an error in the mounted call (in child of ch
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`B\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`B\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -367,7 +367,7 @@ exports[`can catch errors can catch an error in the mounted call (in child of ch
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`C\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`C\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -385,7 +385,7 @@ exports[`can catch errors can catch an error in the mounted call (in child of ch
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = component(\`Boom\`, {}, key+\`__1\`,null, node, ctx);
+      b3 = component(\`Boom\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -417,7 +417,7 @@ exports[`can catch errors can catch an error in the mounted call (in root compon
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = component(\`ErrorComponent\`, {}, key+\`__1\`,null, node, ctx);
+      b3 = component(\`ErrorComponent\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -445,11 +445,11 @@ exports[`can catch errors can catch an error in the mounted call 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -496,12 +496,12 @@ exports[`can catch errors can catch an error in the willPatch call 1`] = `
   let block1 = createBlock(\`<div><span><block-text-0/></span><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {message: ctx['state'].message}, key+\`__1\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {message: ctx['state'].message}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].message;
-    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([txt1], [b3]);
   }
 }"
@@ -549,11 +549,11 @@ exports[`can catch errors can catch an error in the willStart call 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -600,13 +600,13 @@ exports[`can catch errors can catch an error origination from a child's willStar
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    let b3 = component(\`ClassicCompoent\`, {}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`ClassicCompoent\`, {}, key + \`__1\`, node, ctx);
-    let b4 = component(\`ErrorComponent\`, {}, key+\`__2\`,null, node, ctx);
+    let b4 = component(\`ErrorComponent\`, {}, key + \`__2\`, node, ctx);
     return multi([b3, b4]);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b5 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__3\`,null, node, ctx);
+    let b5 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -670,7 +670,7 @@ exports[`can catch errors catchError in catchError 1`] = `
     if (ctx['error']) {
       b2 = text(\`Error\`);
     } else {
-      b3 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2, b3]);
   }
@@ -685,7 +685,7 @@ exports[`can catch errors catchError in catchError 2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Boom\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Boom\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -713,7 +713,7 @@ exports[`can catch errors catching error, rethrow, render parent  -- a main comp
   
   function slot1(ctx, node, key = \\"\\") {
     let Comp1 = ctx['cp'].Comp;
-    return toggler(Comp1, component(Comp1, {}, key+\`__1\`,null, node, ctx));
+    return toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
   }
   
   return function template(ctx, node, key = \\"\\") {
@@ -724,7 +724,7 @@ exports[`can catch errors catching error, rethrow, render parent  -- a main comp
       let key1 = ctx['cp'].id;
       const v1 = ctx['cp'];
       const ctx1 = capture(ctx);
-      c_block1[i1] = withKey(component(\`ErrorHandler\`, {onError: ()=>this.cleanUp(v1.id),slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2__\${key1}\`,null, node, ctx), key1);
+      c_block1[i1] = withKey(component(\`ErrorHandler\`, {onError: ()=>this.cleanUp(v1.id),slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
   }
@@ -749,7 +749,7 @@ exports[`can catch errors catching error, rethrow, render parent  -- a main comp
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -780,6 +780,71 @@ exports[`can catch errors catching error, rethrow, render parent  -- a main comp
 }"
 `;
 
+exports[`can catch errors catching in child makes parent render 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, capture, withKey } = helpers;
+  
+  function slot1(ctx, node, key = \\"\\") {
+    let Comp1 = ctx['elem'][1];
+    return toggler(Comp1, component(Comp1, {id: ctx['elem'][0]}, key + \`__1\`, node, ctx));
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(Object.entries(this.elements));
+    for (let i1 = 0; i1 < l_block1; i1++) {
+      ctx[\`elem\`] = v_block1[i1];
+      let key1 = ctx['elem'][0];
+      const v1 = ctx['elem'];
+      const ctx1 = capture(ctx);
+      c_block1[i1] = withKey(component(\`Catch\`, {onError: (error)=>this.onError(v1[0],error),slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2__\${key1}\`, node, ctx), key1);
+    }
+    return list(c_block1);
+  }
+}"
+`;
+
+exports[`can catch errors catching in child makes parent render 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { callSlot } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return callSlot(ctx, node, key, 'default', false, {});
+  }
+}"
+`;
+
+exports[`can catch errors catching in child makes parent render 3`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`can catch errors catching in child makes parent render 4`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><block-text-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = 'Child '+ctx['props'].id;
+    return block1([txt1]);
+  }
+}"
+`;
+
 exports[`can catch errors error in mounted on a component with a sibling (properly mounted) 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -788,12 +853,12 @@ exports[`can catch errors error in mounted on a component with a sibling (proper
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`ErrorComponent\`, {}, key+\`__2\`,null, node, ctx);
+    return component(\`ErrorComponent\`, {}, key + \`__2\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`OK\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`OK\`, {}, key + \`__1\`, node, ctx);
-    let b4 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__3\`,null, node, ctx);
+    let b4 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
     return block1([], [b2, b4]);
   }
 }"
@@ -849,7 +914,7 @@ exports[`can catch errors onError in class inheritance is called if rethrown 1`]
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Concrete\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Concrete\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -879,7 +944,7 @@ exports[`can catch errors onError in class inheritance is not called if no rethr
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Concrete\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Concrete\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -911,7 +976,7 @@ exports[`errors and promises a rendering error in a sub component will reject th
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -953,7 +1018,7 @@ exports[`errors and promises a rendering error will reject the render promise (w
   let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     let txt1 = ctx['x'].y;
     return block1([txt1], [b2]);
   }

tests/components/__snapshots__/event_handling.test.ts.snap

@@ -1,5 +1,33 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`event handling Invalid handler throws an error 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<button block-handler-0=\\"click\\">click</button>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let hdlr1 = [ctx['dosomething'], ctx];
+    return block1([hdlr1]);
+  }
+}"
+`;
+
+exports[`event handling handler is not called if component is destroyed 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<span block-handler-0=\\"click\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let hdlr1 = [ctx['click'], ctx];
+    return block1([hdlr1]);
+  }
+}"
+`;
+
 exports[`event handling handler receive the event as argument 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -9,7 +37,7 @@ exports[`event handling handler receive the event as argument 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let hdlr1 = [ctx['inc'], ctx];
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     let txt1 = ctx['state'].value;
     return block1([hdlr1, txt1], [b2]);
   }
@@ -29,6 +57,37 @@ exports[`event handling handler receive the event as argument 2`] = `
 }"
 `;
 
+exports[`event handling input blur event is not called if component is destroyed 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><block-child-0/><textarea/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['state'].cond) {
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    }
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`event handling input blur event is not called if component is destroyed 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<input block-handler-0=\\"blur\\"/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let hdlr1 = [ctx['blur'], ctx];
+    return block1([hdlr1]);
+  }
+}"
+`;
+
 exports[`event handling objects from scope are properly captured by t-on 1`] = `
 "function anonymous(bdom, helpers
 ) {

tests/components/__snapshots__/higher_order_component.test.ts.snap

@@ -6,7 +6,7 @@ exports[`basics basic use 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {p: 1}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {p: 1}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -33,10 +33,10 @@ exports[`basics can select a sub widget  1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     if (ctx['env'].options.flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     if (!ctx['env'].options.flag) {
-      b3 = component(\`OtherChild\`, {}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`OtherChild\`, {}, key + \`__2\`, node, ctx);
     }
     return multi([b2, b3]);
   }
@@ -77,10 +77,10 @@ exports[`basics can select a sub widget, part 2 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     if (!ctx['state'].flag) {
-      b3 = component(\`OtherChild\`, {}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`OtherChild\`, {}, key + \`__2\`, node, ctx);
     }
     return multi([b2, b3]);
   }
@@ -119,7 +119,7 @@ exports[`basics sub widget is interactive 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {p: 1}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {p: 1}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -147,7 +147,7 @@ exports[`basics top level sub widget with a parent 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ComponentB\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ComponentB\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -159,7 +159,7 @@ exports[`basics top level sub widget with a parent 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`ComponentC\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`ComponentC\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;

tests/components/__snapshots__/hooks.test.ts.snap

@@ -43,7 +43,7 @@ exports[`hooks can use onWillStart, onWillUpdateProps 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`MyComponent\`, {value: ctx['state'].value}, key+\`__1\`,null, node, ctx);
+    return component(\`MyComponent\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -110,7 +110,7 @@ exports[`hooks parent and child env 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let b2 = text(ctx['env'].val);
-    let b3 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return multi([b2, b3]);
   }
 }"
@@ -164,7 +164,7 @@ exports[`hooks use sub env supports arbitrary descriptor 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -251,7 +251,7 @@ exports[`hooks useExternalListener 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`MyComponent\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`MyComponent\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }

tests/components/__snapshots__/lifecycle.test.ts.snap

@@ -21,8 +21,8 @@ exports[`lifecycle hooks component semantics 1`] = `
   let block1 = createBlock(\`<div>A<block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`B\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`B\`, {}, key + \`__1\`, node, ctx);
-    let b3 = component(\`C\`, {}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`C\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -50,11 +50,11 @@ exports[`lifecycle hooks component semantics 3`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3,b4;
-    b2 = component(\`D\`, {}, key+\`__1\`,null, node, ctx);
+    b2 = component(\`D\`, {}, key + \`__1\`, node, ctx);
     if (ctx['state'].flag) {
-      b3 = component(\`E\`, {}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`E\`, {}, key + \`__2\`, node, ctx);
     } else {
-      b4 = component(\`F\`, {}, key+\`__3\`,null, node, ctx);
+      b4 = component(\`F\`, {}, key + \`__3\`, node, ctx);
     }
     return block1([], [b2, b3, b4]);
   }
@@ -110,7 +110,7 @@ exports[`lifecycle hooks components are unmounted and destroyed if no longer in
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      let b3 = component(\`Child\`, {n: ctx['state'].n}, key+\`__1\`,null, node, ctx);
+      let b3 = component(\`Child\`, {n: ctx['state'].n}, key + \`__1\`, node, ctx);
       b2 = block2([], [b3]);
     }
     return multi([b2]);
@@ -140,7 +140,7 @@ exports[`lifecycle hooks components are unmounted destroyed if no longer in DOM
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].ok) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }
@@ -168,7 +168,7 @@ exports[`lifecycle hooks hooks are called in proper order in widget creation/des
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -187,6 +187,28 @@ exports[`lifecycle hooks hooks are called in proper order in widget creation/des
 }"
 `;
 
+exports[`lifecycle hooks lifecycle callbacks are bound to component 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return component(\`Test\`, {rev: ctx['rev']}, key + \`__1\`, node, ctx);
+  }
+}"
+`;
+
+exports[`lifecycle hooks lifecycle callbacks are bound to component 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(ctx['props'].rev);
+  }
+}"
+`;
+
 exports[`lifecycle hooks lifecycle semantics 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -195,7 +217,7 @@ exports[`lifecycle hooks lifecycle semantics 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {a: ctx['state'].a}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {a: ctx['state'].a}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -222,7 +244,7 @@ exports[`lifecycle hooks lifecycle semantics, part 2 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasChild) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }
@@ -235,7 +257,7 @@ exports[`lifecycle hooks lifecycle semantics, part 2 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`GrandChild\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -261,7 +283,7 @@ exports[`lifecycle hooks lifecycle semantics, part 3 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasChild) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }
@@ -276,7 +298,7 @@ exports[`lifecycle hooks lifecycle semantics, part 4 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasChild) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }
@@ -289,7 +311,7 @@ exports[`lifecycle hooks lifecycle semantics, part 4 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`GrandChild\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -315,7 +337,7 @@ exports[`lifecycle hooks lifecycle semantics, part 5 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasChild) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }
@@ -341,7 +363,7 @@ exports[`lifecycle hooks lifecycle semantics, part 6 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: ctx['state'].value}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -380,7 +402,7 @@ exports[`lifecycle hooks mounted hook is called on every mount, not just the fir
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasChild) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }
@@ -408,7 +430,7 @@ exports[`lifecycle hooks mounted hook is called on subcomponents, in proper orde
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -437,7 +459,7 @@ exports[`lifecycle hooks mounted hook is called on subsubcomponents, in proper o
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }
@@ -452,7 +474,7 @@ exports[`lifecycle hooks mounted hook is called on subsubcomponents, in proper o
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ChildChild\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ChildChild\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -477,7 +499,7 @@ exports[`lifecycle hooks onWillRender 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -505,7 +527,7 @@ exports[`lifecycle hooks patched hook is called after updateProps 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {a: ctx['state'].a}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {a: ctx['state'].a}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -588,7 +610,7 @@ exports[`lifecycle hooks sub widget (inside sub node): hooks are correctly calle
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return multi([b2]);
   }
@@ -616,7 +638,7 @@ exports[`lifecycle hooks willPatch, patched hook are called on subsubcomponents,
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {n: ctx['state'].n}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {n: ctx['state'].n}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -630,7 +652,7 @@ exports[`lifecycle hooks willPatch, patched hook are called on subsubcomponents,
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`ChildChild\`, {n: ctx['props'].n}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`ChildChild\`, {n: ctx['props'].n}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -656,7 +678,7 @@ exports[`lifecycle hooks willStart hook is called on sub component 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -711,7 +733,7 @@ exports[`lifecycle hooks willStart, mounted on subwidget rendered after main is
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     if (ctx['state'].ok) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     } else {
       b3 = block3();
     }
@@ -739,7 +761,7 @@ exports[`lifecycle hooks willUpdateProps hook is called 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {n: ctx['state'].n}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {n: ctx['state'].n}, key + \`__1\`, node, ctx);
   }
 }"
 `;

tests/components/__snapshots__/props.test.ts.snap

@@ -8,7 +8,7 @@ exports[`basics accept ES6-like syntax for props (with getters) 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {greetings: ctx['greetings']}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {greetings: ctx['greetings']}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -42,7 +42,7 @@ exports[`basics arrow functions as prop correctly capture their scope 1`] = `
       let key1 = ctx['item'].val;
       const v1 = ctx['onClick'];
       const v2 = ctx['item'];
-      c_block1[i1] = withKey(component(\`Child\`, {onClick: ev=>v1(v2.val,ev)}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block1[i1] = withKey(component(\`Child\`, {onClick: ev=>v1(v2.val,ev)}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
   }
@@ -71,7 +71,7 @@ exports[`basics explicit object prop 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {value: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {value: ctx['state'].val}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -97,7 +97,7 @@ exports[`basics prop names can contain - 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {'prop-name': 7}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {'prop-name': 7}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -122,7 +122,7 @@ exports[`basics support prop names that aren't valid bare object property names
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {'some-dashed-prop': 5,'a.b': 'keyword prop'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {'some-dashed-prop': 5}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -158,7 +158,7 @@ exports[`basics t-set with a body expression can be passed in props, and then t-
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx[\`abc\`] = new LazyValue(value1, ctx, node);
-    let b3 = component(\`Child\`, {val: ctx['abc']}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Child\`, {val: ctx['abc']}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -192,7 +192,7 @@ exports[`basics t-set with a body expression can be used as textual prop 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"abc\\", \`42\`);
-    let b2 = component(\`Child\`, {val: ctx['abc']}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {val: ctx['abc']}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -224,7 +224,7 @@ exports[`basics t-set works  1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"val\\", 42);
-    let b2 = component(\`Child\`, {val: ctx['val']}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -250,7 +250,7 @@ exports[`basics template string in prop 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {propName: \`1\${ctx['someVal']}3\`}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {propName: \`1\${ctx['someVal']}3\`}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -273,7 +273,7 @@ exports[`bound functions is referentially equal after update 1`] = `
   let { bind } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {val: ctx['state'].val,fn: bind(ctx, ctx['someFunction'])}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {val: ctx['state'].val,fn: bind(ctx, ctx['someFunction'])}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -296,7 +296,7 @@ exports[`can bind function prop with bind suffix 1`] = `
   let { bind } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {doSomething: bind(ctx, ctx['doSomething'])}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {doSomething: bind(ctx, ctx['doSomething'])}, key + \`__1\`, node, ctx);
   }
 }"
 `;

tests/components/__snapshots__/props_validation.test.ts.snap

@@ -10,7 +10,7 @@ exports[`default props can set default required boolean values 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -46,7 +46,7 @@ exports[`default props can set default values 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -76,7 +76,7 @@ exports[`default props default values are also set whenever component is updated
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['state'].p}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -104,7 +104,7 @@ exports[`props validation can specify that additional props are allowed (array)
   return function template(ctx, node, key = \\"\\") {
     const props1 = {message: 'm',otherProp: 'o'}
     helpers.validateProps(\`Child\`, props1, ctx)
-    return component(\`Child\`, props1, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, props1, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -130,7 +130,7 @@ exports[`props validation can specify that additional props are allowed (object)
   return function template(ctx, node, key = \\"\\") {
     const props1 = {message: 'm',otherProp: 'o'}
     helpers.validateProps(\`Child\`, props1, ctx)
-    return component(\`Child\`, props1, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, props1, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -158,7 +158,7 @@ exports[`props validation can validate a prop with multiple types 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -187,7 +187,7 @@ exports[`props validation can validate a prop with multiple types 3`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -216,7 +216,7 @@ exports[`props validation can validate a prop with multiple types 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -232,7 +232,7 @@ exports[`props validation can validate an array with given primitive type 1`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -261,7 +261,7 @@ exports[`props validation can validate an array with given primitive type 3`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -290,7 +290,7 @@ exports[`props validation can validate an array with given primitive type 5`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -306,7 +306,7 @@ exports[`props validation can validate an array with given primitive type 6`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -322,7 +322,7 @@ exports[`props validation can validate an array with multiple sub element types
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -351,7 +351,7 @@ exports[`props validation can validate an array with multiple sub element types
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -380,7 +380,7 @@ exports[`props validation can validate an array with multiple sub element types
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -409,7 +409,7 @@ exports[`props validation can validate an array with multiple sub element types
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -425,7 +425,7 @@ exports[`props validation can validate an object with simple shape 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -454,7 +454,7 @@ exports[`props validation can validate an object with simple shape 3`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -470,7 +470,7 @@ exports[`props validation can validate an object with simple shape 4`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -486,7 +486,7 @@ exports[`props validation can validate an object with simple shape 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -502,7 +502,7 @@ exports[`props validation can validate an optional props 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -531,7 +531,7 @@ exports[`props validation can validate an optional props 3`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -560,7 +560,7 @@ exports[`props validation can validate an optional props 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -576,7 +576,7 @@ exports[`props validation can validate recursively complicated prop def 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -605,7 +605,7 @@ exports[`props validation can validate recursively complicated prop def 3`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -634,7 +634,7 @@ exports[`props validation can validate recursively complicated prop def 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -650,7 +650,7 @@ exports[`props validation default values are applied before validating props at
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['state'].p}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -680,7 +680,7 @@ exports[`props validation missing required boolean prop causes an error 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -696,7 +696,7 @@ exports[`props validation mix of optional and mandatory 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {}
     helpers.validateProps(\`Child\`, props1, ctx)
-    let b2 = component(\`Child\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -712,7 +712,7 @@ exports[`props validation props are validated in dev mode (code snapshot) 1`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {message: 1}
     helpers.validateProps(\`Child\`, props1, ctx)
-    let b2 = component(\`Child\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -742,7 +742,7 @@ exports[`props validation props are validated whenever component is updated 1`]
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['state'].p}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -772,7 +772,7 @@ exports[`props validation props: list of strings 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -788,7 +788,7 @@ exports[`props validation validate simple types 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -804,7 +804,7 @@ exports[`props validation validate simple types 2`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -833,7 +833,7 @@ exports[`props validation validate simple types 4`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -849,7 +849,7 @@ exports[`props validation validate simple types 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -865,7 +865,7 @@ exports[`props validation validate simple types 6`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -894,7 +894,7 @@ exports[`props validation validate simple types 8`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -910,7 +910,7 @@ exports[`props validation validate simple types 9`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -926,7 +926,7 @@ exports[`props validation validate simple types 10`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -955,7 +955,7 @@ exports[`props validation validate simple types 12`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -971,7 +971,7 @@ exports[`props validation validate simple types 13`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -987,7 +987,7 @@ exports[`props validation validate simple types 14`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1016,7 +1016,7 @@ exports[`props validation validate simple types 16`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1032,7 +1032,7 @@ exports[`props validation validate simple types 17`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1048,7 +1048,7 @@ exports[`props validation validate simple types 18`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1077,7 +1077,7 @@ exports[`props validation validate simple types 20`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1093,7 +1093,7 @@ exports[`props validation validate simple types 21`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1109,7 +1109,7 @@ exports[`props validation validate simple types 22`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1138,7 +1138,7 @@ exports[`props validation validate simple types 24`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1154,7 +1154,7 @@ exports[`props validation validate simple types, alternate form 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1170,7 +1170,7 @@ exports[`props validation validate simple types, alternate form 2`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1199,7 +1199,7 @@ exports[`props validation validate simple types, alternate form 4`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1215,7 +1215,7 @@ exports[`props validation validate simple types, alternate form 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1231,7 +1231,7 @@ exports[`props validation validate simple types, alternate form 6`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1260,7 +1260,7 @@ exports[`props validation validate simple types, alternate form 8`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1276,7 +1276,7 @@ exports[`props validation validate simple types, alternate form 9`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1292,7 +1292,7 @@ exports[`props validation validate simple types, alternate form 10`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1321,7 +1321,7 @@ exports[`props validation validate simple types, alternate form 12`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1337,7 +1337,7 @@ exports[`props validation validate simple types, alternate form 13`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1353,7 +1353,7 @@ exports[`props validation validate simple types, alternate form 14`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1382,7 +1382,7 @@ exports[`props validation validate simple types, alternate form 16`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1398,7 +1398,7 @@ exports[`props validation validate simple types, alternate form 17`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1414,7 +1414,7 @@ exports[`props validation validate simple types, alternate form 18`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1443,7 +1443,7 @@ exports[`props validation validate simple types, alternate form 20`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1459,7 +1459,7 @@ exports[`props validation validate simple types, alternate form 21`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1475,7 +1475,7 @@ exports[`props validation validate simple types, alternate form 22`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1504,7 +1504,7 @@ exports[`props validation validate simple types, alternate form 24`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1520,7 +1520,7 @@ exports[`props validation validation is only done in dev mode 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {}
     helpers.validateProps(\`SubComp\`, props1, ctx)
-    let b2 = component(\`SubComp\`, props1, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1534,7 +1534,7 @@ exports[`props validation validation is only done in dev mode 2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`SubComp\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`SubComp\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

tests/components/__snapshots__/reactivity.test.ts.snap

@@ -52,7 +52,7 @@ exports[`reactivity in lifecycle state changes in willUnmount do not trigger rer
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }

tests/components/__snapshots__/refs.test.ts.snap

@@ -57,7 +57,7 @@ exports[`refs refs are properly bound in slots 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].val;
     const ctx1 = capture(ctx);
-    let b3 = component(\`Dialog\`, {slots: {'footer': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'footer': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([txt1], [b3]);
   }
 }"

tests/components/__snapshots__/slots.test.ts.snap

@@ -8,7 +8,7 @@ exports[`slots can define a default content 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Dialog\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Dialog\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -53,7 +53,7 @@ exports[`slots can define and call slots 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b4 = component(\`Dialog\`, {slots: {'header': {__render: slot1, __ctx: ctx1}, 'footer': {__render: slot2, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b4 = component(\`Dialog\`, {slots: {'header': {__render: slot1, __ctx: ctx1}, 'footer': {__render: slot2, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b4]);
   }
 }"
@@ -95,7 +95,7 @@ exports[`slots can define and call slots with params 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b4 = component(\`Dialog\`, {slots: {'header': {__render: slot1, __ctx: ctx1, param: ctx['var']}, 'footer': {__render: slot2, __ctx: ctx1, param: '5'}}}, key+\`__1\`,null, node, ctx);
+    let b4 = component(\`Dialog\`, {slots: {'header': {__render: slot1, __ctx: ctx1, param: ctx['var']}, 'footer': {__render: slot2, __ctx: ctx1, param: '5'}}}, key + \`__1\`, node, ctx);
     return block1([], [b4]);
   }
 }"
@@ -130,12 +130,12 @@ exports[`slots can render node with t-ref and Component in same slot 1`] = `
     const refs = ctx.__owl__.refs;
     const ref1 = (el) => refs[\`div\`] = el;
     let b2 = block2([ref1]);
-    let b3 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return multi([b2, b3]);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -170,7 +170,7 @@ exports[`slots can use component in default-content of t-slot 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -182,7 +182,7 @@ exports[`slots can use component in default-content of t-slot 2`] = `
   let { callSlot } = helpers;
   
   function defaultContent1(ctx, node, key = \\"\\") {
-    return component(\`GrandChild\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
@@ -208,7 +208,7 @@ exports[`slots can use t-call in default-content of t-slot 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -253,7 +253,7 @@ exports[`slots content is the default slot (variation) 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -283,7 +283,7 @@ exports[`slots content is the default slot 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -318,7 +318,7 @@ exports[`slots default content is not rendered if named slot is provided 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b3 = component(\`Dialog\`, {slots: {'header': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'header': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -355,7 +355,7 @@ exports[`slots default content is not rendered if slot is provided 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -394,7 +394,7 @@ exports[`slots default slot next to named slot, with default content 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b3 = component(\`Dialog\`, {slots: {'footer': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'footer': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -434,7 +434,7 @@ exports[`slots default slot work with text nodes (variation) 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -463,7 +463,7 @@ exports[`slots default slot work with text nodes 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -507,7 +507,7 @@ exports[`slots dynamic t-slot call 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b6 = component(\`Toggler\`, {slots: {'slot1': {__render: slot1, __ctx: ctx1}, 'slot2': {__render: slot2, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b6 = component(\`Toggler\`, {slots: {'slot1': {__render: slot1, __ctx: ctx1}, 'slot2': {__render: slot2, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b6]);
   }
 }"
@@ -553,7 +553,7 @@ exports[`slots dynamic t-slot call with default 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b6 = component(\`Toggler\`, {slots: {'slot1': {__render: slot1, __ctx: ctx1}, 'slot2': {__render: slot2, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b6 = component(\`Toggler\`, {slots: {'slot1': {__render: slot1, __ctx: ctx1}, 'slot2': {__render: slot2, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b6]);
   }
 }"
@@ -589,7 +589,7 @@ exports[`slots fun: two calls to the same slot 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -616,7 +616,7 @@ exports[`slots missing slots are ignored 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Dialog\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Dialog\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -654,7 +654,7 @@ exports[`slots multiple roots are allowed in a default slot 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b5 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b5 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -693,7 +693,7 @@ exports[`slots multiple roots are allowed in a named slot 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b5 = component(\`Dialog\`, {slots: {'content': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b5 = component(\`Dialog\`, {slots: {'content': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -721,16 +721,16 @@ exports[`slots multiple slots containing components 1`] = `
   let { capture } = helpers;
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`C\`, {val: 1}, key+\`__1\`,null, node, ctx);
+    return component(\`C\`, {val: 1}, key + \`__1\`, node, ctx);
   }
   
   function slot2(ctx, node, key = \\"\\") {
-    return component(\`C\`, {val: 2}, key+\`__2\`,null, node, ctx);
+    return component(\`C\`, {val: 2}, key + \`__2\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`B\`, {slots: {'s1': {__render: slot1, __ctx: ctx1}, 's2': {__render: slot2, __ctx: ctx1}}}, key+\`__3\`,null, node, ctx);
+    return component(\`B\`, {slots: {'s1': {__render: slot1, __ctx: ctx1}, 's2': {__render: slot2, __ctx: ctx1}}}, key + \`__3\`, node, ctx);
   }
 }"
 `;
@@ -782,7 +782,7 @@ exports[`slots named slot inside slot 1`] = `
   
   function slot2(ctx, node, key = \\"\\") {
     const ctx2 = capture(ctx);
-    return component(\`Child\`, {slots: {'brol': {__render: slot3, __ctx: ctx2}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'brol': {__render: slot3, __ctx: ctx2}}}, key + \`__1\`, node, ctx);
   }
   
   function slot3(ctx, node, key = \\"\\") {
@@ -792,7 +792,7 @@ exports[`slots named slot inside slot 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b5 = component(\`Child\`, {slots: {'brol': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    let b5 = component(\`Child\`, {slots: {'brol': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -831,7 +831,7 @@ exports[`slots named slot inside slot, part 3 1`] = `
   
   function slot2(ctx, node, key = \\"\\") {
     const ctx2 = capture(ctx);
-    return component(\`Child\`, {slots: {'brol': {__render: slot3, __ctx: ctx2}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'brol': {__render: slot3, __ctx: ctx2}}}, key + \`__1\`, node, ctx);
   }
   
   function slot3(ctx, node, key = \\"\\") {
@@ -841,7 +841,7 @@ exports[`slots named slot inside slot, part 3 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b5 = component(\`Child\`, {slots: {'brol': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    let b5 = component(\`Child\`, {slots: {'brol': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -871,7 +871,7 @@ exports[`slots named slots can define a default content 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Dialog\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Dialog\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -913,7 +913,7 @@ exports[`slots named slots inside slot, again 1`] = `
   
   function slot2(ctx, node, key = \\"\\") {
     const ctx2 = capture(ctx);
-    return component(\`Child\`, {slots: {'brol2': {__render: slot3, __ctx: ctx2}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'brol2': {__render: slot3, __ctx: ctx2}}}, key + \`__1\`, node, ctx);
   }
   
   function slot3(ctx, node, key = \\"\\") {
@@ -923,7 +923,7 @@ exports[`slots named slots inside slot, again 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b5 = component(\`Child\`, {slots: {'brol1': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    let b5 = component(\`Child\`, {slots: {'brol1': {__render: slot1, __ctx: ctx1}, 'default': {__render: slot2, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -962,15 +962,15 @@ exports[`slots nested slots in same template 1`] = `
   let block1 = createBlock(\`<span id=\\"parent\\"><block-child-0/></span>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child2\`, {slots: {'default': {__render: slot2, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    return component(\`Child2\`, {slots: {'default': {__render: slot2, __ctx: ctx}}}, key + \`__2\`, node, ctx);
   }
   
   function slot2(ctx, node, key = \\"\\") {
-    return component(\`Child3\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child3\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b4 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__3\`,null, node, ctx);
+    let b4 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
     return block1([], [b4]);
   }
 }"
@@ -1025,11 +1025,11 @@ exports[`slots nested slots: evaluation context and parented relationship 1`] =
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Slot\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+    return component(\`Slot\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -1045,7 +1045,7 @@ exports[`slots nested slots: evaluation context and parented relationship 2`] =
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`GrandChild\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`GrandChild\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1085,7 +1085,7 @@ exports[`slots no named slot content => just no children 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Dialog\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Dialog\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1115,7 +1115,7 @@ exports[`slots simple default slot 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1153,7 +1153,7 @@ exports[`slots simple default slot with params 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1, __scope: \\"slotScope\\"}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1, __scope: \\"slotScope\\"}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1189,7 +1189,7 @@ exports[`slots simple default slot with params 3`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1219,7 +1219,7 @@ exports[`slots simple default slot, variation 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1251,7 +1251,7 @@ exports[`slots slot and (inline) t-call 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -1300,7 +1300,7 @@ exports[`slots slot and t-call 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -1346,7 +1346,7 @@ exports[`slots slot and t-esc 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -1375,13 +1375,13 @@ exports[`slots slot are properly rendered if inner props are changed 1`] = `
   let block1 = createBlock(\`<div><button block-handler-0=\\"click\\">Inc[<block-text-1/>]</button><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`SomeComponent\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+    return component(\`SomeComponent\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
     let hdlr1 = [ctx['inc'], ctx];
     let txt1 = ctx['state'].val;
-    let b3 = component(\`GenericComponent\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`GenericComponent\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([hdlr1, txt1], [b3]);
   }
 }"
@@ -1416,6 +1416,93 @@ exports[`slots slot are properly rendered if inner props are changed 3`] = `
 }"
 `;
 
+exports[`slots slot content has different key from other content -- dynamic slot 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  function slot1(ctx, node, key = \\"\\") {
+    return component(\`Child\`, {parent: 'Parent'}, key + \`__1\`, node, ctx);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    return component(\`SlotDisplay\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
+  }
+}"
+`;
+
+exports[`slots slot content has different key from other content -- dynamic slot 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { callSlot } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = component(\`Child\`, {parent: 'SlotDisplay'}, key + \`__1\`, node, ctx);
+    const slot1 = (ctx['slotName']);
+    let b3 = toggler(slot1, callSlot(ctx, node, key, slot1), true, {});
+    return multi([b2, b3]);
+  }
+}"
+`;
+
+exports[`slots slot content has different key from other content -- dynamic slot 3`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><block-text-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['props'].parent;
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`slots slot content has different key from other content -- static slot 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  function slot1(ctx, node, key = \\"\\") {
+    return component(\`Child\`, {parent: 'Parent'}, key + \`__1\`, node, ctx);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    return component(\`SlotDisplay\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
+  }
+}"
+`;
+
+exports[`slots slot content has different key from other content -- static slot 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { callSlot } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = component(\`Child\`, {parent: 'SlotDisplay'}, key + \`__1\`, node, ctx);
+    let b3 = callSlot(ctx, node, key, 'default', false, {});
+    return multi([b2, b3]);
+  }
+}"
+`;
+
+exports[`slots slot content has different key from other content -- static slot 3`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><block-text-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['props'].parent;
+    return block1([txt1]);
+  }
+}"
+`;
+
 exports[`slots slot content is bound to caller (variation) 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -1434,7 +1521,7 @@ exports[`slots slot content is bound to caller (variation) 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1467,7 +1554,7 @@ exports[`slots slot content is bound to caller 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1495,11 +1582,11 @@ exports[`slots slot preserves properly parented relationship 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`GrandChild\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -1543,7 +1630,7 @@ exports[`slots slot preserves properly parented relationship, even through t-cal
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b3 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -1555,7 +1642,7 @@ exports[`slots slot preserves properly parented relationship, even through t-cal
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`GrandChild\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`GrandChild\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1593,7 +1680,7 @@ exports[`slots slots and wrapper components 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Link\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Link\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1619,7 +1706,7 @@ exports[`slots slots are properly bound to correct component 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -1664,7 +1751,7 @@ exports[`slots slots are rendered with proper context 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].val;
     const ctx1 = capture(ctx);
-    let b3 = component(\`Dialog\`, {slots: {'footer': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'footer': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([txt1], [b3]);
   }
 }"
@@ -1707,7 +1794,7 @@ exports[`slots slots are rendered with proper context, part 2 1`] = `
       ctx[\`user\`] = v_block2[i1];
       let key1 = ctx['user'].id;
       const ctx1 = capture(ctx);
-      let b7 = component(\`Link\`, {to: '/user/'+ctx['user'].id,slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1__\${key1}\`,null, node, ctx);
+      let b7 = component(\`Link\`, {to: '/user/'+ctx['user'].id,slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([], [b7]), key1);
     }
     let b2 = list(c_block2);
@@ -1755,7 +1842,7 @@ exports[`slots slots are rendered with proper context, part 3 1`] = `
       let key1 = ctx['user'].id;
       setContextValue(ctx, \\"userdescr\\", 'User '+ctx['user'].name);
       const ctx1 = capture(ctx);
-      let b5 = component(\`Link\`, {to: '/user/'+ctx['user'].id,slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1__\${key1}\`,null, node, ctx);
+      let b5 = component(\`Link\`, {to: '/user/'+ctx['user'].id,slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([], [b5]), key1);
     }
     let b2 = list(c_block2);
@@ -1797,7 +1884,7 @@ exports[`slots slots are rendered with proper context, part 4 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"userdescr\\", 'User '+ctx['state'].user.name);
     const ctx1 = capture(ctx);
-    let b3 = component(\`Link\`, {to: '/user/'+ctx['state'].user.id,slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Link\`, {to: '/user/'+ctx['state'].user.id,slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -1838,7 +1925,7 @@ exports[`slots slots in slots, with vars 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"test\\", ctx['state'].name);
     const ctx1 = capture(ctx);
-    let b3 = component(\`A\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`A\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -1857,7 +1944,7 @@ exports[`slots slots in slots, with vars 2`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`B\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`B\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -1898,7 +1985,7 @@ exports[`slots slots in t-foreach and re-rendering 1`] = `
       ctx[\`n_index\`] = i1;
       let key1 = ctx['n_index'];
       const ctx1 = capture(ctx);
-      c_block2[i1] = withKey(component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block2[i1] = withKey(component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -1952,7 +2039,7 @@ exports[`slots slots in t-foreach in t-foreach 1`] = `
         ctx[\`node2\`] = v_block6[i2];
         let key2 = ctx['node2'].key;
         const ctx1 = capture(ctx);
-        c_block6[i2] = withKey(component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1__\${key1}__\${key2}\`,null, node, ctx), key2);
+        c_block6[i2] = withKey(component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}__\${key2}\`, node, ctx), key2);
       }
       ctx = ctx.__proto__;
       let b6 = list(c_block6);
@@ -2003,7 +2090,7 @@ exports[`slots slots in t-foreach with t-set and re-rendering 1`] = `
       let key1 = ctx['n_index'];
       setContextValue(ctx, \\"dummy\\", ctx['n_index']);
       const ctx1 = capture(ctx);
-      c_block2[i1] = withKey(component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block2[i1] = withKey(component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -2042,7 +2129,7 @@ exports[`slots t-debug on a t-set-slot (defining a slot) 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b3 = component(\`Dialog\`, {slots: {'content': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'content': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -2080,7 +2167,7 @@ exports[`slots t-set t-value in a slot 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -2141,7 +2228,7 @@ exports[`slots t-slot in recursive templates 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Wrapper\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    return component(\`Wrapper\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -2169,11 +2256,11 @@ exports[`slots t-slot nested within another slot 1`] = `
   let block1 = createBlock(\`<span id=\\"c1\\"><block-child-0/></span>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child3\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child3\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -2188,7 +2275,7 @@ exports[`slots t-slot nested within another slot 2`] = `
   let block1 = createBlock(\`<span id=\\"c2\\"><block-child-0/></span>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Portal\`, {slots: {'default': {__render: slot2, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Portal\`, {slots: {'default': {__render: slot2, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
   
   function slot2(ctx, node, key = \\"\\") {
@@ -2196,7 +2283,7 @@ exports[`slots t-slot nested within another slot 2`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b4 = component(\`Modal\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b4 = component(\`Modal\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b4]);
   }
 }"
@@ -2257,7 +2344,7 @@ exports[`slots t-slot scope context 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Dialog\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -2277,7 +2364,7 @@ exports[`slots t-slot scope context 2`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Wrapper\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(\`Wrapper\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -2309,7 +2396,7 @@ exports[`slots t-slot within dynamic t-call 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    let b3 = component(\`Slotted\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Slotted\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -2338,7 +2425,7 @@ exports[`slots t-slot within dynamic t-call 3`] = `
   let block1 = createBlock(\`<div class=\\"slot\\"><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -2365,11 +2452,11 @@ exports[`slots template can just return a slot 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: ctx['state'].value}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`SlotComponent\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`SlotComponent\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"

tests/components/__snapshots__/style_class.test.ts.snap

@@ -6,7 +6,7 @@ exports[`style and class handling can set class on multi root component 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'fromparent'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'fromparent'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -34,7 +34,7 @@ exports[`style and class handling can set class on sub component, as prop 1`] =
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'some-class'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'some-class'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -59,7 +59,7 @@ exports[`style and class handling can set class on sub sub component 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'fromparent'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'fromparent'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -70,7 +70,7 @@ exports[`style and class handling can set class on sub sub component 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`ChildChild\`, {class: (ctx['props'].class||'')+' fromchild'}, key+\`__1\`,null, node, ctx);
+    return component(\`ChildChild\`, {class: (ctx['props'].class||'')+' fromchild'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -95,7 +95,7 @@ exports[`style and class handling can set more than one class on sub component 1
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'a  b'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'a  b'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -147,7 +147,7 @@ exports[`style and class handling class on sub component, which is switched to a
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'someclass',child: ctx['state'].child}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'someclass',child: ctx['state'].child}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -160,9 +160,9 @@ exports[`style and class handling class on sub component, which is switched to a
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     if (ctx['props'].child==='a') {
-      b2 = component(\`ChildA\`, {class: ctx['props'].class}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`ChildA\`, {class: ctx['props'].class}, key + \`__1\`, node, ctx);
     } else {
-      b3 = component(\`ChildB\`, {class: ctx['props'].class}, key+\`__2\`,null, node, ctx);
+      b3 = component(\`ChildB\`, {class: ctx['props'].class}, key + \`__2\`, node, ctx);
     }
     return multi([b2, b3]);
   }
@@ -205,7 +205,7 @@ exports[`style and class handling class with extra whitespaces (variation) 1`] =
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {class: 'a  b c   d'}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {class: 'a  b c   d'}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -231,7 +231,7 @@ exports[`style and class handling class with extra whitespaces 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'a  b c   d'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'a  b c   d'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -256,7 +256,7 @@ exports[`style and class handling component class and parent class combine toget
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'from parent'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'from parent'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -310,7 +310,7 @@ exports[`style and class handling empty class attribute is not added on widget r
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {class: undefined}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {class: undefined}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -336,7 +336,7 @@ exports[`style and class handling error in subcomponent with class 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'a'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'a'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -362,7 +362,7 @@ exports[`style and class handling no class is set is child ignores it 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: 'hey'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: 'hey'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -386,7 +386,7 @@ exports[`style and class handling no class is set is parent does not give it as
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -411,7 +411,7 @@ exports[`style and class handling style is properly added on widget root el 1`]
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {style: 'font-weight: bold;'}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {style: 'font-weight: bold;'}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -438,7 +438,7 @@ exports[`style and class handling t-att-class is properly added/removed on widge
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {class: {b:ctx['state'].b}}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {class: {b:ctx['state'].b}}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -464,7 +464,7 @@ exports[`style and class handling t-att-class is properly added/removed on widge
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {class: {a:true,b:ctx['state'].b}}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {class: {a:true,b:ctx['state'].b}}, key + \`__1\`, node, ctx);
   }
 }"
 `;

tests/components/__snapshots__/t_call.test.ts.snap

@@ -48,7 +48,7 @@ exports[`t-call dynamic t-call: key is propagated 1`] = `
   let { call } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     const template1 = (ctx['sub']);
     let b3 = call(this, template1, ctx, node, key + \`__2\`);
     return multi([b2, b3]);
@@ -76,7 +76,7 @@ exports[`t-call dynamic t-call: key is propagated 3`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -196,7 +196,7 @@ exports[`t-call parent is set within t-call 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -233,7 +233,7 @@ exports[`t-call parent is set within t-call with no parentNode 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -251,6 +251,56 @@ exports[`t-call parent is set within t-call with no parentNode 3`] = `
 }"
 `;
 
+exports[`t-call recursive t-call binding this -- static t-call 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue, getTemplate } = helpers;
+  const callTemplate_1 = getTemplate(\`recursive\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1;
+    setContextValue(ctx, \\"level\\", 0);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call recursive t-call binding this -- static t-call 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue, getTemplate } = helpers;
+  const callTemplate_1 = getTemplate(\`recursive\`);
+  
+  let block3 = createBlock(\`<div block-handler-0=\\"click.stop\\"><block-text-1/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    let b2;
+    if (ctx['level']<2) {
+      let hdlr1 = [\\"stop\\", ctx['onClicked'].bind(this), ctx];
+      let txt1 = ctx['level'];
+      let b3 = block3([hdlr1, txt1]);
+      ctx = Object.create(ctx);
+      ctx[isBoundary] = 1;
+      setContextValue(ctx, \\"level\\", ctx['level']+1);
+      let b4 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+      ctx = ctx.__proto__;
+      b2 = multi([b3, b4]);
+    }
+    return multi([b2]);
+  }
+}"
+`;
+
 exports[`t-call sub components in two t-calls 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -280,7 +330,7 @@ exports[`t-call sub components in two t-calls 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -332,7 +382,7 @@ exports[`t-call t-call in t-foreach and children component 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {val: ctx['val']}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
   }
 }"
 `;

tests/components/__snapshots__/t_component.test.ts.snap

@@ -9,7 +9,7 @@ exports[`t-component can switch between dynamic components without the need for
   
   return function template(ctx, node, key = \\"\\") {
     let Comp1 = ctx['constructor'].components[ctx['state'].child];
-    let b2 = toggler(Comp1, component(Comp1, {}, key+\`__1\`,null, node, ctx));
+    let b2 = toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
     return block1([], [b2]);
   }
 }"
@@ -49,7 +49,7 @@ exports[`t-component can use dynamic components (the class) if given (with diffe
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['state'].child;
     let Comp1 = ctx['myComponent'];
-    return toggler(tKey_1, toggler(Comp1, component(Comp1, {}, key+\`__1\`,tKey_1, node, ctx)));
+    return toggler(tKey_1, toggler(Comp1, component(Comp1, {}, tKey_1 + key + \`__1\`, node, ctx)));
   }
 }"
 `;
@@ -88,7 +88,7 @@ exports[`t-component can use dynamic components (the class) if given 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['state'].child;
     let Comp1 = ctx['myComponent'];
-    return toggler(tKey_1, toggler(Comp1, component(Comp1, {}, key+\`__1\`,tKey_1, node, ctx)));
+    return toggler(tKey_1, toggler(Comp1, component(Comp1, {}, tKey_1 + key + \`__1\`, node, ctx)));
   }
 }"
 `;
@@ -128,7 +128,7 @@ exports[`t-component modifying a sub widget 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let Comp1 = ctx['Counter'];
-    let b2 = toggler(Comp1, component(Comp1, {}, key+\`__1\`,null, node, ctx));
+    let b2 = toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
     return block1([], [b2]);
   }
 }"
@@ -157,7 +157,7 @@ exports[`t-component switching dynamic component 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let Comp1 = ctx['Child'];
-    return toggler(Comp1, component(Comp1, {}, key+\`__1\`,null, node, ctx));
+    return toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
   }
 }"
 `;
@@ -193,7 +193,7 @@ exports[`t-component t-component works in simple case 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let Comp1 = ctx['Child'];
-    return toggler(Comp1, component(Comp1, {}, key+\`__1\`,null, node, ctx));
+    return toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
   }
 }"
 `;

tests/components/__snapshots__/t_foreach.test.ts.snap

@@ -15,7 +15,7 @@ exports[`list of components components in a node in a t-foreach  1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
       let key1 = 'li_'+ctx['item'];
-      let b4 = component(\`Child\`, {item: ctx['item']}, key+\`__1__\${key1}\`,null, node, ctx);
+      let b4 = component(\`Child\`, {item: ctx['item']}, key + \`__1__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([], [b4]), key1);
     }
     let b2 = list(c_block2);
@@ -55,7 +55,7 @@ exports[`list of components crash on duplicate key in dev mode 1`] = `
       keys1.add(key1);
       const props1 = {}
       helpers.validateProps(\`Child\`, props1, ctx)
-      c_block1[i1] = withKey(component(\`Child\`, props1, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block1[i1] = withKey(component(\`Child\`, props1, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
   }
@@ -88,7 +88,7 @@ exports[`list of components list of sub components inside other nodes 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`blip\`] = v_block2[i1];
       let key1 = ctx['blip'].id;
-      let b4 = component(\`SubComponent\`, {}, key+\`__1__\${key1}\`,null, node, ctx);
+      let b4 = component(\`SubComponent\`, {}, key + \`__1__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([], [b4]), key1);
     }
     let b2 = list(c_block2);
@@ -131,7 +131,7 @@ exports[`list of components reconciliation alg works for t-foreach in t-foreach
         ctx[\`blip\`] = v_block3[i2];
         ctx[\`blip_index\`] = i2;
         let key2 = ctx['blip_index'];
-        c_block3[i2] = withKey(component(\`Child\`, {blip: ctx['blip']}, key+\`__1__\${key1}__\${key2}\`,null, node, ctx), key2);
+        c_block3[i2] = withKey(component(\`Child\`, {blip: ctx['blip']}, key + \`__1__\${key1}__\${key2}\`, node, ctx), key2);
       }
       ctx = ctx.__proto__;
       c_block2[i1] = withKey(list(c_block3), key1);
@@ -177,7 +177,7 @@ exports[`list of components reconciliation alg works for t-foreach in t-foreach,
       for (let i2 = 0; i2 < l_block4; i2++) {
         ctx[\`col\`] = v_block4[i2];
         let key2 = ctx['col'];
-        let b6 = component(\`Child\`, {row: ctx['row'],col: ctx['col']}, key+\`__1__\${key1}__\${key2}\`,null, node, ctx);
+        let b6 = component(\`Child\`, {row: ctx['row'],col: ctx['col']}, key + \`__1__\${key1}__\${key2}\`, node, ctx);
         c_block4[i2] = withKey(block5([], [b6]), key2);
       }
       ctx = ctx.__proto__;
@@ -216,7 +216,7 @@ exports[`list of components simple list 1`] = `
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`elem\`] = v_block1[i1];
       let key1 = ctx['elem'].id;
-      c_block1[i1] = withKey(component(\`Child\`, {value: ctx['elem'].value}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block1[i1] = withKey(component(\`Child\`, {value: ctx['elem'].value}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
   }
@@ -251,7 +251,7 @@ exports[`list of components sub components rendered in a loop 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`number\`] = v_block2[i1];
       let key1 = ctx['number'];
-      c_block2[i1] = withKey(component(\`Child\`, {n: ctx['number']}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block2[i1] = withKey(component(\`Child\`, {n: ctx['number']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -287,7 +287,7 @@ exports[`list of components sub components with some state rendered in a loop 1`
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`number\`] = v_block2[i1];
       let key1 = ctx['number'];
-      c_block2[i1] = withKey(component(\`Child\`, {}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block2[i1] = withKey(component(\`Child\`, {}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -323,7 +323,7 @@ exports[`list of components switch component position 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`c\`] = v_block2[i1];
       let key1 = ctx['c'];
-      c_block2[i1] = withKey(component(\`Child\`, {key: ctx['c']}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block2[i1] = withKey(component(\`Child\`, {key: ctx['c']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -360,7 +360,7 @@ exports[`list of components t-foreach with t-component, and update 1`] = `
       ctx[\`n\`] = v_block2[i1];
       ctx[\`n_index\`] = i1;
       let key1 = ctx['n_index'];
-      c_block2[i1] = withKey(component(\`Child\`, {val: ctx['n_index']}, key+\`__1__\${key1}\`,null, node, ctx), key1);
+      c_block2[i1] = withKey(component(\`Child\`, {val: ctx['n_index']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);

tests/components/__snapshots__/t_key.test.ts.snap

@@ -15,7 +15,7 @@ exports[`t-key t-foreach with t-key switch component position 1`] = `
       ctx[\`c\`] = v_block2[i1];
       let key1 = ctx['c'];
       const tKey_1 = ctx['key1'];
-      c_block2[i1] = withKey(component(\`Child\`, {key: ctx['c']+ctx['key1']}, key+\`__1__\${key1}\`,tKey_1, node, ctx), tKey_1 + key1);
+      c_block2[i1] = withKey(component(\`Child\`, {key: ctx['c']+ctx['key1']}, tKey_1 + key + \`__1__\${key1}\`, node, ctx), tKey_1 + key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -44,7 +44,7 @@ exports[`t-key t-key on Component 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key'];
-    return toggler(tKey_1, component(\`Child\`, {key: ctx['key']}, key+\`__1\`,tKey_1, node, ctx));
+    return toggler(tKey_1, component(\`Child\`, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx));
   }
 }"
 `;
@@ -72,7 +72,7 @@ exports[`t-key t-key on Component as a function 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key'];
-    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key']}, key+\`__1\`,tKey_1, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx));
     return block1([], [b2]);
   }
 }"
@@ -101,9 +101,9 @@ exports[`t-key t-key on multiple Components 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key1'];
-    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key1']}, key+\`__1\`,tKey_1, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key1']}, tKey_1 + key + \`__1\`, node, ctx));
     const tKey_2 = ctx['key2'];
-    let b3 = toggler(tKey_2, component(\`Child\`, {key: ctx['key2']}, key+\`__2\`,tKey_2, node, ctx));
+    let b3 = toggler(tKey_2, component(\`Child\`, {key: ctx['key2']}, tKey_2 + key + \`__2\`, node, ctx));
     return block1([], [b2, b3]);
   }
 }"
@@ -157,7 +157,7 @@ exports[`t-key t-key on multiple Components with t-call 1 2`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key'];
-    return toggler(tKey_1, component(\`Child\`, {key: ctx['key']}, key+\`__1\`,tKey_1, node, ctx));
+    return toggler(tKey_1, component(\`Child\`, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx));
   }
 }"
 `;
@@ -199,9 +199,9 @@ exports[`t-key t-key on multiple Components with t-call 2 2`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key1'];
-    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key1']}, key+\`__1\`,tKey_1, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key1']}, tKey_1 + key + \`__1\`, node, ctx));
     const tKey_2 = ctx['key2'];
-    let b3 = toggler(tKey_2, component(\`Child\`, {key: ctx['key2']}, key+\`__2\`,tKey_2, node, ctx));
+    let b3 = toggler(tKey_2, component(\`Child\`, {key: ctx['key2']}, tKey_2 + key + \`__2\`, node, ctx));
     return multi([b2, b3]);
   }
 }"

tests/components/__snapshots__/t_on.test.ts.snap

@@ -131,7 +131,7 @@ exports[`t-on t-on on destroyed components 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      b2 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     }
     return block1([], [b2]);
   }

tests/components/__snapshots__/t_props.test.ts.snap

@@ -8,7 +8,7 @@ exports[`t-props basic use 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, ctx['some'].obj, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, ctx['some'].obj, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -36,7 +36,7 @@ exports[`t-props t-props and other props 1`] = `
   let block1 = createBlock(\`<div><div><block-child-0/></div></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Comp\`, Object.assign({}, ctx['state1'], {a: ctx['a']}), key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Comp\`, Object.assign({}, ctx['state1'], {a: ctx['a']}), key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -65,7 +65,7 @@ exports[`t-props t-props only 1`] = `
   let block1 = createBlock(\`<div><div><block-child-0/></div></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Comp\`, ctx['state'], key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Comp\`, ctx['state'], key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -93,7 +93,7 @@ exports[`t-props t-props with props 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, Object.assign({}, ctx['props'], {a: 1,b: 2}), key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, Object.assign({}, ctx['childProps'], {a: 1,b: 2}), key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

tests/components/__snapshots__/t_set.test.ts.snap

@@ -21,7 +21,7 @@ exports[`t-set slot setted value (with t-set) not accessible with t-esc 1`] = `
     setContextValue(ctx, \\"iter\\", 'source');
     let txt1 = ctx['iter'];
     const ctx1 = capture(ctx);
-    let b2 = component(\`Childcomp\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Childcomp\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     let txt2 = ctx['iter'];
     return block1([txt1, txt2], [b2]);
   }
@@ -63,12 +63,12 @@ exports[`t-set slots with a t-set with a component in body 1`] = `
   }
   
   function value1(ctx, node, key = \\"\\") {
-    return component(\`C\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`C\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -116,14 +116,14 @@ exports[`t-set slots with an t-set with a component in body 1`] = `
   }
   
   function value1(ctx, node, key = \\"\\") {
-    let b3 = component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     let b4 = block4();
     return multi([b3, b4]);
   }
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Blorg\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    return component(\`Blorg\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -167,12 +167,12 @@ exports[`t-set slots with an unused t-set with a component in body 1`] = `
   }
   
   function value1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key+\`__2\`,null, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -267,7 +267,7 @@ exports[`t-set t-set not altered by child comp 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"iter\\", 'source');
     let txt1 = ctx['iter'];
-    let b2 = component(\`Childcomp\`, {}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Childcomp\`, {}, key + \`__1\`, node, ctx);
     let txt2 = ctx['iter'];
     return block1([txt1, txt2], [b2]);
   }
@@ -328,7 +328,7 @@ exports[`t-set t-set with a component in body 1`] = `
   let block1 = createBlock(\`<div><div><block-child-0/></div></div>\`);
   
   function value1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {

tests/components/basics.test.ts

@@ -1,5 +1,5 @@
 import { App, Component, mount, status, useState, xml } from "../../src";
-import { elem, makeTestFixture, nextTick, snapshotEverything } from "../helpers";
+import { elem, makeTestFixture, nextTick, snapshotEverything, useLogLifecycle } from "../helpers";
 import { markup } from "../../src/utils";
 
 let fixture: HTMLElement;
@@ -794,6 +794,112 @@ describe("basics", () => {
     await nextTick();
     expect(fixture.textContent!.trim()).toBe("2__3");
   });
+
+  test("component children doesn't leak (if case)", async () => {
+    class Child extends Component {
+      static template = xml`<div />`;
+      setup() {
+        useLogLifecycle();
+      }
+    }
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`<Child t-if="ifVar" />`;
+      ifVar = true;
+    }
+
+    const parent = await mount(Parent, fixture);
+    expect(Object.keys(parent.__owl__.children).length).toStrictEqual(1);
+    expect([
+      "Child:setup",
+      "Child:willStart",
+      "Child:willRender",
+      "Child:rendered",
+      "Child:mounted",
+    ]).toBeLogged();
+
+    parent.ifVar = false;
+    parent.render();
+    await nextTick();
+    expect(Object.keys(parent.__owl__.children).length).toStrictEqual(0);
+    expect(["Child:willUnmount", "Child:willDestroy"]).toBeLogged();
+  });
+
+  test("component children doesn't leak (t-key case)", async () => {
+    // This test should encompass the t-foreach and t-call cases too (because they also use a flavor of some key)
+    class Child extends Component {
+      static template = xml`<div />`;
+      setup() {
+        useLogLifecycle();
+      }
+    }
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`<Child t-key="keyVar" />`;
+      keyVar = 1;
+    }
+
+    const parent = await mount(Parent, fixture);
+    expect(Object.keys(parent.__owl__.children).length).toStrictEqual(1);
+    expect([
+      "Child:setup",
+      "Child:willStart",
+      "Child:willRender",
+      "Child:rendered",
+      "Child:mounted",
+    ]).toBeLogged();
+
+    parent.keyVar = 2;
+    parent.render();
+    await nextTick();
+    expect(Object.keys(parent.__owl__.children).length).toStrictEqual(1);
+    expect([
+      "Child:setup",
+      "Child:willStart",
+      "Child:willRender",
+      "Child:rendered",
+      "Child:willUnmount",
+      "Child:willDestroy",
+      "Child:mounted",
+    ]).toBeLogged();
+  });
+
+  test("GrandChild display is controlled by its GrandParent", async () => {
+    class GrandChild extends Component {
+      static template = xml`<div />`;
+      setup() {
+        useLogLifecycle();
+      }
+    }
+
+    class Child extends Component {
+      static components = { GrandChild };
+      static template = xml`<GrandChild t-if="props.displayGrandChild" />`;
+    }
+
+    class Parent extends Component {
+      static template = xml`<t t-component="myComp" displayGrandChild="displayGrandChild"/>`;
+      myComp = Child;
+      displayGrandChild = true;
+    }
+
+    const parent = await mount(Parent, fixture);
+    expect(fixture.innerHTML).toBe("<div></div>");
+    expect([
+      "GrandChild:setup",
+      "GrandChild:willStart",
+      "GrandChild:willRender",
+      "GrandChild:rendered",
+      "GrandChild:mounted",
+    ]).toBeLogged();
+
+    parent.displayGrandChild = false;
+    parent.render();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("");
+
+    expect(["GrandChild:willUnmount", "GrandChild:willDestroy"]).toBeLogged();
+  });
 });
 
 describe("mount targets", () => {

tests/components/concurrency.test.ts

@@ -2908,6 +2908,64 @@ test("two sequential renderings before an animation frame", async () => {
   expect(["Parent:willPatch", "Child:willPatch", "Child:patched", "Parent:patched"]).toBeLogged();
 });
 
+test("t-key on dom node having a component", async () => {
+  let def: any;
+  class Child extends Component {
+    static template = xml`<t t-esc="props.key" />`;
+    setup() {
+      onWillStart(() => def);
+      useLogLifecycle(this.props.key);
+    }
+  }
+
+  class Parent extends Component {
+    key = 1;
+    myComp = Child;
+    static template = xml`<div t-key="key"><t t-component="myComp" key="key" /></div>`;
+  }
+
+  const parent = await mount(Parent, fixture);
+  expect(fixture.innerHTML).toBe("<div>1</div>");
+
+  def = makeDeferred();
+  parent.key = 2;
+  parent.render();
+
+  await nextTick();
+  expect([
+    "Child (1):setup",
+    "Child (1):willStart",
+    "Child (1):willRender",
+    "Child (1):rendered",
+    "Child (1):mounted",
+    "Child (2):setup",
+    "Child (2):willStart",
+  ]).toBeLogged();
+  expect(fixture.innerHTML).toBe("<div>1</div>");
+  parent.key = 3;
+  parent.render();
+
+  const prevDef = def;
+  def = undefined;
+
+  parent.key = 3;
+  parent.render();
+  prevDef.resolve();
+  await nextTick();
+
+  expect(fixture.innerHTML).toBe("<div>3</div>");
+  expect([
+    "Child (3):setup",
+    "Child (3):willStart",
+    "Child (3):willRender",
+    "Child (3):rendered",
+    "Child (1):willUnmount",
+    "Child (1):willDestroy",
+    "Child (2):willDestroy",
+    "Child (3):mounted",
+  ]).toBeLogged();
+});
+
 test("t-key on dynamic async component (toggler is never patched)", async () => {
   let def: any;
   class Child extends Component {
@@ -2955,16 +3013,122 @@ test("t-key on dynamic async component (toggler is never patched)", async () =>
 
   expect(fixture.innerHTML).toBe("<div>3</div>");
   expect([
-    "Child (2):willDestroy",
     "Child (3):setup",
     "Child (3):willStart",
     "Child (3):willRender",
     "Child (3):rendered",
     "Child (1):willUnmount",
     "Child (1):willDestroy",
+    "Child (2):willDestroy",
     "Child (3):mounted",
   ]).toBeLogged();
 });
+
+test("t-foreach with dynamic async component", async () => {
+  let def: any;
+  class Child extends Component {
+    static template = xml`<div t-esc="props.key" />`;
+    setup() {
+      onWillStart(() => def);
+      useLogLifecycle(this.props.key);
+    }
+  }
+
+  class Parent extends Component {
+    list: any = [[1]];
+    myComp = Child;
+    static template = xml`<t t-foreach="list" t-as="arr" t-key="arr_index">
+        <t t-if="arr" t-component="myComp" key="arr[0]" />
+      </t>`;
+  }
+
+  const parent = await mount(Parent, fixture);
+  expect(fixture.innerHTML).toBe("<div>1</div>");
+
+  def = makeDeferred();
+  parent.list = [, [2]];
+  parent.render();
+
+  await nextTick();
+  expect([
+    "Child (1):setup",
+    "Child (1):willStart",
+    "Child (1):willRender",
+    "Child (1):rendered",
+    "Child (1):mounted",
+    "Child (2):setup",
+    "Child (2):willStart",
+  ]).toBeLogged();
+  expect(fixture.innerHTML).toBe("<div>1</div>");
+  parent.list = [, , [3]];
+  parent.render();
+
+  const prevDef = def;
+  def = undefined;
+
+  parent.render();
+  prevDef.resolve();
+  await nextTick();
+
+  expect(fixture.innerHTML).toBe("<div>3</div>");
+  expect([
+    "Child (3):setup",
+    "Child (3):willStart",
+    "Child (3):willRender",
+    "Child (3):rendered",
+    "Child (1):willUnmount",
+    "Child (1):willDestroy",
+    "Child (2):willDestroy",
+    "Child (3):mounted",
+  ]).toBeLogged();
+});
+
+test("Cascading renders after microtaskTick", async () => {
+  const state = [{ id: 0 }, { id: 1 }];
+  let child: any;
+  let parent: any;
+
+  class Element extends Component {
+    static template = xml`<t t-esc="props.id" />`;
+  }
+
+  class Child extends Component {
+    static components = { Element };
+    static template = xml`
+      <t t-foreach="state" t-as="elem" t-key="elem.id">
+        <Element id="elem.id"/>
+      </t>`;
+    state = state;
+    setup() {
+      child = this;
+    }
+  }
+
+  class Parent extends Component {
+    static components = { Child };
+    static template = xml`<Child /> _ <t t-foreach="state" t-as="elem" t-key="elem.id" t-esc="elem.id"/>`;
+    state = state;
+    setup() {
+      parent = this;
+    }
+  }
+
+  await mount(Parent, fixture);
+  expect(fixture.innerHTML).toBe("01 _ 01");
+
+  state.push({ id: 2 });
+  parent.render();
+  child.render();
+
+  await Promise.resolve();
+  expect(fixture.innerHTML).toBe("01 _ 01");
+  state.push({ id: 3 });
+  parent.render();
+  child.render();
+
+  await nextTick();
+  expect(fixture.innerHTML).toBe("0123 _ 0123");
+});
 //   test.skip("components with shouldUpdate=false", async () => {
 //     const state = { p: 1, cc: 10 };
 

tests/components/error_handling.test.ts

@@ -1033,4 +1033,56 @@ describe("can catch errors", () => {
     await nextTick();
     expect(fixture.innerHTML).toBe("<div>Sibling</div>");
   });
+
+  test("catching in child makes parent render", async () => {
+    class Child extends Component {
+      static template = xml`<div t-esc="'Child ' + props.id" />`;
+    }
+
+    class ErrorComp extends Component {
+      static template = xml`<div />`;
+      setup() {
+        throw new Error("Error Component");
+      }
+    }
+
+    class Catch extends Component {
+      static template = xml`<t t-slot="default" />`;
+      setup() {
+        onError((error) => {
+          this.props.onError(error);
+        });
+      }
+    }
+
+    const steps: any[] = [];
+    class Parent extends Component {
+      static components = { Catch };
+      static template = xml`
+        <t t-foreach="Object.entries(this.elements)" t-as="elem" t-key="elem[0]">
+          <Catch onError="(error) => this.onError(elem[0], error)">
+            <t t-component="elem[1]" id="elem[0]" />
+          </Catch>
+        </t>
+      `;
+
+      elements: any = {};
+
+      onError(id: any, error: Error) {
+        steps.push(error.message);
+        delete this.elements[id];
+        this.elements[2] = Child;
+        this.render();
+      }
+    }
+
+    const parent = await mount(Parent, fixture);
+    expect(fixture.innerHTML).toBe("");
+
+    parent.elements[1] = ErrorComp;
+    parent.render();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div>Child 2</div>");
+    expect(steps).toEqual(["Error Component"]);
+  });
 });

tests/components/event_handling.test.ts

@@ -1,5 +1,5 @@
-import { makeTestFixture, snapshotEverything, nextTick } from "../helpers";
+import { makeTestFixture, snapshotEverything, nextTick, logStep, nextMicroTick } from "../helpers";
-import { mount, Component, useState, xml } from "../../src/index";
+import { mount, Component, useState, xml, App } from "../../src/index";
 
 snapshotEverything();
 
@@ -33,6 +33,28 @@ describe("event handling", () => {
     expect(fixture.innerHTML).toBe("<span><div>simple vnode</div>2</span>");
   });
 
+  test("Invalid handler throws an error", async () => {
+    window.addEventListener(
+      "error",
+      (ev) => {
+        logStep(ev.error.message);
+        ev.preventDefault();
+      },
+      { once: true }
+    );
+
+    class Parent extends Component {
+      static template = xml`<button t-on-click="dosomething">click</button>`;
+
+      doSomething() {}
+    }
+
+    await mount(Parent, fixture);
+    expect([]).toBeLogged();
+    fixture.querySelector("button")!.click();
+    expect(["Invalid handler (expected a function, received: 'undefined')"]).toBeLogged();
+  });
+
   test("support for callable expression in event handler", async () => {
     class Counter extends Component {
       static template = xml`
@@ -93,4 +115,60 @@ describe("event handling", () => {
     expect(onClickArgs![0]).toBe(1);
     expect(onClickArgs![1]).toBeInstanceOf(MouseEvent);
   });
+
+  test("handler is not called if component is destroyed", async () => {
+    class Parent extends Component {
+      static template = xml`<span t-on-click="click"/>`;
+      click() {
+        logStep("click");
+      }
+    }
+
+    const app = new App(Parent);
+    await app.mount(fixture);
+    const span = fixture.querySelector("span")!;
+
+    span.click();
+    expect(["click"]).toBeLogged();
+
+    app.destroy();
+    expect([]).toBeLogged();
+
+    span.click();
+    expect([]).toBeLogged();
+  });
+
+  test("input blur event is not called if component is destroyed", async () => {
+    class Child extends Component {
+      static template = xml`<input t-on-blur="blur"/>`;
+
+      blur() {
+        logStep("blur");
+      }
+    }
+    class Parent extends Component {
+      static template = xml`
+      <div>
+        <t t-if="state.cond"><Child/></t>
+        <textarea/>
+      </div>`;
+      static components = { Child };
+
+      state = useState({ cond: true });
+    }
+
+    const parent = await mount(Parent, fixture);
+
+    fixture.querySelector("input")!.focus();
+    await nextMicroTick();
+    // to unfocus input
+    fixture.querySelector("textarea")!.focus();
+    expect(["blur"]).toBeLogged();
+
+    fixture.querySelector("input")!.focus();
+    parent.state.cond = false;
+    await nextTick();
+    // input is removed when component is destroyed => nothing should happen
+    expect([]).toBeLogged();
+  });
 });

tests/components/lifecycle.test.ts

@@ -5,10 +5,13 @@ import {
   onPatched,
   onWillUpdateProps,
   onWillRender,
+  onWillDestroy,
+  onRendered,
 } from "../../src/component/lifecycle_hooks";
 import { status } from "../../src/component/status";
 import {
   elem,
+  logStep,
   makeDeferred,
   makeTestFixture,
   nextTick,
@@ -1196,4 +1199,58 @@ describe("lifecycle hooks", () => {
     expect(["Parent:willPatch", "Parent:patched"]).toBeLogged();
     expect(fixture.innerHTML).toBe("<span>Patched</span>");
   });
+
+  test("lifecycle callbacks are bound to component", async () => {
+    expect.assertions(14);
+    let instance: any;
+
+    class Test extends Component {
+      static template = xml`<t t-esc="props.rev" />`;
+      setup() {
+        instance = this;
+        onWillStart(this.logger("onWillStart"));
+        onMounted(this.logger("onMounted"));
+        onWillUpdateProps(this.logger("onWillUpdateProps"));
+        onWillPatch(this.logger("onWillPatch"));
+        onPatched(this.logger("onPatched"));
+        onWillUnmount(this.logger("onWillUnmount"));
+        onWillDestroy(this.logger("onWillDestroy"));
+        onWillRender(this.logger("onWillRender"));
+        onRendered(this.logger("onRendered"));
+      }
+      logger(hookName: string) {
+        return function (this: Test) {
+          logStep(hookName);
+          expect(this === instance).toBe(true);
+        };
+      }
+    }
+
+    class Parent extends Component {
+      static template = xml`<Test rev="rev" />`;
+      static components = { Test };
+      rev = 0;
+    }
+
+    const app = new App(Parent);
+    const comp = await app.mount(fixture);
+    comp.rev++;
+    comp.render();
+    await nextTick();
+    app.destroy();
+
+    expect([
+      "onWillStart",
+      "onWillRender",
+      "onRendered",
+      "onMounted",
+      "onWillUpdateProps",
+      "onWillRender",
+      "onRendered",
+      "onWillPatch",
+      "onPatched",
+      "onWillUnmount",
+      "onWillDestroy",
+    ]).toBeLogged();
+  });
 });

tests/components/props.test.ts

@@ -142,17 +142,16 @@ describe("basics", () => {
   });
 
   test("support prop names that aren't valid bare object property names", async () => {
-    expect.assertions(4);
+    expect.assertions(3);
     class Child extends Component {
       static template = xml`<button t-on-click="props.onClick"/>`;
       setup() {
         expect(this.props["some-dashed-prop"]).toBe(5);
-        expect(this.props["a.b"]).toBe("keyword prop");
       }
     }
 
     class Parent extends Component {
-      static template = xml`<Child some-dashed-prop="5" a.b="'keyword prop'"/>`;
+      static template = xml`<Child some-dashed-prop="5"/>`;
       static components = { Child };
     }
     await mount(Parent, fixture);
@@ -225,3 +224,18 @@ test("bound functions is referentially equal after update", async () => {
   expect(fixture.innerHTML).toBe("3");
   expect(isEqual).toBe(true);
 });
+
+test("throw if prop uses an unknown suffix", async () => {
+  class Child extends Component {
+    static template = xml`<t t-esc="props.val"/>`;
+  }
+
+  class Parent extends Component {
+    static template = xml`<Child val.somesuffix="state.val"/>`;
+    static components = { Child };
+  }
+
+  await expect(async () => {
+    await mount(Parent, fixture);
+  }).rejects.toThrowError("Invalid prop suffix");
+});

tests/components/slots.test.ts

@@ -1544,4 +1544,49 @@ describe("slots", () => {
     }
     await mount(Parent, fixture);
   });
+
+  test("slot content has different key from other content -- static slot", async () => {
+    class Child extends Component {
+      static template = xml`<div t-esc="props.parent" />`;
+    }
+
+    class SlotDisplay extends Component {
+      static components = { Child };
+      static template = xml`<Child parent="'SlotDisplay'" /><t t-slot="default" />`;
+    }
+
+    class Parent extends Component {
+      static components = { Child, SlotDisplay };
+      static template = xml`
+         <SlotDisplay>
+           <Child parent="'Parent'" />
+         </SlotDisplay>`;
+    }
+
+    await mount(Parent, fixture);
+    expect(fixture.innerHTML).toBe("<div>SlotDisplay</div><div>Parent</div>");
+  });
+
+  test("slot content has different key from other content -- dynamic slot", async () => {
+    class Child extends Component {
+      static template = xml`<div t-esc="props.parent" />`;
+    }
+
+    class SlotDisplay extends Component {
+      static components = { Child };
+      slotName = "default";
+      static template = xml`<Child parent="'SlotDisplay'" /><t t-slot="{{ slotName }}" />`;
+    }
+
+    class Parent extends Component {
+      static components = { Child, SlotDisplay };
+      static template = xml`
+         <SlotDisplay>
+           <Child parent="'Parent'" />
+         </SlotDisplay>`;
+    }
+
+    await mount(Parent, fixture);
+    expect(fixture.innerHTML).toBe("<div>SlotDisplay</div><div>Parent</div>");
+  });
 });

tests/components/t_call.test.ts

@@ -206,4 +206,42 @@ describe("t-call", () => {
 
     expect(fixture.innerHTML).toBe(`<div id="0"></div><div id="1"></div>`);
   });
+
+  test("recursive t-call binding this -- static t-call", async () => {
+    let clickCount = 0;
+    class Parent extends Component {
+      onClicked?: Function;
+      setup() {
+        const instance = this;
+
+        this.onClicked = function () {
+          clickCount++;
+          expect(this).toBe(instance);
+        };
+      }
+
+      static template = xml`
+          <div><t t-call="recursive"><t t-set="level" t-value="0" /></t></div>
+      `;
+    }
+
+    const app = new App(Parent);
+    app.addTemplate(
+      "recursive",
+      `
+        <t t-if="level &lt; 2" >
+          <div t-on-click.stop="onClicked.bind(this)" t-esc="level" />
+          <t t-call="recursive">
+            <t t-set="level" t-value="level + 1" />
+          </t>
+        </t>
+    `
+    );
+
+    await app.mount(fixture);
+    for (const div of fixture.querySelectorAll("div")) {
+      div.click();
+    }
+    expect(clickCount).toBe(2);
+  });
 });

tests/components/t_props.test.ts

@@ -95,12 +95,12 @@ describe("t-props", () => {
     class Parent extends Component {
       static template = xml`
           <div>
-              <Child t-props="props" a="1" b="2" />
+              <Child t-props="childProps" a="1" b="2" />
           </div>
         `;
       static components = { Child };
 
-      props = { a: "a", c: "c" };
+      childProps = { a: "a", c: "c" };
     }
 
     await mount(Parent, fixture);

tests/misc/__snapshots__/memo.test.ts.snap

@@ -16,7 +16,7 @@ exports[`Memo if no prop change, prevent renderings from above  1`] = `
     let b2 = text(ctx['state'].a);
     let b3 = text(ctx['state'].b);
     let b4 = text(ctx['state'].c);
-    let b9 = component(\`Memo\`, {a: ctx['state'].a,b: ctx['state'].b,slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b9 = component(\`Memo\`, {a: ctx['state'].a,b: ctx['state'].b,slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return multi([b2, b3, b4, b9]);
   }
 }"
@@ -28,12 +28,12 @@ exports[`Memo if no props, prevent renderings from above  1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: ctx['state'].value}, key+\`__2\`,null, node, ctx);
+    return component(\`Child\`, {value: ctx['state'].value}, key + \`__2\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {value: ctx['state'].value}, key+\`__1\`,null, node, ctx);
+    let b2 = component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
-    let b4 = component(\`Memo\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__3\`,null, node, ctx);
+    let b4 = component(\`Memo\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
     return multi([b2, b4]);
   }
 }"
@@ -61,7 +61,7 @@ exports[`Memo if no props, prevent renderings from above (work with simple html)
   
   return function template(ctx, node, key = \\"\\") {
     let b2 = text(ctx['state'].value);
-    let b4 = component(\`Memo\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b4 = component(\`Memo\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return multi([b2, b4]);
   }
 }"

tests/misc/__snapshots__/portal.test.ts.snap

@@ -1,5 +1,150 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`Portal Add and remove portals 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, Portal, capture, withKey } = helpers;
+  
+  function slot1(ctx, node, key = \\"\\") {
+    let b3 = text(\` Portal\`);
+    let b4 = text(ctx['portalId']);
+    return multi([b3, b4]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);
+    for (let i1 = 0; i1 < l_block1; i1++) {
+      ctx[\`portalId\`] = v_block1[i1];
+      let key1 = ctx['portalId'];
+      const ctx1 = capture(ctx);
+      c_block1[i1] = withKey(component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
+    }
+    return list(c_block1);
+  }
+}"
+`;
+
+exports[`Portal Add and remove portals on div 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, Portal, capture, withKey } = helpers;
+  
+  let block2 = createBlock(\`<div> Portal<block-text-0/></div>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    let txt1 = ctx['portalId'];
+    return block2([txt1]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);
+    for (let i1 = 0; i1 < l_block1; i1++) {
+      ctx[\`portalId\`] = v_block1[i1];
+      let key1 = ctx['portalId'];
+      const ctx1 = capture(ctx);
+      c_block1[i1] = withKey(component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
+    }
+    return list(c_block1);
+  }
+}"
+`;
+
+exports[`Portal Add and remove portals with t-foreach 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, Portal, capture, withKey } = helpers;
+  
+  let block2 = createBlock(\`<div><block-text-0/><block-child-0/></div>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    let b4 = text(\` Portal\`);
+    let b5 = text(ctx['portalId']);
+    return multi([b4, b5]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);
+    for (let i1 = 0; i1 < l_block1; i1++) {
+      ctx[\`portalId\`] = v_block1[i1];
+      let key1 = ctx['portalId'];
+      let txt1 = ctx['portalId'];
+      const ctx1 = capture(ctx);
+      let b6 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
+      c_block1[i1] = withKey(block2([txt1], [b6]), key1);
+    }
+    return list(c_block1);
+  }
+}"
+`;
+
+exports[`Portal Add and remove portals with t-foreach and destroy 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, Portal, capture, withKey } = helpers;
+  
+  let block2 = createBlock(\`<div><block-text-0/><block-child-0/></div>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    let b4 = text(\` Portal\`);
+    let b5 = text(ctx['portalId']);
+    return multi([b4, b5]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);
+    for (let i1 = 0; i1 < l_block1; i1++) {
+      ctx[\`portalId\`] = v_block1[i1];
+      let key1 = ctx['portalId'];
+      let txt1 = ctx['portalId'];
+      const ctx1 = capture(ctx);
+      let b6 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
+      c_block1[i1] = withKey(block2([txt1], [b6]), key1);
+    }
+    return list(c_block1);
+  }
+}"
+`;
+
+exports[`Portal Add and remove portals with t-foreach inside div 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, Portal, capture, withKey } = helpers;
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block3 = createBlock(\`<div><block-text-0/><block-child-0/></div>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    let b5 = text(\` Portal\`);
+    let b6 = text(ctx['portalId']);
+    return multi([b5, b6]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['portalIds']);
+    for (let i1 = 0; i1 < l_block2; i1++) {
+      ctx[\`portalId\`] = v_block2[i1];
+      let key1 = ctx['portalId'];
+      let txt1 = ctx['portalId'];
+      const ctx1 = capture(ctx);
+      let b7 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
+      c_block2[i1] = withKey(block3([txt1], [b7]), key1);
+    }
+    let b2 = list(c_block2);
+    return block1([], [b2]);
+  }
+}"
+`;
+
 exports[`Portal Portal composed with t-slot 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -8,11 +153,11 @@ exports[`Portal Portal composed with t-slot 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child2\`, {customHandler: ctx['_handled']}, key+\`__1\`,null, node, ctx);
+    return component(\`Child2\`, {customHandler: ctx['_handled']}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -22,14 +167,14 @@ exports[`Portal Portal composed with t-slot 2`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { callSlot } = helpers;
+  let { Portal, callSlot } = helpers;
   
   function slot1(ctx, node, key = \\"\\") {
     return callSlot(ctx, node, key, 'default', false, {});
   }
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    return component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -52,6 +197,7 @@ exports[`Portal basic use of portal 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><span>1</span><block-child-0/></div>\`);
   let block2 = createBlock(\`<p>2</p>\`);
@@ -61,7 +207,7 @@ exports[`Portal basic use of portal 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -71,6 +217,7 @@ exports[`Portal basic use of portal in dev mode 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><span>1</span><block-child-0/></div>\`);
   let block2 = createBlock(\`<p>2</p>\`);
@@ -80,9 +227,27 @@ exports[`Portal basic use of portal in dev mode 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const props1 = {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
-    helpers.validateProps(\`Portal\`, props1, ctx)
+    return block1([], [b3]);
-    let b3 = component(\`Portal\`, props1, key+\`__1\`,null, node, ctx);
+  }
+}"
+`;
+
+exports[`Portal basic use of portal on div 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
+  
+  let block1 = createBlock(\`<div><span>1</span><block-child-0/></div>\`);
+  let block2 = createBlock(\`<div><p>2</p></div>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    return block2();
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -92,18 +257,19 @@ exports[`Portal conditional use of Portal (with sub Component) 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block2 = createBlock(\`<span>1</span>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b4;
     b2 = block2();
     if (ctx['state'].hasPortal) {
-      b4 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+      b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     }
     return multi([b2, b4]);
   }
@@ -128,6 +294,7 @@ exports[`Portal conditional use of Portal 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block2 = createBlock(\`<span>1</span>\`);
   let block3 = createBlock(\`<p>2</p>\`);
@@ -140,28 +307,143 @@ exports[`Portal conditional use of Portal 1`] = `
     let b2,b4;
     b2 = block2();
     if (ctx['state'].hasPortal) {
-      b4 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+      b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     }
     return multi([b2, b4]);
   }
 }"
 `;
 
+exports[`Portal conditional use of Portal with child and div 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['state'].hasPortal) {
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    }
+    return multi([b2]);
+  }
+}"
+`;
+
+exports[`Portal conditional use of Portal with child and div 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, Portal, capture, withKey } = helpers;
+  
+  let block1 = createBlock(\`<div><span>hasPortal</span><block-child-0/></div>\`);
+  let block3 = createBlock(\`<p>thePortal</p>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    return block3();
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([1]);
+    for (let i1 = 0; i1 < l_block2; i1++) {
+      ctx[\`elem\`] = v_block2[i1];
+      let key1 = ctx['elem'];
+      const ctx1 = capture(ctx);
+      c_block2[i1] = withKey(component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
+    }
+    let b2 = list(c_block2);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`Portal conditional use of Portal with child and div, variation 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block2 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['state'].hasPortal) {
+      let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+      b2 = block2([], [b3]);
+    }
+    return multi([b2]);
+  }
+}"
+`;
+
+exports[`Portal conditional use of Portal with child and div, variation 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { prepareList, Portal, capture, withKey } = helpers;
+  
+  let block2 = createBlock(\`<span>hasPortal</span>\`);
+  let block4 = createBlock(\`<p>thePortal</p>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    return block4();
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = block2();
+    ctx = Object.create(ctx);
+    const [k_block3, v_block3, l_block3, c_block3] = prepareList([1]);
+    for (let i1 = 0; i1 < l_block3; i1++) {
+      ctx[\`elem\`] = v_block3[i1];
+      let key1 = ctx['elem'];
+      const ctx1 = capture(ctx);
+      c_block3[i1] = withKey(component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
+    }
+    let b3 = list(c_block3);
+    return multi([b2, b3]);
+  }
+}"
+`;
+
+exports[`Portal conditional use of Portal with div 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
+  
+  let block2 = createBlock(\`<div><span>hasPortal</span><block-child-0/></div>\`);
+  let block3 = createBlock(\`<p>thePortal</p>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    return block3();
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['state'].hasPortal) {
+      let b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+      b2 = block2([], [b4]);
+    }
+    return multi([b2]);
+  }
+}"
+`;
+
 exports[`Portal lifecycle hooks of portal sub component are properly called 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block1 = createBlock(\`<div><block-child-0/><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
     let b3;
     if (ctx['state'].hasChild) {
-      b3 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+      b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     }
     return block1([], [b3]);
   }
@@ -186,6 +468,7 @@ exports[`Portal portal could have dynamically no content 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<span><block-text-0/></span>\`);
@@ -200,7 +483,7 @@ exports[`Portal portal could have dynamically no content 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b4 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b4]);
   }
 }"
@@ -210,15 +493,16 @@ exports[`Portal portal destroys on crash 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {error: ctx['state'].error}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {error: ctx['state'].error}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -242,15 +526,16 @@ exports[`Portal portal with child and props 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -274,6 +559,7 @@ exports[`Portal portal with dynamic body 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<span><block-text-0/></span>\`);
@@ -291,7 +577,7 @@ exports[`Portal portal with dynamic body 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b5 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b5 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -301,6 +587,7 @@ exports[`Portal portal with many children 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<div>1</div>\`);
@@ -313,7 +600,7 @@ exports[`Portal portal with many children 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b5 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b5 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -323,6 +610,7 @@ exports[`Portal portal with no content 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -335,7 +623,7 @@ exports[`Portal portal with no content 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b4 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b4]);
   }
 }"
@@ -345,6 +633,7 @@ exports[`Portal portal with only text as content 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -353,7 +642,7 @@ exports[`Portal portal with only text as content 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -363,6 +652,7 @@ exports[`Portal portal with target not in dom 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<div>2</div>\`);
@@ -372,7 +662,7 @@ exports[`Portal portal with target not in dom 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#does-not-exist',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#does-not-exist',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -382,15 +672,16 @@ exports[`Portal portal's parent's env is not polluted 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -409,10 +700,51 @@ exports[`Portal portal's parent's env is not polluted 2`] = `
 }"
 `;
 
+exports[`Portal simple catchError with portal 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2,b3;
+    if (ctx['error']) {
+      b2 = text(\`Error\`);
+    } else {
+      b3 = component(\`Boom\`, {}, key + \`__1\`, node, ctx);
+    }
+    return block1([], [b2, b3]);
+  }
+}"
+`;
+
+exports[`Portal simple catchError with portal 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
+  
+  let block1 = createBlock(\`<div><span>1</span><block-child-0/></div>\`);
+  let block2 = createBlock(\`<p><block-text-0/></p>\`);
+  
+  function slot1(ctx, node, key = \\"\\") {
+    let txt1 = ctx['a'].b.c;
+    return block2([txt1]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    return block1([], [b3]);
+  }
+}"
+`;
+
 exports[`Portal with target in template (after portal) 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><span>1</span><block-child-0/><div id=\\"local-target\\"/></div>\`);
   let block2 = createBlock(\`<p>2</p>\`);
@@ -422,7 +754,7 @@ exports[`Portal with target in template (after portal) 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#local-target',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#local-target',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -432,6 +764,7 @@ exports[`Portal with target in template (before portal) 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><div id=\\"local-target\\"/><span>1</span><block-child-0/></div>\`);
   let block2 = createBlock(\`<p>2</p>\`);
@@ -441,16 +774,17 @@ exports[`Portal with target in template (before portal) 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#local-target',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__1\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#local-target',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
 `;
 
-exports[`Portal: Props validation target is mandatory 1`] = `
+exports[`Portal: Props validation target must be a valid selector 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<div>2</div>\`);
@@ -460,18 +794,17 @@ exports[`Portal: Props validation target is mandatory 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const props1 = {slots: {'default': {__render: slot1, __ctx: ctx}}}
+    let b3 = component(Portal, {target: ' ',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
-    helpers.validateProps(\`Portal\`, props1, ctx)
-    let b3 = component(\`Portal\`, props1, key+\`__1\`,null, node, ctx);
     return block1([], [b3]);
   }
 }"
 `;
 
-exports[`Portal: Props validation target is not list 1`] = `
+exports[`Portal: Props validation target must be a valid selector 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<div>2</div>\`);
@@ -481,9 +814,7 @@ exports[`Portal: Props validation target is not list 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const props1 = {target: ['body'],slots: {'default': {__render: slot1, __ctx: ctx}}}
+    let b3 = component(Portal, {target: 'aa',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
-    helpers.validateProps(\`Portal\`, props1, ctx)
-    let b3 = component(\`Portal\`, props1, key+\`__1\`,null, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -493,15 +824,16 @@ exports[`Portal: UI/UX focus is kept across re-renders 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { Portal } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {val: ctx['state'].val}, key+\`__1\`,null, node, ctx);
+    return component(\`Child\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    let b3 = component(\`Portal\`, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key+\`__2\`,null, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"

tests/misc/portal.test.ts

@@ -1,4 +1,5 @@
 import {
+  App,
   Component,
   mount,
   onError,
@@ -8,9 +9,9 @@ import {
   onWillUnmount,
   useState,
 } from "../../src";
-import { Portal, xml } from "../../src/";
+import { xml } from "../../src/";
-import { elem, makeTestFixture, nextTick, snapshotEverything } from "../helpers";
 import { DEV_MSG } from "../../src/app/app";
+import { elem, makeTestFixture, nextTick, snapshotEverything } from "../helpers";
 
 let fixture: HTMLElement;
 let originalconsoleWarn = console.warn;
@@ -52,13 +53,12 @@ afterEach(() => {
 describe("Portal", () => {
   test("basic use of portal", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
           <div>
             <span>1</span>
-            <Portal target="'#outside'">
+            <t t-portal="'#outside'">
               <p>2</p>
-            </Portal>
+            </t>
           </div>`;
     }
 
@@ -67,16 +67,68 @@ describe("Portal", () => {
 
     expect(fixture.innerHTML).toBe('<div id="outside"><p>2</p></div><div><span>1</span></div>');
   });
-
+  test("basic use of portal on div", async () => {
-  test("basic use of portal in dev mode", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
           <div>
             <span>1</span>
-            <Portal target="'#outside'">
+            <div t-portal="'#outside'">
               <p>2</p>
-            </Portal>
+            </div>
+          </div>`;
+    }
+
+    addOutsideDiv(fixture);
+    await mount(Parent, fixture);
+
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"><div><p>2</p></div></div><div><span>1</span></div>'
+    );
+  });
+  test("simple catchError with portal", async () => {
+    class Boom extends Component {
+      static template = xml`
+          <div>
+            <span>1</span>
+            <t t-portal="'#outside'">
+              <p><t t-esc="a.b.c"/></p>
+            </t>
+          </div>`;
+    }
+
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <t t-if="error">Error</t>
+          <t t-else="">
+            <Boom />
+          </t>
+        </div>`;
+      static components = { Boom };
+
+      error: any = false;
+
+      setup() {
+        onError((err) => {
+          this.error = err;
+          this.render();
+        });
+      }
+    }
+    addOutsideDiv(fixture);
+
+    await mount(Parent, fixture);
+    expect(fixture.innerHTML).toBe('<div id="outside"></div><div>Error</div>');
+  });
+
+  test("basic use of portal in dev mode", async () => {
+    class Parent extends Component {
+      static template = xml`
+          <div>
+            <span>1</span>
+            <t t-portal="'#outside'">
+              <p>2</p>
+            </t>
           </div>`;
     }
 
@@ -88,12 +140,11 @@ describe("Portal", () => {
 
   test("conditional use of Portal", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <span>1</span>
-            <Portal target="'#outside'" t-if="state.hasPortal">
+            <t t-portal="'#outside'" t-if="state.hasPortal">
               <p>2</p>
-            </Portal>`;
+            </t>`;
 
       state = useState({ hasPortal: false });
     }
@@ -120,12 +171,12 @@ describe("Portal", () => {
       static template = xml`<p><t t-esc="props.val"/></p>`;
     }
     class Parent extends Component {
-      static components = { Portal, Child };
+      static components = { Child };
       static template = xml`
               <span>1</span>
-              <Portal t-if="state.hasPortal" target="'#outside'">
+              <t t-portal="'#outside'" t-if="state.hasPortal">
                 <Child val="state.val"/>
-              </Portal>`;
+              </t>`;
       state = useState({ hasPortal: false, val: 1 });
     }
 
@@ -153,14 +204,13 @@ describe("Portal", () => {
 
   test("with target in template (before portal)", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <div>
               <div id="local-target"></div>
               <span>1</span>
-              <Portal target="'#local-target'">
+              <t t-portal="'#local-target'">
                 <p>2</p>
-              </Portal>
+              </t>
             </div>`;
     }
 
@@ -172,13 +222,12 @@ describe("Portal", () => {
 
   test("with target in template (after portal)", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <div>
               <span>1</span>
-              <Portal target="'#local-target'">
+              <t t-portal="'#local-target'">
                 <p>2</p>
-              </Portal>
+              </t>
               <div id="local-target"></div>
             </div>`;
     }
@@ -191,12 +240,11 @@ describe("Portal", () => {
 
   test("portal with target not in dom", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <div>
-              <Portal target="'#does-not-exist'">
+              <t t-portal="'#does-not-exist'">
                 <div>2</div>
-              </Portal>
+              </t>
             </div>`;
     }
 
@@ -232,12 +280,12 @@ describe("Portal", () => {
       }
     }
     class Parent extends Component {
-      static components = { Portal, Child };
+      static components = { Child };
       static template = xml`
             <div>
-              <Portal target="'#outside'">
+              <t t-portal="'#outside'">
                 <Child val="state.val"/>
-              </Portal>
+              </t>
             </div>`;
       state = useState({ val: 1 });
     }
@@ -255,12 +303,11 @@ describe("Portal", () => {
 
   test("portal with only text as content", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <div>
-              <Portal target="'#outside'">
+              <t t-portal="'#outside'">
                 <t t-esc="'only text'"/>
-              </Portal>
+              </t>
             </div>`;
     }
 
@@ -271,12 +318,11 @@ describe("Portal", () => {
 
   test("portal with no content", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <div>
-              <Portal target="'#outside'">
+              <t t-portal="'#outside'">
                 <t t-if="false" t-esc="'ABC'"/>
-              </Portal>
+              </t>
             </div>`;
     }
 
@@ -287,13 +333,12 @@ describe("Portal", () => {
 
   test("portal with many children", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <div>
-              <Portal target="'#outside'">
+              <t t-portal="'#outside'">
                 <div>1</div>
                 <p>2</p>
-              </Portal>
+              </t>
             </div>`;
     }
     addOutsideDiv(fixture);
@@ -303,13 +348,12 @@ describe("Portal", () => {
 
   test("portal with dynamic body", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <div>
-              <Portal target="'#outside'">
+              <t t-portal="'#outside'">
                 <span t-if="state.val" t-esc="state.val"/>
                 <div t-else=""/>
-              </Portal>
+              </t>
             </div>`;
       state = useState({ val: "ab" });
     }
@@ -326,12 +370,11 @@ describe("Portal", () => {
 
   test("portal could have dynamically no content", async () => {
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
             <div>
-              <Portal target="'#outside'">
+              <t t-portal="'#outside'">
                 <span t-if="state.val" t-esc="state.val"/>
-              </Portal>
+              </t>
             </div>`;
       state = useState({ val: "ab" });
     }
@@ -359,12 +402,12 @@ describe("Portal", () => {
     }
 
     class Parent extends Component {
-      static components = { Portal, Child };
+      static components = { Child };
       static template = xml`
             <div>
-              <Portal t-if="state.hasChild" target="'#outside'">
+              <t t-portal="'#outside'" t-if="state.hasChild">
                 <Child val="state.val"/>
-              </Portal>
+              </t>
             </div>`;
       state = useState({ hasChild: false, val: 1 });
       setup() {
@@ -424,12 +467,12 @@ describe("Portal", () => {
       state = {};
     }
     class Parent extends Component {
-      static components = { Portal, Child };
+      static components = { Child };
       static template = xml`
         <div>
-          <Portal target="'#outside'" >
+          <t t-portal="'#outside'" >
             <Child error="state.error"/>
-          </Portal>
+          </t>
         </div>`;
       state = { error: false };
       setup() {
@@ -455,12 +498,12 @@ describe("Portal", () => {
             <button>child</button>`;
     }
     class Parent extends Component {
-      static components = { Portal, Child };
+      static components = { Child };
       static template = xml`
             <div>
-              <Portal target="'#outside'">
+              <t t-portal="'#outside'">
                 <Child />
-              </Portal>
+              </t>
             </div>`;
     }
     const env = {};
@@ -482,11 +525,11 @@ describe("Portal", () => {
       }
     }
     class Child extends Component {
-      static components = { Portal, Child2 };
+      static components = { Child2 };
       static template = xml`
-            <Portal target="'#outside'">
+            <t t-portal="'#outside'">
               <t t-slot="default"/>
-            </Portal>`;
+            </t>`;
     }
     class Parent extends Component {
       static components = { Child, Child2 };
@@ -508,6 +551,306 @@ describe("Portal", () => {
     elem(childInst!).dispatchEvent(new CustomEvent("custom"));
     expect(steps).toEqual(["custom"]);
   });
+
+  test("Add and remove portals", async () => {
+    class Parent extends Component {
+      static template = xml`
+          <t t-portal="'#outside'" t-foreach="portalIds" t-as="portalId" t-key="portalId">
+            Portal<t t-esc="portalId"/>
+          </t>`;
+      portalIds = useState([] as any);
+    }
+
+    addOutsideDiv(fixture);
+    const parent = await mount(Parent, fixture);
+
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.portalIds.push(1);
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"> Portal1</div>');
+
+    parent.portalIds.push(2);
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"> Portal1 Portal2</div>');
+
+    parent.portalIds.pop();
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"> Portal1</div>');
+
+    parent.portalIds.pop();
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+  });
+
+  test("Add and remove portals on div", async () => {
+    class Parent extends Component {
+      static template = xml`
+          <div t-portal="'#outside'" t-foreach="portalIds" t-as="portalId" t-key="portalId">
+            Portal<t t-esc="portalId"/>
+          </div>`;
+      portalIds = useState([] as any);
+    }
+
+    addOutsideDiv(fixture);
+    const parent = await mount(Parent, fixture);
+
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.portalIds.push(1);
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"><div> Portal1</div></div>');
+
+    parent.portalIds.push(2);
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"><div> Portal1</div><div> Portal2</div></div>'
+    );
+
+    parent.portalIds.pop();
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"><div> Portal1</div></div>');
+
+    parent.portalIds.pop();
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+  });
+
+  test("Add and remove portals with t-foreach", async () => {
+    class Parent extends Component {
+      static template = xml`
+          <t t-foreach="portalIds" t-as="portalId" t-key="portalId">
+            <div>
+              <t t-esc="portalId"/>
+              <t t-portal="'#outside'">
+                Portal<t t-esc="portalId"/>
+              </t>
+            </div>
+          </t>`;
+      portalIds = useState([] as any);
+    }
+
+    addOutsideDiv(fixture);
+    const parent = await mount(Parent, fixture);
+
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.portalIds.push(1);
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"> Portal1</div><div>1</div>');
+
+    parent.portalIds.push(2);
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"> Portal1 Portal2</div><div>1</div><div>2</div>'
+    );
+
+    parent.portalIds.pop();
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"> Portal1</div><div>1</div>');
+
+    parent.portalIds.pop();
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+  });
+
+  test("Add and remove portals with t-foreach and destroy", async () => {
+    class Parent extends Component {
+      static template = xml`
+          <t t-foreach="portalIds" t-as="portalId" t-key="portalId">
+            <div>
+              <t t-esc="portalId"/>
+              <t t-portal="'#outside'">
+                Portal<t t-esc="portalId"/>
+              </t>
+            </div>
+          </t>`;
+      portalIds = useState([] as any);
+    }
+
+    addOutsideDiv(fixture);
+    const app = new App(Parent);
+    const parent = await app.mount(fixture);
+
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.portalIds.push(1);
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"> Portal1</div><div>1</div>');
+
+    parent.portalIds.push(2);
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"> Portal1 Portal2</div><div>1</div><div>2</div>'
+    );
+
+    app.destroy();
+    //This will test explicitly that we don't use an await nextTick(); after the destroy.
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+  });
+
+  test("conditional use of Portal with div", async () => {
+    class Parent extends Component {
+      static template = xml`
+              <t t-if="state.hasPortal">
+                <div>
+                  <span>hasPortal</span>
+                  <t t-portal="'#outside'">
+                    <p>thePortal</p>
+                  </t>
+                </div>
+              </t>`;
+
+      state = useState({ hasPortal: false });
+    }
+
+    addOutsideDiv(fixture);
+    const parent = await mount(Parent, fixture);
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"><p>thePortal</p></div><div><span>hasPortal</span></div>'
+    );
+
+    parent.state.hasPortal = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"><p>thePortal</p></div><div><span>hasPortal</span></div>'
+    );
+  });
+
+  test("conditional use of Portal with child and div", async () => {
+    class Child extends Component {
+      static template = xml`
+        <div>
+          <span>hasPortal</span>
+          <t t-foreach="[1]" t-as="elem" t-key="elem">
+            <t t-portal="'#outside'">
+              <p>thePortal</p>
+            </t>
+          </t>
+        </div>`;
+    }
+    class Parent extends Component {
+      static template = xml`
+        <t t-if="state.hasPortal">
+          <Child />
+        </t>`;
+
+      static components = { Child };
+
+      state = useState({ hasPortal: false });
+    }
+
+    addOutsideDiv(fixture);
+    const parent = await mount(Parent, fixture);
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"><p>thePortal</p></div><div><span>hasPortal</span></div>'
+    );
+
+    parent.state.hasPortal = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"><p>thePortal</p></div><div><span>hasPortal</span></div>'
+    );
+  });
+
+  test("conditional use of Portal with child and div, variation", async () => {
+    class Child extends Component {
+      static template = xml`
+          <span>hasPortal</span>
+          <t t-foreach="[1]" t-as="elem" t-key="elem">
+            <t t-portal="'#outside'">
+              <p>thePortal</p>
+            </t>
+          </t>`;
+    }
+    class Parent extends Component {
+      static template = xml`
+        <t t-if="state.hasPortal">
+          <div>
+            <Child />
+          </div>
+        </t>`;
+
+      static components = { Child };
+
+      state = useState({ hasPortal: false });
+    }
+
+    addOutsideDiv(fixture);
+    const parent = await mount(Parent, fixture);
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"><p>thePortal</p></div><div><span>hasPortal</span></div>'
+    );
+
+    parent.state.hasPortal = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"></div>');
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"><p>thePortal</p></div><div><span>hasPortal</span></div>'
+    );
+  });
+  test("Add and remove portals with t-foreach inside div", async () => {
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <t t-foreach="portalIds" t-as="portalId" t-key="portalId">
+            <div>
+              <t t-esc="portalId"/>
+              <t t-portal="'#outside'">
+                Portal<t t-esc="portalId"/>
+              </t>
+            </div>
+          </t>
+        </div>`;
+      portalIds = useState([] as any);
+    }
+
+    addOutsideDiv(fixture);
+    const parent = await mount(Parent, fixture);
+
+    expect(fixture.innerHTML).toBe('<div id="outside"></div><div></div>');
+
+    parent.portalIds.push(1);
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"> Portal1</div><div><div>1</div></div>');
+
+    parent.portalIds.push(2);
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div id="outside"> Portal1 Portal2</div><div><div>1</div><div>2</div></div>'
+    );
+
+    parent.portalIds.pop();
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"> Portal1</div><div><div>1</div></div>');
+
+    parent.portalIds.pop();
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div id="outside"></div><div></div>');
+  });
 });
 
 describe("Portal: UI/UX", () => {
@@ -517,12 +860,12 @@ describe("Portal: UI/UX", () => {
             <input id="target-me" t-att-placeholder="props.val"/>`;
     }
     class Parent extends Component {
-      static components = { Portal, Child };
+      static components = { Child };
       static template = xml`
             <div>
-              <Portal target="'#outside'">
+              <t t-portal="'#outside'">
                 <Child val="state.val"/>
-              </Portal>
+              </t>
             </div>`;
       state = useState({ val: "ab" });
     }
@@ -545,17 +888,13 @@ describe("Portal: UI/UX", () => {
 });
 
 describe("Portal: Props validation", () => {
-  test("target is mandatory", async () => {
+  test("target is mandatory 1", async () => {
-    const consoleInfo = console.info;
-    console.info = jest.fn();
-
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
         <div>
-          <Portal>
+          <t t-portal>
             <div>2</div>
-          </Portal>
+          </t>
         </div>`;
     }
     let error: Error;
@@ -565,21 +904,16 @@ describe("Portal: Props validation", () => {
       error = e as Error;
     }
     expect(error!).toBeDefined();
-    expect(error!.message).toBe(`Missing props 'target' (component 'Portal')`);
+    expect(error!.message).toContain(`attribute without value.`);
-    console.info = consoleInfo;
-    expect(mockConsoleWarn).toBeCalledTimes(1);
   });
 
-  test("target is not list", async () => {
+  test("target is mandatory 2", async () => {
-    const consoleInfo = console.info;
-    console.info = jest.fn();
     class Parent extends Component {
-      static components = { Portal };
       static template = xml`
         <div>
-          <Portal target="['body']">
+          <t t-portal="">
             <div>2</div>
-          </Portal>
+          </t>
         </div>`;
     }
     let error: Error;
@@ -589,8 +923,44 @@ describe("Portal: Props validation", () => {
       error = e as Error;
     }
     expect(error!).toBeDefined();
-    expect(error!.message).toBe(`Invalid Prop 'target' in component 'Portal'`);
+    expect(error!.message).toBe(`Unexpected token ','`);
-    console.info = consoleInfo;
+  });
-    expect(mockConsoleWarn).toBeCalledTimes(1);
+
+  test("target must be a valid selector", async () => {
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <t t-portal="' '">
+            <div>2</div>
+          </t>
+        </div>`;
+    }
+    let error: Error;
+    try {
+      await mount(Parent, fixture, { dev: true });
+    } catch (e) {
+      error = e as Error;
+    }
+    expect(error!).toBeDefined();
+    expect(error!.message).toBe(`' ' is not a valid selector`);
+  });
+
+  test("target must be a valid selector 2", async () => {
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <t t-portal="'aa'">
+            <div>2</div>
+          </t>
+        </div>`;
+    }
+    let error: Error;
+    try {
+      await mount(Parent, fixture, { dev: true });
+    } catch (e) {
+      error = e as Error;
+    }
+    expect(error!).toBeDefined();
+    expect(error!.message).toBe(`invalid portal target`);
   });
 });

tests/reactivity.test.ts

@@ -7,7 +7,8 @@ import {
   useState,
   xml,
 } from "../src";
-import { batched, reactive } from "../src/reactivity";
+import { reactive } from "../src/reactivity";
+import { batched } from "../src/utils";
 import {
   makeDeferred,
   makeTestFixture,