wip

With this commit, component only render child
components if they have different props (shallow
equality). Otherwise, we trust the reactivity
system to make sure that all impacted components
are updated

.github/workflows/deploy.yml

@@ -5,7 +5,7 @@ name: Node.js CI
 
 on:
   pull_request:
-    branches: [ master ]
+    branches: [ master, owl-next ]
 
 jobs:
   build:
@@ -25,4 +25,3 @@ jobs:
     - run: npm install
     - run: npm run test
     - run: npm run check-formatting
-    - run: npm run build

CHANGELOG.md

@@ -1,4 +1,4 @@
-# Changelog
+# ChangeLog
 
 This document contains an overview of all changes between Owl 1.x and
 Owl 2.x, with some pointers on how to update the code.
@@ -8,16 +8,13 @@ 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.
 
-## From Owl 1.x to Owl 2.0
+## Changes
-
-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))
-- breaking: component.el is removed ([details](#9-componentel-is-removed))
+- new `useEffect` hook
-- new `useEffect` hook ([doc](doc/reference/hooks.md#useeffect))
+- new `onDestroyed`, `onWillRender` and `onRendered` hooks
-- 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))
@@ -25,78 +22,46 @@ All changes are documented here in no particular order.
 - 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: components can no longer be mounted with position=self ([details](#11-components-can-no-longer-be-mounted-with-positionself))
+- 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: `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))
-- breaking: prop validation system does not allow default prop on a mandatory (not optional) prop ([doc](doc/reference/props.md#props-validation))
-- breaking: rendering a component does not necessarily render child components ([details](#40-rendering-a-component-does-not-necessarily-render-child-components))
-
-
-
-**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-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: components can no longer be mounted with position=self ([details](#11-components-can-no-longer-be-mounted-with-positionself))
-- breaking: `t-on` does not accept expressions, only functions ([details](#30-t-on-does-not-accept-expressions-only-functions))
 - breaking: `t-on` does not work on components any more ([details](#12-t-on-does-not-work-on-components-any-more))
-- new: an error is thrown if an handler defined in a `t-on-` directive is not a function (failed silently previously in some cases)
 - breaking: `t-component` no longer accepts strings ([details](#17-t-component-no-longer-accepts-strings))
-- new: the `this` variable in template expressions is now bound to the component
-
-
-**Reactivity**
-
-- finer grained reactivity: owl 2 tracks change per key/component
-- finer grained reactivity: sub components can reobserve state ([doc](doc/reference/reactivity.md))
-- new: `reactive` function: create reactive state (without being linked to a component) ([doc](doc/reference/reactivity.md#reactive))
-- new: `markRaw` function: mark an object or array so that it is ignored by the reactivity system ([doc](doc/reference/reactivity.md#markraw))
-- new: `toRaw` function: given a reactive objet, return the raw (non reactive) underlying object ([doc](doc/reference/reactivity.md#toraw))
-
-
-**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))
 
+**Slots**
+
+- breaking: `t-set` does not define a slot any more ([details](#3-t-set-will-no-longer-work-to-define-a-slot))
 
 **Miscellaneous**
 
 - improved performance
 - much simpler code 
-- new App class to encapsulate a root Owl component (with the config for that application) ([doc](doc/reference/app.md))
+- finer grained reactivity: owl 2 tracks change per key/component
-- new `useEffect` hook ([doc](doc/reference/hooks.md#useeffect))
+- finer grained reactivity: sub components can reobserve state
+- new App class to encapsulate a root Owl component (with the config for that application)
+- new `Memo` component
 - breaking: `Context` is removed ([details](#15-context-is-removed))
 - breaking: `env` is now totally empty ([details](#16-env-is-now-totally-empty))
-- breaking: `env` is now frozen ([details](#28-env-is-now-frozen))
-- new hook: `useChildSubEnv` (only applies to child components) ([details](#27-usechildsubenv-only-applies-to-child-components))
 - 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))
 - breaking: transition system is removed ([details](#24-transition-system-is-removed))
 - breaking: no more global components or templates ([details](#25-no-more-global-components-or-templates))
 - breaking: `AsyncRoot` utility component is removed ([details](#26-asyncroot-utility-component-is-removed))
-- breaking: `renderToString` function on qweb has been removed ([details](#32-rendertostring-on-qweb-has-been-removed))
+- breaking: `useSubEnv` only applies to child components ([details](#27-usesubenv-only-applies-to-child-components))
-- breaking: `debounce` utility function has been removed ([details](#34-debounce-utility-function-has-been-removed))
+- breaking: `env` is now frozen ([details](#28-env-is-now-frozen))
-- breaking: `browser` object has been removed ([details](#39-browser-object-has-been-removed))
+- 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))
+
 
 ## Details/Rationale/Migration
 
@@ -130,8 +95,6 @@ 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.
@@ -183,8 +146,6 @@ 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:
@@ -248,21 +209,40 @@ Rationale: `shouldUpdate` is a dangerous method to use, that may cause a lot of
 issues. Vue does not have such a mechanism (see https://github.com/vuejs/vue/issues/4255),
 because the reactivity system in Vue is smart enough to only rerender the minimal
 subset of components that is subscribed to a piece of state. Now, Owl 2 features
-a much more powerful reactivity system, so the same rationale applies: in a way,
+a much more powerful reactivity system.
-it's like each Owl 2 component has a `shouldUpdate` method that precisely tracks
-every value used by the component.
 
-Migration code: remove the `shouldUpdate` methods, and it should work as well
+Migration code: remove the `shouldUpdate` methods. Then, maybe the following
-as before.
+ideas may help:
 
-### 9. component.el is removed
+- try to organize the state/architecture to minimize the number of state updates
+- take advantage of the finer reactivity system. For example, if we have a list
+  of items, with a component for each item, we can write this:
 
-This comes from the fact that Owl 2 supports fragments (arbitrary content).
+  ```js
+  class Item extends Component {
+      setup() {
+          this.item = useState(this.props.item); // and only use this, not props.item
+      }
+  }
+  ```
+  Doing so will make it that each `Item` component will register itself as an
+  observer of its own item, and will be the only component being rerendered when
+  its item object is updated.
+- use the `Memo` component to wrap some piece of template. `Memo` memoize its
+  content, and only update itself if its props are different (shallow comparison):
+  
+  ```xml
+    <Memo a="state.a" b="state.b"> 
+        <t t-esc="state.a"/>
+        <t t-esc="state.b"/>
+        <t t-esc="state.c"/>
+    </Memo>
+  ```
 
-Migration: if one need a reference to the root htmlelement of a template, it is
+### 9. component.el may be a text node, and is no longer `null`
-suggested to simply add a `ref` on it, and access the reference as needed.
 
-Documentation: [Refs](doc/reference/refs.md)
+This comes from the fact that Owl 2 supports fragments (arbitrary content). When
+it is not defined, it was `null` in Owl 1 and is `undefined` in owl 2.
 
 ### 10. style/class on components are now regular props
 
@@ -305,13 +285,7 @@ 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`. Remember that you the root component
+prepended in something, maybe a `div`.
-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
 
@@ -338,16 +312,8 @@ 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
@@ -405,8 +371,6 @@ 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:
@@ -432,8 +396,6 @@ 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`.
@@ -485,12 +447,8 @@ bus.addEventListener('event-name', callback);
 Rationale: it makes it easier to have just one interface to remember, it makes
 the code simpler
 
-Migration: most bus methods need to be adapted. So, `bus.on("event-type", owner, (info) => {...})` has to be
+Migration: most bus methods need to be adapted. So, `bus.on(...)` has to be
-rewritten like this: `bus.addEventListener("event-type", (({detail: info}) => {...}).bind(owner))`.
+rewritten like this: `bus.addEventListener(...)`.
-
-Do not forget to similarly replace `bus.off(...)` by `bus.removeEventListener(...)`
-
-Documentation: [EventBus](doc/reference/utils.md#eventbus)
 
 ### 22. `Store` is removed
 
@@ -553,12 +511,14 @@ either a fallback when the data is not ready, or the actual component with data
 as props.  If there is no escape, and `AsyncRoot` is needed, please reach out to
 us so we can study this usecase.
 
-### 27. `useChildSubEnv` (only applies to child components)
+### 27. `useSubEnv` only applies to child components
+
+In Owl 1, a call to `useSubEnv` would define a new environment for the children
+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.
 
-In Owl, a call to `useSubEnv` would define a new environment for the children
-AND the component. It is very useful, but in some cases, one only need to update
-the children component environment. This can now be done with a new hook:
-[`useChildSubEnv`](doc/reference/hooks.md#usesubenv-and-usechildsubenv)
 
 ### 28. `env` is now frozen
 
@@ -573,8 +533,6 @@ 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
@@ -615,8 +573,6 @@ 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
@@ -628,175 +584,3 @@ So, the following template works for components:
   <div>2</div>
   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
-the qweb instance knew all templates. But now, the closest analogy is the `App`
-class, but it is not as convenient, since the `app` instance is no longer visible
-to components (while before, `qweb` was in the environment).
-
-Also, this can easily be done in userspace, by mounting a component in a div.  For example:
-
-```js
-export async function renderToString(template, context) {
-  class C extends Component {
-    static template = template;
-    setup () {
-        Object.assign(this, context);
-    }
-  }
-  const div = document.createElement('div');
-  document.body.appendChild(div);
-  const app = new App(C);
-  await app.mount(div);
-  const result = div.innerHTML;
-  app.destroy();
-  div.remove();
-  return result;
-}
-```
-
-The function above works for most cases, but is asynchronous.  An alternative
-function could look like this:
-
-```js
-const { App, blockDom } = owl;
-const app = new App(Component); // act as a template repository
-
-function renderToString(template, context = {}) {
-  app.addTemplate(template, template, { allowDuplicate: true });
-  const templateFn = app.getTemplate(template);
-  const bdom = templateFn(context, {});
-  const div = document.createElement('div')
-  blockDom.mount(bdom, div);
-  return div.innerHTML;
-}
-```
-
-This is a synchronous function, so it will not work with components, but it should
-be useful for most simple templates.
-
-Also note that these two examples do not translate their templates. To do that,
-they need to be modified to pass the proper translate function to the `App`
-configuration.
-
-### 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).
-
-## 40. Rendering a component does not necessarily render child components
-
-Before, if one had the following component tree:
-
-```mermaid
-  graph TD;
-      A-->B;
-      A-->C;
-```
-
-when `A` would render, it would also render `B` and `C`. Now, in Owl 2, it will 
-(shallow) compare the before and after props, and `B` or `C` will only be rerendered
-if their props have changed.
-
-Now, the question is what happens if the props have changed, but in a deeper way?
-In that case, Owl will know, because each props are now reactive. So, if some
-inner value read by `B` was changed, then only `B` will be updated.
-
-Rationale: This was just not possible in Owl 1, but it now possible. This is
-due to the rewriteof the underlying rendering engine and the reactivity
-system. The goal is to have a big performance boost in large screen with many
-components: now Owl only rerender what is strictly useful.
-

README.md

@@ -1,4 +1,4 @@
-<h1 align="center">🦉 <a href="https://odoo.github.io/owl/">Owl Framework</a> 🦉</h1>
+<h1 align="center">🦉 <a href="https://odoo.github.io/owl/">OWL Framework</a> 🦉</h1>
 
  [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
 [![npm version](https://badge.fury.io/js/@odoo%2Fowl.svg)](https://badge.fury.io/js/@odoo%2Fowl)
@@ -6,111 +6,112 @@
 
 _Class based components with hooks, reactive state and concurrent mode_
 
-**Try it online!** you can experiment with the Owl framework in an online [playground](https://odoo.github.io/owl/playground).
-
 ## Project Overview
 
-The Odoo Web Library (Owl) is a smallish (~<20kb gzipped) UI framework built by
+The Odoo Web Library (OWL) is a smallish (~<20kb gzipped) UI framework intended to
-[Odoo](https://www.odoo.com/) for its products. Owl is a modern
+be the basis for the [Odoo](https://www.odoo.com/) Web Client. Owl is a modern
 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 fine grained reactivity system similar to Vue,
+- a reactivity system based on hooks,
-- hooks
+- concurrent mode by default,
-- fragments
-- asynchronous rendering
 
-Owl components are defined with ES6 classes and xml templates, uses an
+Owl components are defined with ES6 classes, they use QWeb templates, an
 underlying virtual DOM, integrates beautifully with hooks, and the rendering is
 asynchronous.
 
-Quick links:
+**Try it online!** An online playground is available at
+[https://odoo.github.io/owl/playground](https://odoo.github.io/owl/playground)
+to let you experiment with the Owl framework. There are some code examples to
+showcase some interesting features.
 
-- [documentation](#documentation),
+Owl is currently stable.  Possible future changes are explained in the
-- [changelog](CHANGELOG.md) (from Owl 1.x to 2.x),
+[roadmap](roadmap.md).
-- [playground](https://odoo.github.io/owl/playground)
+
+## Why Owl?
+
+Why did Odoo decide to make Yet Another Framework?  This is really a question
+that deserves [a long answer](doc/miscellaneous/why_owl.md). But in short, we believe that
+while the current state of the art frameworks are excellent, they are not
+optimized for our use case, and there is still room for something else.
+
+If you are interested in a comparison with React or Vue, you will
+find some more additional information [here](doc/miscellaneous/comparison.md).
 
 ## Example
 
 Here is a short example to illustrate interactive components:
 
 ```javascript
-const { Component, useState, mount, xml } = owl;
+const { Component, useState, mount } = owl;
+const { xml } = owl.tags;
 
 class Counter extends Component {
   static template = xml`
-    <button t-on-click="() => state.value = state.value + props.increment">
+    <button t-on-click="state.value++">
       Click Me! [<t t-esc="state.value"/>]
     </button>`;
 
   state = useState({ value: 0 });
 }
 
-class Root extends Component {
+class App extends Component {
   static template = xml`
-    <span>Hello Owl</span>
+    <div>
-    <Counter increment="2"/>`;
+      <span>Hello Owl</span>
+      <Counter />
+    </div>`;
 
   static components = { Counter };
 }
 
-mount(Root, document.body);
+mount(App, { target: 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/templates.md#inline-templates) to define inline templates.
+Also, all examples here uses the [`xml` helper](doc/reference/tags.md#xml-tag) to define inline templates.
 But this is not mandatory, many applications will load templates separately.
 
 More interesting examples can be found on the
 [playground](https://odoo.github.io/owl/playground) application.
 
+## Design Principles
+
+OWL is designed to be used in highly dynamic applications where changing
+requirements are common and code needs to be maintained by large teams.
+
+- **XML based**: templates are based on the XML format, which allows interesting
+  applications. For example, they could be stored in a database and modified
+  dynamically with `xpaths`.
+- **templates compilation in the browser**: this may not be a good fit for all
+  applications, but if you need to generate dynamically user interfaces in the
+  browser, this is very powerful. For example, a generic form view component
+  could generate a specific form user interface for each various models, from a XML view.
+- **no toolchain required**: this is extremely useful for some applications, if,
+  for various reasons (security/deployment/dynamic modules/specific assets tools),
+  it is not ok to use standard web tools based on `npm`.
+
+Owl is not designed to be fast nor small (even though it is quite good on those
+two topics). It is a no nonsense framework to build applications. There is only
+one way to define components (with classes). There is no black magic. It just
+works.
+
+
 ## Documentation
 
-### Learning Owl
+A complete documentation for Owl can be found here:
 
-Are you new to Owl? This is the place to start!
+- [Main documentation page](doc/readme.md).
 
-- [Tutorial: create a TodoList application](doc/learning/tutorial_todoapp.md)
+Some of the most important pages are:
+
+- [Tutorial: 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)
+- [QWeb templating language](doc/reference/qweb_templating_language.md)
-
-### Reference
-
-- [Overview](doc/readme.md)
-- [App](doc/reference/app.md)
 - [Component](doc/reference/component.md)
-- [Component Lifecycle](doc/reference/component.md#lifecycle)
-- [Concurrency Model](doc/reference/concurrency_model.md)
-- [Dynamic sub components](doc/reference/component.md#dynamic-sub-components)
-- [Environment](doc/reference/environment.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)
-- [Loading Templates](doc/reference/app.md#loading-templates)
-- [Mounting a component](doc/reference/app.md#mount-helper)
-- [Portal](doc/reference/portal.md)
-- [Props](doc/reference/props.md)
-- [Props Validation](doc/reference/props.md#props-validation)
-- [Reactivity](doc/reference/reactivity.md)
-- [Rendering SVG](doc/reference/templates.md#rendering-svg)
-- [Refs](doc/reference/refs.md)
-- [Slots](doc/reference/slots.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
-
-- [Notes On Owl Architecture](doc/miscellaneous/architecture.md)
-- [Comparison with React/Vue](doc/miscellaneous/comparison.md)
-- [Why did Odoo build Owl?](doc/miscellaneous/why_owl.md)
-- [Changelog (from owl 1.x to 2.x)](CHANGELOG.md)
-- [Notes on compiled templates](doc/miscellaneous/compiled_template.md)
 
 ## Installing Owl
 
@@ -122,5 +123,8 @@ npm install @odoo/owl
 
 If you want to use a simple `<script>` tag, the last release can be downloaded here:
 
-- [owl-1.4.10](https://github.com/odoo/owl/releases/tag/v1.4.10)
+- [owl-1.4.7](https://github.com/odoo/owl/releases/tag/v1.4.7)
 
+## License
+
+OWL is [LGPL licensed](./LICENSE).

doc/learning/how_to_debug.md

@@ -0,0 +1,43 @@
+# 🦉 How to debug Owl applications 🦉
+
+Non trivial applications become quickly more difficult to understand. It is then
+useful to have a solid understanding of what is going on. To help with that,
+logging useful information is extremely valuable. There is a [javascript file](../../tools/debug.js) which can be evaluated in an application.
+
+Once it is executed, it will log a lot of information on each component main hooks. The following code is a minified version to make it easier to copy/paste:
+
+```
+function debugOwl(t,e){let n,o="[OWL_DEBUG]";function r(t){let e;try{e=JSON.stringify(t||{})}catch(t){e="<JSON error>"}return e.length>200&&(e=e.slice(0,200)+"..."),e}if(Object.defineProperty(t.Component,"current",{get:()=>n,set(s){n=s;const i=s.constructor.name;if(e.componentBlackList&&e.componentBlackList.test(i))return;if(e.componentWhiteList&&!e.componentWhiteList.test(i))return;let l;Object.defineProperty(n,"__owl__",{get:()=>l,set(n){!function(n,s,i){let l=`${s}<id=${i}>`,c=t=>console.log(`${o} ${l} ${t}`),u=t=>(!e.methodBlackList||!e.methodBlackList.includes(t))&&!(e.methodWhiteList&&!e.methodWhiteList.includes(t));u("constructor")&&c(`constructor, props=${r(n.props)}`);u("willStart")&&t.hooks.onWillStart(()=>{c("willStart")});u("mounted")&&t.hooks.onMounted(()=>{c("mounted")});u("willUpdateProps")&&t.hooks.onWillUpdateProps(t=>{c(`willUpdateProps, nextprops=${r(t)}`)});u("willPatch")&&t.hooks.onWillPatch(()=>{c("willPatch")});u("patched")&&t.hooks.onPatched(()=>{c("patched")});u("willUnmount")&&t.hooks.onWillUnmount(()=>{c("willUnmount")});const d=n.__render.bind(n);n.__render=function(...t){c("rendering template"),d(...t)};const h=n.render.bind(n);n.render=function(...t){const e=n.__owl__;let o="render";return e.isMounted||e.currentFiber||(o+=" (warning: component is not mounted, this render has no effect)"),c(o),h(...t)};const p=n.mount.bind(n);n.mount=function(...t){return c("mount"),p(...t)}}(s,i,(l=n).id)}})}}),e.logScheduler){let e=t.Component.scheduler.start,n=t.Component.scheduler.stop;t.Component.scheduler.start=function(){this.isRunning||console.log(`${o} scheduler: start running tasks queue`),e.call(this)},t.Component.scheduler.stop=function(){this.isRunning&&console.log(`${o} scheduler: stop running tasks queue`),n.call(this)}}if(e.logStore){let e=t.Store.prototype.dispatch;t.Store.prototype.dispatch=function(t,...n){return console.log(`${o} store: action '${t}' dispatched. Payload: '${r(n)}'`),e.call(this,t,...n)}}}
+debugOwl(owl, {
+  // componentBlackList: /App/,  // regexp
+  // componentWhiteList: /SomeComponent/, // regexp
+  // methodBlackList: ["mounted"], // list of method names
+  // methodWhiteList: ["willStart"], // list of method names
+  logScheduler: false,  // display/mute scheduler logs
+  logStore: true,     // display/mute store logs
+});
+```
+
+The above code, once pasted somewhere in the main javascript file of an owl
+application, will log information looking like this:
+
+```
+[OWL_DEBUG] TodoApp<id=1> constructor, props={}
+[OWL_DEBUG] TodoApp<id=1> mount
+[OWL_DEBUG] TodoApp<id=1> willStart
+[OWL_DEBUG] TodoApp<id=1> rendering template
+[OWL_DEBUG] TodoItem<id=2> constructor, props={"id":2,"completed":false,"title":"hey"}
+[OWL_DEBUG] TodoItem<id=2> willStart
+[OWL_DEBUG] TodoItem<id=3> constructor, props={"id":4,"completed":false,"title":"aaa"}
+[OWL_DEBUG] TodoItem<id=3> willStart
+[OWL_DEBUG] TodoItem<id=2> rendering template
+[OWL_DEBUG] TodoItem<id=3> rendering template
+[OWL_DEBUG] TodoItem<id=3> mounted
+[OWL_DEBUG] TodoItem<id=2> mounted
+[OWL_DEBUG] TodoApp<id=1> mounted
+```
+
+Each component has an internal `id`, which is very useful when debugging.
+
+Note that it is certainly useful to run this code at some point in an application,
+just to get a feel of what each user action implies, for the framework.

doc/learning/how_to_test.md

@@ -30,21 +30,27 @@ To help with this, it is useful to have a `helper.js` file that contains some
 common utility functions:
 
 ```js
-let lastFixture = null;
-
 export function makeTestFixture() {
   let fixture = document.createElement("div");
   document.body.appendChild(fixture);
-  if (lastFixture) {
-    lastFixture.remove();
-  }
-  lastFixture = fixture;
   return fixture;
 }
 
-export async function nextTick() {
+export function nextTick() {
-  await new Promise((resolve) => setTimeout(resolve));
+  let requestAnimationFrame = owl.Component.scheduler.requestAnimationFrame;
-  await new Promise((resolve) => requestAnimationFrame(resolve));
+  return new Promise(function(resolve) {
+    setTimeout(() => requestAnimationFrame(() => resolve()));
+  });
+}
+
+export function makeTestEnv() {
+    // application specific. It needs a way to load actual templates
+    const templates = ...;
+
+    return {
+        qweb: new QWeb(templates),
+        ..., // each service can be mocked here
+    };
 }
 ```
 
@@ -53,7 +59,7 @@ With such a file, a typical test suite for Jest will look like this:
 ```js
 // in SomeComponent.test.js
 import { SomeComponent } from "../../src/ui/SomeComponent";
-import { nextTick, makeTestFixture } from '../helpers';
+import { nextTick, makeTestFixture, makeTestEnv} from '../helpers';
 
 
 //------------------------------------------------------------------------------
@@ -64,6 +70,9 @@ let env: Env;
 
 beforeEach(() => {
   fixture = makeTestFixture();
+  env = makeTestEnv();
+  // we set here the default environment for each component created in the test
+  Component.env = env;
 });
 
 afterEach(() => {
@@ -76,7 +85,7 @@ afterEach(() => {
 describe("SomeComponent", () => {
   test("component behaves as expected", async () => {
     const props = {...}; // depends on the component
-    const comp = await mount(SomeComponent, fixture, { props });
+    const comp = await mount(SomeComponent, { target: fixture, props });
 
     // do some assertions
     expect(...).toBe(...);
@@ -93,3 +102,29 @@ describe("SomeComponent", () => {
 Note that Owl does wait for the next animation frame to actually update the DOM.
 This is why it is necessary to wait with the `nextTick` (or other methods) to
 make sure that the DOM is up-to-date.
+
+It is sometimes useful to wait until Owl is completely done updating components
+(in particular, if we have a highly concurrent user interface). This next
+helper simply polls every 20ms the internal Owl task queue and returns a promise
+which resolves when it is empty:
+
+```js
+function afterUpdates() {
+  return new Promise((resolve, reject) => {
+    let timer = setTimeout(poll, 20);
+    let counter = 0;
+    function poll() {
+      counter++;
+      if (owl.Component.scheduler.tasks.length) {
+        if (counter > 10) {
+          reject(new Error("timeout"));
+        } else {
+          timer = setTimeout(poll);
+        }
+      } else {
+        resolve();
+      }
+    }
+  });
+}
+```

doc/learning/how_to_write_sfc.md

@@ -0,0 +1,52 @@
+# 🦉 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/overview.md

@@ -0,0 +1,133 @@
+# 🦉 Quick Overview 🦉
+
+Owl components in an application are used to define a (dynamic) tree of components.
+
+```
+        Root
+        /   \
+       A     B
+      / \
+     C   D
+```
+
+**State:** each component can manage its own local state. It is a simple ES6
+class, there are no special rules:
+
+```js
+class Counter extends Component {
+  static template = xml`
+    <button t-on-click="increment">
+      Click Me! [<t t-esc="state.value"/>]
+    </button>`;
+
+  state = { value: 0 };
+
+  increment() {
+    this.state.value++;
+    this.render();
+  }
+}
+```
+
+The example above shows a component with a local state. Note that since there
+is nothing magical to the `state` object, we need to manually call the `render`
+function whenever we update it. This can quickly become annoying (and not
+efficient if we do it too much). There is a better way: using the `useState`
+hook, which transforms an object into a reactive version of itself:
+
+```js
+const { useState } = owl.hooks;
+
+class Counter extends Component {
+  static template = xml`
+    <button t-on-click="increment">
+      Click Me! [<t t-esc="state.value"/>]
+    </button>`;
+
+  state = useState({ value: 0 });
+
+  increment() {
+    this.state.value++;
+  }
+}
+```
+
+Note that the `t-on-click` handler can even be replaced by an inline statement:
+
+```xml
+    <button t-on-click="state.value++">
+```
+
+**Props:** sub components often needs some information from their parents. This
+is done by adding the required information to the template. This will then be
+accessible by the sub component in the `props` object. Note that there is an
+important rule here: the information contained in the `props` object is not
+owned by the sub component, and should never be modified.
+
+```js
+class Child extends Component {
+  static template = xml`<div>Hello <t t-esc="props.name"/></div>`;
+}
+
+class Parent extends Component {
+  static template = xml`
+    <div>
+        <Child name="'Owl'" />
+        <Child name="'Framework'" />
+    </div>`;
+  static components = { Child };
+}
+```
+
+**Communication:** there are multiple ways to communicate information between
+components. However, the two most important ways are the following:
+
+- from parent to children: by using `props`,
+- from a children to one of its parent: by triggering events.
+
+The following example illustrate both mechanisms:
+
+```js
+class OrderLine extends Component {
+  static template = xml`
+    <div t-on-click="add">
+        <div><t t-esc="props.line.name"/></div>
+        <div>Quantity: <t t-esc="props.line.quantity"/></div>
+    </div>`;
+
+  add() {
+    this.trigger("add-to-order", { line: this.props.line });
+  }
+}
+
+class Parent extends Component {
+  static template = xml`
+    <div t-on-add-to-order="addToOrder">
+        <OrderLine
+            t-foreach="orders"
+            t-as="line"
+            line="line" />
+    </div>`;
+  static components = { OrderLine };
+  orders = useState([
+    { id: 1, name: "Coffee", quantity: 0 },
+    { id: 2, name: "Tea", quantity: 0 },
+  ]);
+
+  addToOrder(event) {
+    const line = event.detail.line;
+    line.quantity++;
+  }
+}
+```
+
+In this example, the `OrderLine` component trigger a `add-to-order` event. This
+will generate a DOM event which will bubble along the DOM tree. It will then be
+intercepted by the parent component, which will then get the line (from the
+`detail` key) and then increment its quantity. See the page on [event handling](../reference/event_handling.md)
+for more details on how events work.
+
+Note that this example would have also worked if the `OrderLine` component
+directly modifies the `line` object. However, this is not a good practice: this
+only works because the `props` object received by the child component is reactive,
+so the child component is then coupled to the parents implementation.

doc/learning/quick_start.md

@@ -36,8 +36,6 @@ hello_owl/
 The file `owl.js` can be downloaded from the last release published at
 [https://github.com/odoo/owl/releases](https://github.com/odoo/owl/releases). It
 is a single javascript file which export all Owl into the global `owl` object.
-Note that there are multiple files, and in this case, we need one of the two
-files suffixed with `.iife`: they are built to be directly used in a browser.
 
 Now, `index.html` should contain the following:
 
@@ -47,24 +45,30 @@ Now, `index.html` should contain the following:
   <head>
     <title>Hello Owl</title>
     <script src="owl.js"></script>
-  </head>
-  <body>
     <script src="app.js"></script>
-  </body>
+  </head>
+  <body></body>
 </html>
 ```
 
 And `app.js` should look like this:
 
 ```js
-const { Component, mount, xml } = owl;
+const { Component, mount } = owl;
+const { xml } = owl.tags;
+const { whenReady } = owl.utils;
 
 // Owl Components
-class Root extends Component {
+class App extends Component {
   static template = xml`<div>Hello Owl</div>`;
 }
 
-mount(Root, document.body);
+// Setup code
+function setup() {
+  mount(App, target: { document.body })
+}
+
+whenReady(setup);
 ```
 
 Now, simply loading this html file in a browser should display a welcome message.
@@ -89,16 +93,14 @@ Let us start a new project with the following file structure:
 ```
 hello_owl/
   src/
+    app.js
     index.html
     main.js
     owl.js
-    root.js
 ```
 
 As previously, the file `owl.js` can be downloaded from the last release published at
 [https://github.com/odoo/owl/releases](https://github.com/odoo/owl/releases).
-Note that there are multiple files, and in this case, we need one of the two
-files suffixed with `.iife`: they are built to be directly used in a browser.
 
 Now, `index.html` should contain the following:
 
@@ -108,33 +110,37 @@ Now, `index.html` should contain the following:
   <head>
     <title>Hello Owl</title>
     <script src="owl.js"></script>
-  </head>
-  <body>
     <script src="main.js" type="module"></script>
-  </body>
+  </head>
+  <body></body>
 </html>
 ```
 
 Not that the `main.js` script tag has the `type="module"` attribute. This means
 that the browser will parse the script as a module, and load all its dependencies.
 
-Here is the content of `root.js` and `main.js`:
+Here is the content of `app.js` and `main.js`:
 
 ```js
-// root.js ----------------------------------------------------------------------
+// app.js ----------------------------------------------------------------------
-const { Component, mount, xml } = owl;
+const { Component, mount } = owl;
+const { xml } = owl.tags;
 
-export class Root extends Component {
+export class App extends Component {
   static template = xml`<div>Hello Owl</div>`;
 }
 
 // main.js ---------------------------------------------------------------------
-import { Root } from "./root.js";
+import { App } from "./app.js";
 
-mount(Root, document.body);
+function setup() {
+  mount(App, { target: document.body });
+}
+
+owl.utils.whenReady(setup);
 ```
 
-The `main.js` file imports the `root.js` file. Note that the import statement has
+The `main.js` file import the `app.js` file. Note that the import statement has
 a `.js` suffix, which is important. Most text editor can understand this syntax
 and will provide autocompletion.
 
@@ -187,11 +193,11 @@ hello_owl/
     index.html
   src/
     components/
-      Root.js
+      App.js
     main.js
   tests/
     components/
-      Root.test.js
+      App.test.js
     helpers.js
   .gitignore
   package.json
@@ -218,15 +224,13 @@ Note that there are no `<script>` tag here. They will be injected by webpack.
 Now, let's have a look at the javascript files:
 
 ```js
-// src/components/Root.js -------------------------------------------------------
+// src/components/App.js -------------------------------------------------------
-import { Component, xml, useState } from "@odoo/owl";
+import { Component, tags, useState } from "@odoo/owl";
 
-export class Root extends Component {
+const { xml } = tags;
-  static template = xml`
-    <div t-on-click="update">
-      Hello <t t-esc="state.text"/>
-    </div>`;
 
+export class App extends Component {
+  static template = xml`<div t-on-click="update">Hello <t t-esc="state.text"/></div>`;
   state = useState({ text: "Owl" });
   update() {
     this.state.text = this.state.text === "Owl" ? "World" : "Owl";
@@ -235,12 +239,16 @@ export class Root extends Component {
 
 // src/main.js -----------------------------------------------------------------
 import { utils, mount } from "@odoo/owl";
-import { Root } from "./components/Root";
+import { App } from "./components/App";
 
-mount(Root, document.body);
+function setup() {
+  mount(App, { target: document.body });
+}
 
-// tests/components/Root.test.js ------------------------------------------------
+utils.whenReady(setup);
-import { Root } from "../../src/components/Root";
+
+// tests/components/App.test.js ------------------------------------------------
+import { App } from "../../src/components/App";
 import { makeTestFixture, nextTick, click } from "../helpers";
 import { mount } from "@odoo/owl";
 
@@ -254,9 +262,9 @@ afterEach(() => {
   fixture.remove();
 });
 
-describe("Root", () => {
+describe("App", () => {
   test("Works as expected...", async () => {
-    await mount(Root, fixture);
+    await mount(App, { target: fixture });
     expect(fixture.innerHTML).toBe("<div>Hello Owl</div>");
 
     click(fixture, "div");
@@ -270,8 +278,9 @@ import { Component } from "@odoo/owl";
 import "regenerator-runtime/runtime";
 
 export async function nextTick() {
-  await new Promise((resolve) => setTimeout(resolve));
+  return new Promise(function (resolve) {
-  await new Promise((resolve) => requestAnimationFrame(resolve));
+    setTimeout(() => Component.scheduler.requestAnimationFrame(() => resolve()));
+  });
 }
 
 export function makeTestFixture() {

doc/learning/tutorial_todoapp.md

@@ -50,11 +50,10 @@ the following content:
     <meta charset="UTF-8" />
     <title>OWL Todo App</title>
     <link rel="stylesheet" href="app.css" />
-  </head>
-  <body>
     <script src="owl.js"></script>
     <script src="app.js"></script>
-  </body>
+  </head>
+  <body></body>
 </html>
 ```
 
@@ -72,34 +71,44 @@ Note that we put everything inside an immediately executed function to avoid lea
 anything to the global scope.
 
 Finally, `owl.js` should be the last version downloaded from the Owl repository (you can use `owl.min.js` if you prefer). Be aware that you should download the `owl.iife.js` or `owl.iife.min.js`, because these files
-are built to run directly on the browser, and rename it `owl.js` (other files such as `owl.cjs.js` are
+are built to run directly on the browser (other files such as `owl.cjs.js` are
 built to be bundled by other tools).
 
 Now, the project should be ready. Loading the `index.html` file into a browser
 should show an empty page, with the title `Owl Todo App`, and it should log a
-message such as `hello owl 2.x.y` in the console.
+message such as `hello owl 1.0.0` in the console.
 
 ## 2. Adding a first component
 
 An Owl application is made out of [components](../reference/component.md), with
-a single root component. Let us start by defining a `Root` component. Replace the
+a single root component. Let us start by defining an `App` component. Replace the
 content of the function in `app.js` by the following code:
 
 ```js
-const { Component, mount, xml } = owl;
+const { Component, mount } = owl;
+const { xml } = owl.tags;
+const { whenReady } = owl.utils;
 
 // Owl Components
-class Root extends Component {
+class App extends Component {
   static template = xml`<div>todo app</div>`;
 }
 
-mount(Root, document.body);
+// Setup code
+function setup() {
+  mount(App, { target: document.body });
+}
+
+whenReady(setup);
 ```
 
 Now, reloading the page in a browser should display a message.
 
-The code is pretty simple: we define a component with an inline template, then
+The code is pretty simple, but let us explain the last line in more detail. The
-mount it in the document body.
+browser tries to execute the javascript code in `app.js` as quickly as possible,
+and it could happen that the DOM is not ready yet when we try to mount the `App`
+component. To avoid this situation, we use the [`whenReady`](../reference/utils.md#whenready)
+helper to delay the execution of the `setup` function until the DOM is ready.
 
 Note 1: in a larger project, we would split the code in multiple files, with
 components in a sub folder, and a main file that would initialize the application.
@@ -116,7 +125,7 @@ class App extends Component {}
 App.template = xml`<div>todo app</div>`;
 ```
 
-Note 3: writing inline templates with the [`xml` helper](../reference/templates.md#inline-templates)
+Note 3: writing inline templates with the [`xml` helper](../reference/tags.md#xml-tag)
 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,
@@ -140,20 +149,20 @@ with the following keys:
   tasks. Since the title is something created/edited by the user, it offers
   no guarantee that it is unique. So, we will generate a unique `id` number for
   each task.
-- `text`: a string, to explain what the task is about.
+- `title`: a string, to explain what the task is about.
 - `isCompleted`: a boolean, to keep track of the status of the task
 
 Now that we decided on the internal format of the state, let us add some demo
 data and a template to the `App` component:
 
 ```js
-class Root extends Component {
+class App extends Component {
   static template = xml/* xml */ `
     <div class="task-list">
         <t t-foreach="tasks" t-as="task" t-key="task.id">
             <div class="task">
                 <input type="checkbox" t-att-checked="task.isCompleted"/>
-                <span><t t-esc="task.text"/></span>
+                <span><t t-esc="task.title"/></span>
             </div>
         </t>
     </div>`;
@@ -161,26 +170,26 @@ class Root extends Component {
   tasks = [
     {
       id: 1,
-      text: "buy milk",
+      title: "buy milk",
       isCompleted: true,
     },
     {
       id: 2,
-      text: "clean house",
+      title: "clean house",
       isCompleted: false,
     },
   ];
 }
 ```
 
-The template contains a [`t-foreach`](../reference/templates.md#loops) loop to iterate
+The template contains a [`t-foreach`](../reference/qweb_templating_language.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/templates.md#dynamic-attributes) makes
+prefixing an attribute by [`t-att`](../reference/qweb_templating_language.md#dynamic-attributes) makes
 it dynamic. Owl will evaluate the expression and set it as the value of the
 attribute.
 
@@ -236,25 +245,29 @@ a little bit:
 // -------------------------------------------------------------------------
 // Task Component
 // -------------------------------------------------------------------------
-class Task extends Component {
+const TASK_TEMPLATE = xml /* xml */`
-  static template = xml /* xml */`
     <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
-      <input type="checkbox" t-att-checked="props.task.isCompleted"/>
+        <input type="checkbox" t-att-checked="props.task.isCompleted"/>
-      <span><t t-esc="props.task.title"/></span>
+        <span><t t-esc="props.task.title"/></span>
     </div>`;
-  static props = ["task"];
+
+class Task extends Component {
+    static template = TASK_TEMPLATE;
+    static props = ["task"];
 }
 
 // -------------------------------------------------------------------------
-// Root Component
+// App Component
 // -------------------------------------------------------------------------
-class Root extends Component {
+const APP_TEMPLATE = xml /* xml */`
-  static template = xml /* xml */`
     <div class="task-list">
-      <t t-foreach="tasks" t-as="task" t-key="task.id">
+        <t t-foreach="tasks" t-as="task" t-key="task.id">
-        <Task task="task"/>
+            <Task task="task"/>
-      </t>
+        </t>
     </div>`;
+
+class App extends Component {
+    static template = APP_TEMPLATE;
     static components = { Task };
 
     tasks = [
@@ -263,9 +276,14 @@ class Root extends Component {
 }
 
 // -------------------------------------------------------------------------
-// Setup
+// Setup code
 // -------------------------------------------------------------------------
-mount(Root, document.body, {dev: true});
+function setup() {
+    owl.config.mode = "dev";
+    mount(App, { target: document.body });
+}
+
+whenReady(setup);
 ```
 
 A lot of stuff happened here:
@@ -274,22 +292,24 @@ A lot of stuff happened here:
 - whenever we define a sub component, it needs to be added to the static
   [`components`](../reference/component.md#static-properties)
   key of its parent, so Owl can get a reference to it,
+- the templates have been extracted out of the components, to make it easier to
+  differentiate the "view/template" code from the "script/behavior" code,
 - 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.md#props-validation). This is extremely
+  [error](../reference/props_validation.md). This is extremely
   useful when refactoring components
 - finally, to activate the props validation, we need to set Owl's
-  [mode](../reference/app.md#configuration) to `dev`. This is done in the last argument
+  [mode](../reference/config.md#mode) to `dev`. This is done in the `setup`
-  of the `mount` function. Note that this should be removed when an app is used in a real
+  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.
 
 ## 6. Adding tasks (part 1)
 
 We still use a list of hardcoded tasks. It's really time to give the user a way
-to add tasks himself. The first step is to add an input to the `Root` component.
+to add tasks himself. The first step is to add an input to the `App` component.
-But this input will be outside of the task list, so we need to adapt `Root`
+But this input will be outside of the task list, so we need to adapt `App`
 template, js, and css:
 
 ```xml
@@ -307,9 +327,9 @@ template, js, and css:
 addTask(ev) {
     // 13 is keycode for ENTER
     if (ev.keyCode === 13) {
-        const text = ev.target.value.trim();
+        const title = ev.target.value.trim();
         ev.target.value = "";
-        console.log('adding task', text);
+        console.log('adding task', title);
         // todo
     }
 }
@@ -338,9 +358,10 @@ task. Notice that when you load the page, the input is not focused. But adding
 tasks is a core feature of a task list, so let us make it as fast as possible by
 focusing the input.
 
-We need to execute code when the `Root` component is ready (mounted). Let's do
+Since `App` is a component, it has a
-that using the `onMounted` hook. We will also need to get a reference to the
+[`mounted` lifecycle method](../reference/component.md#lifecycle) that we can
-input, by using the `t-ref` directive with the [`useRef`](../reference/hooks.md#useref) hook:
+implement. We will also need to get a reference to the input, by using the
+`t-ref` directive with the [`useRef`](../reference/hooks.md#useref) hook:
 
 ```xml
 <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
@@ -348,21 +369,22 @@ input, by using the `t-ref` directive with the [`useRef`](../reference/hooks.md#
 
 ```js
 // on top of file:
-const { Component, mount, xml, useRef, onMounted } = owl;
+const { useRef } = owl.hooks;
 ```
 
 ```js
 // in App
-setup() {
+inputRef = useRef("add-input");
-    const inputRef = useRef("add-input");
+
-    onMounted(() => inputRef.el.focus());
+mounted() {
+    this.inputRef.el.focus();
 }
 ```
 
-This is a very common situation: whenever we need to perform some actions depending
+The `inputRef` is defined as a class field, so it is equivalent to defining it
-on the lifecycle of a component, we need to do it in the `setup` method, by using
+in the constructor. It simply instructs Owl to keep a reference to anything with
-one of the lifecycle hook. Here, we first get a reference to the `inputRef`,
+the corresponding `t-ref` keyword. We then implement the `mounted` lifecycle
-then in the `onMounted` hook, we simply focus the html element.
+method, where we now have an active reference that we can use to focus the input.
 
 ## 7. Adding tasks (part 2)
 
@@ -383,12 +405,12 @@ Now, the `addTask` method can be implemented:
 addTask(ev) {
     // 13 is keycode for ENTER
     if (ev.keyCode === 13) {
-        const text = ev.target.value.trim();
+        const title = ev.target.value.trim();
         ev.target.value = "";
-        if (text) {
+        if (title) {
             const newTask = {
                 id: this.nextId++,
-                text: text,
+                title: title,
                 isCompleted: false,
             };
             this.tasks.push(newTask);
@@ -406,7 +428,7 @@ the user interface. We can fix the issue by making `tasks` reactive, with the
 
 ```js
 // on top of the file
-const { Component, mount, xml, useRef, onMounted, useState } = owl;
+const { useRef, useState } = owl.hooks;
 
 // replace the task definition in App with the following:
 tasks = useState([]);
@@ -421,8 +443,12 @@ did not change in opacity. This is because there is no code to modify the
 `isCompleted` flag.
 
 Now, this is an interesting situation: the task is displayed by the `Task`
-component, but it is not the owner of its state, so ideally, it should not modify it.
+component, but it is not the owner of its state, so it cannot modify it. Instead,
-However, for now, that's what we will do (this will be improved in a later step).
+we want to communicate the request to toggle a task to the `App` component.
+Since `App` is a parent of `Task`, we can
+[trigger](../reference/event_handling.md) an event in `Task` and listen
+for it in `App`.
+
 In `Task`, change the `input` to:
 
 ```xml
@@ -433,23 +459,36 @@ and add the `toggleTask` method:
 
 ```js
 toggleTask() {
-  this.props.task.isCompleted = !this.props.task.isCompleted;
+    this.trigger('toggle-task', {id: this.props.task.id});
+}
+```
+
+We now need to listen for that event in the `App` template:
+
+```xml
+<div class="task-list" t-on-toggle-task="toggleTask">
+```
+
+and implement the `toggleTask` code:
+
+```js
+toggleTask(ev) {
+    const task = this.tasks.find(t => t.id === ev.detail.id);
+    task.isCompleted = !task.isCompleted;
 }
 ```
 
 ## 9. Deleting tasks
 
-Let us now add the possibility do delete tasks. This is different from the previous
+Let us now add the possibility do delete tasks. To do that, we first need to add
-feature: deleting task has to be done on the task itself, but the actual operation
+a trash icon on each task, then we will proceed just like in the previous section.
-need to be done on the task list. So, we need to communicate the request to the
-`Root` component. This is usually done by providing a callback in a prop.
 
 First, let us update the `Task` template, css and js:
 
 ```xml
 <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
     <input type="checkbox" t-att-checked="props.task.isCompleted" t-on-click="toggleTask"/>
-    <span><t t-esc="props.task.text"/></span>
+    <span><t t-esc="props.task.title"/></span>
     <span class="delete" t-on-click="deleteTask">🗑</span>
 </div>
 ```
@@ -478,226 +517,218 @@ First, let us update the `Task` template, css and js:
 ```
 
 ```js
-static props = ["task", "onDelete"];
-
 deleteTask() {
-    this.props.onDelete(this.props.task);
+    this.trigger('delete-task', {id: this.props.task.id});
 }
 ```
 
-And now, we need to provide the `onDelete` callback to each tasks in the `Root`
+And now, we need to listen to the `delete-task` event in `App`:
-component:
 
 ```xml
-  <Task task="task" onDelete.bind="deleteTask"/>
+<div class="task-list" t-on-toggle-task="toggleTask" t-on-delete-task="deleteTask">
 ```
 
 ```js
-deleteTask(task) {
+deleteTask(ev) {
-    const index = this.tasks.findIndex(t => t.id === task.id);
+    const index = this.tasks.findIndex(t => t.id === ev.detail.id);
     this.tasks.splice(index, 1);
 }
 ```
 
-Notice that the `onDelete` prop is defined with a `.bind` suffix: this is a special
-suffix that makes sure the function callback is bound to the component.
-
 ## 10. Using a store
 
-Looking at the code, it is apparent that all the code handling tasks is scattered
+Looking at the code, it is apparent that we now have code to handle tasks
-all around the application. Also, it mixes UI code and business logic
+scattered in more than one place. Also, it mixes UI code and business logic
-code. Owl does not provide any high level abstraction to manage business logic,
+code. Owl has a way to manage state separately from the user interface: a
-but it is easy to do it with the basic reactivity primitives (`useState` and `reactive`).
+[`Store`](../reference/store.md).
 
-Let us use it in our application to implement a central store. This is a pretty
+Let us use it in our application. This is a pretty large refactoring (for our
-large refactoring (for our application), since it involves extracting all task
+application), since it involves extracting all task related code out of the
-related code out of the components. Here is the new content of the `app.js` file:
+components. Here is the new content of the `app.js` file:
 
 ```js
-const { Component, mount, xml, useRef, onMounted, useState, reactive, useEnv } = owl;
+const { Component, Store, mount } = owl;
+const { xml } = owl.tags;
+const { whenReady } = owl.utils;
+const { useRef, useDispatch, useStore } = owl.hooks;
 
 // -------------------------------------------------------------------------
 // Store
 // -------------------------------------------------------------------------
-function useStore() {
+const actions = {
-  const env = useEnv();
+  addTask({ state }, title) {
-  return useState(env.store);
+    title = title.trim();
-}
+    if (title) {
-
-// -------------------------------------------------------------------------
-// TaskList
-// -------------------------------------------------------------------------
-class TaskList {
-  nextId = 1;
-  tasks = [];
-
-  addTask(text) {
-    text = text.trim();
-    if (text) {
       const task = {
-        id: this.nextId++,
+        id: state.nextId++,
-        text: text,
+        title: title,
         isCompleted: false,
       };
-      this.tasks.push(task);
+      state.tasks.push(task);
     }
-  }
+  },
-
+  toggleTask({ state }, id) {
-  toggleTask(task) {
+    const task = state.tasks.find((t) => t.id === id);
     task.isCompleted = !task.isCompleted;
-  }
+  },
-
+  deleteTask({ state }, id) {
-  deleteTask(task) {
+    const index = state.tasks.findIndex((t) => t.id === id);
-    const index = this.tasks.findIndex((t) => t.id === task.id);
+    state.tasks.splice(index, 1);
-    this.tasks.splice(index, 1);
+  },
-  }
+};
-}
+const initialState = {
-
+  nextId: 1,
-function createTaskStore() {
+  tasks: [],
-  return reactive(new TaskList());
+};
-}
 
 // -------------------------------------------------------------------------
 // Task Component
 // -------------------------------------------------------------------------
-class Task extends Component {
+const TASK_TEMPLATE = xml/* xml */ `
-  static template = xml/* xml */ `
     <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
-      <input type="checkbox" t-att-checked="props.task.isCompleted" t-on-click="() => store.toggleTask(props.task)"/>
+        <input type="checkbox" t-att-checked="props.task.isCompleted"
-      <span><t t-esc="props.task.text"/></span>
+                t-on-click="dispatch('toggleTask', props.task.id)"/>
-      <span class="delete" t-on-click="() => store.deleteTask(props.task)">🗑</span>
+        <span><t t-esc="props.task.title"/></span>
+        <span class="delete" t-on-click="dispatch('deleteTask', props.task.id)">🗑</span>
     </div>`;
 
+class Task extends Component {
+  static template = TASK_TEMPLATE;
   static props = ["task"];
-
+  dispatch = useDispatch();
-  setup() {
-    this.store = useStore();
-  }
 }
 
 // -------------------------------------------------------------------------
-// Root Component
+// App Component
 // -------------------------------------------------------------------------
-class Root extends Component {
+const APP_TEMPLATE = xml/* xml */ `
-  static template = xml/* xml */ `
     <div class="todo-app">
-      <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
+        <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
-      <div class="task-list">
+        <div class="task-list">
-        <t t-foreach="store.tasks" t-as="task" t-key="task.id">
+            <t t-foreach="tasks" t-as="task" t-key="task.id">
-          <Task task="task"/>
+                <Task task="task"/>
-        </t>
+            </t>
-      </div>
+        </div>
     </div>`;
+
+class App extends Component {
+  static template = APP_TEMPLATE;
   static components = { Task };
 
-  setup() {
+  inputRef = useRef("add-input");
-    const inputRef = useRef("add-input");
+  tasks = useStore((state) => state.tasks);
-    onMounted(() => inputRef.el.focus());
+  dispatch = useDispatch();
-    this.store = useStore();
+
+  mounted() {
+    this.inputRef.el.focus();
   }
 
   addTask(ev) {
     // 13 is keycode for ENTER
     if (ev.keyCode === 13) {
-      this.store.addTask(ev.target.value);
+      this.dispatch("addTask", ev.target.value);
       ev.target.value = "";
     }
   }
 }
 
 // -------------------------------------------------------------------------
-// Setup
+// Setup code
 // -------------------------------------------------------------------------
-const env = {
+function setup() {
-  store: createTaskStore(),
+  owl.config.mode = "dev";
-};
+  const store = new Store({ actions, state: initialState });
-mount(Root, document.body, { dev: true, env });
+  App.env.store = store;
+  mount(App, { target: document.body });
+}
+
+whenReady(setup);
 ```
 
-## 11. Saving tasks in local storage
+## 11-Saving tasks in local storage
 
 Now, our TodoApp works great, except if the user closes or refresh the browser!
 It is really inconvenient to only keep the state of the application in memory.
 To fix this, we will save the tasks in the local storage. With our current
-codebase, it is a simple change: we need to save tasks to local storage and
+codebase, it is a simple change: only the setup code needs to be updated.
-listen to any change.
 
 ```js
-class TaskList {
+function makeStore() {
-  constructor(tasks) {
+  const localState = window.localStorage.getItem("todoapp");
-    this.tasks = tasks || [];
+  const state = localState ? JSON.parse(localState) : initialState;
-    const taskIds = this.tasks.map((t) => t.id);
+  const store = new Store({ state, actions });
-    this.nextId = taskIds.length ? Math.max(...taskIds) + 1 : 1;
+  store.on("update", null, () => {
-  }
+    localStorage.setItem("todoapp", JSON.stringify(store.state));
-  // ...
+  });
+  return store;
 }
 
-function createTaskStore() {
+function setup() {
-  const saveTasks = () => localStorage.setItem("todoapp", JSON.stringify(taskStore.tasks));
+  owl.config.mode = "dev";
-  const initialTasks = JSON.parse(localStorage.getItem("todoapp") || "[]");
+  const env = { store: makeStore() };
-  const taskStore = reactive(new TaskList(initialTasks), saveTasks);
+  mount(App, { target: document.body, env });
-  saveTasks();
-  return taskStore;
 }
 ```
 
-The key point is that the `reactive` function takes a callback that will be called
+The key point is to use the fact that the store is an
-every time an observed value is changed. Note that we need to call the `saveTasks`
+[`EventBus`](../reference/event_bus.md) which triggers an `update` event
-method initially to make sure we observe all current values.
+whenever it is updated.
 
 ## 12. Filtering tasks
 
 We are almost done, we can add/update/delete tasks. The only missing feature is
 the possibility to display the task according to their completed status. We will
-need to keep track of the state of the filter in `Root`, then filter the visible
+need to keep track of the state of the filter in `App`, then filter the visible
 tasks according to its value.
 
 ```js
-class Root extends Component {
+// on top of file, readd useState:
-  static template = xml /* xml */`
+const { useRef, useDispatch, useState, useStore } = owl.hooks;
-    <div class="todo-app">
+
-      <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
+// in App:
-      <div class="task-list">
+filter = useState({value: "all"})
+
+get displayedTasks() {
+    switch (this.filter.value) {
+        case "active": return this.tasks.filter(t => !t.isCompleted);
+        case "completed": return this.tasks.filter(t => t.isCompleted);
+        case "all": return this.tasks;
+    }
+}
+
+setFilter(filter) {
+    this.filter.value = filter;
+}
+```
+
+Finally, we need to display the visible filters. We can do that, and at the
+same time, display the number of tasks in a small panel below the main list:
+
+```xml
+<div class="todo-app">
+    <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
+    <div class="task-list">
         <t t-foreach="displayedTasks" t-as="task" t-key="task.id">
-          <Task task="task"/>
+            <Task task="task"/>
         </t>
-      </div>
+    </div>
-      <div class="task-panel" t-if="store.tasks.length">
+    <div class="task-panel" t-if="tasks.length">
         <div class="task-counter">
-          <t t-esc="displayedTasks.length"/>
+            <t t-esc="displayedTasks.length"/>
-          <t t-if="displayedTasks.length lt store.tasks.length">
+            <t t-if="displayedTasks.length lt tasks.length">
-              / <t t-esc="store.tasks.length"/>
+                / <t t-esc="tasks.length"/>
-          </t>
+            </t>
-          task(s)
+            task(s)
         </div>
         <div>
-          <span t-foreach="['all', 'active', 'completed']"
+            <span t-foreach="['all', 'active', 'completed']"
-            t-as="f" t-key="f"
+                t-as="f" t-key="f"
-            t-att-class="{active: filter.value===f}"
+                t-att-class="{active: filter.value===f}"
-            t-on-click="() => this.setFilter(f)"
+                t-on-click="setFilter(f)"
-            t-esc="f"/>
+                t-esc="f"/>
         </div>
-      </div>
+    </div>
-    </div>`;
+</div>
-
-  setup() {
-    ...
-    this.filter = useState({ value: "all" });
-  }
-
-  get displayedTasks() {
-    const tasks = this.store.tasks;
-    switch (this.filter.value) {
-      case "active": return tasks.filter(t => !t.isCompleted);
-      case "completed": return tasks.filter(t => t.isCompleted);
-      case "all": return tasks;
-    }
-  }
-
-  setFilter(filter) {
-    this.filter.value = filter;
-  }
-}
 ```
 
 ```css
@@ -722,8 +753,8 @@ class Root extends Component {
 }
 ```
 
-Notice here that we set dynamically the css class of the filter with the object
+Notice here that we set dynamically the class of the filter with the object
-syntax.
+syntax: each key is a class that we want to set if its value is truthy.
 
 ## 13. The Final Touch
 
@@ -738,16 +769,16 @@ the user experience.
 }
 ```
 
-2. Make the text of a task clickable, to toggle its checkbox:
+2. Make the title of a task clickable, to toggle its checkbox:
 
 ```xml
 <input type="checkbox" t-att-checked="props.task.isCompleted"
     t-att-id="props.task.id"
     t-on-click="dispatch('toggleTask', props.task.id)"/>
-<label t-att-for="props.task.id"><t t-esc="props.task.text"/></label>
+<label t-att-for="props.task.id"><t t-esc="props.task.title"/></label>
 ```
 
-3. Strike the text of completed task:
+3. Strike the title of completed task:
 
 ```css
 .task.done label {
@@ -779,145 +810,142 @@ For reference, here is the final code:
 
 ```js
 (function () {
-  const { Component, mount, xml, useRef, onMounted, useState, reactive, useEnv } = owl;
+  const { Component, Store, mount } = owl;
+  const { xml } = owl.tags;
+  const { whenReady } = owl.utils;
+  const { useRef, useDispatch, useState, useStore } = owl.hooks;
 
   // -------------------------------------------------------------------------
   // Store
   // -------------------------------------------------------------------------
-  function useStore() {
+  const actions = {
-    const env = useEnv();
+    addTask({ state }, title) {
-    return useState(env.store);
+      title = title.trim();
-  }
+      if (title) {
-
-  // -------------------------------------------------------------------------
-  // TaskList
-  // -------------------------------------------------------------------------
-  class TaskList {
-    constructor(tasks) {
-      this.tasks = tasks || [];
-      const taskIds = this.tasks.map((t) => t.id);
-      this.nextId = taskIds.length ? Math.max(...taskIds) + 1 : 1;
-    }
-
-    addTask(text) {
-      text = text.trim();
-      if (text) {
         const task = {
-          id: this.nextId++,
+          id: state.nextId++,
-          text: text,
+          title: title,
           isCompleted: false,
         };
-        this.tasks.push(task);
+        state.tasks.push(task);
       }
-    }
+    },
-
+    toggleTask({ state }, id) {
-    toggleTask(task) {
+      const task = state.tasks.find((t) => t.id === id);
       task.isCompleted = !task.isCompleted;
-    }
+    },
+    deleteTask({ state }, id) {
+      const index = state.tasks.findIndex((t) => t.id === id);
+      state.tasks.splice(index, 1);
+    },
+  };
 
-    deleteTask(task) {
+  const initialState = {
-      const index = this.tasks.findIndex((t) => t.id === task.id);
+    nextId: 1,
-      this.tasks.splice(index, 1);
+    tasks: [],
-    }
+  };
-  }
-
-  function createTaskStore() {
-    const saveTasks = () => localStorage.setItem("todoapp", JSON.stringify(taskStore.tasks));
-    const initialTasks = JSON.parse(localStorage.getItem("todoapp") || "[]");
-    const taskStore = reactive(new TaskList(initialTasks), saveTasks);
-    saveTasks();
-    return taskStore;
-  }
 
   // -------------------------------------------------------------------------
   // Task Component
   // -------------------------------------------------------------------------
+  const TASK_TEMPLATE = xml/* xml */ `
+    <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
+        <input type="checkbox" t-att-checked="props.task.isCompleted"
+            t-att-id="props.task.id"
+            t-on-click="dispatch('toggleTask', props.task.id)"/>
+        <label t-att-for="props.task.id"><t t-esc="props.task.title"/></label>
+        <span class="delete" t-on-click="dispatch('deleteTask', props.task.id)">🗑</span>
+    </div>`;
+
   class Task extends Component {
-    static template = xml/* xml */ `
+    static template = TASK_TEMPLATE;
-      <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
-        <input type="checkbox"
-          t-att-id="props.task.id"
-          t-att-checked="props.task.isCompleted"
-          t-on-click="() => store.toggleTask(props.task)"/>
-        <label t-att-for="props.task.id"><t t-esc="props.task.text"/></label>
-        <span class="delete" t-on-click="() => store.deleteTask(props.task)">🗑</span>
-      </div>`;
-
     static props = ["task"];
-
+    dispatch = useDispatch();
-    setup() {
-      this.store = useStore();
-    }
   }
 
   // -------------------------------------------------------------------------
-  // Root Component
+  // App Component
   // -------------------------------------------------------------------------
-  class Root extends Component {
+  const APP_TEMPLATE = xml/* xml */ `
-    static template = xml/* xml */ `
+    <div class="todo-app">
-      <div class="todo-app">
         <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
         <div class="task-list">
-          <t t-foreach="displayedTasks" t-as="task" t-key="task.id">
+            <Task t-foreach="displayedTasks" t-as="task" t-key="task.id" task="task"/>
-            <Task task="task"/>
-          </t>
         </div>
-        <div class="task-panel" t-if="store.tasks.length">
+        <div class="task-panel" t-if="tasks.length">
-          <div class="task-counter">
+            <div class="task-counter">
-            <t t-esc="displayedTasks.length"/>
+                <t t-esc="displayedTasks.length"/>
-            <t t-if="displayedTasks.length lt store.tasks.length">
+                <t t-if="displayedTasks.length lt tasks.length">
-                / <t t-esc="store.tasks.length"/>
+                    / <t t-esc="tasks.length"/>
-            </t>
+                </t>
-            task(s)
+                task(s)
-          </div>
+            </div>
-          <div>
+            <div>
-            <span t-foreach="['all', 'active', 'completed']"
+                <span t-foreach="['all', 'active', 'completed']"
-              t-as="f" t-key="f"
+                    t-as="f" t-key="f"
-              t-att-class="{active: filter.value===f}"
+                    t-att-class="{active: filter.value===f}"
-              t-on-click="() => this.setFilter(f)"
+                    t-on-click="setFilter(f)"
-              t-esc="f"/>
+                    t-esc="f"/>
-          </div>
+            </div>
         </div>
-      </div>`;
+    </div>`;
+
+  class App extends Component {
+    static template = APP_TEMPLATE;
     static components = { Task };
 
-    setup() {
+    inputRef = useRef("add-input");
-      const inputRef = useRef("add-input");
+    tasks = useStore((state) => state.tasks);
-      onMounted(() => inputRef.el.focus());
+    filter = useState({ value: "all" });
-      this.store = useStore();
+    dispatch = useDispatch();
-      this.filter = useState({ value: "all" });
+
+    mounted() {
+      this.inputRef.el.focus();
     }
 
     addTask(ev) {
       // 13 is keycode for ENTER
       if (ev.keyCode === 13) {
-        this.store.addTask(ev.target.value);
+        this.dispatch("addTask", ev.target.value);
         ev.target.value = "";
       }
     }
 
     get displayedTasks() {
-      const tasks = this.store.tasks;
       switch (this.filter.value) {
         case "active":
-          return tasks.filter((t) => !t.isCompleted);
+          return this.tasks.filter((t) => !t.isCompleted);
         case "completed":
-          return tasks.filter((t) => t.isCompleted);
+          return this.tasks.filter((t) => t.isCompleted);
         case "all":
-          return tasks;
+          return this.tasks;
       }
     }
-
     setFilter(filter) {
       this.filter.value = filter;
     }
   }
 
   // -------------------------------------------------------------------------
-  // Setup
+  // Setup code
   // -------------------------------------------------------------------------
-  const env = { store: createTaskStore() };
+  function makeStore() {
-  mount(Root, document.body, { dev: true, env });
+    const localState = window.localStorage.getItem("todoapp");
+    const state = localState ? JSON.parse(localState) : initialState;
+    const store = new Store({ state, actions });
+    store.on("update", null, () => {
+      localStorage.setItem("todoapp", JSON.stringify(store.state));
+    });
+    return store;
+  }
+
+  function setup() {
+    owl.config.mode = "dev";
+    const env = { store: makeStore() };
+    mount(App, { target: document.body, env });
+  }
+
+  whenReady(setup);
 })();
 ```
 

doc/miscellaneous/architecture.md

@@ -1,68 +0,0 @@
-# 🦉 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

@@ -14,7 +14,8 @@ discussed, feel free to open an issue/submit a PR to correct this text.
 - [Tooling/Build Step](#toolingbuild-step)
 - [Templating](#templating)
 - [Asynchronous rendering](#asynchronous-rendering)
-- [Reactivity](#reactivity)
+- [Reactiveness](#reactiveness)
+- [State Management](#state-management)
 - [Hooks](#hooks)
 
 ## Size
@@ -78,7 +79,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/templates.md#inline-templates) tag helper function, which makes use of
+example is the [`xml`](../reference/tags.md#xml-tag) 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 +127,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/templates.md#inline-templates) tag helper:
+[`xml`](../reference/tags.md#xml-tag) tag helper:
 
 ```js
 class Clock extends Component {
@@ -172,7 +173,7 @@ more convoluted. For example, in Vue, you need to use a dynamic import keyword
 that needs to be transpiled at build time in order for the component to be loaded
 asynchronously (see [the documentation](https://vuejs.org/v2/guide/components-dynamic-async.html#Async-Components)).
 
-## Reactivity
+## Reactiveness
 
 React has a simple model: whenever the state changes, it is
 replaced with a new state (via the `setState` method). Then, the DOM is patched.

doc/miscellaneous/compiled_template.md

@@ -1,98 +0,0 @@
-# 🦉 Notes On Owl Compiled Templates 🦉
-
-This page will explain what an Owl compiled template look like. This is a
-technical document intended for developers interested in understanding how Owl
-works internally.
-
-Broadly speaking, Owl compiles templates into a javascript function (a closure)
-that returns a function (the "render" function). The point of the closure is to
-have a place to store all values specific to the template (in particular, "blocks").
-Once a template is compiled, its closure function is called once to get the
-render function, and from then on, only the render function is used.
-
-The render function takes some context (and some additional information) and
-return a virtual dom representation of the rendered template, as a block tree.
-A block tree is a very light weight representation that only contains the dynamic
-part of the template, and its structure. It is actually independant of the
-static part of the templates (which are contained in the blocks captured by the
-closure). This means that the work performed at render time is only to collect
-dynamic data, and to describe the block structure of the result.
-
-It looks like this, in pseudo code:
-
-```js
-function closure(bdom, helpers) {
-    // here is some place to put stuff specific to the template, such as
-    // blocks
-    ...
-
-    return function render(context, node, key) {
-        // only build here all dynamic parts of the template
-        // build a block tree
-        return tree;
-    }
-}
-```
-
-Now, let us see an example. Consider the following template:
-
-```xml
-<div class="some-class">
-    <div class="blabla">
-        <span><t t-esc="state.value"/></span>
-    </div>
-    <t t-if="state.info">
-        <p class="info" t-att-class="someAttribute">
-            <t t-esc="state.info"/>
-        </p>
-    </t>
-    <SomeComponent value="value"/>
-</div>
-```
-
-If you look carefully, there are 5 dynamic things:
-
-- a text value (the first `t-esc`),
-- a sub block (the `t-if`),
-- a dynamic attribute (the `t-att-class` attribute),
-- another text value (the second `t-esc`),
-- and finally, a sub component
-
-Here is the compiled code for this template:
-
-```js
-function closure(bdom, helpers) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-
-  let block1 = createBlock(
-    `<div class="some-class"><div class="blabla"><span><block-text-0/></span></div><block-child-0/><block-child-1/></div>`
-  );
-  let block2 = createBlock(`<p class="info" block-attribute-0="class"><block-text-1/></p>`);
-
-  return function render(ctx, node, key = "") {
-    let b2, b3;
-    let txt1 = ctx["state"].value;
-    if (ctx["state"].info) {
-      let attr1 = ctx["someAttribute"];
-      let txt2 = ctx["state"].info;
-      b2 = block2([attr1, txt2]);
-    }
-    b3 = component(`SomeComponent`, { value: ctx["value"] }, key + `__1`, node, ctx);
-    return block1([txt1], [b2, b3]);
-  };
-}
-```
-
-The values captured in the closure capture the static part of the template: we
-define here two blocks (which contains a template node, that can be deep cloned
-whenever a block is mounted). Then the render function only describes the block
-tree structure of the result, depending on the context. This means that we
-minimize the amount of work done at render time.
-
-Then, when we want to patch the dom, Owl will uses the `patch` function from
-blockdom, which then will diff the block tree, and deep clone new blocks whenever
-a new block is inserted, keep track of dynamic parts of each block, and update
-them accordingly.
-
-With this design, the cost of rendering a template is proportional to the number
-of dynamic values, and not to the size of the template.

doc/miscellaneous/rendering.md

@@ -0,0 +1,32 @@
+# 🦉 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

@@ -0,0 +1,18 @@
+# 🦉 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

@@ -1,48 +1,55 @@
-# 🦉 Owl overview 🦉
+# 🦉 OWL Documentation 🦉
 
-Here is a list of everything exported by the Owl library:
+## Learning Owl
 
-Main entities:
+Are you new to Owl? This is the place to start!
 
-- [`App`](reference/app.md): represent an Owl application (mainly a root component,a set of templates, and a config)
+- [Tutorial: create a TodoList application](learning/tutorial_todoapp.md)
-- [`Component`](reference/component.md): the main class to define a concrete Owl component
+- [Quick Overview](learning/overview.md)
-- [`mount`](reference/app.md#mount-helper): main entry point for most application: mount a component to a target
+- [How to start an Owl project](learning/quick_start.md)
-- [`xml`](reference/templates.md#inline-templates): helper to define an inline template
+- [How to test Components](learning/how_to_test.md)
+- [How to write Single File Components](learning/how_to_write_sfc.md)
+- [How to write debug Owl applications](learning/how_to_debug.md)
 
-Reactivity
+## Reference
 
-- [`useState`](reference/reactivity.md#usestate): create a reactive object (hook, linked to a specific component)
+You will find here a complete reference of every feature, class or object
-- [`reactive`](reference/reactivity.md#reactive): create a reactive object (not linked to any component)
+provided by Owl.
-- [`markRaw`](reference/reactivity.md#markraw): mark an object or array so that it is ignored by the reactivity system
-- [`toRaw`](reference/reactivity.md#toraw): given a reactive objet, return the raw (non reactive) underlying object
 
-Lifecycle hooks:
+- [Animations](reference/animations.md)
+- [Browser](reference/browser.md)
+- [Component](reference/component.md)
+- [Content](reference/content.md)
+- [Concurrency Model](reference/concurrency_model.md)
+- [Configuration](reference/config.md)
+- [Context](reference/context.md)
+- [Environment](reference/environment.md)
+- [Event Bus](reference/event_bus.md)
+- [Event Handling](reference/event_handling.md)
+- [Error Handling](reference/error_handling.md)
+- [Hooks](reference/hooks.md)
+- [Mounting a component](reference/mounting.md)
+- [Miscellaneous Components](reference/misc.md)
+- [Observer](reference/observer.md)
+- [Props](reference/props.md)
+- [Props Validation](reference/props_validation.md)
+- [QWeb Templating Language](reference/qweb_templating_language.md)
+- [QWeb Engine](reference/qweb_engine.md)
+- [Slots](reference/slots.md)
+- [Tags](reference/tags.md)
+- [Utils](reference/utils.md)
 
-- [`onWillStart`](reference/component.md#willstart): hook to define asynchronous code that should be executed before component is rendered
+## Other Topics
-- [`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:
+This section provides miscellaneous document that explains some topics
+which cannot be considered either a tutorial, or reference documentation.
 
-- [`useComponent`](reference/hooks.md#usecomponent): return a reference to the current component (useful to create derived hooks)
+- [Owl architecture: the Virtual DOM](miscellaneous/vdom.md)
-- [`useEffect`](reference/hooks.md#useeffect): define an effect with its dependencies
+- [Owl architecture: the rendering pipeline](miscellaneous/rendering.md)
-- [`useEnv`](reference/hooks.md#useenv): return a reference to the current env
+- [Comparison with React/Vue](miscellaneous/comparison.md)
-- [`useExternalListener`](reference/hooks.md#useexternallistener): add a listener outside of a component DOM
+- [Why did Odoo built Owl?](miscellaneous/why_owl.md)
-- [`useRef`](reference/hooks.md#useref): get an object representing a reference (`t-ref`)
-- [`useChildSubEnv`](reference/hooks.md#usesubenv-and-usechildsubenv): extend the current env with additional information (for child components)
-- [`useSubEnv`](reference/hooks.md#usesubenv-and-usechildsubenv): extend the current env with additional information (for current component and child components)
 
-Utility/helpers:
+---
 
-- [`EventBus`](reference/utils.md#eventbus): a simple event bus
+Found an issue in the documentation? A broken link? Some outdated information?
-- [`loadFile`](reference/utils.md#loadfile): an helper to load a file from the server
+Please open an issue or submit a PR!
-- [`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

@@ -0,0 +1,127 @@
+# 🦉 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

@@ -1,112 +0,0 @@
-# 🦉 App 🦉
-
-## Content
-
-- [Overview](#overview)
-- [API](#api)
-- [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.
-
-## API
-
-- **`constructor(Root[, config])`**: first argument should be a component class (not
-  an instance), and the optional second argument is a configuration object (see below).
-
-- **`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
-
-## Configuration
-
-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)
-- **`test (boolean, default=false)`**: `test` mode is the same as `dev` mode, except
-  that Owll will not log a message to warn that Owl is 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` 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

@@ -0,0 +1,33 @@
+# 🦉 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
-asynchronous hooks, it is possible to build complex highly concurrent applications.
+methods, 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,8 +35,7 @@ two phases: _virtual rendering_ and _patching_.
 
 ### Virtual rendering
 
-This phase represent the process of rendering a template, in memory, which creates
+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
-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`
@@ -95,7 +94,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: updating a component**. Now, let's assume that the user clicked on some
+**Scenario 2: rerendering 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`,
@@ -137,7 +136,8 @@ 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`.
+only one currently available tag: `xml`, but we plan to add other tags later,
+such as a `css` tag, which will be used to write [single file components](../learning/how_to_write_sfc.md).
 
 ### Asynchronous Rendering
 
@@ -160,4 +160,22 @@ 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.
+   second, and only once (see [`owl.utils.loadJS`](utils.md#loadjs))
+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

@@ -0,0 +1,44 @@
+# 🦉 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

@@ -0,0 +1,36 @@
+# 🦉 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 a shared object given to all components in a tree. It is not
+An environment is an object which contains a [`QWeb` instance](qweb_engine.md). Whenever
-used by Owl itself, but it is useful for application developers to provide a
+a root component is created, it is assigned an environment (see
-simple communication channel between components (in addition to the props).
+[below](#setting-an-environment) for more info on this). This environment is
-
+then automatically given to each sub component (and accessible in the `this.env`
-The `env` given to the [`App`](app.md) is assigned to the `env` component
+property).
-property.
 
 ```
     Root
@@ -22,14 +22,31 @@ property.
    A    B
 ```
 
-Also, the `env` object is frozen when the application is started. This is done
+This way, all components share the same `QWeb` instance. Owl internally requires
-to ensure a simpler mental model of what's happening in runtime. Note that it
+that the environment has a `qweb` key which maps to a
-is only shallowly frozen, so sub objects can be modified.
+[`QWeb`](qweb_engine.md) instance. This is the QWeb instance that will be used to
+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
 
-The correct way to customize an environment is to simply give it to the `App`,
+An Owl application needs an [environment](environment.md) to be executed. The
-whenever it is created.
+environment has an important key: the [QWeb](qweb_engine.md) instance, which will render
+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 = {
@@ -39,38 +56,81 @@ 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,
 from the perspective of a specific component and its children. In that case, the
 solution presented above will not work, since it sets the global environment.
 
-There are two hooks for this situation: [`useSubEnv` and `useChildSubEnv`](hooks.md#usesubenv-and-usechildsubenv).
+There is a hook for this situation: [`useSubEnv`](hooks.md#usesubenv).
 
 ```js
-class SomeComponent extends Component {
+class FormComponent extends Component {
-  setup() {
+  constructor(parent, props) {
-    useSubEnv({ myKey: someValue }); // myKey is now available for all child components
+    super(parent, props);
+    useSubEnv({ myKey: someValue });
   }
 }
 ```
 
 ## Content of an Environment
 
-The `env` object content is totally up to the application developer. However,
+Some good use cases for additional keys in the environment are:
-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,30 +3,60 @@
 ## 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 feedback.
+without any user-visible state.
 
-Clearly, it is usually a little bit extreme to destroy the application. This
+Clearly, it sometimes is a little bit extreme to destroy the application. This
-is why we need a mechanism to handle rendering errors (and errors coming
+is why we have a builtin mechanism to handle rendering errors (and errors coming
-from lifecycle hooks): the `onError` hook.
+from lifecycle hooks): the `catchError` hook.
 
-The main idea is that the `onError` hook register a function that will be called
+## Example
-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.
 
-## Managing Errors
+For example, here is how we could implement an `ErrorBoundary` component:
 
-Whenever the `onError` lifecycle hook is used, all errors coming from
+```xml
+<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 `onError` method. This allows us to properly handle the error, and to
+to the `catchError` method. This allows us to properly handle the error, and to
 not break the application.
 
 There are important things to know:
@@ -35,41 +65,17 @@ 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 `onError` or any other
+- errors coming from event handlers are NOT managed by `catchError` or any other
   owl mechanism. This is up to the application developer to properly recover
   from an error
 
-- if an error handler is unable to properly handle an error, it can just rethrow
+Also, it may be useful to know that whenever an error is caught, it is then
-  an error, and Owl will try looking for another error handler up the component
+broadcasted to the application by an event on the `qweb` instance. It may be
-  tree.
+useful, for example, to log the error somewhere.
-
-## 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
-class ErrorBoundary extends Component {
+env.qweb.on("error", null, function (error) {
-  static template = xml`
+  // do something
-    <t t-if="error" t-slot="fallback">An error occurred</t>
+  // react to the error
-    <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_bus.md

@@ -0,0 +1,25 @@
+# 🦉 Event Bus 🦉
+
+It is sometimes useful to use a `Bus` to communicate informations between various
+parts of the code. Owl has a very simple bus class, which manages subscriptions,
+triggering events, and callbacks.
+
+```js
+const bus = new owl.core.EventBus();
+
+bus.on("some-event", null, function (...args) {
+  console.log(...args);
+});
+
+bus.trigger("some-event", 1, 2, 3);
+// [1,2,3] will be logged to the console
+```
+
+Its API is:
+
+| Method                           | Description                       |
+| -------------------------------- | --------------------------------- |
+| `on(eventType, owner, callback)` | add a listener                    |
+| `off(eventType, owner)`          | remove all listeners for an owner |
+| `trigger(eventType, ...args)`    | trigger an event                  |
+| `clear`                          | remove all subscriptions          |

doc/reference/event_handling.md

@@ -3,14 +3,22 @@
 ## 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_. This
+elements to some specific events. This is what makes a template _alive_. There
-is done with the `t-on` directive. For example:
+are four different use cases.
+
+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>
@@ -23,28 +31,93 @@ button.addEventListener("click", component.someMethod.bind(component));
 ```
 
 The suffix (`click` in this example) is simply the name of the actual DOM
-event. The value of the `t-on` expression should be a valid javascript expression
+event.
-that evaluates to a function in the context of the current component. So, one
+
-can get a reference to the event, or pass some additional arguments. For example,
+## Business DOM Events
-all the following expressions are valid:
+
+A _business_ DOM event is triggered by a call to `trigger` on a component.
 
 ```xml
-<button t-on-click="someMethod">Do something</button>
+<MyComponent t-on-menu-loaded="someMethod" />
-<button t-on-click="() => this.increment(3)">Add 3</button>
-<button t-on-click="ev => this.doStuff(ev, 'value')">Do something</button>
 ```
 
-Notice the use of the `this` keyword in the lambda function: this is the
+```js
-correct way to call a method on the component in a lambda function.
+ class MyComponent {
+     someWhere() {
+         const payload = ...;
+         this.trigger('menu-loaded', payload);
+     }
+ }
+```
 
-One could use the following expression:
+The call to `trigger` generates an `OwlEvent`, a subclass of [_CustomEvent_](https://developer.mozilla.org/docs/Web/Guide/Events/Creating_and_triggering_events)
+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="() => increment(3)">Add 3</button>
+<button t-on-click="someMethod(expr)">Do something</button>
 ```
 
-But then, the increment function may be unbound (unless the component binds it
+Here, `expr` is a valid Owl expression, so it could be `true` or some variable
-in its setup function, for example).
+from the rendering context.
+
+### 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
 
@@ -52,13 +125,12 @@ 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>
@@ -77,26 +149,3 @@ 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,17 +3,24 @@
 ## Content
 
 - [Overview](#overview)
-- [The Hook Rule](#the-hook-rule)
+- [Example: Mouse Position](#example-mouse-position)
-- [Lifecycle hooks](#lifecycle-hooks)
+- [Example: Autofocus](#example-autofocus)
-- [Other hooks](#other-hooks)
+- [Reference](#reference)
+  - [One Rule](#one-rule)
   - [`useState`](#usestate)
+  - [`onMounted`](#onmounted)
+  - [`onWillUnmount`](#onwillunmount)
+  - [`onWillPatch`](#onwillpatch)
+  - [`onPatched`](#onpatched)
+  - [`onWillStart`](#onwillstart)
+  - [`onWillUpdateProps`](#onwillupdateprops)
+  - [`useContext`](#usecontext)
   - [`useRef`](#useref)
-  - [`useSubEnv` and `useChildSubEnv`](#usesubenv-and-usechildsubenv)
+  - [`useSubEnv`](#usesubenv)
   - [`useExternalListener`](#useexternallistener)
   - [`useComponent`](#usecomponent)
   - [`useEnv`](#useenv)
-  - [`useEffect`](#useeffect)
+  - [Making customized hooks](#making-customized-hooks)
-- [Example: Mouse Position](#example-mouse-position)
 
 ## Overview
 
@@ -32,9 +39,96 @@ 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.
 
-## The Hook Rule
+## Example: mouse position
 
-There is only one rule: every hook for a component has to be called in the _setup_ method, or in class fields:
+Here is the classical example of a non trivial hook to track the mouse position.
+
+```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
@@ -42,6 +136,14 @@ 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() {
@@ -57,24 +159,15 @@ class SomeComponent extends Component {
 }
 ```
 
-## Lifecycle Hooks
+As you can see, the `useState` hook does not need to be given a reference to
+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.
 
-All lifecycle hooks are documented in detail in their specific [section](component.md#lifecycle).
+Hooks need to be called in the constructor to ensure that this reference is
-
+properly set. This is also a good thing for performance reasons (Owl can use
-| Hook                                                  | Description                                                            |
+this to optimize its implementation), and for a clean architecture (this makes
-| ----------------------------------------------------- | ---------------------------------------------------------------------- |
+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`
 
@@ -85,9 +178,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, Component } = owl;
+const { useState } = owl.hooks;
 
-class Counter extends Component {
+class Counter extends owl.Component {
   static template = xml`
     <button t-on-click="increment">
         Click Me! [<t t-esc="state.value"/>]
@@ -104,38 +197,128 @@ class Counter extends 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 only work on a html element tagged by the
+of a component, rendered by Owl. It can work either on a DOM node, or on a component,
-`t-ref` directive:
+tagged by the `t-ref` directive:
 
 ```xml
 <div>
-    <input t-ref="someDiv"/>
+    <div t-ref="someDiv"/>
-    <span>hello</span>
+    <SubComponent t-ref="someComponent"/>
 </div>
 ```
 
 In this example, the component will be able to access the `div` and the component
-`SubComponent` with the `useRef` hook:
+`SubComponent` using the `useRef` hook:
 
 ```js
 class Parent extends Component {
-  inputRef = useRef("someComponent");
+  subRef = useRef("someComponent");
+  divRef = useRef("someDiv");
 
   someMethod() {
     // here, if component is mounted, refs are active:
-    // - this.inputRef.el is the input HTMLElement
+    // - this.divRef.el is the div 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, the actual HTMLElement instance is accessed with
+As shown by the example above, html elements are accessed by using the `el`
-the `el` key.
+key, and components references are accessed with `comp`.
+
+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-`](templates.md#dynamic-attributes) and
+(like the [`t-attf-`](qweb_templating_language.md#dynamic-attributes) and
 `t-component` directives). For example,
 
 ```xml
@@ -152,41 +335,31 @@ this.ref2 = useRef("component_2");
 References are only guaranteed to be active while the parent component is mounted.
 If this is not the case, accessing `el` or `comp` on it will return `null`.
 
-### `useSubEnv` and `useChildSubEnv`
+### `useSubEnv`
 
 The environment is sometimes useful to share some common information between
 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 `useChildSubEnv` hook may be useful: it lets a component add some
+This is where the `useSubEnv` hook may be useful: it lets a component add some
-information to the environment in a way that only its children
+information to the environment in a way that only the component and its children
 can access it:
 
 ```js
 class FormComponent extends Component {
-  setup() {
+  constructor(...args) {
+    super(...args);
     const model = makeModel();
-    // model will be available on this.env for this component and all children
     useSubEnv({ model });
-    // someKey will be available on this.env for all children
-    useChildSubEnv({ someKey: "value" });
   }
 }
 ```
 
-The `useSubEnv` and `useChildSubEnv` hooks take one argument: an object which
+The `useSubEnv` takes one argument: an object which contains some key/value that
-contains some key/value that will be added to the current environment. These hooks
+will be added to the parent environment. Note that it will extend, not replace
-will create a new env object with the new information:
+the parent environment. And of course, the parent environment will not be
-
+affected.
-- `useSubEnv` will assign this new `env` to itself and to all children components
-- `useChildSubEnv` will only assign this new `env` to all children components.
-
-As usual in Owl, [environments](environment.md) created with these two hooks are
-frozen, to prevent unwanted modifications.
-
-Note that both these hooks can be called an arbitrary number of times. The `env`
-will then be updated accordingly.
 
 ### `useExternalListener`
 
@@ -199,126 +372,65 @@ to be closed:
 useExternalListener(window, "click", this.closeMenu);
 ```
 
-### `useComponent`
+### Making customized hooks
 
-The `useComponent` hook is useful as a building block for some customized hooks,
+Hooks are a wonderful way to organize the code of a complex component by feature
-that may need a reference to the component calling them.
+instead of by lifecycle methods. They are like mixins, except that they can be
+easily composed together.
 
-```js
+But, like every good things in life, hooks should be used with moderation. They are
-function useSomething() {
+not the solution to every problem.
-  const component = useComponent();
-  // now, component is bound to the instance of the current component
-}
-```
 
-### `useEnv`
+- they may be overkill: if your component needs to perform some action specific
+  to itself (so, the specific code does not need to be shared), there is nothing
+  wrong with a simple class method:
 
-The `useEnv` hook is useful as a building block for some customized hooks,
+  ```js
-that may need a reference to the env of the component calling them.
+  // maybe overkill
-
+  class A extends Component {
-```js
+    constructor(...args) {
-function useSomething() {
+      super(...args);
-  const env = useEnv();
+      useMySpecificHook();
-  // now, env is bound to the env of the current component
+    }
-}
-```
-
-### `useEffect`
-
-This hook will run a callback when a component is mounted and patched, and
-will run a cleanup function before patching and before unmounting the
-the component (only if some dependencies have changed).
-
-It has almost the same API as the React `useEffect` hook, except that the dependencies
-are defined by a function instead of just the dependencies.
-
-The `useEffect` hook takes two function: the effect function and the dependency
-function. The effect function perform some task and return (optionally) a cleanup
-function. The dependency function returns a list of dependencies. If any of these
-dependencies changes, then the current effect will be cleaned up and reexecuted.
-
-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");
   }
-}
-```
 
-## Example: mouse position
+  // ok
-
+  class B extends Component {
-Here is the classical example of a non trivial hook to track the mouse position.
+    constructor(...args) {
-
+      super(...args);
-```js
+      this.performSpecificTask();
-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);
-  });
 
-  return position;
+  Note that the second solution is easier to extend in sub components.
-}
 
-// Main root component
+- they may be harder to test: if a customized hook injects some external side
-class Root extends Component {
+  effect dependency, then it is harder to test without doing some non obvious
-  static template = xml`<div>Mouse: <t t-esc="mouse.x"/>, <t t-esc="mouse.y"/></div>`;
+  manipulation. For example, assume that we want to give a reference to a
+  router in a `useRouter` hook. We could do this:
 
-  // this hooks is bound to the 'mouse' property.
+  ```js
-  mouse = useMouse();
+  const router = new Router(...);
-}
-```
 
-Note that we use the prefix `use` for hooks, just like in React. This is just
+  function useRouter() {
-a convention.
+      return router;
+  }
+  ```
+
+  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

@@ -1,92 +0,0 @@
-# 🦉 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

@@ -0,0 +1,133 @@
+# 🦉 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

@@ -0,0 +1,60 @@
+# 🦉 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

@@ -0,0 +1,52 @@
+# 🦉 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

@@ -1,17 +0,0 @@
-# 🦉 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,11 +4,8 @@
 
 - [Overview](#overview)
 - [Definition](#definition)
-- [Binding function props](#binding-function-props)
-- [Dynamic Props](#dynamic-props)
-- [Default Props](#default-props)
-- [Props validation](#props-validation)
 - [Good Practices](#good-practices)
+- [Dynamic Props](#dynamic-props)
 
 ## Overview
 
@@ -41,6 +38,8 @@ 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:
 
@@ -48,6 +47,7 @@ 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,193 +55,7 @@ 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.
-  - `optional`: if true, the prop is not mandatory
-
-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.
-
-Note that default values cannot be defined for a mandatory props. Doing so will
-result in a prop validation error.
-
-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],
-   optionalProp: { type: Number, optional: true }
-  };
-
-  ...
-}
-```
-
-```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
 
@@ -264,3 +78,20 @@ 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

@@ -0,0 +1,103 @@
+# 🦉 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

@@ -0,0 +1,153 @@
+# 🦉 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/qweb_templating_language.md

@@ -1,11 +1,12 @@
-# 🦉 Templates 🦉
+# 🦉 QWeb Templating Language🦉
 
 ## Content
 
 - [Overview](#overview)
 - [Directives](#directives)
-- [QWeb Template reference](#qweb-template-reference)
+- [Reference](#reference)
   - [White Spaces](#white-spaces)
+  - [Root Nodes](#root-nodes)
   - [Expression Evaluation](#expression-evaluation)
   - [Static html Nodes](#static-html-nodes)
   - [Outputting Data](#outputting-data)
@@ -15,20 +16,17 @@
   - [Dynamic Class Attribute](#dynamic-class-attribute)
   - [Dynamic Tag Names](#dynamic-tag-names)
   - [Loops](#loops)
-  - [Sub Templates](#sub-templates)
+  - [Rendering Sub Templates](#rendering-sub-templates)
   - [Dynamic Sub Templates](#dynamic-sub-templates)
+  - [Translations](#translations)
   - [Debugging](#debugging)
-- [Fragments](#fragments)
-- [Inline templates](#inline-templates)
-- [Rendering svg](#rendering-svg)
-- [Restrictions](#restrictions)
 
 ## Overview
 
-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
+[QWeb](https://www.odoo.com/documentation/13.0/reference/qweb.html) is the primary
+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. Also, since Owl is a live
+generate a virtual dom representation of the HTML.
-component system, there are additional directives specific to Owl (such as `t-on`).
 
 ```xml
 <div>
@@ -55,33 +53,34 @@ 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-out`                        | [Outputting value, possibly without escaping](#outputting-data) |
+| `t-raw`                        | [Outputting value, 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](#sub-templates)                       |
+| `t-call`                       | [Rendering sub templates](#rendering-sub-templates)            |
-| `t-debug`, `t-log`             | [Debugging](#debugging)                                         |
+| `t-debug`, `t-log`             | [Debugging](#debugging)                                        |
-| `t-translation`                | [Disabling the translation of a node](translations.md)          |
+| `t-translation`                | [Disabling the translation of a node](#translations)           |
+| `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#sub-components)         |
+| `t-component`, `t-props` | [Defining a sub component](component.md#composition)                            |
-| `t-ref`                                | [Setting a reference to a dom node or a sub component](refs.md) |
+| `t-ref`                  | [Setting a reference to a dom node or a sub component](component.md#references) |
-| `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-portal`                             | [Portal](portal.md)                                             |
+| `t-transition`           | [Defining an animation](animations.md#css-transitions)                          |
-| `t-slot`, `t-set-slot`, `t-slot-scope` | [Rendering a slot](slots.md)                                    |
+| `t-slot`                 | [Rendering a slot](slots.md)                                                    |
-| `t-model`                              | [Form input bindings](input_bindings.md)                        |
+| `t-model`                | [Form input bindings](component.md#form-input-bindings)                         |
-| `t-tag`                                | [Rendering nodes with dynamic tag name](#dynamic-tag-names)     |
+| `t-tag`                  | [Rendering nodes with dynamic tag name](#dynamic-tag-names)                     |
 
-## QWeb Template Reference
+## Reference
 
 ### White Spaces
 
@@ -91,6 +90,32 @@ 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
@@ -165,29 +190,24 @@ rendered with the value `value` set to `42` in the rendering context yields:
 <p>42</p>
 ```
 
-The `t-out` directive is almost the same as `t-esc`, but possibly without the
+The `t-raw` directive is almost the same as `t-esc`, but without the escaping.
-escaping. The difference is that the value received by the `t-out` directive
+This is mostly useful to inject a raw html string somewhere. Obviously, this
-will only be not-escaped if it has been marked as such, using the `markup`
+is unsafe to do in general, and should only be used for strings known to be safe.
-utility function:
 
-For example, in the following component:
+```xml
-
+<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>");
-}
 ```
 
-The first `t-out` will act as a `t-esc` directive, which means that the content
+rendered with the value `value` set to `<span>foo</span>` in the rendering context yields:
-of `value1` will be escaped. However, since `value2` has been tagged as a markup,
+
-this will be injected as html.
+```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
 
@@ -348,7 +368,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-key="i">
+<t t-foreach="[1, 2, 3]" t-as="i">
     <p><t t-esc="i"/></p>
 </t>
 ```
@@ -364,17 +384,13 @@ 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" t-key="i">
+<p t-foreach="[1, 2, 3]" t-as="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).
 
@@ -400,7 +416,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" t-key="i">
+<p t-foreach="Array(3)" t-as="i">
     <t t-set="existing_variable" t-value="true"/>
     <t t-set="new_variable" t-value="true"/>
     <!-- existing_variable and new_variable now true -->
@@ -414,14 +430,17 @@ 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 make sure we keep the actual DOM node instead of replacing it with
+algorithm to keep the actual DOM node as much as possible.
-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-key="item_index"><t t-esc="item.text"/></p>
+<p t-foreach="items" t-as="item"><t t-esc="item.text"/></p>
 ```
 
 The result will be two `<p>` tags with text `a` and `b`. Now, if we swap them,
@@ -482,7 +501,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.
 
-### Sub Templates
+### Rendering 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
@@ -555,6 +574,21 @@ 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:
@@ -577,117 +611,3 @@ 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.
-
-**Important note:** Owl needs to properly set the namespace for each svg elements.
-Since Owl compile each template separately, it is not able to determine easily
-if a template is supposed to be included in a svg namespace or not. Therefore,
-Owl depends on a heuristic: if a tag is either `svg`, `g` or `path`, then it will
-be considered as svg. In practice, this means that each component or each sub
-templates (included with `t-call`) should have one of these tag as root tag.
-
-## Restrictions
-
-Note that Owl templates forbid the use of tag and or attributes starting with
-the `block-` string. This restriction prevents name collision with the internal
-code of Owl.
-
-```xml
-<div><block-1>this will not be accepted by Owl</block-1></div>
-```

doc/reference/reactivity.md

@@ -1,131 +0,0 @@
-# 🦉 Reactivity 🦉
-
-## Content
-
-- [Overview](#overview)
-- [`useState`](#usestate)
-- [`reactive`](#reactive)
-- [`markRaw`](#markraw)
-- [`toRaw`](#toraw)
-
-## 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.
-
-Since version 2.0, Owl applies the fine grained reactivity at the component
-level: props are automatically turned into reactive object, so Owl can track
-which part of these props are consumed by each component, and is therefore able
-to only rerender the impacted components.
-
-## `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.
-
-## `markRaw`
-
-Marks an object so that it is ignored by the reactivity system. This function returns its argument.
-
-```js
-const someObject = markRaw(...);
-const state = useState({
-  a: 1,
-  obj: someObject
-});
-// here, state.obj === someObject
-```
-
-This is useful in some rare cases. For example, some complex and large object such
-that going through the reactivity system may cause a non trivial performance slowdown.
-
-However, use this function with caution: this is an escape hatch from the reactivity
-system, and as such, using it may cause subtle and unintended issues!
-
-## `toRaw`
-
-Given a reactive object, this function returns the underlying, non-reactive,
-corresponding object.
-
-```js
-// in setup
-const state = useState({ value: 1 });
-
-// later:
-const rawState = toRaw(this.state);
-rawState.value = 3; // will NOT be picked up by the reactivity system!!!
-```
-
-Here again, this is useful in some situations where we want to explicitely bypass
-Owl, but using this function means that the responsability of coordinating
-state update is given to the user code, instead of Owl. Subtle bugs may arise!
-
-Also, normal (non-reactive objects) will be directly returned by `toRaw`:
-
-```js
-const obj = { a: 1 };
-console.log(toRaw(obj) === obj); // true
-```

doc/reference/refs.md

@@ -1,37 +0,0 @@
-# 🦉 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,92 +3,71 @@
 ## Content
 
 - [Overview](#overview)
-- [Named slots](#named-slots)
+- [Example](#example)
-- [Rendering Context](#rendering-context)
+- [Reference](#reference)
-- [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 `Navbar`
+to make generic components. For example, imagine a generic `Dialog`
-component, which displays a navbar, but with some customizable content. Since
+component, which is able to display some arbitrary content.
-the specific content is only known to the user of the `Navbar`, it would be nice
+
-to specify it in the template where `Navbar` is used:
+Obviously, we want to use this component everywhere in our application, to
+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>
+<div t-name="Dialog" class="modal">
-    <Navbar>
+  <div class="modal-title"><t t-esc="props.title"/></div>
-      <span>Hello Owl</span>
+  <div class="modal-content">
-    </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>
 ```
 
-And one could use it with the `t-set-slot` directive:
+Slots are defined by the caller, with the `t-set-slot` directive:
 
 ```xml
-<InfoBox>
+<div t-name="SomeComponent">
-  <t t-set-slot="title">
+  <div>some component</div>
-    Specific Title. It could be html also.
+  <Dialog title="'Some Dialog'">
-  </t>
+    <t t-set-slot="content">
-  <t t-set-slot="content">
+      <div>hey</div>
-    <!-- some template here, with html, events, whatever -->
+    </t>
-  </t>
+    <t t-set-slot="footer">
-</InfoBox>
+      <button t-on-click="doSomething">ok</button>
+    </t>
+  </Dialog>
+</div>
 ```
 
-## Rendering context
+In this example, the component `Dialog` will render the slots `content` and `footer`
+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.
 
-The content of the slots is actually rendered with the rendering context corresponding
+Note: Owl previously used the `t-set` directive to define the content of a slot.
-to where it was defined, not where it is positioned. This allows the user to define
+This is deprecated and should no longer be used in new code.
-event handlers that will be bound to the correct component (usually, the
-grandparent of the slot content).
 
-## Default Slot
+## Reference
 
-All elements inside the component which are not a named slot will be treated as
+### Default Slot
-part of the content of the `default` slot. For example:
+
+The first element inside the component which is not a named slot will
+be considered the `default` slot. For example:
 
 ```xml
 <div t-name="Parent">
@@ -102,20 +81,7 @@ part of the content of the `default` slot. For example:
 </div>
 ```
 
-One can mix default slot and named slots:
+### Default content
-
-```xml
-<div>
-  <Child>
-    default content
-    <t t-set-slot="footer">
-      content for footer slot here
-    </t>
-  </Child>
-</div>
-```
-
-## Default content
 
 Slots can define a default content, in case the parent did not define them:
 
@@ -130,7 +96,12 @@ Slots can define a default content, in case the parent did not define them:
 <!-- will be rendered as: <div><span>default content</span></div> -->
 ```
 
-## Dynamic Slots
+Rendering context: the content of the slots is actually rendered with the
+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:
@@ -138,117 +109,3 @@ 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 params works like normal props, so one can use the `.bind` suffix to
-bind a function if needed.
-
-## Slot scopes
-
-For other kinds of advanced use cases, the content of a slot may depends on some
-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-slot-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
-<MyComponent>
-    <t t-set-slot="foo" t-slot-scope="scope">
-        content
-        <t t-esc="scope.bool"/>
-        <t t-esc="scope.num"/>
-    </t>
-</MyComponent>
-```
-
-And the child component that includes the slot can provide values like this:
-
-```xml
-<t t-slot="foo" bool="other_var" num="5">
-```
-
-In the case of the default slot, you may declare the slot scope directly on the
-component itself:
-
-```xml
-<MyComponent t-slot-scope="scope">
-    content
-    <t t-esc="scope.bool"/>
-    <t t-esc="scope.num"/>
-</MyComponent>
-```
-
-Slot values works like normal props, so one can use the `.bind` suffix to
-bind a function if needed.

doc/reference/tags.md

@@ -0,0 +1,184 @@
+# 🦉 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/translations.md

@@ -1,70 +0,0 @@
-# 🦉 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, translatableAttributes: ["data-title"] });
-// ...
-```
-
-It is also possible to remove an attribute from the default list by prefixing it with `-`:
-
-```js
-const app = new App(Root, {
-  templates,
-  tranaslateFn,
-  translatableAttributes: ["data-title", "-title"],
-});
-// data-title attribute will be translated, but not title attribute...
-```

doc/reference/utils.md

@@ -6,8 +6,11 @@ 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)
-- [`EventBus`](#eventbus): a simple EventBus
+- [`escape`](#escape): sanitizing strings
+- [`debounce`](#debounce): limiting rate of function calls
+- [`shallowEqual`](#shallowequal): shallow object comparison
 
 ## `whenReady`
 
@@ -16,20 +19,40 @@ 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
-const { whenReady } = owl;
+Promise.all([loadFile("templates.xml"), owl.utils.whenReady()]).then(function ([templates]) {
-
+  const qweb = new owl.QWeb({ templates });
-await whenReady();
+  const env = { qweb };
-// do something
+  await mount(App, { env, target: document.body });
+});
 ```
 
 or alternatively:
 
 ```js
-whenReady(function () {
+owl.utils.whenReady(function () {
-  // do something
+  const qweb = new owl.QWeb();
+  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
@@ -37,22 +60,89 @@ 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 loadFile("templates.xml");
+  const templates = await owl.utils.loadFile("templates.xml");
-  // do something
+  const qweb = new owl.QWeb({ templates });
+  return { qweb };
 }
 ```
 
-## `EventBus`
+Note that unlike `loadJS`, this function returns the content of the file as a
+string. It does not add a `script` tag or any other side effect.
 
-It is a simple `EventBus`, with the same API as usual DOM elements, and an
+## `escape`
-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
-const bus = new EventBus();
+class BadComponent extends Component {
-bus.addEventListener("event", () => console.log("something happened"));
+  // some template with a ref to a div
+  // some code ...
 
-bus.trigger("event"); // 'something happened' is logged
+  mounted() {
+    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

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "2.0.0-beta.1",
+  "version": "1.4.7",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "browser": "dist/owl.iife.js",
@@ -13,15 +13,15 @@
     "node": ">=12.18.3"
   },
   "scripts": {
-    "build:bundle": "rollup -c --failAfterWarnings",
+    "build:bundle": "rollup -c",
     "build": "npm run build:bundle",
     "test": "jest",
-    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --watch --testTimeout=5000000",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand --watch",
     "test:watch": "jest --watch",
-    "playground:serve": "python3 tools/server.py || python tools/server.py",
+    "tools:serve": "python3 tools/server.py || python tools/server.py",
-    "playground": "npm run build && npm run playground:serve",
+    "tools": "npm run build && npm run tools:serve",
-    "preplayground:watch": "npm run build",
+    "pretools:watch": "npm run build",
-    "playground:watch": "npm-run-all  --parallel playground:serve \"build:* -- --watch\"",
+    "tools:watch": "npm-run-all  --parallel tools:serve \"build:* -- --watch\"",
     "prettier": "prettier {src/*.ts,src/**/*.ts,tests/*.ts,tests/**/*.ts,doc/*.md,doc/**/*.md} --write",
     "check-formatting": "prettier {src/*.ts,src/**/*.ts,tests/*.ts,tests/**/*.ts,doc/*.md,doc/**/*.md} --check",
     "publish": "npm run build && npm publish",
@@ -46,14 +46,13 @@
     "git-rev-sync": "^1.12.0",
     "github-api": "^3.3.0",
     "jest": "^27.1.0",
-    "jest-diff": "^27.3.1",
     "jest-environment-jsdom": "^27.1.0",
     "live-server": "^1.2.1",
     "npm-run-all": "^4.1.5",
     "prettier": "2.4.1",
     "rollup": "^2.56.3",
     "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-typescript2": "^0.31.1",
+    "rollup-plugin-typescript2": "^0.30.0",
     "sass": "^1.16.1",
     "source-map-support": "^0.5.10",
     "ts-jest": "^27.0.5",

roadmap.md

@@ -1,6 +1,6 @@
 # 🦉 OWL Roadmap 🦉
 
-- Current version: 1.4.10
+- Current version: 1.4.7
 - Status: stable
 
 This roadmap is only an attempt at predicting Owl's future.  Everything may

src/app/app.ts

@@ -1,10 +1,8 @@
-import { Component, ComponentConstructor } from "../component/component";
+import { Component } from "../component/component";
 import { ComponentNode } from "../component/component_node";
 import { MountOptions } from "../component/fibers";
 import { Scheduler } from "../component/scheduler";
-import { TemplateSet, TemplateSetConfig } from "./template_set";
+import { TemplateSet } from "./template_set";
-import { nodeErrorHandlers } from "../component/error_handling";
-import { validateTarget } from "../utils";
 
 // reimplement dev mode stuff see last change in 0f7a8289a6fb8387c3c1af41c6664b2a8448758f
 
@@ -12,87 +10,58 @@ export interface Env {
   [key: string]: any;
 }
 
-export interface AppConfig<P, E> extends TemplateSetConfig {
+export interface AppConfig {
-  props?: P;
+  dev?: boolean;
-  env?: E;
+  env?: Env;
-  test?: boolean;
+  translatableAttributes?: string[];
+  translateFn?: (s: string) => string;
 }
 
-export const DEV_MSG = () => {
+export const DEV_MSG = `Owl is running in 'dev' mode.
-  const hash = (window as any).owl ? (window as any).owl.__info__.hash : "master";
-
-  return `Owl is running in 'dev' mode.
 
 This is not suitable for production use.
-See https://github.com/odoo/owl/blob/${hash}/doc/reference/app.md#configuration for more information.`;
+See https://github.com/odoo/owl/blob/master/doc/reference/config.md#mode for more information.`;
-};
 
-export class App<
+export class App<T extends typeof Component = any> extends TemplateSet {
-  T extends abstract new (...args: any) => any = any,
+  Root: T;
-  P extends object = any,
+  props: any;
-  E = any
+  env: Env = Object.freeze({});
-> extends TemplateSet {
+  scheduler = new Scheduler(window.requestAnimationFrame.bind(window));
-  static validateTarget = validateTarget;
+  root: ComponentNode | null = null;
 
-  Root: ComponentConstructor<P, E>;
+  constructor(Root: T, props?: any) {
-  props: P;
+    super();
-  env: E;
-  scheduler = new Scheduler();
-  root: ComponentNode<P, E> | null = null;
-
-  constructor(Root: ComponentConstructor<P, E>, config: AppConfig<P, E> = {}) {
-    super(config);
     this.Root = Root;
-    if (config.test) {
+    this.props = props;
-      this.dev = true;
-    }
-    if (this.dev && !config.test) {
-      console.info(DEV_MSG());
-    }
-    const descrs = Object.getOwnPropertyDescriptors(config.env || {});
-    this.env = Object.freeze(Object.defineProperties({}, descrs)) as E;
-    this.props = config.props || ({} as P);
   }
 
-  mount(target: HTMLElement, options?: MountOptions): Promise<Component<P, E> & InstanceType<T>> {
+  configure(config: AppConfig): App<T> {
-    App.validateTarget(target);
+    if (config.dev) {
-    const node = this.makeNode(this.Root, this.props);
+      this.dev = config.dev;
-    const prom = this.mountNode(node, target, options);
+      console.info(DEV_MSG);
+    }
+    if (config.env) {
+      this.env = Object.freeze(Object.assign({}, config.env));
+    }
+    if (config.translateFn) {
+      this.translateFn = config.translateFn;
+    }
+    if (config.translatableAttributes) {
+      this.translatableAttributes = config.translatableAttributes;
+    }
+    return this;
+  }
+
+  mount(target: HTMLElement, options?: MountOptions): Promise<InstanceType<T>> {
+    if (!(target instanceof HTMLElement)) {
+      throw new Error("Cannot mount component: the target is not a valid DOM element");
+    }
+    if (!document.body.contains(target)) {
+      throw new Error("Cannot mount a component on a detached dom node");
+    }
+    const node = new ComponentNode(this.Root, this.props, this);
     this.root = node;
-    return prom;
+    return node.mountComponent(target, options);
-  }
-
-  makeNode(Component: ComponentConstructor, props: any): ComponentNode {
-    return new ComponentNode(Component, props, this);
-  }
-
-  mountNode(node: ComponentNode, target: HTMLElement, options?: MountOptions) {
-    const promise: any = new Promise((resolve, reject) => {
-      let isResolved = false;
-      // manually set a onMounted callback.
-      // that way, we are independant from the current node.
-      node.mounted.push(() => {
-        resolve(node.component);
-        isResolved = true;
-      });
-
-      // Manually add the last resort error handler on the node
-      let handlers = nodeErrorHandlers.get(node);
-      if (!handlers) {
-        handlers = [];
-        nodeErrorHandlers.set(node, handlers);
-      }
-      handlers.unshift((e) => {
-        if (isResolved) {
-          console.error(e);
-        } else {
-          reject(e);
-        }
-        throw e;
-      });
-    });
-    node.mountComponent(target, options);
-    return promise;
   }
 
   destroy() {
@@ -101,15 +70,3 @@ export class App<
     }
   }
 }
-
-export async function mount<
-  T extends abstract new (...args: any) => any = any,
-  P extends object = any,
-  E = any
->(
-  C: T & ComponentConstructor<P, E>,
-  target: HTMLElement,
-  config: AppConfig<P, E> & MountOptions = {}
-): Promise<Component<P, E> & InstanceType<T>> {
-  return new App(C, config).mount(target, config);
-}

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";
-import { TARGET } from "../reactivity";
 
 /**
  * This file contains utility functions that will be injected in each template,
@@ -18,25 +17,19 @@ function callSlot(
   parent: any,
   key: string,
   name: string,
-  dynamic: boolean,
+  defaultSlot?: (ctx: any, key: string) => BDom,
-  extra: any,
+  dynamic?: boolean
-  defaultContent?: (ctx: any, node: any, key: string) => BDom
 ): BDom {
-  key = key + "__slot_" + name;
+  const slots = ctx.__owl__.slots;
-  const slots = ctx.props[TARGET].slots || {};
+  const slotFn = slots[name];
-  const { __render, __ctx, __scope } = slots[name] || {};
+  const slotBDom = slotFn ? slotFn(parent, key) : null;
-  const slotScope = Object.create(__ctx || {});
+  if (defaultSlot) {
-  if (__scope) {
-    slotScope[__scope] = extra || {};
-  }
-  const slotBDom = __render ? __render.call(__ctx.__owl__.component, slotScope, parent, key) : null;
-  if (defaultContent) {
     let child1: BDom | undefined = undefined;
     let child2: BDom | undefined = undefined;
     if (slotBDom) {
       child1 = dynamic ? toggler(name, slotBDom) : slotBDom;
     } else {
-      child2 = defaultContent.call(ctx.__owl__.component, ctx, parent, key);
+      child2 = defaultSlot(parent, key);
     }
     return multi([child1, child2]);
   }
@@ -103,25 +96,6 @@ function shallowEqual(l1: any[], l2: any[]): boolean {
   return true;
 }
 
-class LazyValue {
-  fn: any;
-  ctx: any;
-  node: any;
-  constructor(fn: any, ctx: any, node: any) {
-    this.fn = fn;
-    this.ctx = capture(ctx);
-    this.node = node;
-  }
-
-  evaluate(): any {
-    return this.fn(this.ctx, this.node);
-  }
-
-  toString() {
-    return this.evaluate().toString();
-  }
-}
-
 /*
  * Safely outputs `value` as a block depending on the nature of `value`
  */
@@ -134,10 +108,7 @@ export function safeOutput(value: any): ReturnType<typeof toggler> {
   if (value instanceof Markup) {
     safeKey = `string_safe`;
     block = html(value as string);
-  } else if (value instanceof LazyValue) {
+  } else if (typeof value === "string") {
-    safeKey = `lazy_value`;
-    block = value.evaluate();
-  } else if (value instanceof String || typeof value === "string") {
     safeKey = "string_unsafe";
     block = text(value);
   } else {
@@ -148,42 +119,7 @@ export function safeOutput(value: any): ReturnType<typeof toggler> {
   return toggler(safeKey, block);
 }
 
-let boundFunctions = new WeakMap();
+export const UTILS = {
-
-function bind(ctx: any, fn: Function): Function {
-  let component = ctx.__owl__.component;
-  let boundFnMap = boundFunctions.get(component);
-  if (!boundFnMap) {
-    boundFnMap = new WeakMap();
-    boundFunctions.set(component, boundFnMap);
-  }
-  let boundFn = boundFnMap.get(fn);
-  if (!boundFn) {
-    boundFn = fn.bind(component);
-    boundFnMap.set(fn, boundFn);
-  }
-  return boundFn;
-}
-
-type RefMap = { [key: string]: HTMLElement | null };
-type RefSetter = (el: HTMLElement | null) => void;
-
-function multiRefSetter(refs: RefMap, name: string): RefSetter {
-  let count = 0;
-  return (el) => {
-    if (el) {
-      count++;
-      if (count > 1) {
-        throw new Error("Cannot have 2 elements with same ref name at the same time");
-      }
-    }
-    if (count === 0 || el) {
-      refs[name] = el;
-    }
-  };
-}
-
-export const helpers = {
   withDefault,
   zero: Symbol("zero"),
   isBoundary,
@@ -192,11 +128,8 @@ export const helpers = {
   withKey,
   prepareList,
   setContextValue,
-  multiRefSetter,
   shallowEqual,
   toNumber,
   validateProps,
-  LazyValue,
   safeOutput,
-  bind,
 };

src/app/template_set.ts

@@ -1,89 +1,31 @@
-import { createBlock, html, list, multi, text, toggler, comment } from "../blockdom";
+import { createBlock, html, list, multi, text, toggler } from "../blockdom";
 import { compile, Template } from "../compiler";
-import { markRaw } from "../reactivity";
+import { component } from "../component/component_node";
-import { Portal } from "../portal";
+import { UTILS } from "./template_helpers";
-import { component, getCurrent } from "../component/component_node";
-import { helpers } from "./template_helpers";
-import { globalTemplates } from "../utils";
 
-const bdom = { text, createBlock, list, multi, html, toggler, component, comment };
+const bdom = { text, createBlock, list, multi, html, toggler, component };
 
-function parseXML(xml: string): Document {
+export const globalTemplates: { [key: string]: string | Node } = {};
-  const parser = new DOMParser();
-
-  const doc = parser.parseFromString(xml, "text/xml");
-  if (doc.getElementsByTagName("parsererror").length) {
-    let msg = "Invalid XML in template.";
-    const parsererrorText = doc.getElementsByTagName("parsererror")[0].textContent;
-    if (parsererrorText) {
-      msg += "\nThe parser has produced the following error message:\n" + parsererrorText;
-      const re = /\d+/g;
-      const firstMatch = re.exec(parsererrorText);
-      if (firstMatch) {
-        const lineNumber = Number(firstMatch[0]);
-        const line = xml.split("\n")[lineNumber - 1];
-        const secondMatch = re.exec(parsererrorText);
-        if (line && secondMatch) {
-          const columnIndex = Number(secondMatch[0]) - 1;
-          if (line[columnIndex]) {
-            msg +=
-              `\nThe error might be located at xml line ${lineNumber} column ${columnIndex}\n` +
-              `${line}\n${"-".repeat(columnIndex - 1)}^`;
-          }
-        }
-      }
-    }
-    throw new Error(msg);
-  }
-  return doc;
-}
-
-/**
- * Returns the helpers object that will be injected in each template closure
- * function
- */
-function makeHelpers(getTemplate: (name: string) => Template): any {
-  return Object.assign({}, helpers, {
-    Portal,
-    markRaw,
-    getTemplate,
-    call: (owner: any, subTemplate: string, ctx: any, parent: any, key: any) => {
-      const template = getTemplate(subTemplate);
-      return toggler(subTemplate, template.call(owner, ctx, parent, key));
-    },
-  });
-}
-
-export interface TemplateSetConfig {
-  dev?: boolean;
-  translatableAttributes?: string[];
-  translateFn?: (s: string) => string;
-  templates?: string | Document;
-}
 
 export class TemplateSet {
-  dev: boolean;
   rawTemplates: typeof globalTemplates = Object.create(globalTemplates);
   templates: { [name: string]: Template } = {};
   translateFn?: (s: string) => string;
   translatableAttributes?: string[];
-  helpers: any;
+  utils: typeof UTILS;
+  dev?: boolean;
 
-  constructor(config: TemplateSetConfig = {}) {
+  constructor() {
-    this.dev = config.dev || false;
+    const call = (subTemplate: string, ctx: any, parent: any) => {
-    this.translateFn = config.translateFn;
+      const template = this.getTemplate(subTemplate);
-    this.translatableAttributes = config.translatableAttributes;
+      return toggler(subTemplate, template(ctx, parent));
-    if (config.templates) {
+    };
-      this.addTemplates(config.templates);
+
-    }
+    const getTemplate = (name: string) => this.getTemplate(name);
-    this.helpers = makeHelpers(this.getTemplate.bind(this));
+    this.utils = Object.assign({}, UTILS, { getTemplate, call });
   }
 
-  addTemplate(
+  addTemplate(name: string, template: string | Node, options: { allowDuplicate?: boolean } = {}) {
-    name: string,
-    template: string | Element,
-    options: { allowDuplicate?: boolean } = {}
-  ) {
     if (name in this.rawTemplates && !options.allowDuplicate) {
       throw new Error(`Template ${name} already defined`);
     }
@@ -91,13 +33,10 @@ export class TemplateSet {
   }
 
   addTemplates(xml: string | Document, options: { allowDuplicate?: boolean } = {}) {
-    if (!xml) {
+    xml = xml instanceof Document ? xml : new DOMParser().parseFromString(xml, "text/xml");
-      // empty string
-      return;
-    }
-    xml = xml instanceof Document ? xml : parseXML(xml);
     for (const template of xml.querySelectorAll("[t-name]")) {
       const name = template.getAttribute("t-name")!;
+      template.removeAttribute("t-name");
       this.addTemplate(name, template, options);
     }
   }
@@ -106,32 +45,21 @@ export class TemplateSet {
     if (!(name in this.templates)) {
       const rawTemplate = this.rawTemplates[name];
       if (rawTemplate === undefined) {
-        let extraInfo = "";
+        throw new Error(`Missing template: "${name}"`);
-        try {
-          const componentName = getCurrent().component.constructor.name;
-          extraInfo = ` (for component "${componentName}")`;
-        } catch {}
-        throw new Error(`Missing template: "${name}"${extraInfo}`);
       }
-      const templateFn = this._compileTemplate(name, rawTemplate);
+      const templateFn = compile(rawTemplate, {
+        name,
+        dev: this.dev,
+        translateFn: this.translateFn,
+        translatableAttributes: this.translatableAttributes,
+      });
+
       // first add a function to lazily get the template, in case there is a
       // recursive call to the template name
-      const templates = this.templates;
+      this.templates[name] = (context, parent) => this.templates[name](context, parent);
-      this.templates[name] = function (context, parent) {
+      const template = templateFn(bdom, this.utils);
-        return templates[name].call(this, context, parent);
-      };
-      const template = templateFn(bdom, this.helpers);
       this.templates[name] = template;
     }
     return this.templates[name];
   }
-
-  _compileTemplate(name: string, template: string | Element) {
-    return compile(template, {
-      name,
-      dev: this.dev,
-      translateFn: this.translateFn,
-      translatableAttributes: this.translatableAttributes,
-    });
-  }
 }

src/blockdom/attributes.ts

@@ -1,6 +1,6 @@
 import type { Setter } from "./block_compiler";
 
-const { setAttribute: elemSetAttribute, removeAttribute } = Element.prototype;
+const { setAttribute, removeAttribute } = Element.prototype;
 const tokenList = DOMTokenList.prototype;
 const tokenListAdd = tokenList.add;
 const tokenListRemove = tokenList.remove;
@@ -14,23 +14,11 @@ const wordRegexp = /\s+/;
  * file.
  */
 
-function setAttribute(this: HTMLElement, key: string, value: any) {
-  switch (value) {
-    case false:
-    case undefined:
-      removeAttribute.call(this, key);
-      break;
-    case true:
-      elemSetAttribute.call(this, key, "");
-      break;
-    default:
-      elemSetAttribute.call(this, key, value);
-  }
-}
-
 export function createAttrUpdater(attr: string): Setter<HTMLElement> {
   return function (this: HTMLElement, value: any) {
-    setAttribute.call(this, attr, value);
+    if (value !== false) {
+      setAttribute.call(this, attr, value === true ? "" : value);
+    }
   };
 }
 
@@ -139,7 +127,7 @@ export function updateClass(this: HTMLElement, val: any, oldVal: any) {
 
 export function makePropSetter(name: string): Setter<HTMLElement> {
   return function setProp(this: HTMLElement, value: any) {
-    (this as any)[name] = value || "";
+    (this as any)[name] = value;
   };
 }
 

src/blockdom/block_compiler.ts

@@ -113,7 +113,7 @@ interface IntermediateTree {
   nextSibling: IntermediateTree | null;
   el: Node;
   info: DynamicInfo[];
-  isRef?: boolean;
+  forceRef?: boolean;
   refIdx?: number;
   refN: number;
   currentNS: string | null;
@@ -127,7 +127,8 @@ function buildTree(
   switch (node.nodeType) {
     case Node.ELEMENT_NODE: {
       // HTMLElement
-      let currentNS = domParentTree && domParentTree.currentNS;
+      let isActive = false;
+      let currentNS = parent && parent.currentNS;
       const tagName = (node as Element).tagName;
       let el: Node | undefined = undefined;
       const info: DynamicInfo[] = [];
@@ -135,14 +136,14 @@ function buildTree(
         const index = parseInt(tagName.slice(11), 10);
         info.push({ type: "text", idx: index });
         el = document.createTextNode("");
+        isActive = true;
       }
       if (tagName.startsWith("block-child-")) {
-        if (!domParentTree!.isRef) {
+        domParentTree!.forceRef = true;
-          addRef(domParentTree!);
-        }
         const index = parseInt(tagName.slice(12), 10);
         info.push({ type: "child", idx: index });
         el = document.createTextNode("");
+        isActive = true;
       }
       const attrs = (node as Element).attributes;
       const ns = attrs.getNamedItem("block-ns");
@@ -160,6 +161,7 @@ function buildTree(
           const attrName = attrs[i].name;
           const attrValue = attrs[i].value;
           if (attrName.startsWith("block-handler-")) {
+            isActive = true;
             const idx = parseInt(attrName.slice(14), 10);
             info.push({
               type: "handler",
@@ -167,6 +169,7 @@ function buildTree(
               event: attrValue,
             });
           } else if (attrName.startsWith("block-attribute-")) {
+            isActive = true;
             const idx = parseInt(attrName.slice(16), 10);
             info.push({
               type: "attribute",
@@ -175,11 +178,13 @@ function buildTree(
               tag: tagName,
             });
           } else if (attrName === "block-attributes") {
+            isActive = true;
             info.push({
               type: "attributes",
               idx: parseInt(attrValue, 10),
             });
           } else if (attrName === "block-ref") {
+            isActive = true;
             info.push({
               type: "ref",
               idx: parseInt(attrValue, 10),
@@ -196,7 +201,7 @@ function buildTree(
         nextSibling: null,
         el,
         info,
-        refN: 0,
+        refN: isActive ? 1 : 0,
         currentNS,
       };
 
@@ -210,6 +215,8 @@ function buildTree(
           const tagName = (childNode as Element).tagName;
           const index = parseInt(tagName.slice(12), 10);
           info.push({ idx: index, type: "child", isOnlyChild: true });
+          isActive = true;
+          tree.refN = 1;
         } else {
           tree.firstChild = buildTree(node.firstChild, tree, tree);
           el.appendChild(tree.firstChild.el);
@@ -222,8 +229,11 @@ function buildTree(
           }
         }
       }
-      if (tree.info.length) {
+      if (isActive) {
-        addRef(tree);
+        let cur: IntermediateTree | null = tree;
+        while ((cur = cur.parent)) {
+          cur.refN++;
+        }
       }
       return tree;
     }
@@ -248,13 +258,6 @@ function buildTree(
   throw new Error("boom");
 }
 
-function addRef(tree: IntermediateTree) {
-  tree.isRef = true;
-  do {
-    tree.refN++;
-  } while ((tree = tree.parent as any));
-}
-
 function parentTree(tree: IntermediateTree): IntermediateTree | null {
   let parent = tree.parent;
   while (parent && parent.nextSibling === tree) {
@@ -299,18 +302,23 @@ interface BlockCtx {
   locations: IndexedLocation[];
   children: Child[];
   cbRefs: number[];
-  refList: (() => void)[][];
 }
 
-function buildContext(tree: IntermediateTree, ctx?: BlockCtx, fromIdx?: number): BlockCtx {
+function buildContext(
+  tree: IntermediateTree,
+  ctx?: BlockCtx,
+  fromIdx?: number,
+  toIdx?: number
+): BlockCtx {
   if (!ctx) {
     const children = new Array(tree.info.filter((v) => v.type === "child").length);
-    ctx = { collectors: [], locations: [], children, cbRefs: [], refN: tree.refN, refList: [] };
+    ctx = { collectors: [], locations: [], children, cbRefs: [], refN: tree.refN };
     fromIdx = 0;
+    toIdx = tree.refN - 1;
   }
   if (tree.refN) {
     const initialIdx = fromIdx!;
-    const isRef = tree.isRef;
+    const isRef = tree.forceRef || tree.info.length > 0;
     const firstChild = tree.firstChild ? tree.firstChild.refN : 0;
     const nextSibling = tree.nextSibling ? tree.nextSibling.refN : 0;
 
@@ -328,13 +336,13 @@ function buildContext(tree: IntermediateTree, ctx?: BlockCtx, fromIdx?: number):
     if (nextSibling) {
       const idx = fromIdx! + firstChild;
       ctx.collectors.push({ idx, prevIdx: initialIdx, getVal: nodeGetNextSibling });
-      buildContext(tree.nextSibling!, ctx, idx);
+      buildContext(tree.nextSibling!, ctx, idx, toIdx);
     }
 
     // left
     if (firstChild) {
       ctx.collectors.push({ idx: fromIdx!, prevIdx: initialIdx, getVal: nodeGetFirstChild });
-      buildContext(tree.firstChild!, ctx, fromIdx!);
+      buildContext(tree.firstChild!, ctx, fromIdx!, toIdx! - nextSibling);
     }
   }
 
@@ -409,11 +417,11 @@ function updateCtx(ctx: BlockCtx, tree: IntermediateTree) {
         break;
       }
       case "ref":
-        const index = ctx.cbRefs.push(info.idx) - 1;
+        ctx.cbRefs.push(info.idx);
         ctx.locations.push({
           idx: info.idx,
           refIdx: info.refIdx!,
-          setData: makeRefSetter(index, ctx.refList),
+          setData: setRef,
           updateData: NO_OP,
         });
     }
@@ -427,21 +435,12 @@ function buildBlock(template: HTMLElement, ctx: BlockCtx): BlockType {
   let B = createBlockClass(template, ctx);
 
   if (ctx.cbRefs.length) {
-    const cbRefs = ctx.cbRefs;
+    const refs = ctx.cbRefs;
-    const refList = ctx.refList;
-    let cbRefsNumber = cbRefs.length;
     B = class extends B {
-      mount(parent: HTMLElement, afterNode: Node | null) {
-        refList.push(new Array(cbRefsNumber));
-        super.mount(parent, afterNode);
-        for (let cbRef of refList.pop()!) {
-          cbRef();
-        }
-      }
       remove() {
         super.remove();
-        for (let cbRef of cbRefs) {
+        for (let ref of refs) {
-          let fn = (this as any).data[cbRef];
+          let fn = (this as any).data[ref];
           fn(null);
         }
       }
@@ -486,12 +485,12 @@ function createBlockClass(template: HTMLElement, ctx: BlockCtx): BlockClass {
   const nodeInsertBefore = nodeProto.insertBefore;
   const elementRemove = elementProto.remove;
 
-  class Block {
+  return class Block {
     el: HTMLElement | undefined;
-    parentEl?: HTMLElement | undefined;
-    data: any[] | undefined;
-    children?: (VNode | undefined)[];
     refs: Node[] | undefined;
+    data: any[] | undefined;
+    parentEl?: HTMLElement | undefined;
+    children?: (VNode | undefined)[];
 
     constructor(data?: any[]) {
       this.data = data;
@@ -512,62 +511,46 @@ function createBlockClass(template: HTMLElement, ctx: BlockCtx): BlockClass {
       nodeInsertBefore.call(this.parentEl, this.el!, target);
     }
 
-    toString() {
-      const div = document.createElement("div");
-      this.mount(div, null);
-      return div.innerHTML;
-    }
-
     mount(parent: HTMLElement, afterNode: Node | null) {
-      const el = nodeCloneNode.call(template, true) as HTMLElement;
-      nodeInsertBefore.call(parent, el, afterNode);
-      this.el = el;
-      this.parentEl = parent;
-    }
-    patch(other: Block, withBeforeRemove: boolean) {}
-  }
-
-  if (isDynamic) {
-    Block.prototype.mount = function mount(parent: HTMLElement, afterNode: Node | null) {
       const el = nodeCloneNode.call(template, true);
-      // collecting references
-      const refs: Node[] = new Array(refN);
-      this.refs = refs;
-      refs[0] = el;
-      for (let i = 0; i < colN; i++) {
-        const w = collectors[i];
-        refs[w.idx] = w.getVal.call(refs[w.prevIdx]);
-      }
-
-      // applying data to all update points
-      if (locN) {
-        const data = this.data!;
-        for (let i = 0; i < locN; i++) {
-          const loc = locations[i];
-          loc.setData.call(refs[loc.refIdx], data[i]);
-        }
-      }
-
       nodeInsertBefore.call(parent, el, afterNode);
+      if (isDynamic) {
+        // collecting references
+        const refs: Node[] = new Array(refN);
+        this.refs = refs;
+        refs[0] = el;
+        for (let i = 0; i < colN; i++) {
+          const w = collectors[i];
+          refs[w.idx] = w.getVal.call(refs[w.prevIdx]);
+        }
 
-      // preparing all children
+        // applying data to all update points
-      if (childN) {
+        if (locN) {
-        const children = this.children;
+          const data = this.data!;
-        for (let i = 0; i < childN; i++) {
+          for (let i = 0; i < locN; i++) {
-          const child = children![i];
+            const loc = locations[i];
-          if (child) {
+            loc.setData.call(refs[loc.refIdx], data[i]);
-            const loc = childrenLocs[i];
+          }
-            const afterNode = loc.afterRefIdx ? refs[loc.afterRefIdx] : null;
+        }
-            child.isOnlyChild = loc.isOnlyChild;
+
-            child.mount(refs[loc.parentRefIdx] as any, afterNode);
+        // preparing all children
+        if (childN) {
+          const children = this.children;
+          for (let i = 0; i < childN; i++) {
+            const child = children![i];
+            if (child) {
+              const loc = childrenLocs[i];
+              const afterNode = loc.afterRefIdx ? refs[loc.afterRefIdx] : null;
+              child.isOnlyChild = loc.isOnlyChild;
+              child.mount(refs[loc.parentRefIdx] as any, afterNode);
+            }
           }
         }
       }
       this.el = el as HTMLElement;
       this.parentEl = parent;
-    };
+    }
-
+    patch(other: Block, withBeforeRemove: boolean) {
-    Block.prototype.patch = function patch(other: Block, withBeforeRemove: boolean) {
       if (this === other) {
         return;
       }
@@ -612,17 +595,19 @@ function createBlockClass(template: HTMLElement, ctx: BlockCtx): BlockClass {
           }
         }
       }
-    };
+    }
-  }
+    toString() {
-  return Block;
+      const div = document.createElement("div");
+      this.mount(div, null);
+      return div.innerHTML;
+    }
+  };
 }
 
 function setText(this: Text, value: any) {
   characterDataSetData.call(this, toText(value));
 }
 
-function makeRefSetter(index: number, refs: (() => void)[][]): Setter<HTMLElement> {
+function setRef(this: HTMLElement, fn: any) {
-  return function setRef(this: HTMLElement, fn: any) {
+  fn(this);
-    refs[refs.length - 1][index] = () => fn(this);
-  };
 }

src/blockdom/html.ts

@@ -61,7 +61,6 @@ class VHtml {
       // remove current content
       this.remove();
       this.content = content;
-      this.html = other.html;
     }
   }
 

src/blockdom/index.ts

@@ -4,7 +4,7 @@ export { toggler } from "./toggler";
 export { createBlock } from "./block_compiler";
 export { list } from "./list";
 export { multi } from "./multi";
-export { text, comment } from "./text";
+export { text } from "./text";
 export { html } from "./html";
 
 export interface VNode<T = any> {

src/blockdom/list.ts

@@ -98,6 +98,7 @@ 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 ? c!.toString() : "")).join("");
+    return this.children.map((c) => c!.toString()).join("");
   }
 }
 

src/blockdom/text.ts

@@ -8,17 +8,18 @@ const nodeInsertBefore = nodeProto.insertBefore;
 const characterDataSetData = getDescriptor(characterDataProto, "data").set!;
 const nodeRemoveChild = nodeProto.removeChild;
 
-abstract class VSimpleNode {
+class VText {
-  text: string | String;
+  text: string;
   parentEl?: HTMLElement | undefined;
-  el?: any;
+  el?: Text;
 
-  constructor(text: string | String) {
+  constructor(text: string) {
     this.text = text;
   }
 
-  mountNode(node: Node, parent: HTMLElement, afterNode: Node | null) {
+  mount(parent: HTMLElement, afterNode: Node | null) {
     this.parentEl = parent;
+    const node = document.createTextNode(toText(this.text));
     nodeInsertBefore.call(parent, node, afterNode);
     this.el = node;
   }
@@ -28,6 +29,14 @@ abstract class VSimpleNode {
     nodeInsertBefore.call(this.parentEl, this.el!, target);
   }
 
+  patch(other: VText) {
+    const text2 = other.text;
+    if (this.text !== text2) {
+      characterDataSetData.call(this.el!, toText(text2));
+      this.text = text2;
+    }
+  }
+
   beforeRemove() {}
 
   remove() {
@@ -43,36 +52,10 @@ abstract class VSimpleNode {
   }
 }
 
-class VText extends VSimpleNode {
+export function text(str: string): VNode<VText> {
-  mount(parent: HTMLElement, afterNode: Node | null) {
-    this.mountNode(document.createTextNode(toText(this.text)), parent, afterNode);
-  }
-
-  patch(other: VText) {
-    const text2 = other.text;
-    if (this.text !== text2) {
-      characterDataSetData.call(this.el!, toText(text2));
-      this.text = text2;
-    }
-  }
-}
-
-class VComment extends VSimpleNode {
-  mount(parent: HTMLElement, afterNode: Node | null) {
-    this.mountNode(document.createComment(toText(this.text)), parent, afterNode);
-  }
-
-  patch() {}
-}
-
-export function text(str: string | String): VNode<VText> {
   return new VText(str);
 }
 
-export function comment(str: string): VNode<VComment> {
-  return new VComment(str);
-}
-
 export function toText(value: any): string {
   switch (typeof value) {
     case "string":

src/compiler/code_generator.ts

@@ -19,10 +19,9 @@ import {
   ASTTSet,
   ASTTranslation,
   ASTType,
-  ASTTPortal,
 } from "./parser";
 
-type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
+type BlockType = "block" | "text" | "multi" | "list" | "html";
 
 export interface Config {
   translateFn?: (s: string) => string;
@@ -32,25 +31,19 @@ export interface Config {
 
 export interface CodeGenOptions extends Config {
   hasSafeContext?: boolean;
-  name?: 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
 // -----------------------------------------------------------------------------
 
 class BlockDescription {
   static nextBlockId = 1;
-  static nextDataIds: { [key: string]: number } = {};
+  static nextDataId = 1;
-  static generateId(prefix: string) {
-    this.nextDataIds[prefix] = (this.nextDataIds[prefix] || 0) + 1;
-    return prefix + this.nextDataIds[prefix];
-  }
 
   varName: string;
   blockName: string;
@@ -75,8 +68,8 @@ class BlockDescription {
     this.type = type;
   }
 
-  insertData(str: string, prefix: string = "d"): number {
+  insertData(str: string): number {
-    const id = BlockDescription.generateId(prefix);
+    const id = "d" + BlockDescription.nextDataId++;
     this.target.addLine(`let ${id} = ${str};`);
     return this.data.push(id) - 1;
   }
@@ -127,8 +120,6 @@ interface Context {
   isLast?: boolean;
   translate: boolean;
   tKeyExpr: string | null;
-  nameSpace?: string;
-  tModelSelectedExpr?: string;
 }
 
 function createContext(parentCtx: Context, params?: Partial<Context>) {
@@ -139,8 +130,6 @@ function createContext(parentCtx: Context, params?: Partial<Context>) {
       forceNewBlock: true,
       translate: parentCtx.translate,
       tKeyExpr: null,
-      nameSpace: parentCtx.nameSpace,
-      tModelSelectedExpr: parentCtx.tModelSelectedExpr,
     },
     params
   );
@@ -148,15 +137,12 @@ function createContext(parentCtx: Context, params?: Partial<Context>) {
 
 class CodeTarget {
   name: string;
+  signature: string = "";
   indentLevel = 0;
   loopLevel = 0;
   code: string[] = [];
   hasRoot = false;
   hasCache = false;
-  hasRef: boolean = false;
-  // maps ref name to [id, expr]
-  refInfo: { [name: string]: [string, string] } = {};
-  shouldProtectScope: boolean = false;
 
   constructor(name: string) {
     this.name = name;
@@ -170,34 +156,6 @@ class CodeTarget {
       this.code.splice(idx, 0, prefix + line);
     }
   }
-
-  generateCode(): string {
-    let result: string[] = [];
-    result.push(`function ${this.name}(ctx, node, key = "") {`);
-    if (this.hasRef) {
-      result.push(`  const refs = ctx.__owl__.refs;`);
-      for (let name in this.refInfo) {
-        const [id, expr] = this.refInfo[name];
-        result.push(`  const ${id} = ${expr};`);
-      }
-    }
-    if (this.shouldProtectScope) {
-      result.push(`  ctx = Object.create(ctx);`);
-      result.push(`  ctx[isBoundary] = 1`);
-    }
-    if (this.hasCache) {
-      result.push(`  let cache = ctx.cache || {};`);
-      result.push(`  let nextCache = ctx.cache = {};`);
-    }
-    for (let line of this.code) {
-      result.push(line);
-    }
-    if (!this.hasRoot) {
-      result.push(`return text('');`);
-    }
-    result.push(`}`);
-    return result.join("\n  ");
-  }
 }
 
 const TRANSLATABLE_ATTRS = ["label", "title", "placeholder", "alt"];
@@ -205,44 +163,36 @@ const translationRE = /^(\s*)([\s\S]+?)(\s*)$/;
 
 export class CodeGenerator {
   blocks: BlockDescription[] = [];
-  ids: { [key: string]: number } = {};
+  nextId = 1;
   nextBlockId = 1;
+  shouldProtectScope: boolean = false;
+  shouldDefineAssign: boolean = false;
   hasSafeContext: boolean;
+  hasRef: boolean = false;
   isDebug: boolean = false;
-  targets: CodeTarget[] = [];
+  functions: CodeTarget[] = [];
-  target = new CodeTarget("template");
+  target = new CodeTarget("main");
-  templateName?: string;
+  templateName: string;
   dev: boolean;
   translateFn: (s: string) => string;
-  translatableAttributes: string[] = TRANSLATABLE_ATTRS;
+  translatableAttributes: string[];
   ast: AST;
   staticCalls: { id: string; template: string }[] = [];
-  helpers: Set<string> = new Set();
 
-  constructor(ast: AST, options: CodeGenOptions) {
+  constructor(name: string, ast: AST, options: CodeGenOptions) {
     this.translateFn = options.translateFn || ((s: string) => s);
-    if (options.translatableAttributes) {
+    this.translatableAttributes = options.translatableAttributes || TRANSLATABLE_ATTRS;
-      const attrs = new Set(TRANSLATABLE_ATTRS);
-      for (let attr of options.translatableAttributes) {
-        if (attr.startsWith("-")) {
-          attrs.delete(attr.slice(1));
-        } else {
-          attrs.add(attr);
-        }
-      }
-      this.translatableAttributes = [...attrs];
-    }
     this.hasSafeContext = options.hasSafeContext || false;
     this.dev = options.dev || false;
     this.ast = ast;
-    this.templateName = options.name;
+    this.templateName = name;
   }
 
   generateCode(): string {
     const ast = this.ast;
     this.isDebug = ast.type === ASTType.TDebug;
     BlockDescription.nextBlockId = 1;
-    BlockDescription.nextDataIds = {};
+    BlockDescription.nextDataId = 1;
     this.compileAST(ast, {
       block: null,
       index: 0,
@@ -251,50 +201,68 @@ export class CodeGenerator {
       translate: true,
       tKeyExpr: null,
     });
+
+    let mainCode = this.target.code;
+    this.target.code = [];
+    this.target.indentLevel = 0;
     // define blocks and utility functions
-    let mainCode = [
+    this.addLine(`let { text, createBlock, list, multi, html, toggler, component } = bdom;`);
-      `  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;`,
+    this.addLine(
-    ];
+      `let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;`
-    if (this.helpers.size) {
+    );
-      mainCode.push(`let { ${[...this.helpers].join(", ")} } = helpers;`);
+    if (this.shouldDefineAssign) {
-    }
+      this.addLine(`let assign = Object.assign;`);
-    if (this.templateName) {
-      mainCode.push(`// Template name: "${this.templateName}"`);
     }
 
     for (let { id, template } of this.staticCalls) {
-      mainCode.push(`const ${id} = getTemplate(${template});`);
+      this.addLine(`const ${id} = getTemplate(${template});`);
     }
 
     // define all blocks
     if (this.blocks.length) {
-      mainCode.push(``);
+      this.addLine(``);
       for (let block of this.blocks) {
         if (block.dom) {
           let xmlString = block.asXmlString();
           if (block.dynamicTagName) {
             xmlString = xmlString.replace(/^<\w+/, `<\${tag || '${block.dom.nodeName}'}`);
             xmlString = xmlString.replace(/\w+>$/, `\${tag || '${block.dom.nodeName}'}>`);
-            mainCode.push(`let ${block.blockName} = tag => createBlock(\`${xmlString}\`);`);
+            this.addLine(`let ${block.blockName} = tag => createBlock(\`${xmlString}\`);`);
           } else {
-            mainCode.push(`let ${block.blockName} = createBlock(\`${xmlString}\`);`);
+            this.addLine(`let ${block.blockName} = createBlock(\`${xmlString}\`);`);
           }
         }
       }
     }
 
-    // define all slots/defaultcontent function
+    // define all slots
-    if (this.targets.length) {
+    for (let fn of this.functions) {
-      for (let fn of this.targets) {
+      this.generateFunctions(fn);
-        mainCode.push("");
-        mainCode = mainCode.concat(fn.generateCode());
-      }
     }
 
-    // generate main code
+    // // generate main code
-    mainCode.push("");
+    this.target.indentLevel = 0;
-    mainCode = mainCode.concat("return " + this.target.generateCode());
+    this.addLine(``);
-    const code = mainCode.join("\n  ");
+    this.addLine(`return function template(ctx, node, key = "") {`);
+    if (this.hasRef) {
+      this.addLine(`  const refs = ctx.__owl__.refs;`);
+    }
+    if (this.shouldProtectScope) {
+      this.addLine(`  ctx = Object.create(ctx);`);
+      this.addLine(`  ctx[isBoundary] = 1`);
+    }
+    if (this.target.hasCache) {
+      this.addLine(`  let cache = ctx.cache || {};`);
+      this.addLine(`  let nextCache = ctx.cache = {};`);
+    }
+    for (let line of mainCode) {
+      this.addLine(line);
+    }
+    if (!this.target.hasRoot) {
+      throw new Error("missing root block");
+    }
+    this.addLine("}");
+    const code = this.target.code.join("\n");
 
     if (this.isDebug) {
       const msg = `[Owl Debug]\n${code}`;
@@ -303,25 +271,16 @@ export class CodeGenerator {
     return code;
   }
 
-  compileInNewTarget(prefix: string, ast: AST, ctx: Context): string {
-    const name = this.generateId(prefix);
-    const initialTarget = this.target;
-    const target = new CodeTarget(name);
-    this.targets.push(target);
-    this.target = target;
-    const subCtx: Context = createContext(ctx);
-    this.compileAST(ast, subCtx);
-    this.target = initialTarget;
-    return name;
-  }
-
   addLine(line: string) {
     this.target.addLine(line);
   }
 
   generateId(prefix: string = ""): string {
-    this.ids[prefix] = (this.ids[prefix] || 0) + 1;
+    return `${prefix}${this.nextId++}`;
-    return prefix + this.ids[prefix];
+  }
+
+  generateBlockName(): string {
+    return `block${this.blocks.length + 1}`;
   }
 
   insertAnchor(block: BlockDescription) {
@@ -358,7 +317,6 @@ export class CodeGenerator {
       if (tKeyExpr) {
         keyArg = `${tKeyExpr} + ${keyArg}`;
       }
-      this.helpers.add("withKey");
       this.addLine(`${block.parentVar}[${ctx.index}] = withKey(${blockExpr}, ${keyArg});`);
       return;
     }
@@ -374,23 +332,20 @@ export class CodeGenerator {
     }
   }
 
-  /**
+  generateFunctions(fn: CodeTarget) {
-   * Captures variables that are used inside of an expression. This is useful
+    this.addLine("");
-   * because in compiled code, almost all variables are accessed through the ctx
+    this.addLine(`const ${fn.name} = ${fn.signature}`);
-   * object. In the case of functions, that lookup in the context can be delayed
+    if (fn.hasCache) {
-   * which can cause issues if the value has changed since the function was
+      this.addLine(`let cache = ctx.cache || {};`);
-   * defined.
+      this.addLine(`let nextCache = ctx.cache = {};`);
-   *
-   * @param expr the expression to capture
-   * @param forceCapture whether the expression should capture its scope even if
-   *  it doesn't contain a function. Useful when the expression will be used as
-   *  a function body.
-   * @returns a new expression that uses the captured values
-   */
-  captureExpression(expr: string, forceCapture: boolean = false): string {
-    if (!forceCapture && !expr.includes("=>")) {
-      return compileExpr(expr);
     }
+    for (let line of fn.code) {
+      this.addLine(line);
+    }
+    this.addLine(`}`);
+  }
+
+  captureExpression(expr: string): string {
     const tokens = compileExprToArray(expr);
     const mapping = new Map<string, string>();
     return tokens
@@ -461,8 +416,6 @@ export class CodeGenerator {
       case ASTType.TTranslation:
         this.compileTTranslation(ast, ctx);
         break;
-      case ASTType.TPortal:
-        this.compileTPortal(ast, ctx);
     }
   }
 
@@ -483,14 +436,13 @@ export class CodeGenerator {
     let { block, forceNewBlock } = ctx;
     const isNewBlock = !block || forceNewBlock;
     if (isNewBlock) {
-      block = this.createBlock(block, "comment", ctx);
+      block = this.createBlock(block, "block", ctx);
-      this.insertBlock(`comment(\`${ast.value}\`)`, block, {
+      this.blocks.push(block);
-        ...ctx,
+    }
-        forceNewBlock: forceNewBlock && !block,
+    const text = xmlDoc.createComment(ast.value);
-      });
+    block!.insert(text);
-    } else {
+    if (isNewBlock) {
-      const text = xmlDoc.createComment(ast.value);
+      this.insertBlock("", block!, ctx);
-      block!.insert(text);
     }
   }
 
@@ -519,12 +471,7 @@ export class CodeGenerator {
     const modifiers = rawEvent
       .split(".")
       .slice(1)
-      .map((m) => {
+      .map((m) => `"${m}"`);
-        if (!MODS.has(m)) {
-          throw new Error(`Unknown event modifier: '${m}'`);
-        }
-        return `"${m}"`;
-      });
     let modifiersCode = "";
     if (modifiers.length) {
       modifiersCode = `${modifiers.join(",")}, `;
@@ -534,10 +481,10 @@ export class CodeGenerator {
 
   compileTDomNode(ast: ASTDomNode, ctx: Context) {
     let { block, forceNewBlock } = ctx;
-    const isNewBlock = !block || forceNewBlock || ast.dynamicTag !== null || ast.ns;
+    const isNewBlock = !block || forceNewBlock || ast.dynamicTag !== null;
     let codeIdx = this.target.code.length;
     if (isNewBlock) {
-      if ((ast.dynamicTag || ctx.tKeyExpr || ast.ns) && ctx.block) {
+      if (ast.dynamicTag && ctx.block) {
         this.insertAnchor(ctx.block!);
       }
       block = this.createBlock(block, "block", ctx);
@@ -550,84 +497,57 @@ export class CodeGenerator {
     }
     // attributes
     const attrs: { [key: string]: string } = {};
-    const nameSpace = ast.ns || ctx.nameSpace;
+    if (ast.ns) {
-    if (nameSpace && isNewBlock) {
       // specific namespace uri
-      attrs["block-ns"] = nameSpace;
+      attrs["block-ns"] = ast.ns;
     }
-
     for (let key in ast.attrs) {
-      let expr, attrName;
       if (key.startsWith("t-attf")) {
-        expr = interpolate(ast.attrs[key]);
+        let expr = interpolate(ast.attrs[key]);
-        const idx = block!.insertData(expr, "attr");
+        const idx = block!.insertData(expr);
-
+        attrs["block-attribute-" + idx] = key.slice(7);
-        attrName = key.slice(7);
-        attrs["block-attribute-" + idx] = attrName;
       } else if (key.startsWith("t-att")) {
-        expr = compileExpr(ast.attrs[key]);
+        let expr = compileExpr(ast.attrs[key]);
-        const idx = block!.insertData(expr, "attr");
+        const idx = block!.insertData(expr);
         if (key === "t-att") {
           attrs[`block-attributes`] = String(idx);
         } else {
-          attrName = key.slice(6);
+          attrs[`block-attribute-${idx}`] = key.slice(6);
-          attrs[`block-attribute-${idx}`] = attrName;
         }
       } else if (this.translatableAttributes.includes(key)) {
         attrs[key] = this.translateFn(ast.attrs[key]);
       } else {
-        expr = `"${ast.attrs[key]}"`;
-        attrName = key;
         attrs[key] = ast.attrs[key];
       }
-
-      if (attrName === "value" && ctx.tModelSelectedExpr) {
-        let selectedId = block!.insertData(`${ctx.tModelSelectedExpr} === ${expr}`, "attr");
-        attrs[`block-attribute-${selectedId}`] = "selected";
-      }
     }
 
     // event handlers
     for (let ev in ast.on) {
       const name = this.generateHandlerCode(ev, ast.on[ev]);
-      const idx = block!.insertData(name, "hdlr");
+      const idx = block!.insertData(name);
       attrs[`block-handler-${idx}`] = ev;
     }
 
     // t-ref
     if (ast.ref) {
-      this.target.hasRef = true;
+      this.hasRef = true;
       const isDynamic = INTERP_REGEXP.test(ast.ref);
       if (isDynamic) {
         const str = ast.ref.replace(
           INTERP_REGEXP,
-          (expr) => "${" + this.captureExpression(expr.slice(2, -2), true) + "}"
+          (expr) => "${" + this.captureExpression(expr.slice(2, -2)) + "}"
         );
-        const idx = block!.insertData(`(el) => refs[\`${str}\`] = el`, "ref");
+        const idx = block!.insertData(`(el) => refs[\`${str}\`] = el`);
         attrs["block-ref"] = String(idx);
       } else {
-        let name = ast.ref;
+        const idx = block!.insertData(`(el) => refs[\`${ast.ref}\`] = el`);
-        if (name in this.target.refInfo) {
+        attrs["block-ref"] = String(idx);
-          // ref has already been defined
-          this.helpers.add("multiRefSetter");
-          const info = this.target.refInfo[name];
-          const index = block!.data.push(info[0]) - 1;
-          attrs["block-ref"] = String(index);
-          info[1] = `multiRefSetter(refs, \`${name}\`)`;
-        } else {
-          let id = this.generateId("ref");
-          this.target.refInfo[name] = [id, `(el) => refs[\`${name}\`] = el`];
-          const index = block!.data.push(id) - 1;
-          attrs["block-ref"] = String(index);
-        }
       }
     }
 
     // t-model
-    let tModelSelectedExpr;
     if (ast.model) {
       const {
-        hasDynamicChildren,
         baseExpr,
         expr,
         eventType,
@@ -638,34 +558,25 @@ export class CodeGenerator {
       } = ast.model;
 
       const baseExpression = compileExpr(baseExpr);
-      const bExprId = this.generateId("bExpr");
+      const id = this.generateId();
-      this.addLine(`const ${bExprId} = ${baseExpression};`);
+      this.addLine(`const bExpr${id} = ${baseExpression};`);
 
       const expression = compileExpr(expr);
-      const exprId = this.generateId("expr");
-      this.addLine(`const ${exprId} = ${expression};`);
-
-      const fullExpression = `${bExprId}[${exprId}]`;
 
       let idx: number;
       if (specialInitTargetAttr) {
-        idx = block!.insertData(`${fullExpression} === '${attrs[targetAttr]}'`, "attr");
+        idx = block!.insertData(`${baseExpression}[${expression}] === '${attrs[targetAttr]}'`);
         attrs[`block-attribute-${idx}`] = specialInitTargetAttr;
-      } else if (hasDynamicChildren) {
-        const bValueId = this.generateId("bValue");
-        tModelSelectedExpr = `${bValueId}`;
-        this.addLine(`let ${tModelSelectedExpr} = ${fullExpression}`);
       } else {
-        idx = block!.insertData(`${fullExpression}`, "attr");
+        idx = block!.insertData(`${baseExpression}[${expression}]`);
         attrs[`block-attribute-${idx}`] = targetAttr;
       }
-      this.helpers.add("toNumber");
       let valueCode = `ev.target.${targetAttr}`;
       valueCode = shouldTrim ? `${valueCode}.trim()` : valueCode;
       valueCode = shouldNumberize ? `toNumber(${valueCode})` : valueCode;
 
-      const handler = `[(ev) => { ${fullExpression} = ${valueCode}; }]`;
+      const handler = `[(ev) => { bExpr${id}[${expression}] = ${valueCode}; }]`;
-      idx = block!.insertData(handler, "hdlr");
+      idx = block!.insertData(handler);
       attrs[`block-handler-${idx}`] = eventType;
     }
 
@@ -687,9 +598,6 @@ export class CodeGenerator {
           index: block!.childNumber,
           forceNewBlock: false,
           isLast: ctx.isLast && i === children.length - 1,
-          tKeyExpr: ctx.tKeyExpr,
-          nameSpace,
-          tModelSelectedExpr,
         });
         this.compileAST(child, subCtx);
       }
@@ -704,7 +612,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;
@@ -719,12 +627,10 @@ export class CodeGenerator {
     let { block, forceNewBlock } = ctx;
     let expr: string;
     if (ast.expr === "0") {
-      this.helpers.add("zero");
       expr = `ctx[zero]`;
     } else {
       expr = compileExpr(ast.expr);
       if (ast.defaultValue) {
-        this.helpers.add("withDefault");
         expr = `withDefault(${expr}, \`${ast.defaultValue}\`)`;
       }
     }
@@ -732,7 +638,7 @@ export class CodeGenerator {
       block = this.createBlock(block, "text", ctx);
       this.insertBlock(`text(${expr})`, block, { ...ctx, forceNewBlock: forceNewBlock && !block });
     } else {
-      const idx = block.insertData(expr, "txt");
+      const idx = block.insertData(expr);
       const text = xmlDoc.createElement(`block-text-${idx}`);
       block.insert(text);
     }
@@ -744,13 +650,11 @@ export class CodeGenerator {
       this.insertAnchor(block);
     }
     block = this.createBlock(block, "html", ctx);
-    this.helpers.add(ast.expr === "0" ? "zero" : "safeOutput");
     let expr = ast.expr === "0" ? "ctx[zero]" : `safeOutput(${compileExpr(ast.expr)})`;
     if (ast.body) {
       const nextId = BlockDescription.nextBlockId;
       const subCtx: Context = createContext(ctx);
       this.compileAST({ type: ASTType.Multi, content: ast.body }, subCtx);
-      this.helpers.add("withDefault");
       expr = `withDefault(${expr}, b${nextId})`;
     }
     this.insertBlock(`${expr}`, block, ctx);
@@ -799,7 +703,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;
@@ -827,14 +731,9 @@ export class CodeGenerator {
     const keys = `k_block${block.id}`;
     const l = `l_block${block.id}`;
     const c = `c_block${block.id}`;
-    this.helpers.add("prepareList");
     this.addLine(
       `const [${keys}, ${vals}, ${l}, ${c}] = prepareList(${compileExpr(ast.collection)});`
     );
-    // Throw errors on duplicate keys in dev mode
-    if (this.dev) {
-      this.addLine(`const keys${block.id} = new Set();`);
-    }
     this.addLine(`for (let ${loopVar} = 0; ${loopVar} < ${l}; ${loopVar}++) {`);
     this.target.indentLevel++;
     this.addLine(`ctx[\`${ast.elem}\`] = ${vals}[${loopVar}];`);
@@ -851,16 +750,10 @@ export class CodeGenerator {
       this.addLine(`ctx[\`${ast.elem}_value\`] = ${keys}[${loopVar}];`);
     }
     this.addLine(`let key${this.target.loopLevel} = ${ast.key ? compileExpr(ast.key) : loopVar};`);
-    if (this.dev) {
-      // Throw error on duplicate keys in dev mode
-      this.addLine(
-        `if (keys${block.id}.has(key${this.target.loopLevel})) { throw new Error(\`Got duplicate key in t-foreach: \${key${this.target.loopLevel}}\`)}`
-      );
-      this.addLine(`keys${block.id}.add(key${this.target.loopLevel});`);
-    }
     let id: string;
     if (ast.memo) {
       this.target.hasCache = true;
+      this.shouldDefineAssign = true;
       id = this.generateId();
       this.addLine(`let memo${id} = ${compileExpr(ast.memo)}`);
       this.addLine(`let vnode${id} = cache[key${this.target.loopLevel}];`);
@@ -881,9 +774,7 @@ export class CodeGenerator {
     this.compileAST(ast.body, subCtx);
     if (ast.memo) {
       this.addLine(
-        `nextCache[key${
+        `nextCache[key${this.target.loopLevel}] = assign(${c}[${loopVar}], {memo: memo${id!}});`
-          this.target.loopLevel
-        }] = Object.assign(${c}[${loopVar}], {memo: memo${id!}});`
       );
     }
     this.target.indentLevel--;
@@ -943,7 +834,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;
@@ -963,12 +854,10 @@ export class CodeGenerator {
     if (ast.body) {
       this.addLine(`ctx = Object.create(ctx);`);
       this.addLine(`ctx[isBoundary] = 1;`);
-      this.helpers.add("isBoundary");
       const nextId = BlockDescription.nextBlockId;
       const subCtx: Context = createContext(ctx, { preventRoot: true });
       this.compileAST({ type: ASTType.Multi, content: ast.body }, subCtx);
       if (nextId !== BlockDescription.nextBlockId) {
-        this.helpers.add("zero");
         this.addLine(`ctx[zero] = b${nextId};`);
       }
     }
@@ -984,14 +873,12 @@ export class CodeGenerator {
       const templateVar = this.generateId("template");
       this.addLine(`const ${templateVar} = ${subTemplate};`);
       block = this.createBlock(block, "multi", ctx);
-      this.helpers.add("call");
+      this.insertBlock(`call(${templateVar}, ctx, node, ${key})`, block!, {
-      this.insertBlock(`call(this, ${templateVar}, ctx, node, ${key})`, block!, {
         ...ctx,
         forceNewBlock: !block,
       });
     } else {
       const id = this.generateId(`callTemplate_`);
-      this.helpers.add("getTemplate");
       this.staticCalls.push({ id, template: subTemplate });
       block = this.createBlock(block, "multi", ctx);
       this.insertBlock(`${id}.call(this, ctx, node, ${key})`, block!, {
@@ -1016,15 +903,13 @@ export class CodeGenerator {
   }
 
   compileTSet(ast: ASTTSet, ctx: Context) {
-    this.target.shouldProtectScope = true;
+    this.shouldProtectScope = true;
-    this.helpers.add("isBoundary").add("withDefault");
     const expr = ast.value ? compileExpr(ast.value || "") : "null";
     if (ast.body) {
-      this.helpers.add("LazyValue");
+      const subCtx: Context = createContext(ctx);
-      const bodyAst: AST = { type: ASTType.Multi, content: ast.body };
+      const nextId = `b${BlockDescription.nextBlockId}`;
-      const name = this.compileInNewTarget("value", bodyAst, ctx);
+      this.compileAST({ type: ASTType.Multi, content: ast.body }, subCtx);
-      let value = `new LazyValue(${name}, ctx, node)`;
+      const value = ast.value ? (nextId ? `withDefault(${expr}, ${nextId})` : expr) : nextId;
-      value = ast.value ? (value ? `withDefault(${expr}, ${value})` : expr) : value;
       this.addLine(`ctx[\`${ast.name}\`] = ${value};`);
     } else {
       let value: string;
@@ -1037,7 +922,6 @@ export class CodeGenerator {
       } else {
         value = expr;
       }
-      this.helpers.add("setContextValue");
       this.addLine(`setContextValue(ctx, "${ast.name}", ${value});`);
     }
   }
@@ -1050,104 +934,24 @@ export class CodeGenerator {
     return parts.join("__");
   }
 
-  /**
-   * Formats a prop name and value into a string suitable to be inserted in the
-   * generated code. For example:
-   *
-   * Name              Value            Result
-   * ---------------------------------------------------------
-   * "number"          "state"          "number: ctx['state']"
-   * "something"       ""               "something: undefined"
-   * "some-prop"       "state"          "'some-prop': ctx['state']"
-   * "onClick.bind"    "onClick"        "onClick: bind(ctx, ctx['onClick'])"
-   */
-  formatProp(name: string, value: string): string {
-    value = this.captureExpression(value);
-    if (name.includes(".")) {
-      let [_name, suffix] = name.split(".");
-      if (suffix === "bind") {
-        this.helpers.add("bind");
-        name = _name;
-        value = `bind(ctx, ${value || undefined})`;
-      } else {
-        throw new Error("Invalid prop suffix");
-      }
-    }
-    name = /^[a-z_]+$/i.test(name) ? name : `'${name}'`;
-    return `${name}: ${value || undefined}`;
-  }
-
-  formatPropObject(obj: { [prop: string]: any }): string {
-    const params = [];
-    for (const [n, v] of Object.entries(obj)) {
-      params.push(this.formatProp(n, v));
-    }
-    return params.join(", ");
-  }
-
   compileComponent(ast: ASTComponent, ctx: Context) {
     let { block } = ctx;
+    let extraArgs: { [key: string]: string } = {};
 
     // props
-    const hasSlotsProp = "slots" in ast.props;
     const props: string[] = [];
-    const propExpr = this.formatPropObject(ast.props);
+    for (let p in ast.props) {
-    if (propExpr) {
+      props.push(`${p}: ${compileExpr(ast.props[p]) || undefined}`);
-      props.push(propExpr);
     }
-
-    // slots
-    const hasSlot = !!Object.keys(ast.slots).length;
-    let slotDef: string = "";
-    if (hasSlot) {
-      let ctxStr = "ctx";
-      if (this.target.loopLevel || !this.hasSafeContext) {
-        ctxStr = this.generateId("ctx");
-        this.helpers.add("capture");
-        this.addLine(`const ${ctxStr} = capture(ctx);`);
-      }
-      let slotStr: string[] = [];
-      for (let slotName in ast.slots) {
-        const slotAst = ast.slots[slotName].content;
-        const name = this.compileInNewTarget("slot", slotAst, ctx);
-        const params = [`__render: ${name}, __ctx: ${ctxStr}`];
-        const scope = ast.slots[slotName].scope;
-        if (scope) {
-          params.push(`__scope: "${scope}"`);
-        }
-        if (ast.slots[slotName].attrs) {
-          params.push(this.formatPropObject(ast.slots[slotName].attrs!));
-        }
-        const slotInfo = `{${params.join(", ")}}`;
-        slotStr.push(`'${slotName}': ${slotInfo}`);
-      }
-      slotDef = `{${slotStr.join(", ")}}`;
-    }
-
-    if (slotDef && !(ast.dynamicProps || hasSlotsProp)) {
-      this.helpers.add("markRaw");
-      props.push(`slots: markRaw(${slotDef})`);
-    }
-
     const propStr = `{${props.join(",")}}`;
 
     let propString = propStr;
     if (ast.dynamicProps) {
-      propString = `Object.assign({}, ${compileExpr(ast.dynamicProps)}${
+      if (!props.length) {
-        props.length ? ", " + propStr : ""
+        propString = `Object.assign({}, ${compileExpr(ast.dynamicProps)})`;
-      })`;
+      } else {
-    }
+        propString = `Object.assign({}, ${compileExpr(ast.dynamicProps)}, ${propStr})`;
-
+      }
-    let propVar: string;
-    if ((slotDef && (ast.dynamicProps || hasSlotsProp)) || this.dev) {
-      propVar = this.generateId("props");
-      this.addLine(`const ${propVar!} = ${propString};`);
-      propString = propVar!;
-    }
-
-    if (slotDef && (ast.dynamicProps || hasSlotsProp)) {
-      this.helpers.add("markRaw");
-      this.addLine(`${propVar!}.slots = markRaw(Object.assign(${slotDef}, ${propVar!}.slots))`);
     }
 
     // cmap key
@@ -1161,7 +965,41 @@ export class CodeGenerator {
     }
 
     if (this.dev) {
-      this.addLine(`helpers.validateProps(${expr}, ${propVar!}, ctx);`);
+      const propVar = this.generateId("props");
+      this.addLine(`const ${propVar} = ${propString}`);
+      this.addLine(`helpers.validateProps(${expr}, ${propVar}, ctx)`);
+      propString = propVar;
+    }
+
+    // slots
+    const hasSlot = !!Object.keys(ast.slots).length;
+    let slotDef: string;
+    if (hasSlot) {
+      let ctxStr = "ctx";
+      if (this.target.loopLevel || !this.hasSafeContext) {
+        ctxStr = this.generateId("ctx");
+        this.addLine(`const ${ctxStr} = capture(ctx);`);
+      }
+      let slotStr: string[] = [];
+      const initialTarget = this.target;
+      for (let slotName in ast.slots) {
+        let name = this.generateId("slot");
+        const slot = new CodeTarget(name);
+        slot.signature = "ctx => (node, key) => {";
+        this.functions.push(slot);
+        this.target = slot;
+        const subCtx: Context = createContext(ctx);
+        this.compileAST(ast.slots[slotName], subCtx);
+        if (this.hasRef) {
+          slot.code.unshift(`  const refs = ctx.__owl__.refs`);
+          slotStr.push(`'${slotName}': ${name}(${ctxStr})`);
+        } else {
+          slotStr.push(`'${slotName}': ${name}(${ctxStr})`);
+        }
+      }
+      this.target = initialTarget;
+      slotDef = `{${slotStr.join(", ")}}`;
+      extraArgs.slots = slotDef;
     }
 
     if (block && (ctx.forceNewBlock === false || ctx.tKeyExpr)) {
@@ -1174,7 +1012,12 @@ export class CodeGenerator {
       keyArg = `${ctx.tKeyExpr} + ${keyArg}`;
     }
     const blockArgs = `${expr}, ${propString}, ${keyArg}, node, ctx`;
-    let blockExpr = `component(${blockArgs})`;
+    let blockExpr = `component(${blockArgs}${hasSlot ? ", true" : ""})`;
+    if (Object.keys(extraArgs).length) {
+      this.shouldDefineAssign = true;
+      const content = Object.keys(extraArgs).map((k) => `${k}: ${extraArgs[k]}`);
+      blockExpr = `assign(${blockExpr}, {${content.join(", ")}})`;
+    }
     if (ast.isDynamic) {
       blockExpr = `toggler(${expr}, ${blockExpr})`;
     }
@@ -1183,7 +1026,6 @@ export class CodeGenerator {
   }
 
   compileTSlot(ast: ASTSlot, ctx: Context) {
-    this.helpers.add("callSlot");
     let { block } = ctx;
     let blockString: string;
     let slotName;
@@ -1194,18 +1036,24 @@ export class CodeGenerator {
     } else {
       slotName = "'" + ast.name + "'";
     }
-
-    const scope = ast.attrs ? `{${this.formatPropObject(ast.attrs)}}` : null;
     if (ast.defaultContent) {
-      const name = this.compileInNewTarget("defaultContent", ast.defaultContent, ctx);
+      let name = this.generateId("defaultSlot");
-      blockString = `callSlot(ctx, node, key, ${slotName}, ${dynamic}, ${scope}, ${name})`;
+      const slot = new CodeTarget(name);
+      slot.signature = "ctx => {";
+      this.functions.push(slot);
+      const initialTarget = this.target;
+      const subCtx: Context = createContext(ctx);
+      this.target = slot;
+      this.compileAST(ast.defaultContent, subCtx);
+      this.target = initialTarget;
+      blockString = `callSlot(ctx, node, key, ${slotName}, ${name}, ${dynamic})`;
     } else {
       if (dynamic) {
         let name = this.generateId("slot");
         this.addLine(`const ${name} = ${slotName};`);
-        blockString = `toggler(${name}, callSlot(ctx, node, key, ${name}), ${dynamic}, ${scope})`;
+        blockString = `toggler(${name}, callSlot(ctx, node, key, ${name}))`;
       } else {
-        blockString = `callSlot(ctx, node, key, ${slotName}, ${dynamic}, ${scope})`;
+        blockString = `callSlot(ctx, node, key, ${slotName})`;
       }
     }
     if (block) {
@@ -1220,23 +1068,4 @@ 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

@@ -9,10 +9,8 @@ export type TemplateFunction = (blocks: any, utils: any) => Template;
 interface CompileOptions extends Config {
   name?: string;
 }
-export function compile(
+let nextId = 1;
-  template: string | Element,
+export function compile(template: string | Node, options: CompileOptions = {}): TemplateFunction {
-  options: CompileOptions = {}
-): TemplateFunction {
   // parsing
   const ast = parse(template);
 
@@ -21,10 +19,12 @@ export function compile(
     template instanceof Node
       ? !(template instanceof Element) || template.querySelector("[t-set], [t-call]") === null
       : !template.includes("t-set") && !template.includes("t-call");
+  const name = options.name || `template_${nextId++}`;
 
   // code generation
-  const codeGenerator = new CodeGenerator(ast, { ...options, hasSafeContext });
+  const codeGenerator = new CodeGenerator(name, ast, { ...options, hasSafeContext });
   const code = codeGenerator.generateCode();
+
   // template function
   return new Function("bdom, helpers", code) as TemplateFunction;
 }

src/compiler/inline_expressions.ts

@@ -329,9 +329,7 @@ export function compileExprToArray(expr: string): Token[] {
   // Mark all variables that have been used locally.
   // This assumes the expression has only one scope (incorrect but "good enough for now")
   for (const token of tokens) {
-    if (token.type === "SYMBOL" && token.varName && localVars.has(token.value)) {
+    if (token.type === "SYMBOL" && localVars.has(token.value)) {
-      token.originalValue = token.value;
-      token.value = `_${token.value}`;
       token.isLocal = true;
     }
   }

src/compiler/parser.ts

@@ -20,7 +20,6 @@ export const enum ASTType {
   TSlot,
   TCallBlock,
   TTranslation,
-  TPortal,
 }
 
 export interface ASTText {
@@ -33,17 +32,6 @@ export interface ASTComment {
   value: string;
 }
 
-interface TModelInfo {
-  hasDynamicChildren?: boolean;
-  baseExpr: string;
-  expr: string;
-  targetAttr: string;
-  specialInitTargetAttr: string | null;
-  eventType: "change" | "click" | "input";
-  shouldTrim: boolean;
-  shouldNumberize: boolean;
-}
-
 export interface ASTDomNode {
   type: ASTType.DomNode;
   tag: string;
@@ -52,7 +40,15 @@ export interface ASTDomNode {
   content: AST[];
   ref: string | null;
   on: { [key: string]: string };
-  model?: TModelInfo | null;
+  model: {
+    baseExpr: string;
+    expr: string;
+    targetAttr: string;
+    specialInitTargetAttr: string | null;
+    eventType: "change" | "click" | "input";
+    shouldTrim: boolean;
+    shouldNumberize: boolean;
+  } | null;
   ns: string | null;
 }
 
@@ -96,6 +92,8 @@ export interface ASTTForEach {
   key: string | null;
   body: AST;
   memo: string;
+  isOnlyChild: boolean;
+  hasNoComponent: boolean;
   hasNoFirst: boolean;
   hasNoLast: boolean;
   hasNoIndex: boolean;
@@ -120,13 +118,12 @@ export interface ASTComponent {
   isDynamic: boolean;
   dynamicProps: string | null;
   props: { [name: string]: string };
-  slots: { [name: string]: { content: AST; attrs?: { [key: string]: string }; scope?: string } };
+  slots: { [name: string]: AST };
 }
 
 export interface ASTSlot {
   type: ASTType.TSlot;
   name: string;
-  attrs: { [key: string]: string };
   defaultContent: AST | null;
 }
 
@@ -151,12 +148,6 @@ export interface ASTTranslation {
   content: AST | null;
 }
 
-export interface ASTTPortal {
-  type: ASTType.TPortal;
-  target: string;
-  content: AST;
-}
-
 export type AST =
   | ASTText
   | ASTComment
@@ -174,41 +165,27 @@ export type AST =
   | ASTTCallBlock
   | ASTLog
   | ASTDebug
-  | ASTTranslation
+  | ASTTranslation;
-  | ASTTPortal;
 
 // -----------------------------------------------------------------------------
 // Parser
 // -----------------------------------------------------------------------------
-const cache: WeakMap<Element, AST> = new WeakMap();
-
-export function parse(xml: string | Element): AST {
-  if (typeof xml === "string") {
-    const elem = parseXML(`<t>${xml}</t>`).firstChild as Element;
-    return _parse(elem);
-  }
-  let ast = cache.get(xml);
-  if (!ast) {
-    // we clone here the xml to prevent modifying it in place
-    ast = _parse(xml.cloneNode(true) as Element);
-    cache.set(xml, ast);
-  }
-  return ast;
-}
-
-function _parse(xml: Element): AST {
-  normalizeXML(xml);
-  const ctx = { inPreTag: false, inSVG: false };
-  return parseNode(xml, ctx) || { type: ASTType.Text, value: "" };
-}
-
 interface ParsingContext {
-  tModelInfo?: TModelInfo | null;
   inPreTag: boolean;
   inSVG: boolean;
 }
 
-function parseNode(node: Node, ctx: ParsingContext): AST | null {
+export function parse(xml: string | Node): AST {
+  const node = xml instanceof Element ? xml : parseXML(`<t>${xml}</t>`).firstChild!;
+  const ctx = { inPreTag: false, inSVG: false };
+  const ast = parseNode(node, ctx);
+  if (!ast) {
+    return { type: ASTType.Text, value: "" };
+  }
+  return ast;
+}
+
+function parseNode(node: ChildNode, ctx: ParsingContext): AST | null {
   if (!(node instanceof Element)) {
     return parseTextCommentNode(node, ctx);
   }
@@ -216,7 +193,6 @@ function parseNode(node: Node, 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) ||
@@ -239,7 +215,24 @@ function parseTNode(node: Element, ctx: ParsingContext): AST | null {
   if (node.tagName !== "t") {
     return null;
   }
-  return parseChildNodes(node, ctx);
+  const children: AST[] = [];
+  for (let child of node.childNodes) {
+    const ast = parseNode(child, ctx);
+    if (ast) {
+      children.push(ast);
+    }
+  }
+  switch (children.length) {
+    case 0:
+      return null;
+    case 1:
+      return children[0];
+    default:
+      return {
+        type: ASTType.Multi,
+        content: children,
+      };
+  }
 }
 
 // -----------------------------------------------------------------------------
@@ -248,7 +241,7 @@ function parseTNode(node: Element, ctx: ParsingContext): AST | null {
 const lineBreakRE = /[\r\n]/;
 const whitespaceRE = /\s+/g;
 
-function parseTextCommentNode(node: Node, ctx: ParsingContext): AST | null {
+function parseTextCommentNode(node: ChildNode, ctx: ParsingContext): AST | null {
   if (node.nodeType === Node.TEXT_NODE) {
     let value = node.textContent || "";
     if (!ctx.inPreTag) {
@@ -296,8 +289,6 @@ function parseTDebugLog(node: Element, ctx: ParsingContext): AST | null {
 const hasDotAtTheEnd = /\.[\w_]+\s*$/;
 const hasBracketsAtTheEnd = /\[[^\[]+\]\s*$/;
 
-const ROOT_SVG_TAGS = new Set(["svg", "g", "path"]);
-
 function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
   const { tagName } = node;
   const dynamicTag = node.getAttribute("t-tag");
@@ -305,23 +296,27 @@ function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
   if (tagName === "t" && !dynamicTag) {
     return null;
   }
-  if (tagName.startsWith("block-")) {
+  const children: AST[] = [];
-    throw new Error(`Invalid tag name: '${tagName}'`);
-  }
-  ctx = Object.assign({}, ctx);
   if (tagName === "pre") {
     ctx.inPreTag = true;
   }
-  const shouldAddSVGNS = ROOT_SVG_TAGS.has(tagName) && !ctx.inSVG;
+  const shouldAddSVGNS = tagName === "svg" || (tagName === "g" && !ctx.inSVG);
   ctx.inSVG = ctx.inSVG || shouldAddSVGNS;
   const ns = shouldAddSVGNS ? "http://www.w3.org/2000/svg" : null;
   const ref = node.getAttribute("t-ref");
   node.removeAttribute("t-ref");
 
+  for (let child of node.childNodes) {
+    const ast = parseNode(child, ctx);
+    if (ast) {
+      children.push(ast);
+    }
+  }
+
   const nodeAttrsNames = node.getAttributeNames();
   const attrs: ASTDomNode["attrs"] = {};
   const on: ASTDomNode["on"] = {};
-  let model: TModelInfo | null = null;
+  let model: ASTDomNode["model"] = null;
 
   for (let attr of nodeAttrsNames) {
     const value = node.getAttribute(attr)!;
@@ -369,26 +364,16 @@ function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
         shouldTrim: hasTrimMod && (isOtherInput || isTextarea),
         shouldNumberize: hasNumberMod && (isOtherInput || isTextarea),
       };
-      if (isSelect) {
+    } else {
-        // don't pollute the original ctx
-        ctx = Object.assign({}, ctx);
-        ctx.tModelInfo = model;
-      }
-    } else if (attr.startsWith("block-")) {
-      throw new Error(`Invalid attribute: '${attr}'`);
-    } else if (attr !== "t-name") {
       if (attr.startsWith("t-") && !attr.startsWith("t-att")) {
         throw new Error(`Unknown QWeb directive: '${attr}'`);
       }
-      const tModel = ctx.tModelInfo;
-      if (tModel && ["t-att-value", "t-attf-value"].includes(attr)) {
-        tModel.hasDynamicChildren = true;
-      }
       attrs[attr] = value;
     }
   }
-
+  if (children.length === 1 && children[0].type === ASTType.TForEach) {
-  const children = parseChildren(node, ctx);
+    children[0].isOnlyChild = true;
+  }
   return {
     type: ASTType.DomNode,
     tag: tagName,
@@ -513,6 +498,8 @@ function parseTForEach(node: Element, ctx: ParsingContext): AST | null {
     body,
     memo,
     key,
+    isOnlyChild: false,
+    hasNoComponent: hasNoComponent(body),
     hasNoFirst,
     hasNoLast,
     hasNoIndex,
@@ -520,6 +507,58 @@ 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;
@@ -554,11 +593,17 @@ function parseTCall(node: Element, ctx: ParsingContext): AST | null {
     if (ast && ast.type === ASTType.TComponent) {
       return {
         ...ast,
-        slots: { default: { content: tcall } },
+        slots: { default: tcall },
       };
     }
   }
-  const body = parseChildren(node, ctx);
+  const body: AST[] = [];
+  for (let child of node.childNodes) {
+    const ast = parseNode(child, ctx);
+    if (ast) {
+      body.push(ast);
+    }
+  }
 
   return {
     type: ASTType.TCall,
@@ -592,7 +637,10 @@ function parseTIf(node: Element, ctx: ParsingContext): AST | null {
   }
   const condition = node.getAttribute("t-if")!;
   node.removeAttribute("t-if");
-  const content = parseNode(node, ctx) || { type: ASTType.Text, value: "" };
+  const content = parseNode(node, ctx);
+  if (!content) {
+    throw new Error("hmmm");
+  }
 
   let nextElement = node.nextElementSibling;
   // t-elifs
@@ -639,7 +687,13 @@ function parseTSetNode(node: Element, ctx: ParsingContext): AST | null {
   const defaultValue = node.innerHTML === node.textContent ? node.textContent || null : null;
   let body: AST[] | null = null;
   if (node.textContent !== node.innerHTML) {
-    body = parseChildren(node, ctx);
+    body = [];
+    for (let child of node.childNodes) {
+      let childAst = parseNode(child, ctx);
+      if (childAst) {
+        body.push(childAst);
+      }
+    }
   }
   return { type: ASTType.TSet, name, value, defaultValue, body };
 }
@@ -648,20 +702,6 @@ function parseTSetNode(node: Element, ctx: ParsingContext): AST | null {
 // Components
 // -----------------------------------------------------------------------------
 
-// Error messages when trying to use an unsupported directive on a component
-const directiveErrorMap = new Map([
-  ["t-on", "t-on is no longer supported on components. Consider passing a callback in props."],
-  [
-    "t-ref",
-    "t-ref is no longer supported on components. Consider exposing only the public part of the component's API through a callback prop.",
-  ],
-  ["t-att", "t-att makes no sense on component: props are already treated as expressions"],
-  [
-    "t-attf",
-    "t-attf is not supported on components: use template strings for string interpolation in props",
-  ],
-]);
-
 function parseComponent(node: Element, ctx: ParsingContext): AST | null {
   let name = node.tagName;
   const firstLetter = name[0];
@@ -682,15 +722,13 @@ function parseComponent(node: Element, ctx: ParsingContext): AST | null {
   const dynamicProps = node.getAttribute("t-props");
   node.removeAttribute("t-props");
 
-  const defaultSlotScope = node.getAttribute("t-slot-scope");
-  node.removeAttribute("t-slot-scope");
-
   const props: ASTComponent["props"] = {};
   for (let name of node.getAttributeNames()) {
     const value = node.getAttribute(name)!;
-    if (name.startsWith("t-")) {
+    if (name.startsWith("t-on-")) {
-      const message = directiveErrorMap.get(name.split("-").slice(0, 2).join("-"));
+      throw new Error(
-      throw new Error(message || `unsupported directive on Component: ${name}`);
+        "t-on is no longer supported on Component node. Consider passing a callback in props."
+      );
     } else {
       props[name] = value;
     }
@@ -703,11 +741,6 @@ function parseComponent(node: Element, ctx: ParsingContext): AST | null {
     // named slots
     const slotNodes = Array.from(clone.querySelectorAll("[t-set-slot]"));
     for (let slotNode of slotNodes) {
-      if (slotNode.tagName !== "t") {
-        throw new Error(
-          `Directive 't-set-slot' can only be used on <t> nodes (used on a <${slotNode.tagName}>)`
-        );
-      }
       const name = slotNode.getAttribute("t-set-slot")!;
 
       // check if this is defined in a sub component (in which case it should
@@ -729,30 +762,14 @@ function parseComponent(node: Element, ctx: ParsingContext): AST | null {
       slotNode.remove();
       const slotAst = parseNode(slotNode, ctx);
       if (slotAst) {
-        const slotInfo: any = { content: slotAst };
+        slots[name] = slotAst;
-        const attrs: { [key: string]: string } = {};
-        for (let attributeName of slotNode.getAttributeNames()) {
-          const value = slotNode.getAttribute(attributeName)!;
-          if (attributeName === "t-slot-scope") {
-            slotInfo.scope = value;
-            continue;
-          }
-          attrs[attributeName] = value;
-        }
-        if (Object.keys(attrs).length) {
-          slotInfo.attrs = attrs;
-        }
-        slots[name] = slotInfo;
       }
     }
 
     // default slot
     const defaultContent = parseChildNodes(clone, ctx);
     if (defaultContent) {
-      slots.default = { content: defaultContent };
+      slots.default = defaultContent;
-      if (defaultSlotScope) {
-        slots.default.scope = defaultSlotScope;
-      }
     }
   }
   return { type: ASTType.TComponent, name, isDynamic, dynamicProps, props, slots };
@@ -766,17 +783,9 @@ function parseTSlot(node: Element, ctx: ParsingContext): AST | null {
   if (!node.hasAttribute("t-slot")) {
     return null;
   }
-  const name = node.getAttribute("t-slot")!;
-  node.removeAttribute("t-slot");
-  const attrs: { [key: string]: string } = {};
-  for (let attributeName of node.getAttributeNames()) {
-    const value = node.getAttribute(attributeName)!;
-    attrs[attributeName] = value;
-  }
   return {
     type: ASTType.TSlot,
-    name,
+    name: node.getAttribute("t-slot")!,
-    attrs,
     defaultContent: parseChildNodes(node, ctx),
   };
 }
@@ -792,58 +801,18 @@ 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
 // -----------------------------------------------------------------------------
 
-/**
+function parseChildNodes(node: Element, ctx: ParsingContext): AST | null {
- * Parse all the child nodes of a given node and return a list of ast elements
- */
-function parseChildren(node: Element, ctx: ParsingContext): AST[] {
   const children: AST[] = [];
   for (let child of node.childNodes) {
     const childAst = parseNode(child, ctx);
     if (childAst) {
-      if (childAst.type === ASTType.Multi) {
+      children.push(childAst);
-        children.push(...childAst.content);
-      } else {
-        children.push(childAst);
-      }
     }
   }
-  return children;
-}
-
-/**
- * Parse all the child nodes of a given node and return an ast if possible.
- * In the case there are multiple children, they are wrapped in a astmulti.
- */
-function parseChildNodes(node: Element, ctx: ParsingContext): AST | null {
-  const children = parseChildren(node, ctx);
   switch (children.length) {
     case 0:
       return null;
@@ -853,17 +822,34 @@ function parseChildNodes(node: Element, ctx: ParsingContext): AST | null {
       return { type: ASTType.Multi, content: children };
   }
 }
+function parseXML(xml: string): Document {
+  const parser = new DOMParser();
 
-/**
+  const doc = parser.parseFromString(xml, "text/xml");
- * Normalizes the content of an Element so that t-if/t-elif/t-else directives
+  if (doc.getElementsByTagName("parsererror").length) {
- * immediately follow one another (by removing empty text nodes or comments).
+    let msg = "Invalid XML in template.";
- * Throws an error when a conditional branching statement is malformed. This
+    const parsererrorText = doc.getElementsByTagName("parsererror")[0].textContent;
- * function modifies the Element in place.
+    if (parsererrorText) {
- *
+      msg += "\nThe parser has produced the following error message:\n" + parsererrorText;
- * @param el the element containing the tree that should be normalized
+      const re = /\d+/g;
- */
+      const firstMatch = re.exec(parsererrorText);
-function normalizeTIf(el: Element) {
+      if (firstMatch) {
-  let tbranch = el.querySelectorAll("[t-elif], [t-else]");
+        const lineNumber = Number(firstMatch[0]);
+        const line = xml.split("\n")[lineNumber - 1];
+        const secondMatch = re.exec(parsererrorText);
+        if (line && secondMatch) {
+          const columnIndex = Number(secondMatch[0]) - 1;
+          if (line[columnIndex]) {
+            msg +=
+              `\nThe error might be located at xml line ${lineNumber} column ${columnIndex}\n` +
+              `${line}\n${"-".repeat(columnIndex - 1)}^`;
+          }
+        }
+      }
+    }
+    throw new Error(msg);
+  }
+  let tbranch = doc.querySelectorAll("[t-elif], [t-else]");
   for (let i = 0, ilen = tbranch.length; i < ilen; i++) {
     let node = tbranch[i];
     let prevElem = node.previousElementSibling!;
@@ -897,78 +883,6 @@ function normalizeTIf(el: Element) {
       );
     }
   }
-}
-
-/**
- * Normalizes the content of an Element so that t-esc directives on components
- * are removed and instead places a <t t-esc=""> as the default slot of the
- * component. Also throws if the component already has content. This function
- * modifies the Element in place.
- *
- * @param el the element containing the tree that should be normalized
- */
-function normalizeTEsc(el: Element) {
-  const elements = [...el.querySelectorAll("[t-esc]")].filter(
-    (el) => el.tagName[0] === el.tagName[0].toUpperCase() || el.hasAttribute("t-component")
-  );
-  for (const el of elements) {
-    if (el.childNodes.length) {
-      throw new Error("Cannot have t-esc on a component that already has content");
-    }
-    const value = el.getAttribute("t-esc");
-    el.removeAttribute("t-esc");
-    const t = el.ownerDocument.createElement("t");
-    if (value != null) {
-      t.setAttribute("t-esc", value);
-    }
-    el.appendChild(t);
-  }
-}
-
-/**
- * Normalizes the tree inside a given element and do some preliminary validation
- * on it. This function modifies the Element in place.
- *
- * @param el the element containing the tree that should be normalized
- */
-function normalizeXML(el: Element) {
-  normalizeTIf(el);
-  normalizeTEsc(el);
-}
-
-/**
- * Parses an XML string into an XML document, throwing errors on parser errors
- * instead of returning an XML document containing the parseerror.
- *
- * @param xml the string to parse
- * @returns an XML document corresponding to the content of the string
- */
-function parseXML(xml: string): XMLDocument {
-  const parser = new DOMParser();
-  const doc = parser.parseFromString(xml, "text/xml");
-  if (doc.getElementsByTagName("parsererror").length) {
-    let msg = "Invalid XML in template.";
-    const parsererrorText = doc.getElementsByTagName("parsererror")[0].textContent;
-    if (parsererrorText) {
-      msg += "\nThe parser has produced the following error message:\n" + parsererrorText;
-      const re = /\d+/g;
-      const firstMatch = re.exec(parsererrorText);
-      if (firstMatch) {
-        const lineNumber = Number(firstMatch[0]);
-        const line = xml.split("\n")[lineNumber - 1];
-        const secondMatch = re.exec(parsererrorText);
-        if (line && secondMatch) {
-          const columnIndex = Number(secondMatch[0]) - 1;
-          if (line[columnIndex]) {
-            msg +=
-              `\nThe error might be located at xml line ${lineNumber} column ${columnIndex}\n` +
-              `${line}\n${"-".repeat(columnIndex - 1)}^`;
-          }
-        }
-      }
-    }
-    throw new Error(msg);
-  }
 
   return doc;
 }

src/component/component.ts

@@ -1,42 +1,34 @@
+import type { Env } from "../app/app";
 import type { ComponentNode } from "./component_node";
 
+export type Props = { [key: string]: any };
+
 // -----------------------------------------------------------------------------
 //  Component Class
 // -----------------------------------------------------------------------------
 
-type Props = { [key: string]: any };
+export class Component {
-
-interface StaticComponentProperties {
-  template: string;
-  defaultProps?: any;
-  props?: any;
-}
-
-export type ComponentConstructor<P extends Props = any, E = any> = (new (
-  props: P,
-  env: E,
-  node: ComponentNode
-) => Component<P, E>) &
-  StaticComponentProperties;
-
-export class Component<Props = any, Env = any> {
   static template: string = "";
+  static style: string = "";
   static props?: any;
-  static defaultProps?: any;
 
-  props: Props;
+  props: any;
   env: Env;
   __owl__: ComponentNode;
 
-  constructor(props: Props, env: Env, node: ComponentNode) {
+  constructor(props: any, env: Env, node: ComponentNode) {
     this.props = props;
     this.env = env;
     this.__owl__ = node;
   }
+  get el(): HTMLElement | Text | undefined {
+    const node = this.__owl__;
+    return node.bdom ? (node.bdom.firstNode() as any) : undefined;
+  }
 
   setup() {}
 
-  render(deep: boolean = false) {
+  render(deep: boolean = false): Promise<void> {
-    this.__owl__.render(deep);
+    return this.__owl__.render(deep);
   }
 }

src/component/component_node.ts

@@ -1,8 +1,8 @@
 import type { App, Env } from "../app/app";
 import { BDom, VNode } from "../blockdom";
-import { clearReactivesForCallback, Reactive, reactive, TARGET, NonReactive } from "../reactivity";
+import { clearReactivesForCallback, Reactive, reactive } from "../reactivity";
 import { batched, Callback } from "../utils";
-import { Component, ComponentConstructor } from "./component";
+import { Component, Props } from "./component";
 import { fibersInError, handleError } from "./error_handling";
 import {
   Fiber,
@@ -11,23 +11,18 @@ import {
   MountFiber,
   MountOptions,
   RootFiber,
+  __internal__destroyed
 } from "./fibers";
 import { applyDefaultProps } from "./props_validation";
 import { STATUS } from "./status";
+import { applyStyles } from "./style";
 
 let currentNode: ComponentNode | null = null;
 
-export function getCurrent(): ComponentNode {
+export function getCurrent(): ComponentNode | null {
-  if (!currentNode) {
-    throw new Error("No active component (a hook function should only be called in 'setup')");
-  }
   return currentNode;
 }
 
-export function useComponent(): Component {
-  return currentNode!.component;
-}
-
 // -----------------------------------------------------------------------------
 // Integration with reactivity system (useState)
 // -----------------------------------------------------------------------------
@@ -43,39 +38,41 @@ const batchedRenderFunctions = new WeakMap<ComponentNode, Callback>();
  *  relevant changes
  * @see reactive
  */
-export function useState<T extends object>(state: T): Reactive<T> | NonReactive<T> {
+export function useState<T extends object>(state: T): Reactive<T> {
-  const node = getCurrent();
+  if (!batchedRenderFunctions.has(currentNode!)) {
-  let render = batchedRenderFunctions.get(node)!;
+    batchedRenderFunctions.set(
-  if (!render) {
+      currentNode!,
-    render = batched(node.render.bind(node));
+      batched(() => currentNode!.render())
-    batchedRenderFunctions.set(node, render);
+    );
-    // manual implementation of onWillDestroy to break cyclic dependency
-    node.willDestroy.push(clearReactivesForCallback.bind(null, render));
   }
-  return reactive(state, render);
+  const render = batchedRenderFunctions.get(currentNode!)!;
+  const reactiveState = reactive(state, render);
+
+  // manual implementation of onWillUnmount to break cyclic dependency
+  currentNode!.willUnmount.unshift( clearReactivesForCallback.bind(null, render))
+  return reactiveState;
 }
 
 // -----------------------------------------------------------------------------
 // component function (used in compiled template code)
 // -----------------------------------------------------------------------------
-type Props = { [key: string]: any };
-
 function arePropsDifferent(props1: Props, props2: Props): boolean {
   for (let k in props1) {
     if (props1[k] !== props2[k]) {
       return true;
     }
   }
-  return Object.keys(props1).length !== Object.keys(props2).length;
+  return false;
 }
-
+export function component(
-export function component<P extends object>(
+  name: string | typeof Component,
-  name: string | ComponentConstructor<P>,
+  props: any,
-  props: P,
   key: string,
   ctx: ComponentNode,
-  parent: any
+  parent: any,
-): ComponentNode<P> {
+  hasSlots: boolean = false
+): ComponentNode {
+  console.warn('asdf')
   let node: any = ctx.children[key];
   let isDynamic = typeof name !== "string";
 
@@ -93,8 +90,9 @@ export function component<P extends object>(
 
   const parentFiber = ctx.fiber!;
   if (node) {
-    const currentProps = node.component.props[TARGET];
+    console.warn('coucou');
-    if (parentFiber.deep || arePropsDifferent(currentProps, props)) {
+    if (hasSlots || parentFiber.deep || arePropsDifferent(node.component.props, props)) {
+      console.warn('coucou3');
       node.updateAndRender(props, parentFiber);
     }
   } else {
@@ -111,7 +109,8 @@ export function component<P extends object>(
     node = new ComponentNode(C, props, ctx.app, ctx);
     ctx.children[key] = node;
 
-    node.initiateRender(new Fiber(node, parentFiber));
+    const fiber = makeChildFiber(node, parentFiber);
+    node.initiateRender(fiber);
   }
   return node;
 }
@@ -122,11 +121,13 @@ export function component<P extends object>(
 
 type LifecycleHook = Function;
 
-export class ComponentNode<P extends object = any, E = any> implements VNode<ComponentNode<P, E>> {
+export class ComponentNode<T extends typeof Component = typeof Component>
+  implements VNode<ComponentNode>
+{
   el?: HTMLElement | Text | undefined;
   app: App;
   fiber: Fiber | null = null;
-  component: Component<P, E>;
+  component: InstanceType<T>;
   bdom: BDom | null = null;
   status: STATUS = STATUS.NEW;
 
@@ -135,6 +136,7 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
   level: number;
   childEnv: Env;
   children: { [key: string]: ComponentNode } = Object.create(null);
+  slots: any = {};
   refs: any = {};
 
   willStart: LifecycleHook[] = [];
@@ -143,9 +145,9 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
   mounted: LifecycleHook[] = [];
   willPatch: LifecycleHook[] = [];
   patched: LifecycleHook[] = [];
-  willDestroy: LifecycleHook[] = [];
+  destroyed: LifecycleHook[] = [];
 
-  constructor(C: ComponentConstructor<P, E>, props: P, app: App, parent?: ComponentNode) {
+  constructor(C: T, props: any, app: App, parent?: ComponentNode) {
     currentNode = this;
     this.app = app;
     this.parent = parent || null;
@@ -153,23 +155,27 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
     applyDefaultProps(props, C);
     const env = (parent && parent.childEnv) || app.env;
     this.childEnv = env;
-    props = useState(props);
+    // if (props) {
+    //   props = useState(props);
+    // }
     this.component = new C(props, env, this) as any;
     this.renderFn = app.getTemplate(C.template).bind(this.component, this.component, this);
+    if (C.style) {
+      applyStyles(C);
+    }
     this.component.setup();
-    currentNode = null;
   }
 
-  mountComponent(target: any, options?: MountOptions) {
+  mountComponent(target: any, options?: MountOptions): Promise<InstanceType<T>> {
     const fiber = new MountFiber(this, target, options);
     this.app.scheduler.addFiber(fiber);
     this.initiateRender(fiber);
+    return fiber.promise.then(() => this.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 {
@@ -184,132 +190,85 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
   }
 
   async render(deep: boolean = false) {
-    let current = this.fiber;
+    let fiber = this.fiber;
-    if (current && current.root!.locked) {
+    if (fiber && !fiber.bdom && !fibersInError.has(fiber)) {
-      await Promise.resolve();
+      return fiber.root.promise;
-      // situation may have changed after the microtask tick
-      current = this.fiber;
     }
-    if (current) {
+    if (!this.bdom && !fiber) {
-      if (!current.bdom && !fibersInError.has(current)) {
+      // should find a way to return the future mounting promise
-        if (deep) {
-          // we want the render from this point on to be with deep=true
-          current.deep = deep;
-        }
-        return;
-      }
-      // if current rendering was with deep=true, we want this one to be the same
-      deep = deep || current.deep;
-    } else if (!this.bdom) {
       return;
     }
-
+    fiber = makeRootFiber(this);
-    const fiber = makeRootFiber(this);
     fiber.deep = deep;
-    this.fiber = fiber;
     this.app.scheduler.addFiber(fiber);
     await Promise.resolve();
     if (this.status === STATUS.DESTROYED) {
       return;
     }
-    // We only want to actually render the component if the following two
+    if (this.fiber === fiber) {
-    // conditions are true:
-    // * this.fiber: it could be null, in which case the render has been cancelled
-    // * (current || !fiber.parent): if current is not null, this means that the
-    //   render function was called when a render was already occurring. In this
-    //   case, the pending rendering was cancelled, and the fiber needs to be
-    //   rendered to complete the work.  If current is null, we check that the
-    //   fiber has no parent.  If that is the case, the fiber was downgraded from
-    //   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 === fiber && (current || !fiber.parent)) {
       this._render(fiber);
     }
+    return fiber.root.promise;
   }
 
   _render(fiber: Fiber | RootFiber) {
     try {
       fiber.bdom = this.renderFn();
-      fiber.root!.counter--;
+      fiber.root.counter--;
     } catch (e) {
       handleError({ node: this, error: e });
     }
   }
 
   destroy() {
-    let shouldRemove = this.status === STATUS.MOUNTED;
+    if (this.status === STATUS.MOUNTED) {
-    this._destroy();
+      callWillUnmount(this);
-    if (shouldRemove) {
       this.bdom!.remove();
     }
-  }
+    callDestroyed(this);
 
-  _destroy() {
+    function callWillUnmount(node: ComponentNode) {
-    const component = this.component;
+      const component = node.component;
-    if (this.status === STATUS.MOUNTED) {
+      for (let cb of node.willUnmount) {
-      for (let cb of this.willUnmount) {
+        cb.call(component);
+      }
+      for (let child of Object.values(node.children)) {
+        if (child.status === STATUS.MOUNTED) {
+          callWillUnmount(child);
+        }
+      }
+    }
+
+    function callDestroyed(node: ComponentNode) {
+      const component = node.component;
+      node.status = STATUS.DESTROYED;
+      for (let child of Object.values(node.children)) {
+        callDestroyed(child);
+      }
+      for (let cb of node.destroyed) {
         cb.call(component);
       }
     }
-    for (let child of Object.values(this.children)) {
-      child._destroy();
-    }
-    for (let cb of this.willDestroy) {
-      cb.call(component);
-    }
-    this.status = STATUS.DESTROYED;
   }
 
   async updateAndRender(props: any, parentFiber: Fiber) {
     // update
     const fiber = makeChildFiber(this, parentFiber);
-    this.fiber = fiber;
+    if (this.willPatch.length) {
+      parentFiber.root.willPatch.push(fiber);
+    }
+    if (this.patched.length) {
+      parentFiber.root.patched.push(fiber);
+    }
     const component = this.component;
     applyDefaultProps(props, component.constructor as any);
-
-    currentNode = this;
-    props = useState(props);
-    currentNode = null;
     const prom = Promise.all(this.willUpdateProps.map((f) => f.call(component, props)));
     await prom;
     if (fiber !== this.fiber) {
       return;
     }
-    component.props = props;
+    this.component.props = props;
     this._render(fiber);
-    const parentRoot = parentFiber.root!;
-    if (this.willPatch.length) {
-      parentRoot.willPatch.push(fiber);
-    }
-    if (this.patched.length) {
-      parentRoot.patched.push(fiber);
-    }
-  }
-
-  /**
-   * Finds a child that has dom that is not yet updated, and update it. This
-   * method is meant to be used only in the context of repatching the dom after
-   * a mounted hook failed and was handled.
-   */
-  updateDom() {
-    if (!this.fiber) {
-      return;
-    }
-    if (this.bdom === this.fiber!.bdom) {
-      // If the error was handled by some child component, we need to find it to
-      // apply its change
-      for (let k in this.children) {
-        const child = this.children[k];
-        child.updateDom();
-      }
-    } else {
-      // if we get here, this is the component that handled the error and rerendered
-      // itself, so we can simply patch the dom
-      this.bdom!.patch(this.fiber!.bdom, false);
-      this.fiber!.appliedToDom = true;
-      this.fiber = null;
-    }
   }
 
   // ---------------------------------------------------------------------------
@@ -335,42 +294,36 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
   }
 
   patch() {
-    if (this.fiber && this.fiber.parent) {
+    if (!this.fiber) {
-      // we only patch here renderings coming from above. renderings initiated
+      // component was not rendered => no need to do anything
-      // by the component will be patched independently in the appropriate
+      return;
-      // fiber.complete
-      this._patch();
-    }
-  }
-  _patch() {
-    const hasChildren = Object.keys(this.children).length > 0;
-    this.bdom!.patch(this!.fiber!.bdom!, hasChildren);
-    if (hasChildren) {
-      this.cleanOutdatedChildren();
     }
+    this.bdom!.patch(this!.fiber!.bdom!, false);
     this.fiber!.appliedToDom = true;
     this.fiber = null;
   }
 
   beforeRemove() {
-    this._destroy();
+    visitRemovedNodes(this);
   }
 
   remove() {
     this.bdom!.remove();
   }
+}
 
-  cleanOutdatedChildren() {
+function visitRemovedNodes(node: ComponentNode) {
-    const children = this.children;
+  if (node.status === STATUS.MOUNTED) {
-    for (const key in children) {
+    const component = node.component;
-      const node = children[key];
+    for (let cb of node.willUnmount) {
-      const status = node.status;
+      cb.call(component);
-      if (status !== STATUS.MOUNTED) {
-        delete children[key];
-        if (status !== STATUS.DESTROYED) {
-          node.destroy();
-        }
-      }
     }
   }
+  for (let child of Object.values(node.children)) {
+    visitRemovedNodes(child);
+  }
+  node.status = STATUS.DESTROYED;
+  if (node.destroyed.length) {
+    __internal__destroyed.push(node);
+  }
 }

src/component/error_handling.ts

@@ -16,26 +16,27 @@ function _handleError(node: ComponentNode | null, error: any, isFirstRound = fal
 
   const errorHandlers = nodeErrorHandlers.get(node);
   if (errorHandlers) {
-    let stopped = false;
+    if (isFirstRound && fiber) {
-    // execute in the opposite order
+      fiber.root.counter--;
-    for (let i = errorHandlers.length - 1; i >= 0; i--) {
+    }
+
+    let propagate = true;
+    for (const h of errorHandlers) {
       try {
-        errorHandlers[i](error);
+        h(error);
-        stopped = true;
+        propagate = false;
-        break;
       } catch (e) {
         error = e;
       }
     }
 
-    if (stopped) {
+    if (propagate) {
-      if (isFirstRound && fiber && fiber.node.fiber) {
+      return _handleError(node.parent, error);
-        fiber.root!.counter--;
-      }
-      return true;
     }
+    return true;
+  } else {
+    return _handleError(node.parent, error);
   }
-  return _handleError(node.parent, error);
 }
 
 type ErrorParams = { error: any } & ({ node: ComponentNode } | { fiber: Fiber });
@@ -44,23 +45,13 @@ export function handleError(params: ErrorParams) {
   const node = "node" in params ? params.node : params.fiber.node;
   const fiber = "fiber" in params ? params.fiber : node.fiber!;
 
-  // resets the fibers on components if possible. This is important so that
+  fibersInError.set(fiber.root, error);
-  // new renderings can be properly included in the initial one, if any.
-  let current: Fiber | null = fiber;
-  do {
-    current.node.fiber = current;
-    current = current.parent;
-  } while (current);
-
-  fibersInError.set(fiber.root!, error);
 
   const handled = _handleError(node, error, true);
   if (!handled) {
-    console.warn(`[Owl] Unhandled error. Destroying the root component`);
     try {
       node.app.destroy();
-    } catch (e) {
+    } catch (e) {}
-      console.error(e);
-    }
   }
+  return handled;
 }

src/component/fibers.ts

@@ -1,13 +1,20 @@
-import { BDom, mount } from "../blockdom";
+import type { BDom } from "../blockdom";
+import { mount } from "../blockdom";
 import type { ComponentNode } from "./component_node";
-import { fibersInError, handleError } from "./error_handling";
 import { STATUS } from "./status";
+import { fibersInError, handleError } from "./error_handling";
 
 export function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber {
   let current = node.fiber;
   if (current) {
-    cancelFibers(current.children);
+    // current is necessarily a rootfiber here
-    current.root = null;
+    let root = parent.root;
+    cancelFibers(root, current.children);
+    current.children = [];
+    current.parent = parent;
+    root.counter++;
+    current.root = root;
+    return current;
   }
   return new Fiber(node, parent);
 }
@@ -15,38 +22,40 @@ 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 = root.counter + 1 - cancelFibers(current.children);
+    root.counter -= cancelFibers(root, current.children);
     current.children = [];
+    root.counter++;
     current.bdom = null;
     if (fibersInError.has(current)) {
       fibersInError.delete(current);
       fibersInError.delete(root);
-      current.appliedToDom = false;
     }
     return current;
   }
-  const fiber = new RootFiber(node, null);
+  const fiber = new RootFiber(node);
   if (node.willPatch.length) {
     fiber.willPatch.push(fiber);
   }
   if (node.patched.length) {
     fiber.patched.push(fiber);
   }
+
   return fiber;
 }
 
 /**
  * @returns number of not-yet rendered fibers cancelled
  */
-function cancelFibers(fibers: Fiber[]): number {
+function cancelFibers(root: any, fibers: Fiber[]): number {
   let result = 0;
   for (let fiber of fibers) {
     fiber.node.fiber = null;
+    fiber.root = root;
     if (!fiber.bdom) {
       result++;
     }
-    result += cancelFibers(fiber.children);
+    result += cancelFibers(root, fiber.children);
   }
   return result;
 }
@@ -54,7 +63,7 @@ function cancelFibers(fibers: Fiber[]): number {
 export class Fiber {
   node: ComponentNode;
   bdom: BDom | null = null;
-  root: RootFiber | null; // A Fiber that has been replaced by another has no root
+  root: RootFiber;
   parent: Fiber | null;
   children: Fiber[] = [];
   appliedToDom = false;
@@ -62,10 +71,10 @@ export class Fiber {
 
   constructor(node: ComponentNode, parent: Fiber | null) {
     this.node = node;
+    node.fiber = this;
     this.parent = parent;
     if (parent) {
-      this.deep = parent.deep;
+      const root = parent.root;
-      const root = parent.root!;
       root.counter++;
       this.root = root;
       parent.children.push(this);
@@ -77,18 +86,27 @@ export class Fiber {
 
 export class RootFiber extends Fiber {
   counter: number = 1;
+  resolve: any;
+  promise: Promise<any>;
+  reject: any;
 
   // only add stuff in this if they have registered some hooks
   willPatch: Fiber[] = [];
   patched: Fiber[] = [];
   mounted: Fiber[] = [];
-  // A fiber is typically locked when it is completing and the patch has not, or is being applied.
+
-  // i.e.: render triggered in onWillUnmount or in willPatch will be delayed
+  constructor(node: ComponentNode) {
-  locked: boolean = false;
+    super(node, null);
+    this.counter = 1;
+
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
 
   complete() {
     const node = this.node;
-    this.locked = true;
     let current: Fiber | undefined = undefined;
     try {
       // Step 1: calling all willPatch lifecycle hooks
@@ -107,8 +125,16 @@ export class RootFiber extends Fiber {
       current = undefined;
 
       // Step 2: patching the dom
-      node._patch();
+      node.bdom!.patch(this.bdom!, Object.keys(node.children).length > 0);
-      this.locked = false;
+      this.appliedToDom = true;
+
+      // Step 3: calling all destroyed hooks
+      for (let node of __internal__destroyed) {
+        for (let cb of node.destroyed) {
+          cb();
+        }
+      }
+      __internal__destroyed.length = 0;
 
       // Step 4: calling all mounted lifecycle hooks
       let mountedFibers = this.mounted;
@@ -131,13 +157,18 @@ export class RootFiber extends Fiber {
           }
         }
       }
+      // unregistering the fiber
+      node.fiber = null;
     } catch (e) {
-      this.locked = false;
+      if (!handleError({ fiber: current || this, error: e })) {
-      handleError({ fiber: current || this, error: e });
+        this.reject(e);
+      }
     }
   }
 }
 
+export let __internal__destroyed: ComponentNode[] = [];
+
 type Position = "first-child" | "last-child";
 
 export interface MountOptions {
@@ -149,7 +180,7 @@ export class MountFiber extends RootFiber {
   position: Position;
 
   constructor(node: ComponentNode, target: HTMLElement, options: MountOptions = {}) {
-    super(node, null);
+    super(node);
     this.target = target;
     this.position = options.position || "last-child";
   }
@@ -157,27 +188,13 @@ export class MountFiber extends RootFiber {
     let current: Fiber | undefined = this;
     try {
       const node = this.node;
-      (node.app.constructor as any).validateTarget(this.target);
+      node.bdom = this.bdom;
-      if (node.bdom) {
+      if (this.position === "last-child" || this.target.childNodes.length === 0) {
-        // this is a complicated situation: if we mount a fiber with an existing
+        mount(node.bdom!, this.target);
-        // bdom, this means that this same fiber was already completed, mounted,
-        // but a crash occurred in some mounted hook. Then, it was handled and
-        // the new rendering is being applied.
-        node.updateDom();
       } else {
-        node.bdom = this.bdom;
+        const firstChild = this.target.childNodes[0];
-        if (this.position === "last-child" || this.target.childNodes.length === 0) {
+        mount(node.bdom!, this.target, firstChild);
-          mount(node.bdom!, this.target);
-        } else {
-          const firstChild = this.target.childNodes[0];
-          mount(node.bdom!, this.target, firstChild);
-        }
       }
-
-      // unregistering the fiber before mounted since it can do another render
-      // and that the current rendering is obviously completed
-      node.fiber = null;
-
       node.status = STATUS.MOUNTED;
       this.appliedToDom = true;
       let mountedFibers = this.mounted;
@@ -188,8 +205,11 @@ export class MountFiber extends RootFiber {
           }
         }
       }
+      node.fiber = null;
     } catch (e) {
-      handleError({ fiber: current as Fiber, error: e });
+      if (!handleError({ fiber: current as Fiber, error: e })) {
+        this.reject(e);
+      }
     }
   }
 }

src/component/handler.ts

@@ -1,5 +1,4 @@
 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);
@@ -31,14 +30,7 @@ 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)) {
-    const handler = data[0];
+    data[0].call(data[1] ? data[1].__owl__.component : null, ev);
-    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

@@ -1,106 +1,72 @@
 import { getCurrent } from "./component_node";
 import { nodeErrorHandlers } from "./error_handling";
 
-function wrapError(fn: (...args: any[]) => any, hookName: string) {
-  const error = new Error(`The following error occurred in ${hookName}: `) as Error & {
-    cause: any;
-  };
-  return (...args: any[]) => {
-    try {
-      const result = fn(...args);
-      if (result instanceof Promise) {
-        return result.catch((cause) => {
-          error.cause = cause;
-          if (cause instanceof Error) {
-            error.message += `"${cause.message}"`;
-          }
-          throw error;
-        });
-      }
-      return result;
-    } catch (cause) {
-      if (cause instanceof Error) {
-        error.message += `"${cause.message}"`;
-      }
-      throw error;
-    }
-  };
-}
-
 // -----------------------------------------------------------------------------
 //  hooks
 // -----------------------------------------------------------------------------
 
 export function onWillStart(fn: () => Promise<void> | void | any) {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.willStart.push(fn);
-  node.willStart.push(decorate(fn.bind(node.component), "onWillStart"));
 }
 
 export function onWillUpdateProps(fn: (nextProps: any) => Promise<void> | void | any) {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.willUpdateProps.push(fn);
-  node.willUpdateProps.push(decorate(fn.bind(node.component), "onWillUpdateProps"));
 }
 
 export function onMounted(fn: () => void | any) {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.mounted.push(fn);
-  node.mounted.push(decorate(fn.bind(node.component), "onMounted"));
 }
 
 export function onWillPatch(fn: () => Promise<void> | any | void) {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.willPatch.unshift(fn);
-  node.willPatch.unshift(decorate(fn.bind(node.component), "onWillPatch"));
 }
 
 export function onPatched(fn: () => void | any) {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.patched.push(fn);
-  node.patched.push(decorate(fn.bind(node.component), "onPatched"));
 }
 
 export function onWillUnmount(fn: () => Promise<void> | void | any) {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.willUnmount.unshift(fn);
-  node.willUnmount.unshift(decorate(fn.bind(node.component), "onWillUnmount"));
 }
 
-export function onWillDestroy(fn: () => Promise<void> | void | any) {
+export function onDestroyed(fn: () => Promise<void> | void | any) {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.destroyed.push(fn);
-  node.willDestroy.push(decorate(fn.bind(node.component), "onWillDestroy"));
 }
 
 export function onWillRender(fn: () => void | any) {
-  const node = getCurrent();
+  const node = getCurrent()!;
   const renderFn = node.renderFn;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.renderFn = () => {
-  node.renderFn = decorate(() => {
+    fn();
-    fn.call(node.component);
     return renderFn();
-  }, "onWillRender");
+  };
 }
 
 export function onRendered(fn: () => void | any) {
-  const node = getCurrent();
+  const node = getCurrent()!;
   const renderFn = node.renderFn;
-  const decorate = node.app.dev ? wrapError : (fn: any) => fn;
+  node.renderFn = () => {
-  node.renderFn = decorate(() => {
     const result = renderFn();
-    fn.call(node.component);
+    fn();
     return result;
-  }, "onRendered");
+  };
 }
 
-type OnErrorCallback = (error: any) => void | any;
+export function onError(fn: (error: Error) => void | any) {
-export function onError(callback: OnErrorCallback) {
+  const node = getCurrent()!;
-  const node = getCurrent();
   let handlers = nodeErrorHandlers.get(node);
-  if (!handlers) {
+  if (handlers) {
+    handlers.push(fn);
+  } else {
     handlers = [];
+    handlers.push(fn);
     nodeErrorHandlers.set(node, handlers);
   }
-  handlers.push(callback.bind(node.component));
 }

src/component/props_validation.ts

@@ -1,16 +1,16 @@
-import { ComponentConstructor } from "./component";
+import { Component } from "./component";
 
 /**
  * Apply default props (only top level).
  *
  * Note that this method does modify in place the props
  */
-export function applyDefaultProps<P>(props: P, ComponentClass: ComponentConstructor<P>) {
+export function applyDefaultProps(props: { [key: string]: any }, ComponentClass: typeof Component) {
-  const defaultProps = ComponentClass.defaultProps;
+  const defaultProps = (ComponentClass as any).defaultProps;
   if (defaultProps) {
     for (let propName in defaultProps) {
-      if ((props as any)[propName] === undefined) {
+      if (props![propName] === undefined) {
-        (props as any)[propName] = defaultProps[propName];
+        props![propName] = defaultProps[propName];
       }
     }
   }
@@ -19,14 +19,6 @@ export function applyDefaultProps<P>(props: P, ComponentClass: ComponentConstruc
 //------------------------------------------------------------------------------
 // Prop validation helper
 //------------------------------------------------------------------------------
-function getPropDescription(staticProps: any) {
-  if (staticProps instanceof Array) {
-    return Object.fromEntries(
-      staticProps.map((p) => (p.endsWith("?") ? [p.slice(0, -1), false] : [p, true]))
-    );
-  }
-  return staticProps || { "*": true };
-}
 
 /**
  * Validate the component props (or next props) against the (static) props
@@ -34,65 +26,60 @@ function getPropDescription(staticProps: any) {
  * visit recursively the props and all the children to check if they are valid.
  * This is why it is only done in 'dev' mode.
  */
-export function validateProps<P>(name: string | ComponentConstructor<P>, props: P, parent?: any) {
+export const validateProps = function (name: string | typeof Component, props: any, parent?: any) {
-  const ComponentClass =
+  const ComponentClass = (
-    typeof name !== "string"
+    typeof name !== "string" ? name : parent.constructor.components[name]
-      ? name
+  ) as typeof Component;
-      : (parent.constructor.components[name] as ComponentConstructor<P> | undefined);
 
-  if (!ComponentClass) {
-    // this is an error, wrong component. We silently return here instead so the
-    // error is triggered by the usual path ('component' function)
-    return;
-  }
   applyDefaultProps(props, ComponentClass);
 
-  const defaultProps = ComponentClass.defaultProps || {};
+  const propsDef = ComponentClass.props;
-  let propsDef = getPropDescription(ComponentClass.props);
+  if (propsDef instanceof Array) {
-  const allowAdditionalProps = "*" in propsDef;
+    // list of strings (prop names)
-
+    for (const propName of propsDef) {
-  for (let propName in propsDef) {
+      if (propName[propName.length - 1] === "?") {
-    if (propName === "*") {
+        // optional prop
-      continue;
+        break;
-    }
+      }
-    const propDef = propsDef[propName];
+      if (!(propName in props)) {
-    let isMandatory = !!propDef;
-    if (typeof propDef === "object" && "optional" in propDef) {
-      isMandatory = !propDef.optional;
-    }
-    if (isMandatory && propName in defaultProps) {
-      throw new Error(
-        `A default value cannot be defined for a mandatory prop (name: '${propName}', component: ${ComponentClass.name})`
-      );
-    }
-    if ((props as any)[propName] === undefined) {
-      if (isMandatory) {
         throw new Error(`Missing props '${propName}' (component '${ComponentClass.name}')`);
-      } else {
-        continue;
       }
     }
-    let isValid;
+    for (let key in props) {
-    try {
+      if (!propsDef.includes(key) && !propsDef.includes(key + "?")) {
-      isValid = isValidProp((props as any)[propName], propDef);
+        throw new Error(`Unknown prop '${key}' given to component '${ComponentClass.name}'`);
-    } catch (e) {
+      }
-      (e as Error).message = `Invalid prop '${propName}' in component ${ComponentClass.name} (${
-        (e as Error).message
-      })`;
-      throw e;
     }
-    if (!isValid) {
+  } else if (propsDef) {
-      throw new Error(`Invalid Prop '${propName}' in component '${ComponentClass.name}'`);
+    // propsDef is an object now
+    for (let propName in propsDef) {
+      if (props[propName] === undefined) {
+        if (propsDef[propName] && !propsDef[propName].optional) {
+          throw new Error(`Missing props '${propName}' (component '${ComponentClass.name}')`);
+        } else {
+          continue;
+        }
+      }
+      let isValid;
+      try {
+        isValid = isValidProp(props[propName], propsDef[propName]);
+      } catch (e) {
+        (e as Error).message = `Invalid prop '${propName}' in component ${ComponentClass.name} (${
+          (e as Error).message
+        })`;
+        throw e;
+      }
+      if (!isValid) {
+        throw new Error(`Invalid Prop '${propName}' in component '${ComponentClass.name}'`);
+      }
     }
-  }
-  if (!allowAdditionalProps) {
     for (let propName in props) {
       if (!(propName in propsDef)) {
         throw new Error(`Unknown prop '${propName}' given to component '${ComponentClass.name}'`);
       }
     }
   }
-}
+};
 
 /**
  * Check if an invidual prop value matches its (static) prop definition

src/component/scheduler.ts

@@ -1,5 +1,5 @@
-import { fibersInError } from "./error_handling";
 import { Fiber, RootFiber } from "./fibers";
+import { fibersInError } from "./error_handling";
 import { STATUS } from "./status";
 
 // -----------------------------------------------------------------------------
@@ -7,15 +7,12 @@ 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() {
+  constructor(requestAnimationFrame: Window["requestAnimationFrame"]) {
-    this.requestAnimationFrame = Scheduler.requestAnimationFrame;
+    this.requestAnimationFrame = requestAnimationFrame;
   }
 
   start() {
@@ -28,7 +25,7 @@ export class Scheduler {
   }
 
   addFiber(fiber: Fiber) {
-    this.tasks.add(fiber.root!);
+    this.tasks.add(fiber.root);
     if (!this.isRunning) {
       this.start();
     }
@@ -41,12 +38,19 @@ export class Scheduler {
   flush() {
     this.tasks.forEach((fiber) => {
       if (fiber.root !== fiber) {
+        // this is wrong! should be something like
+        // if (this.tasks.has(fiber.root)) {
+        //   // parent rendering has completed
+        //   fiber.resolve();
+        //   this.tasks.delete(fiber);
+        // }
         this.tasks.delete(fiber);
         return;
       }
       const hasError = fibersInError.has(fiber);
       if (hasError && fiber.counter !== 0) {
         this.tasks.delete(fiber);
+        fiber.reject(fibersInError.get(fiber));
         return;
       }
       if (fiber.node.status === STATUS.DESTROYED) {
@@ -57,6 +61,7 @@ export class Scheduler {
       if (fiber.counter === 0) {
         if (!hasError) {
           fiber.complete();
+          fiber.resolve();
         }
         this.tasks.delete(fiber);
       }

src/component/style.ts

@@ -0,0 +1,88 @@
+import { Component } from "./component";
+
+export const globalStylesheets: { [key: string]: HTMLStyleElement } = {};
+
+export function registerSheet(id: string, css: string) {
+  const sheet = document.createElement("style");
+  sheet.innerHTML = processSheet(css);
+  globalStylesheets[id] = sheet;
+}
+
+/**
+ * Apply the stylesheets defined by the component. Note that we need to make
+ * sure all inherited stylesheets are applied as well, in a reverse order to
+ * ensure that <style/> will be applied to the DOM in the order they are
+ * included in the document. We then delete the `style` key from the constructor
+ * to make sure we do not apply it again.
+ */
+export function applyStyles(ComponentClass: typeof Component) {
+  const toApply: [string, string][] = [];
+  while (ComponentClass && ComponentClass.style) {
+    if (ComponentClass.hasOwnProperty("style")) {
+      toApply.push([ComponentClass.style, ComponentClass.name]);
+      delete (ComponentClass as any).style;
+    }
+    ComponentClass = Object.getPrototypeOf(ComponentClass);
+  }
+  while (toApply.length) {
+    const [styleId, componentName] = toApply.pop()!;
+    activateSheet(styleId, componentName);
+  }
+}
+
+function activateSheet(id: string, name: string) {
+  const sheet = globalStylesheets[id];
+  if (!sheet) {
+    throw new Error(
+      `Invalid css stylesheet for component '${name}'. Did you forget to use the 'css' tag helper?`
+    );
+  }
+  sheet.dataset.component = name;
+  document.head.appendChild(sheet);
+}
+
+function processSheet(str: string): string {
+  const tokens = str.split(/(\{|\}|;)/).map((s) => s.trim());
+  const selectorStack: string[][] = [];
+  const parts: string[] = [];
+  let rules: string[] = [];
+  function generateSelector(stackIndex: number, parentSelector?: string) {
+    const parts: string[] = [];
+    for (const selector of selectorStack[stackIndex]) {
+      let part = (parentSelector && parentSelector + " " + selector) || selector;
+      if (part.includes("&")) {
+        part = selector.replace(/&/g, parentSelector || "");
+      }
+      if (stackIndex < selectorStack.length - 1) {
+        part = generateSelector(stackIndex + 1, part);
+      }
+      parts.push(part);
+    }
+    return parts.join(", ");
+  }
+  function generateRules() {
+    if (rules.length) {
+      parts.push(generateSelector(0) + " {");
+      parts.push(...rules);
+      parts.push("}");
+      rules = [];
+    }
+  }
+  while (tokens.length) {
+    let token = tokens.shift()!;
+    if (token === "}") {
+      generateRules();
+      selectorStack.pop();
+    } else {
+      if (tokens[0] === "{") {
+        generateRules();
+        selectorStack.push(token.split(/\s*,\s*/));
+        tokens.shift();
+      }
+      if (tokens[0] === ";") {
+        rules.push("  " + token + ";");
+      }
+    }
+  }
+  return parts.join("\n");
+}

src/hooks.ts

@@ -1,6 +1,6 @@
 import type { Env } from "./app/app";
 import { getCurrent } from "./component/component_node";
-import { onMounted, onPatched, onWillUnmount } from "./component/lifecycle_hooks";
+import { onMounted, onPatched, onWillPatch, onWillUnmount } from "./component/lifecycle_hooks";
 
 // -----------------------------------------------------------------------------
 // useRef
@@ -11,11 +11,10 @@ import { onMounted, onPatched, onWillUnmount } from "./component/lifecycle_hooks
  * html node or component.
  */
 export function useRef<T extends HTMLElement = HTMLElement>(name: string): { el: T | null } {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  const refs = node.refs;
   return {
     get el(): T | null {
-      return refs[name] || null;
+      return node.refs[name] || null;
     },
   };
 }
@@ -29,13 +28,7 @@ export function useRef<T extends HTMLElement = HTMLElement>(name: string): { el:
  * need a reference to the env of the component calling them.
  */
 export function useEnv<E extends Env>(): E {
-  return getCurrent().component.env as any;
+  return getCurrent()!.component.env as any;
-}
-
-function extendEnv(currentEnv: Object, extension: Object): Object {
-  const env = Object.create(currentEnv);
-  const descrs = Object.getOwnPropertyDescriptors(extension);
-  return Object.freeze(Object.defineProperties(env, descrs));
 }
 
 /**
@@ -44,15 +37,10 @@ function extendEnv(currentEnv: Object, extension: Object): Object {
  * constructor method.
  */
 export function useSubEnv(envExtension: Env) {
-  const node = getCurrent();
+  const node = getCurrent()!;
-  node.component.env = extendEnv(node.component.env as any, envExtension);
+  node.childEnv = Object.freeze(Object.assign({}, node.childEnv, envExtension));
-  useChildSubEnv(envExtension);
 }
 
-export function useChildSubEnv(envExtension: Env) {
-  const node = getCurrent();
-  node.childEnv = extendEnv(node.childEnv, envExtension);
-}
 // -----------------------------------------------------------------------------
 // useEffect
 // -----------------------------------------------------------------------------
@@ -85,12 +73,17 @@ export function useEffect(effect: Effect, computeDependencies: () => any[] = ()
     cleanup = effect(...dependencies) || NO_OP;
   });
 
-  onPatched(() => {
+  let shouldReapplyOnPatch = false;
+  onWillPatch(() => {
     const newDeps = computeDependencies();
-    const shouldReapply = newDeps.some((val, i) => val !== dependencies[i]);
+    shouldReapplyOnPatch = newDeps.some((val, i) => val !== dependencies[i]);
-    if (shouldReapply) {
+    if (shouldReapplyOnPatch) {
-      dependencies = newDeps;
       cleanup();
+      dependencies = newDeps;
+    }
+  });
+  onPatched(() => {
+    if (shouldReapplyOnPatch) {
       cleanup = effect(...dependencies) || NO_OP;
     }
   });
@@ -121,7 +114,7 @@ export function useExternalListener(
   handler: EventListener,
   eventParams?: AddEventListenerOptions
 ) {
-  const node = getCurrent();
+  const node = getCurrent()!;
   const boundHandler = handler.bind(node.component);
   onMounted(() => target.addEventListener(eventName, boundHandler, eventParams));
   onWillUnmount(() => target.removeEventListener(eventName, boundHandler, eventParams));

src/index.ts

@@ -9,10 +9,8 @@ import {
   remove,
   text,
   toggler,
-  comment,
 } from "./blockdom";
 import { mainEventHandler } from "./component/handler";
-export type { Reactive } from "./reactivity";
 
 config.shouldNormalizeDom = false;
 config.mainEventHandler = mainEventHandler;
@@ -30,16 +28,38 @@ export const blockDom = {
   toggler,
   createBlock,
   html,
-  comment,
 };
 
-export { App, mount } from "./app/app";
+import type { AppConfig } from "./app/app";
-export { Component } from "./component/component";
+import { App } from "./app/app";
-export { useComponent, useState } from "./component/component_node";
+import { Component } from "./component/component";
+import { getCurrent } from "./component/component_node";
+export { useState } from "./component/component_node";
+
+export { App, Component };
+
+export async function mount<T extends typeof Component>(
+  C: T,
+  target: HTMLElement,
+  config: AppConfig = {}
+): Promise<InstanceType<T>> {
+  const app = new App(C);
+  return app.configure(config).mount(target);
+}
+
+export function useComponent(): Component {
+  const current = getCurrent();
+  return current!.component;
+}
+
 export { status } from "./component/status";
-export { reactive, markRaw, toRaw } from "./reactivity";
+export { Portal } from "./portal";
-export { useEffect, useEnv, useExternalListener, useRef, useChildSubEnv, useSubEnv } from "./hooks";
+export { Memo } from "./memo";
-export { EventBus, whenReady, loadFile, markup, xml } from "./utils";
+export { css, xml } from "./tags";
+export { reactive } from "./reactivity";
+export { useEffect, useEnv, useExternalListener, useRef, useSubEnv } from "./hooks";
+export { EventBus, whenReady, loadFile, markup } from "./utils";
+
 export {
   onWillStart,
   onMounted,
@@ -49,7 +69,7 @@ export {
   onPatched,
   onWillRender,
   onRendered,
-  onWillDestroy,
+  onDestroyed,
   onError,
 } from "./component/lifecycle_hooks";
 

src/memo.ts

@@ -0,0 +1,47 @@
+import { Component } from "./component/component";
+import type { ComponentNode } from "./component/component_node";
+import { xml } from "./tags";
+import { Fiber } from "./component/fibers";
+
+export class Memo extends Component {
+  static template = xml`<t t-slot="default"/>`;
+
+  constructor(props: any, env: any, node: ComponentNode) {
+    super(props, env, node);
+
+    // prevent patching process conditionally
+    let applyPatch = false;
+    const patchFn = node.patch;
+    node.patch = () => {
+      if (applyPatch) {
+        patchFn.call(node);
+        applyPatch = false;
+      }
+    };
+
+    // check props change, and render/apply patch if it changed
+    let prevProps = props;
+    const updateAndRender = node.updateAndRender;
+    node.updateAndRender = function (props: any, parentFiber: Fiber) {
+      const shouldUpdate = !shallowEqual(prevProps, props);
+      if (shouldUpdate) {
+        prevProps = props;
+        updateAndRender.call(node, props, parentFiber);
+        applyPatch = true;
+      }
+      return Promise.resolve();
+    };
+  }
+}
+
+/**
+ * we assume that each object have the same set of keys
+ */
+function shallowEqual(p1: any, p2: any): boolean {
+  for (let k in p1) {
+    if (p1[k] !== p2[k]) {
+      return false;
+    }
+  }
+  return true;
+}

src/portal.ts

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

src/reactivity.ts

@@ -1,42 +1,16 @@
 import { Callback } from "./utils";
 
 // Allows to get the target of a Reactive (used for making a new Reactive from the underlying object)
-export const TARGET = Symbol("Target");
+const TARGET = Symbol("Target");
-// Escape hatch to prevent reactivity system to turn something into a reactive
-const SKIP = Symbol("Skip");
 // Special key to subscribe to, to be notified of key creation/deletion
 const KEYCHANGES = Symbol("Key changes");
 
+type ObjectKey = string | number | symbol;
 type Target = object;
-type Collection = Set<any> | Map<any, any> | WeakMap<any, any>;
-type CollectionRawType = "Set" | "Map" | "WeakMap";
-
 export type Reactive<T extends Target = Target> = T & {
   [TARGET]: any;
 };
 
-export type NonReactive<T extends Target = Target> = T & {
-  [SKIP]: any;
-};
-
-const objectToString = Object.prototype.toString;
-const objectHasOwnProperty = Object.prototype.hasOwnProperty;
-
-const SUPPORTED_RAW_TYPES = new Set(["Object", "Array", "Set", "Map", "WeakMap"]);
-const COLLECTION_RAWTYPES = new Set(["Set", "Map", "WeakMap"]);
-
-/**
- * extract "RawType" from strings like "[object RawType]" => this lets us ignore
- * many native objects such as Promise (whose toString is [object Promise])
- * or Date ([object Date]), while also supporting collections without using
- * instanceof in a loop
- *
- * @param obj the object to check
- * @returns the raw type of the object
- */
-function rawType(obj: any) {
-  return objectToString.call(obj).slice(8, -1);
-}
 /**
  * Checks whether a given value can be made into a reactive object.
  *
@@ -44,44 +18,17 @@ function rawType(obj: any) {
  * @returns whether the value can be made reactive
  */
 function canBeMadeReactive(value: any): boolean {
-  if (typeof value !== "object") {
+  return (
-    return false;
+    typeof value === "object" &&
-  }
+    value !== null &&
-  return SUPPORTED_RAW_TYPES.has(rawType(value));
+    !(value instanceof Date) &&
-}
+    !(value instanceof Promise) &&
-/**
+    !(value instanceof String) &&
- * Creates a reactive from the given object/callback if possible and returns it,
+    !(value instanceof Number)
- * returns the original object otherwise.
+  );
- *
- * @param value the value make reactive
- * @returns a reactive for the given object when possible, the original otherwise
- */
-function possiblyReactive(val: any, cb: Callback) {
-  return canBeMadeReactive(val) ? reactive(val, cb) : val;
 }
 
-/**
+const targetToKeysToCallbacks = new WeakMap<Target, Map<ObjectKey, Set<Callback>>>();
- * Mark an object or array so that it is ignored by the reactivity system
- *
- * @param value the value to mark
- * @returns the object itself
- */
-export function markRaw<T extends Target>(value: T): NonReactive<T> {
-  (value as any)[SKIP] = true;
-  return value as NonReactive<T>;
-}
-
-/**
- * Given a reactive objet, return the raw (non reactive) underlying object
- *
- * @param value a reactive value
- * @returns the underlying value
- */
-export function toRaw<T extends object>(value: Reactive<T>): T {
-  return value[TARGET] || value;
-}
-
-const targetToKeysToCallbacks = new WeakMap<Target, Map<PropertyKey, Set<Callback>>>();
 /**
  * Observes a given key on a target with an callback. The callback will be
  * called when the given key changes on the target.
@@ -91,7 +38,7 @@ const targetToKeysToCallbacks = new WeakMap<Target, Map<PropertyKey, Set<Callbac
  *  or deletion)
  * @param callback the function to call when the key changes
  */
-function observeTargetKey(target: Target, key: PropertyKey, callback: Callback): void {
+function observeTargetKey(target: Target, key: ObjectKey, callback: Callback): void {
   if (!targetToKeysToCallbacks.get(target)) {
     targetToKeysToCallbacks.set(target, new Map());
   }
@@ -100,10 +47,6 @@ function observeTargetKey(target: Target, key: PropertyKey, callback: Callback):
     keyToCallbacks.set(key, new Set());
   }
   keyToCallbacks.get(key)!.add(callback);
-  if (!callbacksToTargets.has(callback)) {
-    callbacksToTargets.set(callback, new Set());
-  }
-  callbacksToTargets.get(callback)!.add(target);
 }
 /**
  * Notify Reactives that are observing a given target that a key has changed on
@@ -114,7 +57,7 @@ function observeTargetKey(target: Target, key: PropertyKey, callback: Callback):
  * @param key the key that changed (or Symbol `KEYCHANGES` if a key was created
  *   or deleted)
  */
-function notifyReactives(target: Target, key: PropertyKey): void {
+function notifyReactives(target: Target, key: ObjectKey): void {
   const keyToCallbacks = targetToKeysToCallbacks.get(target);
   if (!keyToCallbacks) {
     return;
@@ -150,10 +93,9 @@ export function clearReactivesForCallback(callback: Callback): void {
       callbacks.delete(callback);
     }
   }
-  targetsToClear.clear();
 }
 
-const reactiveCache = new WeakMap<Target, WeakMap<Callback, Reactive>>();
+const reactiveCache = new WeakMap<Target, Map<Callback, Reactive>>();
 /**
  * Creates a reactive proxy for an object. Reading data on the reactive object
  * subscribes to changes to the data. Writing data on the object will cause the
@@ -181,16 +123,10 @@ const reactiveCache = new WeakMap<Target, WeakMap<Callback, Reactive>>();
  *  reactive has changed
  * @returns a proxy that tracks changes to it
  */
-export function reactive<T extends Target>(
+export function reactive<T extends Target>(target: T, callback: Callback): Reactive<T> {
-  target: T,
-  callback: Callback = () => {}
-): Reactive<T> | NonReactive<T> {
   if (!canBeMadeReactive(target)) {
     throw new Error(`Cannot make the given value reactive`);
   }
-  if (SKIP in target) {
-    return target as NonReactive<T>;
-  }
   const originalTarget = (target as Reactive)[TARGET];
   if (originalTarget) {
     return reactive(originalTarget, callback);
@@ -200,218 +136,55 @@ export function reactive<T extends Target>(
   }
   const reactivesForTarget = reactiveCache.get(target)!;
   if (!reactivesForTarget.has(callback)) {
-    const targetRawType = rawType(target);
+    const proxy = new Proxy(target, {
-    const handler = COLLECTION_RAWTYPES.has(targetRawType)
+      get(target: any, key: ObjectKey, proxy: Reactive<T>) {
-      ? collectionsProxyHandler(target as Collection, callback, targetRawType as CollectionRawType)
+        if (key === TARGET) {
-      : basicProxyHandler<T>(callback);
+          return target;
-    const proxy = new Proxy(target, handler as ProxyHandler<T>) as Reactive<T>;
+        }
+        observeTargetKey(target, key, callback);
+        const value = Reflect.get(target, key, proxy);
+        if (!canBeMadeReactive(value)) {
+          return value;
+        }
+        return reactive(value, callback);
+      },
+      set(target, key, value, proxy) {
+        const isNewKey = !Object.hasOwnProperty.call(target, key);
+        const originalValue = Reflect.get(target, key, proxy);
+        const ret = Reflect.set(target, key, value, proxy);
+        if (isNewKey) {
+          notifyReactives(target, KEYCHANGES);
+        }
+        // While Array length may trigger the set trap, it's not actually set by this
+        // method but is updated behind the scenes, and the trap is not called with the
+        // new value. We disable the "same-value-optimization" for it because of that.
+        if (originalValue !== value || (Array.isArray(target) && key === "length")) {
+          notifyReactives(target, key);
+        }
+        return ret;
+      },
+      deleteProperty(target, key) {
+        const ret = Reflect.deleteProperty(target, key);
+        notifyReactives(target, KEYCHANGES);
+        notifyReactives(target, key);
+        return ret;
+      },
+      ownKeys(target) {
+        observeTargetKey(target, KEYCHANGES, callback);
+        return Reflect.ownKeys(target);
+      },
+      has(target, key) {
+        // TODO: this observes all key changes instead of only the presence of the argument key
+        observeTargetKey(target, KEYCHANGES, callback);
+        return Reflect.has(target, key);
+      },
+    });
     reactivesForTarget.set(callback, proxy);
+    if (!callbacksToTargets.has(callback)) {
+      callbacksToTargets.set(callback, new Set());
+    }
+    callbacksToTargets.get(callback)!.add(target);
   }
   return reactivesForTarget.get(callback) as Reactive<T>;
 }
-/**
+
- * Creates a basic proxy handler for regular objects and arrays.
- *
- * @param callback @see reactive
- * @returns a proxy handler object
- */
-function basicProxyHandler<T extends Target>(callback: Callback): ProxyHandler<T> {
-  return {
-    get(target: any, key: PropertyKey, proxy: Reactive<T>) {
-      if (key === TARGET) {
-        return target;
-      }
-      observeTargetKey(target, key, callback);
-      return possiblyReactive(Reflect.get(target, key, proxy), callback);
-    },
-    set(target, key, value, proxy) {
-      const isNewKey = !objectHasOwnProperty.call(target, key);
-      const originalValue = Reflect.get(target, key, proxy);
-      const ret = Reflect.set(target, key, value, proxy);
-      if (isNewKey) {
-        notifyReactives(target, KEYCHANGES);
-      }
-      // While Array length may trigger the set trap, it's not actually set by this
-      // method but is updated behind the scenes, and the trap is not called with the
-      // new value. We disable the "same-value-optimization" for it because of that.
-      if (originalValue !== value || (Array.isArray(target) && key === "length")) {
-        notifyReactives(target, key);
-      }
-      return ret;
-    },
-    deleteProperty(target, key) {
-      const ret = Reflect.deleteProperty(target, key);
-      // TODO: only notify when something was actually deleted
-      notifyReactives(target, KEYCHANGES);
-      notifyReactives(target, key);
-      return ret;
-    },
-    ownKeys(target) {
-      observeTargetKey(target, KEYCHANGES, callback);
-      return Reflect.ownKeys(target);
-    },
-    has(target, key) {
-      // TODO: this observes all key changes instead of only the presence of the argument key
-      // observing the key itself would observe value changes instead of presence changes
-      // so we may need a finer grained system to distinguish observing value vs presence.
-      observeTargetKey(target, KEYCHANGES, callback);
-      return Reflect.has(target, key);
-    },
-  } as ProxyHandler<T>;
-}
-/**
- * Creates a function that will observe the key that is passed to it when called
- * and delegates to the underlying method.
- *
- * @param methodName name of the method to delegate to
- * @param target @see reactive
- * @param callback @see reactive
- */
-function makeKeyObserver(methodName: "has" | "get", target: any, callback: Callback) {
-  return (key: any) => {
-    key = toRaw(key);
-    observeTargetKey(target, key, callback);
-    return possiblyReactive(target[methodName](key), callback);
-  };
-}
-/**
- * Creates an iterable that will delegate to the underlying iteration method and
- * observe keys as necessary.
- *
- * @param methodName name of the method to delegate to
- * @param target @see reactive
- * @param callback @see reactive
- */
-function makeIteratorObserver(
-  methodName: "keys" | "values" | "entries" | typeof Symbol.iterator,
-  target: any,
-  callback: Callback
-) {
-  return function* () {
-    observeTargetKey(target, KEYCHANGES, callback);
-    const keys = target.keys();
-    for (const item of target[methodName]()) {
-      const key = keys.next().value;
-      observeTargetKey(target, key, callback);
-      yield possiblyReactive(item, callback);
-    }
-  };
-}
-/**
- * Creates a function that will delegate to an underlying method, and check if
- * that method has modified the presence or value of a key, and notify the
- * reactives appropriately.
- *
- * @param setterName name of the method to delegate to
- * @param getterName name of the method which should be used to retrieve the
- *  value before calling the delegate method for comparison purposes
- * @param target @see reactive
- */
-function delegateAndNotify(
-  setterName: "set" | "add" | "delete",
-  getterName: "has" | "get",
-  target: any
-) {
-  return (key: any, value: any) => {
-    key = toRaw(key);
-    const hadKey = target.has(key);
-    const originalValue = target[getterName](key);
-    const ret = target[setterName](key, value);
-    const hasKey = target.has(key);
-    if (hadKey !== hasKey) {
-      notifyReactives(target, KEYCHANGES);
-    }
-    if (originalValue !== value) {
-      notifyReactives(target, key);
-    }
-    return ret;
-  };
-}
-/**
- * Creates a function that will clear the underlying collection and notify that
- * the keys of the collection have changed.
- *
- * @param target @see reactive
- */
-function makeClearNotifier(target: Map<any, any> | Set<any>) {
-  return () => {
-    const allKeys = [...target.keys()];
-    target.clear();
-    notifyReactives(target, KEYCHANGES);
-    for (const key of allKeys) {
-      notifyReactives(target, key);
-    }
-  };
-}
-/**
- * Maps raw type of an object to an object containing functions that can be used
- * to build an appropritate proxy handler for that raw type. Eg: when making a
- * reactive set, calling the has method should mark the key that is being
- * retrieved as observed, and calling the add or delete method should notify the
- * reactives that the key which is being added or deleted has been modified.
- */
-const rawTypeToFuncHandlers = {
-  Set: (target: any, callback: Callback) => ({
-    has: makeKeyObserver("has", target, callback),
-    add: delegateAndNotify("add", "has", target),
-    delete: delegateAndNotify("delete", "has", target),
-    keys: makeIteratorObserver("keys", target, callback),
-    values: makeIteratorObserver("values", target, callback),
-    entries: makeIteratorObserver("entries", target, callback),
-    [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
-    clear: makeClearNotifier(target),
-    get size() {
-      observeTargetKey(target, KEYCHANGES, callback);
-      return target.size;
-    },
-  }),
-  Map: (target: any, callback: Callback) => ({
-    has: makeKeyObserver("has", target, callback),
-    get: makeKeyObserver("get", target, callback),
-    set: delegateAndNotify("set", "get", target),
-    delete: delegateAndNotify("delete", "has", target),
-    keys: makeIteratorObserver("keys", target, callback),
-    values: makeIteratorObserver("values", target, callback),
-    entries: makeIteratorObserver("entries", target, callback),
-    [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
-    clear: makeClearNotifier(target),
-    get size() {
-      observeTargetKey(target, KEYCHANGES, callback);
-      return target.size;
-    },
-  }),
-  WeakMap: (target: any, callback: Callback) => ({
-    has: makeKeyObserver("has", target, callback),
-    get: makeKeyObserver("get", target, callback),
-    set: delegateAndNotify("set", "get", target),
-    delete: delegateAndNotify("delete", "has", target),
-  }),
-};
-/**
- * Creates a proxy handler for collections (Set/Map/WeakMap)
- *
- * @param callback @see reactive
- * @param target @see reactive
- * @returns a proxy handler object
- */
-function collectionsProxyHandler<T extends Collection>(
-  target: T,
-  callback: Callback,
-  targetRawType: CollectionRawType
-): ProxyHandler<T> {
-  // TODO: if performance is an issue we can create the special handlers lazily when each
-  // property is read.
-  const specialHandlers = rawTypeToFuncHandlers[targetRawType](target, callback);
-  return Object.assign(basicProxyHandler(callback), {
-    get(target: any, key: PropertyKey) {
-      if (key === TARGET) {
-        return target;
-      }
-      if (objectHasOwnProperty.call(specialHandlers, key)) {
-        return (specialHandlers as any)[key];
-      }
-      observeTargetKey(target, key, callback);
-      return possiblyReactive(target[key], callback);
-    },
-  }) as ProxyHandler<T>;
-}

src/tags.ts

@@ -0,0 +1,28 @@
+import { registerSheet } from "./component/style";
+import { globalTemplates } from "./app/template_set";
+
+// -----------------------------------------------------------------------------
+//  Global templates
+// -----------------------------------------------------------------------------
+
+export function xml(strings: TemplateStringsArray, ...args: any[]) {
+  const name = `__template__${xml.nextId++}`;
+  const value = String.raw(strings, ...args);
+  globalTemplates[name] = value;
+  return name;
+}
+
+xml.nextId = 1;
+
+// -----------------------------------------------------------------------------
+//  Global stylesheets
+// -----------------------------------------------------------------------------
+
+export function css(strings: TemplateStringsArray, ...args: any[]) {
+  const name = `__sheet__${css.nextId++}`;
+  const value = String.raw(strings, ...args);
+  registerSheet(name, value);
+  return name;
+}
+
+css.nextId = 1;

src/utils.ts

@@ -24,15 +24,6 @@ export function batched(callback: Callback): Callback {
   };
 }
 
-export function validateTarget(target: HTMLElement) {
-  if (!(target instanceof HTMLElement)) {
-    throw new Error("Cannot mount component: the target is not a valid DOM element");
-  }
-  if (!document.body.contains(target)) {
-    throw new Error("Cannot mount a component on a detached dom node");
-  }
-}
-
 export class EventBus extends EventTarget {
   trigger(name: string, payload?: any) {
     this.dispatchEvent(new CustomEvent(name, { detail: payload }));
@@ -71,17 +62,3 @@ export class Markup extends String {}
 export function markup(value: any) {
   return new Markup(value);
 }
-
-// -----------------------------------------------------------------------------
-//  xml tag helper
-// -----------------------------------------------------------------------------
-export const globalTemplates: { [key: string]: string | Element } = {};
-
-export function xml(...args: Parameters<typeof String.raw>) {
-  const name = `__template__${xml.nextId++}`;
-  const value = String.raw(...args);
-  globalTemplates[name] = value;
-  return name;
-}
-
-xml.nextId = 1;

tests/__snapshots__/reactivity.test.ts.snap

@@ -49,16 +49,14 @@ exports[`Reactivity: useState concurrent renderings 3`] = `
 exports[`Reactivity: useState destroyed component before being mounted is inactive 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2;
+    let d1 = ctx['contextObj'].a;
-    if (ctx['state'].flag) {
+    return block1([d1]);
-      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    }
-    return block1([], [b2]);
   }
 }"
 `;
@@ -66,21 +64,8 @@ exports[`Reactivity: useState destroyed component before being mounted is inacti
 exports[`Reactivity: useState destroyed component before being mounted is inactive 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  let block1 = createBlock(\`<span><block-text-0/></span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj'].a;
-    return block1([txt1]);
-  }
-}"
-`;
-
-exports[`Reactivity: useState destroyed component is inactive 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -94,16 +79,35 @@ exports[`Reactivity: useState destroyed component is inactive 1`] = `
 }"
 `;
 
-exports[`Reactivity: useState destroyed component is inactive 2`] = `
+exports[`Reactivity: useState destroyed component is inactive 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj'].a;
+    let d1 = ctx['contextObj'].a;
-    return block1([txt1]);
+    return block1([d1]);
+  }
+}"
+`;
+
+exports[`Reactivity: useState destroyed component is inactive 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['state'].flag) {
+      b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    }
+    return block1([], [b2]);
   }
 }"
 `;
@@ -111,14 +115,15 @@ exports[`Reactivity: useState destroyed component is inactive 2`] = `
 exports[`Reactivity: useState one components can subscribe twice to same context 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/><block-text-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj1'].a;
+    let d1 = ctx['contextObj1'].a;
-    let txt2 = ctx['contextObj2'].b;
+    let d2 = ctx['contextObj2'].b;
-    return block1([txt1, txt2]);
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -126,14 +131,14 @@ exports[`Reactivity: useState one components can subscribe twice to same context
 exports[`Reactivity: useState parent and children subscribed to same context 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
-  let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let d1 = ctx['contextObj'].a;
-    let txt1 = ctx['contextObj'].b;
+    return block1([d1]);
-    return block1([txt1], [b2]);
   }
 }"
 `;
@@ -141,13 +146,15 @@ exports[`Reactivity: useState parent and children subscribed to same context 1`]
 exports[`Reactivity: useState parent and children subscribed to same context 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
-  let block1 = createBlock(\`<span><block-text-0/></span>\`);
+  let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj'].a;
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    return block1([txt1]);
+    let d1 = ctx['contextObj'].b;
+    return block1([d1], [b2]);
   }
 }"
 `;
@@ -218,14 +225,14 @@ exports[`Reactivity: useState several nodes on different level use same context
 exports[`Reactivity: useState two components are updated in parallel 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
-  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let d1 = ctx['contextObj'].value;
-    let b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
+    return block1([d1]);
-    return block1([], [b2, b3]);
   }
 }"
 `;
@@ -233,21 +240,8 @@ exports[`Reactivity: useState two components are updated in parallel 1`] = `
 exports[`Reactivity: useState two components are updated in parallel 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  let block1 = createBlock(\`<span><block-text-0/></span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj'].value;
-    return block1([txt1]);
-  }
-}"
-`;
-
-exports[`Reactivity: useState two components can subscribe to same context 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>\`);
   
@@ -259,16 +253,33 @@ exports[`Reactivity: useState two components can subscribe to same context 1`] =
 }"
 `;
 
-exports[`Reactivity: useState two components can subscribe to same context 2`] = `
+exports[`Reactivity: useState two components can subscribe to same context 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj'].value;
+    let d1 = ctx['contextObj'].value;
-    return block1([txt1]);
+    return block1([d1]);
+  }
+}"
+`;
+
+exports[`Reactivity: useState two components can subscribe to same context 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
+    return block1([], [b2, b3]);
   }
 }"
 `;
@@ -276,7 +287,38 @@ exports[`Reactivity: useState two components can subscribe to same context 2`] =
 exports[`Reactivity: useState two independent components on different levels are updated in parallel 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let d1 = ctx['contextObj'].value;
+    return block1([d1]);
+  }
+}"
+`;
+
+exports[`Reactivity: useState two independent components on different levels are updated in parallel 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`Reactivity: useState two independent components on different levels are updated in parallel 3`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
@@ -288,44 +330,17 @@ exports[`Reactivity: useState two independent components on different levels are
 }"
 `;
 
-exports[`Reactivity: useState two independent components on different levels are updated in parallel 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<span><block-text-0/></span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj'].value;
-    return block1([txt1]);
-  }
-}"
-`;
-
-exports[`Reactivity: useState two independent components on different levels are updated in parallel 3`] = `
-"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 = \\"\\") {
-    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    return block1([], [b2]);
-  }
-}"
-`;
-
 exports[`Reactivity: useState useContext=useState hook is reactive, for one component 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj'].value;
+    let d1 = ctx['contextObj'].value;
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -333,8 +348,23 @@ exports[`Reactivity: useState useContext=useState hook is reactive, for one comp
 exports[`Reactivity: useState useless atoms should be deleted 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<div><block-text-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let d1 = ctx['state'].quantity;
+    return block1([d1]);
+  }
+}"
+`;
+
+exports[`Reactivity: useState useless atoms should be deleted 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/> Total: <block-text-0/> Count: <block-text-1/></div>\`);
   
@@ -348,23 +378,9 @@ exports[`Reactivity: useState useless atoms should be deleted 1`] = `
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);
-    let txt1 = ctx['total'];
+    let d1 = ctx['total'];
-    let txt2 = Object.keys(ctx['state']).length;
+    let d2 = Object.keys(ctx['state']).length;
-    return block1([txt1, txt2], [b2]);
+    return block1([d1, d2], [b2]);
-  }
-}"
-`;
-
-exports[`Reactivity: useState useless atoms should be deleted 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['state'].quantity;
-    return block1([txt1]);
   }
 }"
 `;
@@ -372,13 +388,14 @@ exports[`Reactivity: useState useless atoms should be deleted 2`] = `
 exports[`Reactivity: useState very simple use, with initial value 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['contextObj'].value;
+    let d1 = ctx['contextObj'].value;
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;

tests/app/__snapshots__/app.test.ts.snap

@@ -1,43 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`app App supports env with getters/setters 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div><block-text-0/> <block-text-1/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['env'].someVal;
-    let txt2 = Object.keys(ctx['env'].services);
-    return block1([txt1, txt2]);
-  }
-}"
-`;
-
-exports[`app can configure an app with props 1`] = `
-"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'].value;
-    return block1([txt1]);
-  }
-}"
-`;
-
-exports[`app destroy remove the widget from the DOM 1`] = `
-"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();
-  }
-}"
-`;

tests/app/app.test.ts

@@ -1,62 +0,0 @@
-import { App, Component, xml } from "../../src";
-import { status } from "../../src/component/status";
-import { makeTestFixture, snapshotEverything, nextTick, elem } from "../helpers";
-
-let fixture: HTMLElement;
-
-snapshotEverything();
-
-beforeEach(() => {
-  fixture = makeTestFixture();
-});
-
-describe("app", () => {
-  test("destroy remove the widget from the DOM", async () => {
-    class SomeComponent extends Component {
-      static template = xml`<div/>`;
-    }
-
-    const app = new App(SomeComponent);
-    const comp = await app.mount(fixture);
-    const el = elem(comp);
-    expect(document.contains(el)).toBe(true);
-    app.destroy();
-    expect(document.contains(el)).toBe(false);
-    expect(status(comp)).toBe("destroyed");
-  });
-
-  test("App supports env with getters/setters", async () => {
-    let someVal = "maggot";
-
-    const services: any = { serv1: "" };
-    const env = {
-      get someVal() {
-        return someVal;
-      },
-      services,
-    };
-
-    class SomeComponent extends Component {
-      static template = xml`<div><t t-esc="env.someVal" /> <t t-esc="Object.keys(env.services)" /></div>`;
-    }
-
-    const app = new App(SomeComponent, { env });
-    const comp = await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>maggot serv1</div>");
-    someVal = "brain";
-    services.serv2 = "";
-    comp.render();
-    await nextTick();
-    expect(fixture.innerHTML).toBe("<div>brain serv1,serv2</div>");
-  });
-
-  test("can configure an app with props", async () => {
-    class SomeComponent extends Component {
-      static template = xml`<div t-esc="props.value"/>`;
-    }
-
-    const app = new App(SomeComponent, { props: { value: 333 } });
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>333</div>");
-  });
-});

tests/blockdom/block.test.ts

@@ -227,38 +227,6 @@ describe("misc", () => {
     expect(fixture.innerHTML).toBe("<p>() =&gt; 3tostring</p>");
   });
 
-  test("block with 2 subblocks: variation", async () => {
-    const block = createBlock("<a><b><c><block-child-0/>2</c></b><block-child-1/></a>");
-    const tree = block([], [text("1"), text("3")]);
-    mount(tree, fixture);
-    expect(fixture.innerHTML).toBe("<a><b><c>12</c></b>3</a>");
-  });
-
-  test("block with 2 subblocks: another variation", async () => {
-    const block = createBlock(
-      `<a block-attribute-0="hello"><b><c><block-child-0/>2</c></b><block-child-1/></a>`
-    );
-    const tree = block(["world"], [text("1"), text("3")]);
-    mount(tree, fixture);
-    expect(fixture.innerHTML).toBe(`<a hello="world"><b><c>12</c></b>3</a>`);
-  });
-
-  test("namespace is not propagated to siblings", () => {
-    const block = createBlock(`<div><svg block-ns="someNameSpace"><g/></svg><div></div></div>`);
-
-    const fixture = makeTestFixture();
-    mount(block(), fixture);
-
-    expect(fixture.innerHTML).toBe("<div><svg><g></g></svg><div></div></div>");
-    expect(fixture.querySelector("svg")!.namespaceURI).toBe("someNameSpace");
-    expect(fixture.querySelector("g")!.namespaceURI).toBe("someNameSpace");
-    const allDivs = fixture.querySelectorAll("div");
-    expect(Array.from(allDivs).map((el) => el.namespaceURI)).toEqual([
-      "http://www.w3.org/1999/xhtml",
-      "http://www.w3.org/1999/xhtml",
-    ]);
-  });
-
   //     test.skip("reusing a block skips patching process", async () => {
   //       const block = createBlock('<div><block-text-0/></div>');
   //       const foo = block(["foo"]);

tests/blockdom/block_attributes.test.ts

@@ -26,26 +26,6 @@ test("simple attribute", async () => {
   expect(fixture.innerHTML).toBe(`<div hello="owl"></div>`);
 });
 
-test("updating attribute with falsy value", async () => {
-  const block = createBlock('<div block-attribute-0="hello"></div>');
-  const tree = block([false]);
-
-  mount(tree, fixture);
-  expect(fixture.innerHTML).toBe(`<div></div>`);
-
-  patch(tree, block(["owl"]));
-  expect(fixture.innerHTML).toBe(`<div hello="owl"></div>`);
-
-  patch(tree, block([false]));
-  expect(fixture.innerHTML).toBe(`<div></div>`);
-
-  patch(tree, block(["owl"]));
-  expect(fixture.innerHTML).toBe(`<div hello="owl"></div>`);
-
-  patch(tree, block([undefined]));
-  expect(fixture.innerHTML).toBe(`<div></div>`);
-});
-
 test("dynamic attribute (pair)", async () => {
   const block = createBlock('<div block-attributes="0"></div>');
   const tree = block([["hello", "world"]]);
@@ -57,20 +37,6 @@ test("dynamic attribute (pair)", async () => {
   expect(fixture.innerHTML).toBe(`<div ola="mundo"></div>`);
 });
 
-test("dynamic attribute (pair, with false value)", async () => {
-  const block = createBlock('<div block-attributes="0"></div>');
-  const tree = block([["hello", false]]);
-
-  mount(tree, fixture);
-  expect(fixture.innerHTML).toBe(`<div></div>`);
-
-  patch(tree, block([["hello", "world"]]));
-  expect(fixture.innerHTML).toBe(`<div hello="world"></div>`);
-
-  patch(tree, block([["hello", false]]));
-  expect(fixture.innerHTML).toBe(`<div></div>`);
-});
-
 test("dynamic attribute (object)", async () => {
   const block = createBlock('<div block-attributes="0"></div>');
   const tree = block([{ hello: "world" }]);
@@ -82,23 +48,6 @@ test("dynamic attribute (object)", async () => {
   expect(fixture.innerHTML).toBe(`<div ola="mundo"></div>`);
 });
 
-test("dynamic attribute (object), with falsy values", async () => {
-  const block = createBlock('<div block-attributes="0"></div>');
-  const tree = block([{ hello: "world", blip: false }]);
-
-  mount(tree, fixture);
-  expect(fixture.innerHTML).toBe(`<div hello="world"></div>`);
-
-  patch(tree, block([{ ola: "mundo", blip: undefined }]));
-  expect(fixture.innerHTML).toBe(`<div ola="mundo"></div>`);
-
-  patch(tree, block([{ ola: false, blip: 1 }]));
-  expect(fixture.innerHTML).toBe(`<div blip="1"></div>`);
-
-  patch(tree, block([{ ola: undefined, blip: undefined }]));
-  expect(fixture.innerHTML).toBe(`<div></div>`);
-});
-
 test("class attribute", async () => {
   const block = createBlock('<div block-attribute-0="class"></div>');
   const tree = block(["fire"]);
@@ -116,14 +65,6 @@ test("class attribute", async () => {
   expect(fixture.innerHTML).toBe(`<div class="0"></div>`);
 });
 
-test("attribute with undefined value", async () => {
-  const block = createBlock('<div block-attribute-0="abc"></div>');
-  const tree = block([undefined]);
-
-  mount(tree, fixture);
-  expect(fixture.innerHTML).toBe(`<div></div>`);
-});
-
 test("class attribute with undefined value", async () => {
   const block = createBlock('<div block-attribute-0="class"></div>');
   const tree = block([undefined]);
@@ -169,15 +110,6 @@ describe("properties", () => {
     expect(input.value).toBe("potato");
   });
 
-  test("input with value attribute, and undefined given", () => {
-    const block = createBlock(`<input block-attribute-0="value"/>`);
-
-    const tree = block([undefined]);
-    mount(tree, fixture);
-    const input = fixture.querySelector("input")!;
-    expect(input.value).toBe("");
-  });
-
   test("input type=checkbox with checked attribute", () => {
     // render input with initial value
     const block = createBlock(`<input type="checkbox" block-attribute-0="checked"/>`);

tests/blockdom/block_refs.test.ts

@@ -1,5 +1,4 @@
 import { createBlock, mount, patch, remove } from "../../src/blockdom";
-import { logStep } from "../helpers";
 import { makeTestFixture } from "./helpers";
 
 //------------------------------------------------------------------------------
@@ -56,15 +55,3 @@ test("is in dom when callback is called", async () => {
 
   mount(tree, fixture);
 });
-
-test("callback ref in callback ref with same block", async () => {
-  const block = createBlock('<p block-ref="0"><block-text-1/><block-child-0/></p>');
-  let refFn = (el: HTMLParagraphElement) => logStep(el.outerHTML);
-
-  const child = block([refFn, "child"], []);
-  const parent = block([refFn, "parent"], [child]);
-  mount(parent, fixture);
-
-  expect(fixture.innerHTML).toBe("<p>parent<p>child</p></p>");
-  expect(["<p>child</p>", "<p>parent<p>child</p></p>"]).toBeLogged();
-});

tests/blockdom/comment.test.ts

@@ -1,26 +0,0 @@
-import { comment, mount } from "../../src/blockdom";
-import { makeTestFixture } from "./helpers";
-
-//------------------------------------------------------------------------------
-// Setup and helpers
-//------------------------------------------------------------------------------
-
-let fixture: HTMLElement;
-
-beforeEach(() => {
-  fixture = makeTestFixture();
-});
-
-afterEach(() => {
-  fixture.remove();
-});
-
-test("simple comment node", async () => {
-  const tree = comment("foo");
-  expect(tree.el).toBe(undefined);
-  mount(tree, fixture);
-  expect(fixture.innerHTML).toBe("<!--foo-->");
-  expect(tree.el).not.toBe(undefined);
-  tree.remove();
-  expect(fixture.innerHTML).toBe("");
-});

tests/blockdom/multi.test.ts

@@ -76,16 +76,4 @@ describe("multi blocks", () => {
     mount(text(multi([text("a"), text("b")]) as any), fixture);
     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")])]);
-    mount(tree, fixture);
-    expect(fixture.innerHTML).toBe("<div>foobar</div>");
-  });
 });

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

@@ -3,13 +3,14 @@
 exports[`attributes changing a class with t-att-class (preexisting class 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"hoy\\" block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['v'];
+    let d1 = ctx['v'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -17,13 +18,14 @@ exports[`attributes changing a class with t-att-class (preexisting class 1`] = `
 exports[`attributes changing a class with t-att-class 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['v'];
+    let d1 = ctx['v'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -31,13 +33,14 @@ exports[`attributes changing a class with t-att-class 1`] = `
 exports[`attributes changing an attribute with t-att- 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"value\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['v'];
+    let d1 = ctx['v'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -45,13 +48,14 @@ exports[`attributes changing an attribute with t-att- 1`] = `
 exports[`attributes class and t-att-class should combine together 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\" class=\\"hello\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -59,13 +63,14 @@ exports[`attributes class and t-att-class should combine together 1`] = `
 exports[`attributes class and t-attf-class with ternary operation 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"hello\\" block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = (ctx['value']?'world':'');
+    let d1 = (ctx['value']?'world':'');
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -73,13 +78,14 @@ exports[`attributes class and t-attf-class with ternary operation 1`] = `
 exports[`attributes dynamic attribute evaluating to 0 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -87,13 +93,14 @@ exports[`attributes dynamic attribute evaluating to 0 1`] = `
 exports[`attributes dynamic attribute falsy variable  1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -101,13 +108,14 @@ exports[`attributes dynamic attribute falsy variable  1`] = `
 exports[`attributes dynamic attribute with a dash 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"data-action-id\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['id'];
+    let d1 = ctx['id'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -115,13 +123,14 @@ exports[`attributes dynamic attribute with a dash 1`] = `
 exports[`attributes dynamic attributes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = 'bar';
+    let d1 = 'bar';
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -129,13 +138,14 @@ exports[`attributes dynamic attributes 1`] = `
 exports[`attributes dynamic class attribute 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['c'];
+    let d1 = ctx['c'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -143,13 +153,14 @@ exports[`attributes dynamic class attribute 1`] = `
 exports[`attributes dynamic class attribute evaluating to 0 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -157,13 +168,14 @@ exports[`attributes dynamic class attribute evaluating to 0 1`] = `
 exports[`attributes dynamic empty class attribute 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['c'];
+    let d1 = ctx['c'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -171,41 +183,14 @@ exports[`attributes dynamic empty class attribute 1`] = `
 exports[`attributes dynamic formatted attributes with a dash 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"aria-label\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = \`Some text \${ctx['id']}\`;
+    let d1 = \`Some text \${ctx['id']}\`;
-    return block1([attr1]);
+    return block1([d1]);
-  }
-}"
-`;
-
-exports[`attributes dynamic undefined class attribute 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['c'];
-    return block1([attr1]);
-  }
-}"
-`;
-
-exports[`attributes dynamic undefined generic attribute 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div block-attribute-0=\\"thing\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['c'];
-    return block1([attr1]);
   }
 }"
 `;
@@ -213,13 +198,14 @@ exports[`attributes dynamic undefined generic attribute 1`] = `
 exports[`attributes fixed variable 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -227,13 +213,14 @@ exports[`attributes fixed variable 1`] = `
 exports[`attributes format expression 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = (ctx['value']+37);
+    let d1 = (ctx['value']+37);
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -241,13 +228,14 @@ exports[`attributes format expression 1`] = `
 exports[`attributes format literal 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = \`bar\`;
+    let d1 = \`bar\`;
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -255,13 +243,14 @@ exports[`attributes format literal 1`] = `
 exports[`attributes format multiple 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = \`a \${ctx['value1']} is \${ctx['value2']} of \${ctx['value3']} ]\`;
+    let d1 = \`a \${ctx['value1']} is \${ctx['value2']} of \${ctx['value3']} ]\`;
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -269,13 +258,14 @@ exports[`attributes format multiple 1`] = `
 exports[`attributes format value 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = \`b\${ctx['value']}r\`;
+    let d1 = \`b\${ctx['value']}r\`;
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -283,8 +273,8 @@ exports[`attributes format value 1`] = `
 exports[`attributes from object variables set previously 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><span block-attribute-0=\\"class\\"/></div>\`);
   
@@ -292,8 +282,8 @@ exports[`attributes from object variables set previously 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"o\\", {a:'b'});
-    let attr1 = ctx['o'].a;
+    let d1 = ctx['o'].a;
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -301,8 +291,8 @@ exports[`attributes from object variables set previously 1`] = `
 exports[`attributes from variables set previously (no external node) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span block-attribute-0=\\"class\\"/>\`);
   
@@ -310,8 +300,8 @@ exports[`attributes from variables set previously (no external node) 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"abc\\", 'def');
-    let attr1 = ctx['abc'];
+    let d1 = ctx['abc'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -319,8 +309,8 @@ exports[`attributes from variables set previously (no external node) 1`] = `
 exports[`attributes from variables set previously 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><span block-attribute-0=\\"class\\"/></div>\`);
   
@@ -328,8 +318,8 @@ exports[`attributes from variables set previously 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"abc\\", 'def');
-    let attr1 = ctx['abc'];
+    let d1 = ctx['abc'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -337,13 +327,14 @@ exports[`attributes from variables set previously 1`] = `
 exports[`attributes object 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attributes=\\"0\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -351,7 +342,8 @@ exports[`attributes object 1`] = `
 exports[`attributes static attributes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div foo=\\"a\\" bar=\\"b\\" baz=\\"c\\"/>\`);
   
@@ -364,7 +356,8 @@ exports[`attributes static attributes 1`] = `
 exports[`attributes static attributes on void elements 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<img src=\\"/test.skip.jpg\\" alt=\\"Test\\"/>\`);
   
@@ -377,7 +370,8 @@ exports[`attributes static attributes on void elements 1`] = `
 exports[`attributes static attributes with dashes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div aria-label=\\"Close\\"/>\`);
   
@@ -390,13 +384,14 @@ exports[`attributes static attributes with dashes 1`] = `
 exports[`attributes t-att-class and class should combine together 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"hello\\" block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -404,13 +399,14 @@ exports[`attributes t-att-class and class should combine together 1`] = `
 exports[`attributes t-att-class with multiple classes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = {'a b c':ctx['value']};
+    let d1 = {'a b c':ctx['value']};
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -418,13 +414,14 @@ exports[`attributes t-att-class with multiple classes 1`] = `
 exports[`attributes t-att-class with multiple classes 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = {['a b c']:ctx['value']};
+    let d1 = {['a b c']:ctx['value']};
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -432,13 +429,14 @@ exports[`attributes t-att-class with multiple classes 2`] = `
 exports[`attributes t-att-class with multiple classes, some of which are duplicate 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = {'a b c':ctx['value'],'a b d':!ctx['value']};
+    let d1 = {'a b c':ctx['value'],'a b d':!ctx['value']};
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -446,13 +444,14 @@ exports[`attributes t-att-class with multiple classes, some of which are duplica
 exports[`attributes t-att-class with object 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"static\\" block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = {a:ctx['b'],c:ctx['d'],e:ctx['f']};
+    let d1 = {a:ctx['b'],c:ctx['d'],e:ctx['f']};
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -460,13 +459,14 @@ exports[`attributes t-att-class with object 1`] = `
 exports[`attributes t-attf-class 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = \`hello\`;
+    let d1 = \`hello\`;
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -474,13 +474,14 @@ exports[`attributes t-attf-class 1`] = `
 exports[`attributes t-attf-class should combine with class 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"hello\\" block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = \`world\`;
+    let d1 = \`world\`;
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -488,13 +489,14 @@ exports[`attributes t-attf-class should combine with class 1`] = `
 exports[`attributes t-attf-class with multiple classes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = \`hello \${ctx['word']}\`;
+    let d1 = \`hello \${ctx['word']}\`;
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -502,13 +504,14 @@ exports[`attributes t-attf-class with multiple classes 1`] = `
 exports[`attributes t-attf-class with multiple classes separated by multiple spaces 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = \`hello  \${ctx['word']}\`;
+    let d1 = \`hello  \${ctx['word']}\`;
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -516,13 +519,14 @@ exports[`attributes t-attf-class with multiple classes separated by multiple spa
 exports[`attributes tuple literal 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attributes=\\"0\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ['foo','bar'];
+    let d1 = ['foo','bar'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -530,13 +534,14 @@ exports[`attributes tuple literal 1`] = `
 exports[`attributes tuple variable 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attributes=\\"0\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -544,7 +549,8 @@ exports[`attributes tuple variable 1`] = `
 exports[`attributes two classes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"a b\\"/>\`);
   
@@ -557,14 +563,15 @@ exports[`attributes two classes 1`] = `
 exports[`attributes two dynamic attributes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"foo\\" block-attribute-1=\\"bar\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = 'bar';
+    let d1 = 'bar';
-    let attr2 = 'foo';
+    let d2 = 'foo';
-    return block1([attr1, attr2]);
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -572,13 +579,14 @@ exports[`attributes two dynamic attributes 1`] = `
 exports[`attributes updating classes (with obj notation) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"hoy\\" block-attribute-0=\\"class\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = {'a b':ctx['condition']};
+    let d1 = {'a b':ctx['condition']};
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -586,15 +594,16 @@ exports[`attributes updating classes (with obj notation) 1`] = `
 exports[`attributes various escapes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div foo=\\"&lt;foo\\" block-attribute-0=\\"bar\\" block-attribute-1=\\"baz\\" block-attributes=\\"2\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['bar'];
+    let d1 = ctx['bar'];
-    let attr2 = \`<\${ctx['baz']}>\`;
+    let d2 = \`<\${ctx['baz']}>\`;
-    let attr3 = ctx['qux'];
+    let d3 = ctx['qux'];
-    return block1([attr1, attr2, attr3]);
+    return block1([d1, d2, d3]);
   }
 }"
 `;
@@ -602,7 +611,8 @@ exports[`attributes various escapes 1`] = `
 exports[`attributes various escapes 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div> &lt; </div>\`);
   
@@ -615,13 +625,14 @@ exports[`attributes various escapes 2 1`] = `
 exports[`special cases for some specific html attributes/properties input of type checkbox with t-att-indeterminate 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<input type=\\"checkbox\\" block-attribute-0=\\"indeterminate\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['v'];
+    let d1 = ctx['v'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -629,13 +640,14 @@ exports[`special cases for some specific html attributes/properties input of typ
 exports[`special cases for some specific html attributes/properties input type= checkbox, with t-att-checked 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<input type=\\"checkbox\\" block-attribute-0=\\"checked\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['flag'];
+    let d1 = ctx['flag'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -643,13 +655,14 @@ exports[`special cases for some specific html attributes/properties input type=
 exports[`special cases for some specific html attributes/properties input with t-att-value 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<input block-attribute-0=\\"value\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['v'];
+    let d1 = ctx['v'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -657,13 +670,14 @@ exports[`special cases for some specific html attributes/properties input with t
 exports[`special cases for some specific html attributes/properties select with t-att-value 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<select block-attribute-0=\\"value\\"><option value=\\"potato\\">Potato</option><option value=\\"tomato\\">Tomato</option><option value=\\"onion\\">Onion</option></select>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -671,13 +685,14 @@ exports[`special cases for some specific html attributes/properties select with
 exports[`special cases for some specific html attributes/properties textarea with t-att-value 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<textarea block-attribute-0=\\"value\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let attr1 = ctx['v'];
+    let d1 = ctx['v'];
-    return block1([attr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -685,7 +700,8 @@ exports[`special cases for some specific html attributes/properties textarea wit
 exports[`special cases for some specific html attributes/properties various boolean html attributes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><input type=\\"checkbox\\" checked=\\"checked\\"/><input checked=\\"checked\\"/><div checked=\\"checked\\"/><div selected=\\"selected\\"/><option selected=\\"selected\\" other=\\"1\\"/><input readonly=\\"readonly\\"/><button disabled=\\"disabled\\"/></div>\`);
   

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

@@ -3,10 +3,13 @@
 exports[`comments only a comment 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<!-- comment-->\`);
   
   return function template(ctx, node, key = \\"\\") {
-    return comment(\` comment\`);
+    return block1();
   }
 }"
 `;
@@ -14,7 +17,8 @@ exports[`comments only a comment 1`] = `
 exports[`comments properly handle comments 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div>hello <!-- comment-->owl</div>\`);
   
@@ -27,7 +31,8 @@ exports[`comments properly handle comments 1`] = `
 exports[`comments properly handle comments between t-if/t-else 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   let block2 = createBlock(\`<span>true</span>\`);

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

@@ -0,0 +1,15 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`error handling cannot add twice the same template 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<div/>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;

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

@@ -3,13 +3,15 @@
 exports[`t-on can bind event handler 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['add'], ctx];
+    const v1 = ctx['add'];
-    return block1([hdlr1]);
+    let d1 = [v1, ctx];
+    return block1([d1]);
   }
 }"
 `;
@@ -17,14 +19,15 @@ exports[`t-on can bind event handler 1`] = `
 exports[`t-on can bind handlers with arguments 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const v1 = ctx['add'];
-    let hdlr1 = [()=>v1(5), ctx];
+    let d1 = [()=>v1(5), ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -32,14 +35,15 @@ exports[`t-on can bind handlers with arguments 1`] = `
 exports[`t-on can bind handlers with empty  object 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const v1 = ctx['doSomething'];
-    let hdlr1 = [()=>v1({}), ctx];
+    let d1 = [()=>v1({}), ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -47,14 +51,15 @@ exports[`t-on can bind handlers with empty  object 1`] = `
 exports[`t-on can bind handlers with empty object (with non empty inner string) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const v1 = ctx['doSomething'];
-    let hdlr1 = [()=>v1({}), ctx];
+    let d1 = [()=>v1({}), ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -62,8 +67,8 @@ exports[`t-on can bind handlers with empty object (with non empty inner string)
 exports[`t-on can bind handlers with empty object (with non empty inner string) 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<ul><block-child-0/></ul>\`);
   let block3 = createBlock(\`<li><a block-handler-0=\\"click\\">link</a></li>\`);
@@ -77,8 +82,8 @@ exports[`t-on can bind handlers with empty object (with non empty inner string)
       let key1 = ctx['action_index'];
       const v1 = ctx['activate'];
       const v2 = ctx['action'];
-      let hdlr1 = [()=>v1(v2), ctx];
+      let d1 = [()=>v1(v2), ctx];
-      c_block2[i1] = withKey(block3([hdlr1]), key1);
+      c_block2[i1] = withKey(block3([d1]), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -89,14 +94,15 @@ exports[`t-on can bind handlers with empty object (with non empty inner string)
 exports[`t-on can bind handlers with object arguments 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const v1 = ctx['add'];
-    let hdlr1 = [()=>v1({val:5}), ctx];
+    let d1 = [()=>v1({val:5}), ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -104,14 +110,17 @@ exports[`t-on can bind handlers with object arguments 1`] = `
 exports[`t-on can bind two event handlers 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\" block-handler-1=\\"dblclick\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['handleClick'], ctx];
+    const v1 = ctx['handleClick'];
-    let hdlr2 = [ctx['handleDblClick'], ctx];
+    let d1 = [v1, ctx];
-    return block1([hdlr1, hdlr2]);
+    const v2 = ctx['handleDblClick'];
+    let d2 = [v2, ctx];
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -119,13 +128,15 @@ exports[`t-on can bind two event handlers 1`] = `
 exports[`t-on handler is bound to proper owner 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['add'], ctx];
+    const v1 = ctx['add'];
-    return block1([hdlr1]);
+    let d1 = [v1, ctx];
+    return block1([d1]);
   }
 }"
 `;
@@ -133,8 +144,8 @@ exports[`t-on handler is bound to proper owner 1`] = `
 exports[`t-on handler is bound to proper owner, part 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block2 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
@@ -144,8 +155,9 @@ exports[`t-on handler is bound to proper owner, part 2 1`] = `
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`value\`] = v_block1[i1];
       let key1 = ctx['value'];
-      let hdlr1 = [ctx['add'], ctx];
+      const v1 = ctx['add'];
-      c_block1[i1] = withKey(block2([hdlr1]), key1);
+      let d1 = [v1, ctx];
+      c_block1[i1] = withKey(block2([d1]), key1);
     }
     return list(c_block1);
   }
@@ -155,12 +167,15 @@ exports[`t-on handler is bound to proper owner, part 2 1`] = `
 exports[`t-on handler is bound to proper owner, part 3 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    return callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    const v1 = ctx['add'];
+    let d1 = [v1, ctx];
+    return block1([d1]);
   }
 }"
 `;
@@ -168,13 +183,12 @@ exports[`t-on handler is bound to proper owner, part 3 1`] = `
 exports[`t-on handler is bound to proper owner, part 3 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
+  const callTemplate_2 = getTemplate(\`sub\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['add'], ctx];
+    return callTemplate_2.call(this, ctx, node, key + \`__1\`);
-    return block1([hdlr1]);
   }
 }"
 `;
@@ -182,9 +196,25 @@ exports[`t-on handler is bound to proper owner, part 3 2`] = `
 exports[`t-on handler is bound to proper owner, part 4 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, getTemplate, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const v1 = ctx['add'];
+    let d1 = [v1, ctx];
+    return block1([d1]);
+  }
+}"
+`;
+
+exports[`t-on handler is bound to proper owner, part 4 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  const callTemplate_2 = getTemplate(\`sub\`);
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -196,37 +226,25 @@ exports[`t-on handler is bound to proper owner, part 4 1`] = `
       ctx[\`value_index\`] = i1;
       ctx[\`value_value\`] = k_block1[i1];
       let key1 = ctx['value'];
-      c_block1[i1] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
+      c_block1[i1] = withKey(callTemplate_2.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
     }
     return list(c_block1);
   }
 }"
 `;
 
-exports[`t-on handler is bound to proper owner, part 4 2`] = `
-"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['add'], ctx];
-    return block1([hdlr1]);
-  }
-}"
-`;
-
 exports[`t-on receive event in first argument 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['add'], ctx];
+    const v1 = ctx['add'];
-    return block1([hdlr1]);
+    let d1 = [v1, ctx];
+    return block1([d1]);
   }
 }"
 `;
@@ -234,14 +252,17 @@ exports[`t-on receive event in first argument 1`] = `
 exports[`t-on t-on modifiers (native listener) basic support for native listener 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"myClass\\" block-handler-0=\\"click\\"><button block-handler-1=\\"click\\">Button</button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['divClicked'], ctx];
+    const v1 = ctx['divClicked'];
-    let hdlr2 = [ctx['btnClicked'], ctx];
+    let d1 = [v1, ctx];
-    return block1([hdlr1, hdlr2]);
+    const v2 = ctx['btnClicked'];
+    let d2 = [v2, ctx];
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -249,14 +270,16 @@ exports[`t-on t-on modifiers (native listener) basic support for native listener
 exports[`t-on t-on modifiers (native listener) t-on combined with t-esc 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><button block-handler-0=\\"click\\"><block-text-1/></button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['onClick'], ctx];
+    const v1 = ctx['onClick'];
-    let txt1 = ctx['text'];
+    let d1 = [v1, ctx];
-    return block1([hdlr1, txt1]);
+    let d2 = ctx['text'];
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -264,15 +287,16 @@ exports[`t-on t-on modifiers (native listener) t-on combined with t-esc 1`] = `
 exports[`t-on t-on modifiers (native listener) t-on combined with t-out 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><button block-handler-0=\\"click\\"><block-child-0/></button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['onClick'], ctx];
+    const v1 = ctx['onClick'];
+    let d1 = [v1, ctx];
     let b2 = safeOutput(ctx['html']);
-    return block1([hdlr1], [b2]);
+    return block1([d1], [b2]);
   }
 }"
 `;
@@ -280,14 +304,17 @@ exports[`t-on t-on modifiers (native listener) t-on combined with t-out 1`] = `
 exports[`t-on t-on modifiers (native listener) t-on with .capture modifier 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-handler-0=\\"click.capture\\"><button block-handler-1=\\"click\\">Button</button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [\\"capture\\", ctx['onCapture'], ctx];
+    const v1 = ctx['onCapture'];
-    let hdlr2 = [ctx['doSomething'], ctx];
+    let d1 = [\\"capture\\", v1, ctx];
-    return block1([hdlr1, hdlr2]);
+    const v2 = ctx['doSomething'];
+    let d2 = [v2, ctx];
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -295,13 +322,14 @@ exports[`t-on t-on modifiers (native listener) t-on with .capture modifier 1`] =
 exports[`t-on t-on modifiers (native listener) t-on with empty handler (only modifiers) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><button block-handler-0=\\"click.prevent\\">Button</button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [\\"prevent\\", , ctx];
+    let d1 = [\\"prevent\\", , ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -309,13 +337,15 @@ exports[`t-on t-on modifiers (native listener) t-on with empty handler (only mod
 exports[`t-on t-on modifiers (native listener) t-on with prevent and self modifiers (order matters) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><button block-handler-0=\\"click.prevent.self\\"><span>Button</span></button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [\\"prevent\\",\\"self\\", ctx['onClick'], ctx];
+    const v1 = ctx['onClick'];
-    return block1([hdlr1]);
+    let d1 = [\\"prevent\\",\\"self\\", v1, ctx];
+    return block1([d1]);
   }
 }"
 `;
@@ -323,15 +353,19 @@ exports[`t-on t-on modifiers (native listener) t-on with prevent and self modifi
 exports[`t-on t-on modifiers (native listener) t-on with prevent and/or stop modifiers 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><button block-handler-0=\\"click.prevent\\">Button 1</button><button block-handler-1=\\"click.stop\\">Button 2</button><button block-handler-2=\\"click.prevent.stop\\">Button 3</button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [\\"prevent\\", ctx['onClickPrevented'], ctx];
+    const v1 = ctx['onClickPrevented'];
-    let hdlr2 = [\\"stop\\", ctx['onClickStopped'], ctx];
+    let d1 = [\\"prevent\\", v1, ctx];
-    let hdlr3 = [\\"prevent\\",\\"stop\\", ctx['onClickPreventedAndStopped'], ctx];
+    const v2 = ctx['onClickStopped'];
-    return block1([hdlr1, hdlr2, hdlr3]);
+    let d2 = [\\"stop\\", v2, ctx];
+    const v3 = ctx['onClickPreventedAndStopped'];
+    let d3 = [\\"prevent\\",\\"stop\\", v3, ctx];
+    return block1([d1, d2, d3]);
   }
 }"
 `;
@@ -339,8 +373,8 @@ exports[`t-on t-on modifiers (native listener) t-on with prevent and/or stop mod
 exports[`t-on t-on modifiers (native listener) t-on with prevent modifier in t-foreach 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<a href=\\"#\\" block-handler-0=\\"click.prevent\\"> Edit <block-text-1/></a>\`);
@@ -353,9 +387,9 @@ exports[`t-on t-on modifiers (native listener) t-on with prevent modifier in t-f
       let key1 = ctx['project'];
       const v1 = ctx['onEdit'];
       const v2 = ctx['project'];
-      let hdlr1 = [\\"prevent\\", _ev=>v1(v2.id,_ev), ctx];
+      let d1 = [\\"prevent\\", ev=>v1(v2.id,ev), ctx];
-      let txt1 = ctx['project'].name;
+      let d2 = ctx['project'].name;
-      c_block2[i1] = withKey(block3([hdlr1, txt1]), key1);
+      c_block2[i1] = withKey(block3([d1, d2]), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -366,13 +400,15 @@ exports[`t-on t-on modifiers (native listener) t-on with prevent modifier in t-f
 exports[`t-on t-on modifiers (native listener) t-on with self and prevent modifiers (order matters) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><button block-handler-0=\\"click.self.prevent\\"><span>Button</span></button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [\\"self\\",\\"prevent\\", ctx['onClick'], ctx];
+    const v1 = ctx['onClick'];
-    return block1([hdlr1]);
+    let d1 = [\\"self\\",\\"prevent\\", v1, ctx];
+    return block1([d1]);
   }
 }"
 `;
@@ -380,14 +416,17 @@ exports[`t-on t-on modifiers (native listener) t-on with self and prevent modifi
 exports[`t-on t-on modifiers (native listener) t-on with self modifier 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><button block-handler-0=\\"click\\"><span>Button</span></button><button block-handler-1=\\"click.self\\"><span>Button</span></button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['onClick'], ctx];
+    const v1 = ctx['onClick'];
-    let hdlr2 = [\\"self\\", ctx['onClickSelf'], ctx];
+    let d1 = [v1, ctx];
-    return block1([hdlr1, hdlr2]);
+    const v2 = ctx['onClickSelf'];
+    let d2 = [\\"self\\", v2, ctx];
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -395,14 +434,17 @@ exports[`t-on t-on modifiers (native listener) t-on with self modifier 1`] = `
 exports[`t-on t-on modifiers (synthetic listener) basic support for synthetic 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-handler-0=\\"click.synthetic\\"><button block-handler-1=\\"click.synthetic\\">Button</button></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [\\"synthetic\\", ctx['divClicked'], ctx];
+    const v1 = ctx['divClicked'];
-    let hdlr2 = [\\"synthetic\\", ctx['btnClicked'], ctx];
+    let d1 = [\\"synthetic\\", v1, ctx];
-    return block1([hdlr1, hdlr2]);
+    const v2 = ctx['btnClicked'];
+    let d2 = [\\"synthetic\\", v2, ctx];
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -410,14 +452,15 @@ exports[`t-on t-on modifiers (synthetic listener) basic support for synthetic 1`
 exports[`t-on t-on with inline statement (function call) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const v1 = ctx['state'];
-    let hdlr1 = [()=>v1.incrementCounter(2), ctx];
+    let d1 = [()=>v1.incrementCounter(2), ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -425,14 +468,15 @@ exports[`t-on t-on with inline statement (function call) 1`] = `
 exports[`t-on t-on with inline statement 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Click</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const v1 = ctx['state'];
-    let hdlr1 = [()=>v1.counter++, ctx];
+    let d1 = [()=>v1.counter++, ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -440,14 +484,15 @@ exports[`t-on t-on with inline statement 1`] = `
 exports[`t-on t-on with inline statement, part 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Toggle</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const v1 = ctx['state'];
-    let hdlr1 = [()=>v1.flag=!v1.flag, ctx];
+    let d1 = [()=>v1.flag=!v1.flag, ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -455,15 +500,16 @@ exports[`t-on t-on with inline statement, part 2 1`] = `
 exports[`t-on t-on with inline statement, part 3 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<button block-handler-0=\\"click\\">Toggle</button>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const v1 = ctx['state'];
     const v2 = ctx['someFunction'];
-    let hdlr1 = [()=>v1.n=v2(3), ctx];
+    let d1 = [()=>v1.n=v2(3), ctx];
-    return block1([hdlr1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -471,15 +517,15 @@ exports[`t-on t-on with inline statement, part 3 1`] = `
 exports[`t-on t-on with t-call 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
   
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block1 = createBlock(\`<p block-handler-0=\\"click\\">lucas</p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    const v1 = ctx['update'];
-    return block1([], [b2]);
+    let d1 = [v1, ctx];
+    return block1([d1]);
   }
 }"
 `;
@@ -487,13 +533,15 @@ exports[`t-on t-on with t-call 1`] = `
 exports[`t-on t-on with t-call 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  const callTemplate_2 = getTemplate(\`sub\`);
   
-  let block1 = createBlock(\`<p block-handler-0=\\"click\\">lucas</p>\`);
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['update'], ctx];
+    let b2 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
-    return block1([hdlr1]);
+    return block1([], [b2]);
   }
 }"
 `;
@@ -501,15 +549,15 @@ exports[`t-on t-on with t-call 2`] = `
 exports[`t-on t-on, with arguments and t-call 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
   
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block1 = createBlock(\`<p block-handler-0=\\"click\\">lucas</p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    const v1 = ctx['value'];
-    return block1([], [b2]);
+    let d1 = [()=>this.update(v1), ctx];
+    return block1([d1]);
   }
 }"
 `;
@@ -517,14 +565,15 @@ exports[`t-on t-on, with arguments and t-call 1`] = `
 exports[`t-on t-on, with arguments and t-call 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  const callTemplate_2 = getTemplate(\`sub\`);
   
-  let block1 = createBlock(\`<p block-handler-0=\\"click\\">lucas</p>\`);
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const v1 = ctx['value'];
+    let b2 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
-    let hdlr1 = [()=>this.update(v1), ctx];
+    return block1([], [b2]);
-    return block1([hdlr1]);
   }
 }"
 `;

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

@@ -3,8 +3,8 @@
 exports[`misc complex template 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div block-attribute-0=\\"class\\"><div block-attribute-1=\\"class\\"><div class=\\"batch_header\\"><a block-attribute-2=\\"href\\" block-attribute-3=\\"class\\" title=\\"View Batch\\"><block-text-4/><block-child-0/><i class=\\"arrow fa fa-window-maximize\\"/></a></div><block-child-1/><div class=\\"batch_slots\\"><block-child-2/><block-child-3/></div><div class=\\"batch_commits\\"><block-child-4/></div></div></div>\`);
   let block2 = createBlock(\`<i class=\\"fa fa-exclamation-triangle\\"/>\`);
@@ -18,11 +18,11 @@ exports[`misc complex template 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3,b4,b6,b8;
-    let attr1 = \`batch_tile \${ctx['options'].more?'more':'nomore'}\`;
+    let d1 = \`batch_tile \${ctx['options'].more?'more':'nomore'}\`;
-    let attr2 = \`card bg-\${ctx['klass']}-light\`;
+    let d2 = \`card bg-\${ctx['klass']}-light\`;
-    let attr3 = \`/runbot/batch/\${ctx['batch'].id}\`;
+    let d3 = \`/runbot/batch/\${ctx['batch'].id}\`;
-    let attr4 = \`badge badge-\${ctx['batch'].has_warning?'warning':'light'}\`;
+    let d4 = \`badge badge-\${ctx['batch'].has_warning?'warning':'light'}\`;
-    let txt1 = ctx['batch'].formated_age;
+    let d5 = ctx['batch'].formated_age;
     if (ctx['batch'].has_warning) {
       b2 = block2();
     }
@@ -30,11 +30,11 @@ exports[`misc complex template 1`] = `
       b3 = block3();
     }
     ctx = Object.create(ctx);
-    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['batch'].slot_ids.filter(_slot=>_slot.build_id.id&&!_slot.trigger_id.manual&&(ctx['options'].trigger_display[_slot.trigger_id.id])));
+    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['batch'].slot_ids.filter(slot=>slot.build_id.id&&!slot.trigger_id.manual&&(ctx['options'].trigger_display[slot.trigger_id.id])));
     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}\`, 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);
@@ -53,8 +53,8 @@ exports[`misc complex template 1`] = `
       ctx[\`commit_link\`] = v_block8[i1];
       let key1 = ctx['commit_link'].id;
       let b10,b11,b12,b13;
-      let attr5 = \`/runbot/commit/\${ctx['commit_link'].commit_id}\`;
+      let d6 = \`/runbot/commit/\${ctx['commit_link'].commit_id}\`;
-      let attr6 = \`badge badge-light batch_commit match_type_\${ctx['commit_link'].match_type}\`;
+      let d7 = \`badge badge-light batch_commit match_type_\${ctx['commit_link'].match_type}\`;
       if (ctx['commit_link'].match_type=='new') {
         b10 = block10();
       }
@@ -67,13 +67,13 @@ exports[`misc complex template 1`] = `
       if (ctx['commit_link'].match_type=='base_head') {
         b13 = block13();
       }
-      let txt2 = ctx['commit_link'].commit_dname;
+      let d8 = ctx['commit_link'].commit_dname;
-      let attr7 = 'https://%s/commit/%s'%(ctx['commit_link'].commit_remote_url,ctx['commit_link'].commit_name);
+      let d9 = 'https://%s/commit/%s'%(ctx['commit_link'].commit_remote_url,ctx['commit_link'].commit_name);
-      let txt3 = ctx['commit_link'].commit_subject;
+      let d10 = ctx['commit_link'].commit_subject;
-      c_block8[i1] = withKey(block9([attr5, attr6, txt2, attr7, txt3], [b10, b11, b12, b13]), key1);
+      c_block8[i1] = withKey(block9([d6, d7, d8, d9, d10], [b10, b11, b12, b13]), key1);
     }
     b8 = list(c_block8);
-    return block1([attr1, attr2, attr3, attr4, txt1], [b2, b3, b4, b6, b8]);
+    return block1([d1, d2, d3, d4, d5], [b2, b3, b4, b6, b8]);
   }
 }"
 `;
@@ -81,13 +81,60 @@ exports[`misc complex template 1`] = `
 exports[`misc global 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, isBoundary, withDefault, setContextValue, getTemplate, zero, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`_callee-uses-foo\`);
+  
+  let block1 = createBlock(\`<año block-attribute-0=\\"falló\\"><block-child-0/></año>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let d1 = 'agüero';
+    let b2 = ctx[zero];
+    return block1([d1], [b2]);
+  }
+}"
+`;
+
+exports[`misc global 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let d1 = withDefault(ctx['foo'], \`foo default\`);
+    return block1([d1]);
+  }
+}"
+`;
+
+exports[`misc global 3`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b3 = text(\`toto default\`);
+    let b2 = withDefault(safeOutput(ctx['toto']), b3);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`misc global 4`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   const callTemplate_2 = getTemplate(\`_callee-uses-foo\`);
-  const callTemplate_3 = getTemplate(\`_callee-uses-foo\`);
+  const callTemplate_4 = getTemplate(\`_callee-uses-foo\`);
-  const callTemplate_4 = getTemplate(\`_callee-asc\`);
+  const callTemplate_6 = getTemplate(\`_callee-uses-foo\`);
-  const callTemplate_5 = getTemplate(\`_callee-asc-toto\`);
+  const callTemplate_8 = getTemplate(\`_callee-asc\`);
+  const callTemplate_10 = getTemplate(\`_callee-asc-toto\`);
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   let block4 = createBlock(\`<span><block-text-0/></span>\`);
@@ -104,85 +151,38 @@ exports[`misc global 1`] = `
       ctx[\`value_index\`] = i1;
       ctx[\`value_value\`] = k_block2[i1];
       let key1 = ctx['value'];
-      let txt1 = ctx['value'];
+      let d1 = ctx['value'];
-      let b4 = block4([txt1]);
+      let b4 = block4([d1]);
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
       setContextValue(ctx, \\"foo\\", 'aaa');
-      let b6 = callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`);
+      let b6 = callTemplate_2.call(this, ctx, node, key + \`__1__\${key1}\`);
       ctx = ctx.__proto__;
-      let b7 = callTemplate_2.call(this, ctx, node, key + \`__2__\${key1}\`);
+      let b7 = callTemplate_4.call(this, ctx, node, key + \`__3__\${key1}\`);
       setContextValue(ctx, \\"foo\\", 'bbb');
-      let b8 = callTemplate_3.call(this, ctx, node, key + \`__3__\${key1}\`);
+      let b8 = callTemplate_6.call(this, ctx, node, key + \`__5__\${key1}\`);
       let b5 = multi([b6, b7, b8]);
       ctx[zero] = b5;
-      let b9 = callTemplate_4.call(this, ctx, node, key + \`__4__\${key1}\`);
+      let b9 = callTemplate_8.call(this, ctx, node, key + \`__7__\${key1}\`);
       ctx = ctx.__proto__;
       c_block2[i1] = withKey(multi([b4, b9]), key1);
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);
-    let b10 = callTemplate_5.call(this, ctx, node, key + \`__5\`);
+    let b10 = callTemplate_10.call(this, ctx, node, key + \`__9\`);
     return block1([], [b2, b10]);
   }
 }"
 `;
 
-exports[`misc global 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { withDefault } = helpers;
-  
-  let block1 = createBlock(\`<span><block-text-0/></span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = withDefault(ctx['foo'], \`foo default\`);
-    return block1([txt1]);
-  }
-}"
-`;
-
-exports[`misc global 3`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { zero } = helpers;
-  
-  let block1 = createBlock(\`<año block-attribute-0=\\"falló\\"><block-child-0/></año>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let attr1 = 'agüero';
-    let b2 = ctx[zero];
-    return block1([attr1], [b2]);
-  }
-}"
-`;
-
-exports[`misc global 4`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { safeOutput, withDefault } = helpers;
-  
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b3 = text(\`toto default\`);
-    let b2 = withDefault(safeOutput(ctx['toto']), b3);
-    return block1([], [b2]);
-  }
-}"
-`;
-
 exports[`misc other complex template 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey, getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`LOAD_INFOS_TEMPLATE\`);
+  const callTemplate_14 = getTemplate(\`LOAD_INFOS_TEMPLATE\`);
   
   let block1 = createBlock(\`<div><header><nav class=\\"navbar navbar-expand-md navbar-light bg-light\\"><a block-attribute-0=\\"href\\"><b style=\\"color:#777;\\"><block-text-1/></b></a><button type=\\"button\\" class=\\"navbar-toggler\\" data-toggle=\\"collapse\\" data-target=\\"#top_menu_collapse\\"><span class=\\"navbar-toggler-icon\\"/></button><div class=\\"collapse navbar-collapse\\" id=\\"top_menu_collapse\\" aria-expanded=\\"false\\"><ul class=\\"nav navbar-nav ml-auto text-right\\" id=\\"top_menu\\"><block-child-0/><li class=\\"nav-item divider\\"/><block-child-1/></ul><div><div class=\\"input-group input-group-sm\\"><div class=\\"input-group-prepend input-group-sm\\"><button class=\\"btn btn-default fa fa-cog\\" title=\\"Settings\\" block-handler-2=\\"click\\"/><button class=\\"btn btn-default\\" block-handler-3=\\"click\\"> More </button><block-child-2/></div><input class=\\"form-control\\" type=\\"text\\" placeholder=\\"Search\\" aria-label=\\"Search\\" name=\\"search\\" block-attribute-4=\\"value\\" block-handler-5=\\"keyup\\" block-handler-6=\\"change\\" block-ref=\\"7\\"/><div class=\\"input-group-append\\"><button class=\\"btn btn-default fa fa-eraser\\" block-handler-8=\\"click\\"/></div></div></div></div></nav></header><div class=\\"container-fluid\\" block-ref=\\"9\\"><div class=\\"row\\"><!--div class=\\"form-group col-md-6\\">
                       <h5>Search options</h5>
@@ -215,33 +215,33 @@ exports[`misc other complex template 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const refs = ctx.__owl__.refs;
-    const ref1 = (el) => refs[\`search_input\`] = el;
-    const ref2 = (el) => refs[\`settings_menu\`] = el;
     let b2,b4,b14,b17,b22,b23,b24,b25;
-    let attr1 = \`/runbot/\${ctx['project'].slug}\`;
+    let d1 = \`/runbot/\${ctx['project'].slug}\`;
-    let txt1 = ctx['project'].name;
+    let d2 = ctx['project'].name;
     ctx = Object.create(ctx);
     const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['projects']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`project\`] = v_block2[i1];
       let key1 = ctx['project'].id;
-      let hdlr1 = [ctx['selectProject'](ctx['project']), ctx];
+      const v1 = ctx['selectProject'];
-      let txt2 = ctx['project'].name;
+      const v2 = ctx['project'];
-      c_block2[i1] = withKey(block3([hdlr1, txt2]), key1);
+      let d3 = [v1(v2), ctx];
+      let d4 = ctx['project'].name;
+      c_block2[i1] = withKey(block3([d3, d4]), key1);
     }
     ctx = ctx.__proto__;
     b2 = list(c_block2);
     if (ctx['user']) {
       let b5,b6;
       if (ctx['user'].public) {
-        let attr2 = \`/web/login?redirect=/\`;
+        let d5 = \`/web/login?redirect=/\`;
-        b5 = block5([attr2]);
+        b5 = block5([d5]);
       } else {
         let b7,b10,b13;
         if (ctx['nb_assigned_errors']&&ctx['nb_assigned_errors']>0) {
-          let attr3 = \`You have \${ctx['nb_assigned_errors']} random bug assigned\`;
+          let d6 = \`You have \${ctx['nb_assigned_errors']} random bug assigned\`;
-          let txt3 = ctx['nb_assigned_errors'];
+          let d7 = ctx['nb_assigned_errors'];
-          let b8 = block8([attr3, txt3]);
+          let b8 = block8([d6, d7]);
           let b9 = block9();
           b7 = multi([b8, b9]);
         } else if (ctx['nb_build_errors']&&ctx['nb_build_errors']>0) {
@@ -249,35 +249,42 @@ exports[`misc other complex template 1`] = `
           let b12 = block12();
           b10 = multi([b11, b12]);
         }
-        let txt4 = ctx['user'].name.length>25?ctx['user'].namesubstring(0,23)+'...':ctx['user'].name;
+        let d8 = ctx['user'].name.length>25?ctx['user'].namesubstring(0,23)+'...':ctx['user'].name;
-        let attr4 = \`/web/session/logout?redirect=/\`;
+        let d9 = \`/web/session/logout?redirect=/\`;
-        let attr5 = \`/web\`;
+        let d10 = \`/web\`;
-        b13 = block13([txt4, attr4, attr5]);
+        b13 = block13([d8, d9, d10]);
         b6 = multi([b7, b10, b13]);
       }
       b4 = multi([b5, b6]);
     }
-    let hdlr2 = [ctx['toggleSettingsMenu'], ctx];
+    const v3 = ctx['toggleSettingsMenu'];
-    let hdlr3 = [ctx['toggleMore'], ctx];
+    let d11 = [v3, ctx];
+    const v4 = ctx['toggleMore'];
+    let d12 = [v4, ctx];
     if (ctx['categories']&&ctx['categories'].length>1) {
       ctx = Object.create(ctx);
       const [k_block15, v_block15, l_block15, c_block15] = prepareList(ctx['categories']);
       for (let i1 = 0; i1 < l_block15; i1++) {
         ctx[\`category\`] = v_block15[i1];
         let key1 = ctx['category'].id;
-        let attr6 = ctx['category'].id;
+        let d13 = ctx['category'].id;
-        let attr7 = ctx['category'].id==ctx['options'].active_category_id;
+        let d14 = ctx['category'].id==ctx['options'].active_category_id;
-        let txt5 = ctx['category'].name;
+        let d15 = ctx['category'].name;
-        c_block15[i1] = withKey(block16([attr6, attr7, txt5]), key1);
+        c_block15[i1] = withKey(block16([d13, d14, d15]), key1);
       }
       ctx = ctx.__proto__;
       let b15 = list(c_block15);
       b14 = block14([], [b15]);
     }
-    let attr8 = ctx['search'].value;
+    let d16 = ctx['search'].value;
-    let hdlr4 = [ctx['updateFilter'], ctx];
+    const v5 = ctx['updateFilter'];
-    let hdlr5 = [ctx['updateFilter'], ctx];
+    let d17 = [v5, ctx];
-    let hdlr6 = [ctx['clearSearch'], ctx];
+    const v6 = ctx['updateFilter'];
+    let d18 = [v6, ctx];
+    let d19 = (el) => refs[\`search_input\`] = el;
+    const v7 = ctx['clearSearch'];
+    let d20 = [v7, ctx];
+    let d21 = (el) => refs[\`settings_menu\`] = el;
     if (ctx['triggers']) {
       ctx = Object.create(ctx);
       const [k_block18, v_block18, l_block18, c_block18] = prepareList(ctx['triggers']);
@@ -286,41 +293,46 @@ exports[`misc other complex template 1`] = `
         let key1 = ctx['trigger'].id;
         let b20;
         if (!ctx['trigger'].manual&&ctx['trigger'].project_id===ctx['project'].id&&ctx['trigger'].category_id===ctx['options'].active_category_id) {
-          let attr9 = \`trigger_\${ctx['trigger'].id}\`;
+          let d22 = \`trigger_\${ctx['trigger'].id}\`;
-          let attr10 = \`trigger_\${ctx['trigger'].id}\`;
+          let d23 = \`trigger_\${ctx['trigger'].id}\`;
-          let attr11 = ctx['options'].trigger_display[ctx['trigger'].id];
+          let d24 = ctx['options'].trigger_display[ctx['trigger'].id];
-          let attr12 = ctx['trigger'].id;
+          let d25 = ctx['trigger'].id;
-          let hdlr7 = [ctx['updateTriggerDisplay'], ctx];
+          const v8 = ctx['updateTriggerDisplay'];
-          let attr13 = \`trigger_\${ctx['trigger'].id}\`;
+          let d26 = [v8, ctx];
-          let txt6 = ctx['trigger'].name;
+          let d27 = \`trigger_\${ctx['trigger'].id}\`;
-          b20 = block20([attr9, attr10, attr11, attr12, hdlr7, attr13, txt6]);
+          let d28 = ctx['trigger'].name;
+          b20 = block20([d22, d23, d24, d25, d26, d27, d28]);
         }
         c_block18[i1] = withKey(multi([b20]), key1);
       }
       ctx = ctx.__proto__;
       let b18 = list(c_block18);
-      let hdlr8 = [ctx['triggerAll'], ctx];
+      const v9 = ctx['triggerAll'];
-      let hdlr9 = [ctx['triggerNone'], ctx];
+      let d29 = [v9, ctx];
-      let hdlr10 = [ctx['triggerDefault'], ctx];
+      const v10 = ctx['triggerNone'];
-      let hdlr11 = [ctx['toggleSettingsMenu'], ctx];
+      let d30 = [v10, ctx];
-      let b21 = block21([hdlr8, hdlr9, hdlr10, hdlr11]);
+      const v11 = ctx['triggerDefault'];
+      let d31 = [v11, ctx];
+      const v12 = ctx['toggleSettingsMenu'];
+      let d32 = [v12, ctx];
+      let b21 = block21([d29, d30, d31, d32]);
       b17 = multi([b18, b21]);
     }
     if (ctx['load_infos']) {
-      b22 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+      b22 = callTemplate_14.call(this, ctx, node, key + \`__13\`);
     }
     if (ctx['message']) {
-      let txt7 = ctx['message'];
+      let d33 = ctx['message'];
-      b23 = block23([txt7]);
+      b23 = block23([d33]);
     }
     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\`, node, ctx);
+      let b26 = component(\`BundlesList\`, {bundles: ctx['bundles'].sticky,category_custom_views: ctx['category_custom_views'],search: ctx['search']}, key + \`__15\`, node, ctx);
-      let b27 = component(\`BundlesList\`, {bundles: ctx['bundles'].dev, search: ctx['search']}, key + \`__3\`, node, ctx);
+      let b27 = component(\`BundlesList\`, {bundles: ctx['bundles'].dev,search: ctx['search']}, key + \`__16\`, 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]);
+    return block1([d1, d2, d11, d12, d16, d17, d18, d19, d20, d21], [b2, b4, b14, b17, b22, b23, b24, b25]);
   }
 }"
 `;

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

@@ -3,8 +3,8 @@
 exports[`memory t-foreach does not leak stuff in global scope 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   

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

@@ -3,7 +3,8 @@
 exports[`simple templates, mostly static can render a table row 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<tr><td>cell</td></tr>\`);
   
@@ -16,7 +17,8 @@ exports[`simple templates, mostly static can render a table row 1`] = `
 exports[`simple templates, mostly static div with a class attribute 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"abc\\">foo</div>\`);
   
@@ -29,7 +31,8 @@ exports[`simple templates, mostly static div with a class attribute 1`] = `
 exports[`simple templates, mostly static div with a class attribute with a quote 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div class=\\"a'bc\\">word</div>\`);
   
@@ -42,7 +45,8 @@ exports[`simple templates, mostly static div with a class attribute with a quote
 exports[`simple templates, mostly static div with a span child node 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><span>word</span></div>\`);
   
@@ -55,7 +59,8 @@ exports[`simple templates, mostly static div with a span child node 1`] = `
 exports[`simple templates, mostly static div with an arbitrary attribute with a quote 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div abc=\\"a'bc\\">word</div>\`);
   
@@ -68,7 +73,8 @@ exports[`simple templates, mostly static div with an arbitrary attribute with a
 exports[`simple templates, mostly static div with an empty class attribute 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div>word</div>\`);
   
@@ -81,7 +87,8 @@ exports[`simple templates, mostly static div with an empty class attribute 1`] =
 exports[`simple templates, mostly static div with content 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div>foo</div>\`);
   
@@ -94,13 +101,14 @@ exports[`simple templates, mostly static div with content 1`] = `
 exports[`simple templates, mostly static dom node with t-esc 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['text'];
+    let d1 = ctx['text'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -108,13 +116,14 @@ exports[`simple templates, mostly static dom node with t-esc 1`] = `
 exports[`simple templates, mostly static dom node with t-esc 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['text'];
+    let d1 = ctx['text'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -122,7 +131,8 @@ exports[`simple templates, mostly static dom node with t-esc 2`] = `
 exports[`simple templates, mostly static dynamic text value 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return text(ctx['text']);
@@ -133,7 +143,8 @@ exports[`simple templates, mostly static dynamic text value 1`] = `
 exports[`simple templates, mostly static empty div 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div/>\`);
   
@@ -146,7 +157,8 @@ exports[`simple templates, mostly static empty div 1`] = `
 exports[`simple templates, mostly static empty string 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return text(\`\`);
@@ -157,7 +169,8 @@ exports[`simple templates, mostly static empty string 1`] = `
 exports[`simple templates, mostly static empty string in a template set 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return text(\`\`);
@@ -168,7 +181,8 @@ exports[`simple templates, mostly static empty string in a template set 1`] = `
 exports[`simple templates, mostly static inline template string in t-esc 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return text(\`text\`);
@@ -179,8 +193,8 @@ exports[`simple templates, mostly static inline template string in t-esc 1`] = `
 exports[`simple templates, mostly static inline template string with content in t-esc 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -194,7 +208,8 @@ exports[`simple templates, mostly static inline template string with content in
 exports[`simple templates, mostly static inline template string with variable in context 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return text(\`text \${ctx['v']}\`);
@@ -205,7 +220,8 @@ exports[`simple templates, mostly static inline template string with variable in
 exports[`simple templates, mostly static multiple root nodes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block2 = createBlock(\`<div>foo</div>\`);
   let block3 = createBlock(\`<span>hey</span>\`);
@@ -221,7 +237,8 @@ exports[`simple templates, mostly static multiple root nodes 1`] = `
 exports[`simple templates, mostly static simple string 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return text(\`hello vdom\`);
@@ -232,7 +249,8 @@ exports[`simple templates, mostly static simple string 1`] = `
 exports[`simple templates, mostly static simple string in t tag 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return text(\`hello vdom\`);
@@ -243,7 +261,8 @@ exports[`simple templates, mostly static simple string in t tag 1`] = `
 exports[`simple templates, mostly static static text and dynamic text (no t tag) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2 = text(\`hello \`);
@@ -256,7 +275,8 @@ exports[`simple templates, mostly static static text and dynamic text (no t tag)
 exports[`simple templates, mostly static static text and dynamic text 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2 = text(\`hello \`);
@@ -269,13 +289,14 @@ exports[`simple templates, mostly static static text and dynamic text 1`] = `
 exports[`simple templates, mostly static t-esc in dom node 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['text'];
+    let d1 = ctx['text'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -283,13 +304,14 @@ exports[`simple templates, mostly static t-esc in dom node 1`] = `
 exports[`simple templates, mostly static t-esc in dom node, variations 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div>hello <block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['text'];
+    let d1 = ctx['text'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -297,46 +319,14 @@ exports[`simple templates, mostly static t-esc in dom node, variations 1`] = `
 exports[`simple templates, mostly static t-esc in dom node, variations 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div>hello <block-text-0/> world</div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['text'];
+    let d1 = ctx['text'];
-    return block1([txt1]);
+    return block1([d1]);
-  }
-}"
-`;
-
-exports[`simple templates, mostly static template with multiple t tag with multiple content 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div><block-text-0/><block-text-1/>Loading<block-text-2/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['a'];
-    let txt2 = ctx['b'];
-    let txt3 = ctx['c'];
-    return block1([txt1, txt2, txt3]);
-  }
-}"
-`;
-
-exports[`simple templates, mostly static template with t tag with multiple content 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>Loading<block-child-0/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2;
-    if (false) {
-      b2 = text(\`\`);
-    }
-    return block1([], [b2]);
   }
 }"
 `;
@@ -344,7 +334,8 @@ exports[`simple templates, mostly static template with t tag with multiple conte
 exports[`simple templates, mostly static two t-escs next to each other 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2 = text(ctx['text1']);
@@ -357,7 +348,8 @@ exports[`simple templates, mostly static two t-escs next to each other 1`] = `
 exports[`simple templates, mostly static two t-escs next to each other 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2 = text(ctx['text1']);
@@ -370,14 +362,15 @@ exports[`simple templates, mostly static two t-escs next to each other 2`] = `
 exports[`simple templates, mostly static two t-escs next to each other, in a div 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/><block-text-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['text1'];
+    let d1 = ctx['text1'];
-    let txt2 = ctx['text2'];
+    let d2 = ctx['text2'];
-    return block1([txt1, txt2]);
+    return block1([d1, d2]);
   }
 }"
 `;

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

@@ -3,7 +3,8 @@
 exports[`properly support svg add proper namespace to g tags 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<g block-ns=\\"http://www.w3.org/2000/svg\\"><circle cx=\\"50\\" cy=\\"50\\" r=\\"4\\" stroke=\\"green\\" stroke-width=\\"1\\" fill=\\"yellow\\"/> </g>\`);
   
@@ -16,7 +17,8 @@ exports[`properly support svg add proper namespace to g tags 1`] = `
 exports[`properly support svg add proper namespace to svg 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\" width=\\"100px\\" height=\\"90px\\"><circle cx=\\"50\\" cy=\\"50\\" r=\\"4\\" stroke=\\"green\\" stroke-width=\\"1\\" fill=\\"yellow\\"/> </svg>\`);
   
@@ -29,7 +31,8 @@ exports[`properly support svg add proper namespace to svg 1`] = `
 exports[`properly support svg namespace to g tags not added if already in svg namespace 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><g/></svg>\`);
   
@@ -42,94 +45,13 @@ exports[`properly support svg namespace to g tags not added if already in svg na
 exports[`properly support svg namespace to svg tags added even if already in svg namespace 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
-  let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><svg/></svg>\`);
+  let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><svg block-ns=\\"http://www.w3.org/2000/svg\\"/></svg>\`);
   
   return function template(ctx, node, key = \\"\\") {
     return block1();
   }
 }"
 `;
-
-exports[`properly support svg svg creates new block if it is within html -- 2 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
-  let block2 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><polygon fill=\\"#000000\\" points=\\"0 0 4 4 8 0\\" transform=\\"translate(5 7)\\"/><block-child-0/></svg>\`);
-  let block3 = createBlock(\`<path block-ns=\\"http://www.w3.org/2000/svg\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b3;
-    if (ctx['hasPath']) {
-      b3 = block3();
-    }
-    let b2 = block2([], [b3]);
-    return block1([], [b2]);
-  }
-}"
-`;
-
-exports[`properly support svg svg creates new block if it is within html 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
-  let block2 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><polygon fill=\\"#000000\\" points=\\"0 0 4 4 8 0\\" transform=\\"translate(5 7)\\"/></svg>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2 = block2();
-    return block1([], [b2]);
-  }
-}"
-`;
-
-exports[`properly support svg svg namespace added to sub templates if root tag is path 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { getTemplate } = helpers;
-  const callTemplate_1 = getTemplate(\`path\`);
-  
-  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 templates if root tag is path 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<path block-ns=\\"http://www.w3.org/2000/svg\\"/>\`);
-  
-  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_debug_log.test.ts.snap

@@ -3,7 +3,8 @@
 exports[`debugging t-debug 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<span>hey</span>\`);
@@ -23,7 +24,8 @@ exports[`debugging t-debug 1`] = `
 exports[`debugging t-debug on sub template 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<p>coucou</p>\`);
   
@@ -37,14 +39,14 @@ exports[`debugging t-debug on sub template 1`] = `
 exports[`debugging t-debug on sub template 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
+  const callTemplate_2 = getTemplate(\`sub\`);
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -53,8 +55,8 @@ exports[`debugging t-debug on sub template 2`] = `
 exports[`debugging t-log 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div/>\`);
   

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

@@ -3,17 +3,18 @@
 exports[`t-esc div with falsy values 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><p><block-text-0/></p><p><block-text-1/></p><p><block-text-2/></p><p><block-text-3/></p><p><block-text-4/></p></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['v1'];
+    let d1 = ctx['v1'];
-    let txt2 = ctx['v2'];
+    let d2 = ctx['v2'];
-    let txt3 = ctx['v3'];
+    let d3 = ctx['v3'];
-    let txt4 = ctx['v4'];
+    let d4 = ctx['v4'];
-    let txt5 = ctx['v5'];
+    let d5 = ctx['v5'];
-    return block1([txt1, txt2, txt3, txt4, txt5]);
+    return block1([d1, d2, d3, d4, d5]);
   }
 }"
 `;
@@ -21,13 +22,14 @@ exports[`t-esc div with falsy values 1`] = `
 exports[`t-esc escaping 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['var'];
+    let d1 = ctx['var'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -35,13 +37,14 @@ exports[`t-esc escaping 1`] = `
 exports[`t-esc escaping on a node 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = 'ok';
+    let d1 = 'ok';
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -49,14 +52,14 @@ exports[`t-esc escaping on a node 1`] = `
 exports[`t-esc escaping on a node with a body 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { withDefault } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = withDefault('ok', \`nope\`);
+    let d1 = withDefault('ok', \`nope\`);
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -64,14 +67,14 @@ exports[`t-esc escaping on a node with a body 1`] = `
 exports[`t-esc escaping on a node with a body, as a default 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { withDefault } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = withDefault(ctx['var'], \`nope\`);
+    let d1 = withDefault(ctx['var'], \`nope\`);
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -79,7 +82,8 @@ exports[`t-esc escaping on a node with a body, as a default 1`] = `
 exports[`t-esc falsy values in text nodes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2 = text(ctx['v1']);
@@ -99,13 +103,14 @@ exports[`t-esc falsy values in text nodes 1`] = `
 exports[`t-esc literal 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = 'ok';
+    let d1 = 'ok';
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -113,22 +118,19 @@ exports[`t-esc literal 1`] = `
 exports[`t-esc t-esc is escaped 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, LazyValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   let block2 = createBlock(\`<p>escaped</p>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    return block2();
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
-    ctx[\`var\`] = new LazyValue(value1, ctx, node);
+    let b2 = block2();
-    let txt1 = ctx['var'];
+    ctx[\`var\`] = b2;
-    return block1([txt1]);
+    let d1 = ctx['var'];
+    return block1([d1]);
   }
 }"
 `;
@@ -136,13 +138,14 @@ exports[`t-esc t-esc is escaped 1`] = `
 exports[`t-esc t-esc work with spread operator 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = [...ctx['state'].list];
+    let d1 = [...ctx['state'].list];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -150,9 +153,24 @@ exports[`t-esc t-esc work with spread operator 1`] = `
 exports[`t-esc t-esc=0 is escaped 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, zero, getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let d1 = ctx[zero];
+    return block1([d1]);
+  }
+}"
+`;
+
+exports[`t-esc t-esc=0 is escaped 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  const callTemplate_2 = getTemplate(\`sub\`);
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<p>escaped</p>\`);
@@ -162,37 +180,23 @@ exports[`t-esc t-esc=0 is escaped 1`] = `
     ctx[isBoundary] = 1;
     let b2 = block2();
     ctx[zero] = b2;
-    let b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b3 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
     return block1([], [b3]);
   }
 }"
 `;
 
-exports[`t-esc t-esc=0 is escaped 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { zero } = helpers;
-  
-  let block1 = createBlock(\`<span><block-text-0/></span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx[zero];
-    return block1([txt1]);
-  }
-}"
-`;
-
 exports[`t-esc variable 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['var'];
+    let d1 = ctx['var'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;

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

@@ -3,8 +3,8 @@
 exports[`t-foreach does not pollute the rendering context 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -25,8 +25,8 @@ exports[`t-foreach does not pollute the rendering context 1`] = `
 exports[`t-foreach iterate on items (on a element node) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<span><block-text-0/></span>\`);
@@ -37,8 +37,8 @@ exports[`t-foreach iterate on items (on a element node) 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
       let key1 = ctx['item'];
-      let txt1 = ctx['item'];
+      let d1 = ctx['item'];
-      c_block2[i1] = withKey(block3([txt1]), key1);
+      c_block2[i1] = withKey(block3([d1]), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -49,8 +49,8 @@ exports[`t-foreach iterate on items (on a element node) 1`] = `
 exports[`t-foreach iterate on items 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -80,8 +80,8 @@ exports[`t-foreach iterate on items 1`] = `
 exports[`t-foreach iterate, dict param 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -111,8 +111,8 @@ exports[`t-foreach iterate, dict param 1`] = `
 exports[`t-foreach iterate, position 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -147,8 +147,8 @@ exports[`t-foreach iterate, position 1`] = `
 exports[`t-foreach simple iteration (in a node) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -169,8 +169,8 @@ exports[`t-foreach simple iteration (in a node) 1`] = `
 exports[`t-foreach simple iteration 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -188,8 +188,8 @@ exports[`t-foreach simple iteration 1`] = `
 exports[`t-foreach simple iteration with two nodes inside 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block3 = createBlock(\`<span>a<block-text-0/></span>\`);
   let block4 = createBlock(\`<span>b<block-text-0/></span>\`);
@@ -200,10 +200,10 @@ exports[`t-foreach simple iteration with two nodes inside 1`] = `
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`item\`] = v_block1[i1];
       let key1 = ctx['item'];
-      let txt1 = ctx['item'];
+      let d1 = ctx['item'];
-      let b3 = block3([txt1]);
+      let b3 = block3([d1]);
-      let txt2 = ctx['item'];
+      let d2 = ctx['item'];
-      let b4 = block4([txt2]);
+      let b4 = block4([d2]);
       c_block1[i1] = withKey(multi([b3, b4]), key1);
     }
     return list(c_block1);
@@ -214,9 +214,28 @@ exports[`t-foreach simple iteration with two nodes inside 1`] = `
 exports[`t-foreach t-call with body in t-foreach in t-foreach 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, isBoundary, withDefault, setContextValue, getTemplate, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = text(\` [\`);
+    let b3 = text(ctx['a']);
+    let b4 = text(\`] [\`);
+    let b5 = text(ctx['b']);
+    let b6 = text(\`] [\`);
+    let b7 = text(ctx['c']);
+    let b8 = text(\`] \`);
+    return multi([b2, b3, b4, b5, b6, b7, b8]);
+  }
+}"
+`;
+
+exports[`t-foreach t-call with body in t-foreach in t-foreach 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  const callTemplate_2 = getTemplate(\`sub\`);
   
   let block1 = createBlock(\`<div><block-child-0/><span>[<block-text-0/>][<block-text-1/>][<block-text-2/>]</span></div>\`);
   let block6 = createBlock(\`<span><block-text-0/></span>\`);
@@ -245,31 +264,35 @@ exports[`t-foreach t-call with body in t-foreach in t-foreach 1`] = `
         ctx = Object.create(ctx);
         ctx[isBoundary] = 1;
         setContextValue(ctx, \\"c\\", 'x'+'_'+ctx['a']+'_'+ctx['b']);
-        c_block4[i2] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}__\${key2}\`), key2);
+        c_block4[i2] = withKey(callTemplate_2.call(this, ctx, node, key + \`__1__\${key1}__\${key2}\`), key2);
         ctx = ctx.__proto__;
       }
       ctx = ctx.__proto__;
       let b4 = list(c_block4);
-      let txt1 = ctx['c'];
+      let d1 = ctx['c'];
-      let b6 = block6([txt1]);
+      let b6 = block6([d1]);
       c_block2[i1] = withKey(multi([b4, b6]), key1);
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);
-    let txt2 = ctx['a'];
+    let d2 = ctx['a'];
-    let txt3 = ctx['b'];
+    let d3 = ctx['b'];
-    let txt4 = ctx['c'];
+    let d4 = ctx['c'];
-    return block1([txt2, txt3, txt4], [b2]);
+    return block1([d2, d3, d4], [b2]);
   }
 }"
 `;
 
-exports[`t-foreach t-call with body in t-foreach in t-foreach 2`] = `
+exports[`t-foreach t-call without body in t-foreach in t-foreach 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"c\\", 'x'+'_'+ctx['a']+'_'+ctx['b']);
     let b2 = text(\` [\`);
     let b3 = text(ctx['a']);
     let b4 = text(\`] [\`);
@@ -282,12 +305,12 @@ exports[`t-foreach t-call with body in t-foreach in t-foreach 2`] = `
 }"
 `;
 
-exports[`t-foreach t-call without body in t-foreach in t-foreach 1`] = `
+exports[`t-foreach t-call without body in t-foreach in t-foreach 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, getTemplate, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
+  const callTemplate_2 = getTemplate(\`sub\`);
   
   let block1 = createBlock(\`<div><block-child-0/><span>[<block-text-0/>][<block-text-1/>][<block-text-2/>]</span></div>\`);
   let block6 = createBlock(\`<span><block-text-0/></span>\`);
@@ -311,42 +334,20 @@ exports[`t-foreach t-call without body in t-foreach in t-foreach 1`] = `
         ctx[\`b_index\`] = i2;
         ctx[\`b_value\`] = k_block4[i2];
         let key2 = ctx['b'];
-        c_block4[i2] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}__\${key2}\`), key2);
+        c_block4[i2] = withKey(callTemplate_2.call(this, ctx, node, key + \`__1__\${key1}__\${key2}\`), key2);
       }
       ctx = ctx.__proto__;
       let b4 = list(c_block4);
-      let txt1 = ctx['c'];
+      let d1 = ctx['c'];
-      let b6 = block6([txt1]);
+      let b6 = block6([d1]);
       c_block2[i1] = withKey(multi([b4, b6]), key1);
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);
-    let txt2 = ctx['a'];
+    let d2 = ctx['a'];
-    let txt3 = ctx['b'];
+    let d3 = ctx['b'];
-    let txt4 = ctx['c'];
+    let d4 = ctx['c'];
-    return block1([txt2, txt3, txt4], [b2]);
+    return block1([d2, d3, d4], [b2]);
-  }
-}"
-`;
-
-exports[`t-foreach t-call without body in t-foreach in t-foreach 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    ctx = Object.create(ctx);
-    ctx[isBoundary] = 1
-    setContextValue(ctx, \\"c\\", 'x'+'_'+ctx['a']+'_'+ctx['b']);
-    let b2 = text(\` [\`);
-    let b3 = text(ctx['a']);
-    let b4 = text(\`] [\`);
-    let b5 = text(ctx['b']);
-    let b6 = text(\`] [\`);
-    let b7 = text(ctx['c']);
-    let b8 = text(\`] \`);
-    return multi([b2, b3, b4, b5, b6, b7, b8]);
   }
 }"
 `;
@@ -354,8 +355,8 @@ exports[`t-foreach t-call without body in t-foreach in t-foreach 2`] = `
 exports[`t-foreach t-foreach in t-foreach 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -388,8 +389,8 @@ exports[`t-foreach t-foreach in t-foreach 1`] = `
 exports[`t-foreach t-foreach with t-if inside (no external node) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block3 = createBlock(\`<span><block-text-0/></span>\`);
   
@@ -401,8 +402,8 @@ exports[`t-foreach t-foreach with t-if inside (no external node) 1`] = `
       let key1 = ctx['elem'].id;
       let b3;
       if (ctx['elem'].id<3) {
-        let txt1 = ctx['elem'].text;
+        let d1 = ctx['elem'].text;
-        b3 = block3([txt1]);
+        b3 = block3([d1]);
       }
       c_block1[i1] = withKey(multi([b3]), key1);
     }
@@ -414,8 +415,8 @@ exports[`t-foreach t-foreach with t-if inside (no external node) 1`] = `
 exports[`t-foreach t-foreach with t-if inside 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block4 = createBlock(\`<span><block-text-0/></span>\`);
@@ -428,8 +429,8 @@ exports[`t-foreach t-foreach with t-if inside 1`] = `
       let key1 = ctx['elem'].id;
       let b4;
       if (ctx['elem'].id<3) {
-        let txt1 = ctx['elem'].text;
+        let d1 = ctx['elem'].text;
-        b4 = block4([txt1]);
+        b4 = block4([d1]);
       }
       c_block2[i1] = withKey(multi([b4]), key1);
     }
@@ -442,8 +443,8 @@ exports[`t-foreach t-foreach with t-if inside 1`] = `
 exports[`t-foreach t-key on t-foreach 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<span/>\`);
@@ -465,8 +466,8 @@ exports[`t-foreach t-key on t-foreach 1`] = `
 exports[`t-foreach throws error if invalid loop expression 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<span/>\`);
@@ -490,8 +491,9 @@ exports[`t-foreach throws error if invalid loop expression 1`] = `
 exports[`t-foreach with t-memo 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  let assign = Object.assign;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<p><block-text-0/><block-text-1/></p>\`);
@@ -513,10 +515,10 @@ exports[`t-foreach with t-memo 1`] = `
           continue;
         }
       }
-      let txt1 = ctx['item'].x;
+      let d1 = ctx['item'].x;
-      let txt2 = ctx['item'].y;
+      let d2 = ctx['item'].y;
-      c_block2[i1] = withKey(block3([txt1, txt2]), key1);
+      c_block2[i1] = withKey(block3([d1, d2]), key1);
-      nextCache[key1] = Object.assign(c_block2[i1], {memo: memo1});
+      nextCache[key1] = assign(c_block2[i1], {memo: memo1});
     }
     let b2 = list(c_block2);
     return block1([], [b2]);

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

@@ -3,7 +3,8 @@
 exports[`t-if a t-if next to a div 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block2 = createBlock(\`<div>foo</div>\`);
   
@@ -21,7 +22,8 @@ exports[`t-if a t-if next to a div 1`] = `
 exports[`t-if a t-if with two inner nodes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block3 = createBlock(\`<span>yip</span>\`);
   let block4 = createBlock(\`<div>yip</div>\`);
@@ -41,7 +43,8 @@ exports[`t-if a t-if with two inner nodes 1`] = `
 exports[`t-if boolean value condition elif (no outside node) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3,b4,b5;
@@ -62,7 +65,8 @@ exports[`t-if boolean value condition elif (no outside node) 1`] = `
 exports[`t-if boolean value condition elif 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/><block-child-2/><block-child-3/></div>\`);
   
@@ -85,7 +89,8 @@ exports[`t-if boolean value condition elif 1`] = `
 exports[`t-if boolean value condition else 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><span>begin</span><block-child-0/><block-child-1/><span>end</span></div>\`);
   
@@ -104,7 +109,8 @@ exports[`t-if boolean value condition else 1`] = `
 exports[`t-if boolean value condition false else 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><span>begin</span><block-child-0/><block-child-1/><span>end</span></div>\`);
   
@@ -123,7 +129,8 @@ exports[`t-if boolean value condition false else 1`] = `
 exports[`t-if boolean value condition missing 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -140,7 +147,8 @@ exports[`t-if boolean value condition missing 1`] = `
 exports[`t-if can use some boolean operators in expressions 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/><block-child-2/><block-child-3/><block-child-4/><block-child-5/><block-child-6/><block-child-7/></div>\`);
   
@@ -178,7 +186,8 @@ exports[`t-if can use some boolean operators in expressions 1`] = `
 exports[`t-if div containing a t-if with two inner nodes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<span>yip</span>\`);
@@ -199,7 +208,8 @@ exports[`t-if div containing a t-if with two inner nodes 1`] = `
 exports[`t-if dynamic content after t-if with two children nodes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
   let block3 = createBlock(\`<p>1</p>\`);
@@ -212,8 +222,8 @@ exports[`t-if dynamic content after t-if with two children nodes 1`] = `
       let b4 = block4();
       b2 = multi([b3, b4]);
     }
-    let txt1 = ctx['text'];
+    let d1 = ctx['text'];
-    return block1([txt1], [b2]);
+    return block1([d1], [b2]);
   }
 }"
 `;
@@ -221,7 +231,8 @@ exports[`t-if dynamic content after t-if with two children nodes 1`] = `
 exports[`t-if just a t-if 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2;
@@ -236,7 +247,8 @@ exports[`t-if just a t-if 1`] = `
 exports[`t-if simple t-if/t-else 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
@@ -253,7 +265,8 @@ exports[`t-if simple t-if/t-else 1`] = `
 exports[`t-if simple t-if/t-else in a div 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
@@ -272,7 +285,8 @@ exports[`t-if simple t-if/t-else in a div 1`] = `
 exports[`t-if t-esc with t-elif 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
@@ -291,7 +305,8 @@ exports[`t-if t-esc with t-elif 1`] = `
 exports[`t-if t-esc with t-if 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -308,7 +323,8 @@ exports[`t-if t-esc with t-if 1`] = `
 exports[`t-if t-if and t-else with two nodes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block4 = createBlock(\`<span>a</span>\`);
   let block5 = createBlock(\`<span>b</span>\`);
@@ -330,7 +346,8 @@ exports[`t-if t-if and t-else with two nodes 1`] = `
 exports[`t-if t-if in a div 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -347,7 +364,8 @@ exports[`t-if t-if in a div 1`] = `
 exports[`t-if t-if in a t-if 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<span>1<block-child-0/></span>\`);
@@ -366,26 +384,11 @@ exports[`t-if t-if in a t-if 1`] = `
 }"
 `;
 
-exports[`t-if t-if with empty content 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2,b3;
-    b2 = text(\`hello\`);
-    if (ctx['condition']) {
-      b3 = text(\`\`);
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
 exports[`t-if t-if/t-else with more content 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
@@ -404,8 +407,8 @@ exports[`t-if t-if/t-else with more content 1`] = `
 exports[`t-if t-set, then t-if 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -425,8 +428,8 @@ exports[`t-if t-set, then t-if 1`] = `
 exports[`t-if t-set, then t-if, part 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<span>COUCOU</span>\`);
@@ -448,8 +451,8 @@ exports[`t-if t-set, then t-if, part 2 1`] = `
 exports[`t-if t-set, then t-if, part 3 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   let block2 = createBlock(\`<span>AAA</span>\`);
@@ -474,7 +477,8 @@ exports[`t-if t-set, then t-if, part 3 1`] = `
 exports[`t-if two consecutive t-if 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
@@ -492,7 +496,8 @@ exports[`t-if two consecutive t-if 1`] = `
 exports[`t-if two consecutive t-if in a div 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
@@ -512,7 +517,8 @@ exports[`t-if two consecutive t-if in a div 1`] = `
 exports[`t-if two t-ifs next to each other 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   let block2 = createBlock(\`<span><block-text-0/></span>\`);
@@ -522,8 +528,8 @@ exports[`t-if two t-ifs next to each other 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2,b3;
     if (ctx['condition']) {
-      let txt1 = ctx['text'];
+      let d1 = ctx['text'];
-      b2 = block2([txt1]);
+      b2 = block2([d1]);
     }
     if (ctx['condition']) {
       let b4 = block4();

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

@@ -3,14 +3,15 @@
 exports[`t-key can use t-key directive on a node 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['beer'].id;
-    let txt1 = ctx['beer'].name;
+    let d1 = ctx['beer'].name;
-    return toggler(tKey_1, block1([txt1]));
+    return toggler(tKey_1, block1([d1]));
   }
 }"
 `;
@@ -18,14 +19,15 @@ exports[`t-key can use t-key directive on a node 1`] = `
 exports[`t-key can use t-key directive on a node 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['beer'].id;
-    let txt1 = ctx['beer'].name;
+    let d1 = ctx['beer'].name;
-    return toggler(tKey_1, block1([txt1]));
+    return toggler(tKey_1, block1([d1]));
   }
 }"
 `;
@@ -33,14 +35,15 @@ exports[`t-key can use t-key directive on a node 2 1`] = `
 exports[`t-key can use t-key directive on a node as a function 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['getKey'](ctx['beer']);
-    let txt1 = ctx['beer'].name;
+    let d1 = ctx['beer'].name;
-    return toggler(tKey_1, block1([txt1]));
+    return toggler(tKey_1, block1([d1]));
   }
 }"
 `;
@@ -48,8 +51,8 @@ exports[`t-key can use t-key directive on a node as a function 1`] = `
 exports[`t-key t-key directive in a list 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<ul><block-child-0/></ul>\`);
   let block3 = createBlock(\`<li><block-text-0/></li>\`);
@@ -60,46 +63,11 @@ exports[`t-key t-key directive in a list 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`beer\`] = v_block2[i1];
       let key1 = ctx['beer'].id;
-      let txt1 = ctx['beer'].name;
+      let d1 = ctx['beer'].name;
-      c_block2[i1] = withKey(block3([txt1]), key1);
+      c_block2[i1] = withKey(block3([d1]), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
 `;
-
-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_out.test.ts.snap

@@ -3,8 +3,8 @@
 exports[`t-out literal 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -18,8 +18,8 @@ exports[`t-out literal 1`] = `
 exports[`t-out literal, no outside html element 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return safeOutput('ok');
@@ -30,29 +30,8 @@ exports[`t-out literal, no outside html element 1`] = `
 exports[`t-out multiple calls to t-out 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, zero, getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
-  
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
-  let block2 = createBlock(\`<span>coucou</span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    ctx = Object.create(ctx);
-    ctx[isBoundary] = 1;
-    let b2 = block2();
-    ctx[zero] = b2;
-    let b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
-    return block1([], [b3]);
-  }
-}"
-`;
-
-exports[`t-out multiple calls to t-out 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { zero } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><div>Greeter</div><block-child-1/></div>\`);
   
@@ -64,11 +43,32 @@ exports[`t-out multiple calls to t-out 2`] = `
 }"
 `;
 
+exports[`t-out multiple calls to t-out 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  const callTemplate_2 = getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block2 = createBlock(\`<span>coucou</span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1;
+    let b2 = block2();
+    ctx[zero] = b2;
+    let b3 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
+    return block1([], [b3]);
+  }
+}"
+`;
+
 exports[`t-out not escaping 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -82,29 +82,8 @@ exports[`t-out not escaping 1`] = `
 exports[`t-out t-out 0 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, zero, getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`_basic-callee\`);
-  
-  let block1 = createBlock(\`<div><block-child-0/></div>\`);
-  let block2 = createBlock(\`<div>zero</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    ctx = Object.create(ctx);
-    ctx[isBoundary] = 1;
-    let b2 = block2();
-    ctx[zero] = b2;
-    let b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
-    return block1([], [b3]);
-  }
-}"
-`;
-
-exports[`t-out t-out 0 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { zero } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -115,11 +94,32 @@ exports[`t-out t-out 0 2`] = `
 }"
 `;
 
+exports[`t-out t-out 0 2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  const callTemplate_2 = getTemplate(\`_basic-callee\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block2 = createBlock(\`<div>zero</div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1;
+    let b2 = block2();
+    ctx[zero] = b2;
+    let b3 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
+    return block1([], [b3]);
+  }
+}"
+`;
+
 exports[`t-out t-out and another sibling node 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><span>hello</span><block-child-0/></span>\`);
   
@@ -133,20 +133,17 @@ exports[`t-out t-out and another sibling node 1`] = `
 exports[`t-out t-out bdom 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, LazyValue, safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><span><block-child-0/></span></div>\`);
   let block2 = createBlock(\`<ol>set</ol>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    return block2();
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
-    ctx[\`var\`] = new LazyValue(value1, ctx, node);
+    let b2 = block2();
+    ctx[\`var\`] = b2;
     let b3 = safeOutput(ctx['var']);
     return block1([], [b3]);
   }
@@ -156,8 +153,8 @@ exports[`t-out t-out bdom 1`] = `
 exports[`t-out t-out block 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -171,8 +168,8 @@ exports[`t-out t-out block 1`] = `
 exports[`t-out t-out escaped 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -186,8 +183,8 @@ exports[`t-out t-out escaped 1`] = `
 exports[`t-out t-out markedup 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -201,8 +198,8 @@ exports[`t-out t-out markedup 1`] = `
 exports[`t-out t-out on a node with a body, as a default 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput, withDefault } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -217,8 +214,8 @@ exports[`t-out t-out on a node with a body, as a default 1`] = `
 exports[`t-out t-out on a node with a dom node in body, as a default 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput, withDefault } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   let block3 = createBlock(\`<div>nope</div>\`);
@@ -234,8 +231,8 @@ exports[`t-out t-out on a node with a dom node in body, as a default 1`] = `
 exports[`t-out t-out switch escaped 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -249,8 +246,8 @@ exports[`t-out t-out switch escaped 1`] = `
 exports[`t-out t-out switch escaped on markup 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -264,8 +261,8 @@ exports[`t-out t-out switch escaped on markup 1`] = `
 exports[`t-out t-out switch markup 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -279,23 +276,20 @@ exports[`t-out t-out switch markup 1`] = `
 exports[`t-out t-out switch markup on bdom 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, LazyValue, safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   let block2 = createBlock(\`<ol>set</ol>\`);
   let block3 = createBlock(\`<span><block-child-0/></span>\`);
   let block5 = createBlock(\`<span><block-child-0/></span>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    return block2();
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     let b3,b5;
-    ctx[\`bdom\`] = new LazyValue(value1, ctx, node);
+    let b2 = block2();
+    ctx[\`bdom\`] = b2;
     if (ctx['hasBdom']) {
       let b4 = safeOutput(ctx['bdom']);
       b3 = block3([], [b4]);
@@ -311,8 +305,8 @@ exports[`t-out t-out switch markup on bdom 1`] = `
 exports[`t-out t-out switch markup on escaped 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -326,8 +320,8 @@ exports[`t-out t-out switch markup on escaped 1`] = `
 exports[`t-out t-out with a <t/> in body 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return safeOutput(ctx['var']);
@@ -338,8 +332,8 @@ exports[`t-out t-out with a <t/> in body 1`] = `
 exports[`t-out t-out with arbitrary object 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -353,8 +347,8 @@ exports[`t-out t-out with arbitrary object 1`] = `
 exports[`t-out t-out with arbitrary object 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -368,8 +362,8 @@ exports[`t-out t-out with arbitrary object 2 1`] = `
 exports[`t-out t-out with comment 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -383,8 +377,8 @@ exports[`t-out t-out with comment 1`] = `
 exports[`t-out t-out with just a t-set t-value in body 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     return safeOutput(ctx['var']);
@@ -395,38 +389,8 @@ exports[`t-out t-out with just a t-set t-value in body 1`] = `
 exports[`t-out variable 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  
-  let block1 = createBlock(\`<span><block-child-0/></span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2 = safeOutput(ctx['var']);
-    return block1([], [b2]);
-  }
-}"
-`;
-
-exports[`t-out with a String class 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { safeOutput } = helpers;
-  
-  let block1 = createBlock(\`<span><block-child-0/></span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2 = safeOutput(ctx['var']);
-    return block1([], [b2]);
-  }
-}"
-`;
-
-exports[`t-out with an extended String class 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { safeOutput } = helpers;
   
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
@@ -440,8 +404,8 @@ exports[`t-out with an extended String class 1`] = `
 exports[`t-raw is deprecated should warn 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -455,8 +419,8 @@ exports[`t-raw is deprecated should warn 1`] = `
 exports[`t-raw is deprecated t-out is actually called in t-raw's place 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   

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

@@ -3,15 +3,16 @@
 exports[`t-ref can get a dynamic ref on a node 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><span block-ref=\\"0\\"/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const refs = ctx.__owl__.refs;
     const v1 = ctx['id'];
-    let ref1 = (el) => refs[\`myspan\${v1}\`] = el;
+    let d1 = (el) => refs[\`myspan\${v1}\`] = el;
-    return block1([ref1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -19,14 +20,15 @@ exports[`t-ref can get a dynamic ref on a node 1`] = `
 exports[`t-ref can get a ref on a node 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><span block-ref=\\"0\\"/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const refs = ctx.__owl__.refs;
-    const ref1 = (el) => refs[\`myspan\`] = el;
+    let d1 = (el) => refs[\`myspan\`] = el;
-    return block1([ref1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -34,14 +36,14 @@ exports[`t-ref can get a ref on a node 1`] = `
 exports[`t-ref ref in a t-call 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
+  const callTemplate_2 = getTemplate(\`sub\`);
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -50,14 +52,15 @@ exports[`t-ref ref in a t-call 1`] = `
 exports[`t-ref ref in a t-call 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div>1<span block-ref=\\"0\\"/>2</div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const refs = ctx.__owl__.refs;
-    const ref1 = (el) => refs[\`name\`] = el;
+    let d1 = (el) => refs[\`name\`] = el;
-    return block1([ref1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -65,17 +68,18 @@ exports[`t-ref ref in a t-call 2`] = `
 exports[`t-ref ref in a t-if 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<span block-ref=\\"0\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const refs = ctx.__owl__.refs;
-    const ref1 = (el) => refs[\`name\`] = el;
     let b2;
     if (ctx['condition']) {
-      b2 = block2([ref1]);
+      let d1 = (el) => refs[\`name\`] = el;
+      b2 = block2([d1]);
     }
     return block1([], [b2]);
   }
@@ -85,8 +89,8 @@ exports[`t-ref ref in a t-if 1`] = `
 exports[`t-ref refs in a loop 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<div block-ref=\\"0\\"><block-text-1/></div>\`);
@@ -99,10 +103,10 @@ exports[`t-ref refs in a loop 1`] = `
       ctx[\`item\`] = v_block2[i1];
       let key1 = ctx['item'];
       const tKey_1 = ctx['item'];
-      const v1 = ctx['item'];
+      const v2 = ctx['item'];
-      let ref1 = (el) => refs[\`\${v1}\`] = el;
+      let d1 = (el) => refs[\`\${v2}\`] = el;
-      let txt1 = ctx['item'];
+      let d2 = ctx['item'];
-      c_block2[i1] = withKey(block3([ref1, txt1]), tKey_1 + key1);
+      c_block2[i1] = withKey(block3([d1, d2]), tKey_1 + key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -113,20 +117,21 @@ exports[`t-ref refs in a loop 1`] = `
 exports[`t-ref two refs, one in a t-if 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><p block-ref=\\"0\\"/></div>\`);
   let block2 = createBlock(\`<span block-ref=\\"0\\"/>\`);
   
   return function template(ctx, node, key = \\"\\") {
     const refs = ctx.__owl__.refs;
-    const ref1 = (el) => refs[\`name\`] = el;
-    const ref2 = (el) => refs[\`p\`] = el;
     let b2;
     if (ctx['condition']) {
-      b2 = block2([ref1]);
+      let d1 = (el) => refs[\`name\`] = el;
+      b2 = block2([d1]);
     }
-    return block1([ref2], [b2]);
+    let d2 = (el) => refs[\`p\`] = el;
+    return block1([d2], [b2]);
   }
 }"
 `;

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

@@ -3,8 +3,8 @@
 exports[`t-set evaluate value expression 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
@@ -12,8 +12,8 @@ exports[`t-set evaluate value expression 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"value\\", 1+2);
-    let txt1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -21,8 +21,8 @@ exports[`t-set evaluate value expression 1`] = `
 exports[`t-set evaluate value expression, part 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
@@ -30,8 +30,8 @@ exports[`t-set evaluate value expression, part 2 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"value\\", ctx['somevariable']+2);
-    let txt1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -39,8 +39,8 @@ exports[`t-set evaluate value expression, part 2 1`] = `
 exports[`t-set set from attribute literal (no outside div) 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -54,8 +54,8 @@ exports[`t-set set from attribute literal (no outside div) 1`] = `
 exports[`t-set set from attribute literal 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
@@ -63,8 +63,8 @@ exports[`t-set set from attribute literal 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"value\\", 'ok');
-    let txt1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -72,8 +72,8 @@ exports[`t-set set from attribute literal 1`] = `
 exports[`t-set set from attribute lookup 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
@@ -81,33 +81,8 @@ exports[`t-set set from attribute lookup 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"stuff\\", ctx['value']);
-    let txt1 = ctx['stuff'];
+    let d1 = ctx['stuff'];
-    return block1([txt1]);
+    return block1([d1]);
-  }
-}"
-`;
-
-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']);
   }
 }"
 `;
@@ -115,8 +90,8 @@ exports[`t-set set from body literal (with t-if/t-else 1`] = `
 exports[`t-set set from body literal 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -130,21 +105,18 @@ exports[`t-set set from body literal 1`] = `
 exports[`t-set set from body lookup 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, LazyValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    return text(ctx['value']);
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
-    ctx[\`stuff\`] = new LazyValue(value1, ctx, node);
+    let b2 = text(ctx['value']);
-    let txt1 = ctx['stuff'];
+    ctx[\`stuff\`] = b2;
-    return block1([txt1]);
+    let d1 = ctx['stuff'];
+    return block1([d1]);
   }
 }"
 `;
@@ -152,8 +124,8 @@ exports[`t-set set from body lookup 1`] = `
 exports[`t-set set from empty body 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
@@ -161,8 +133,8 @@ exports[`t-set set from empty body 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"stuff\\", null);
-    let txt1 = ctx['stuff'];
+    let d1 = ctx['stuff'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -170,8 +142,8 @@ exports[`t-set set from empty body 1`] = `
 exports[`t-set t-set and t-if 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -191,22 +163,19 @@ exports[`t-set t-set and t-if 1`] = `
 exports[`t-set t-set body is evaluated immediately 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue, LazyValue, safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<span><block-text-0/></span>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    let txt1 = ctx['v1'];
-    return block2([txt1]);
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"v1\\", 'before');
-    ctx[\`v2\`] = new LazyValue(value1, ctx, node);
+    let d1 = ctx['v1'];
+    let b2 = block2([d1]);
+    ctx[\`v2\`] = b2;
     setContextValue(ctx, \\"v1\\", 'after');
     let b3 = safeOutput(ctx['v2']);
     return block1([], [b3]);
@@ -217,20 +186,18 @@ exports[`t-set t-set body is evaluated immediately 1`] = `
 exports[`t-set t-set can't alter from within callee 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue, getTemplate } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  const callTemplate_1 = getTemplate(\`sub\`);
   
-  let block1 = createBlock(\`<div><p><block-text-0/></p><block-child-0/><p><block-text-1/></p></div>\`);
+  let block1 = createBlock(\`<div><block-text-0/><block-text-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
-    setContextValue(ctx, \\"iter\\", 'source');
+    let d1 = ctx['iter'];
-    let txt1 = ctx['iter'];
+    setContextValue(ctx, \\"iter\\", 'called');
-    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let d2 = ctx['iter'];
-    let txt2 = ctx['iter'];
+    return block1([d1, d2]);
-    return block1([txt1, txt2], [b2]);
   }
 }"
 `;
@@ -238,28 +205,9 @@ exports[`t-set t-set can't alter from within callee 1`] = `
 exports[`t-set t-set can't alter from within callee 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
-  
+  const callTemplate_2 = getTemplate(\`sub\`);
-  let block1 = createBlock(\`<div><block-text-0/><block-text-1/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    ctx = Object.create(ctx);
-    ctx[isBoundary] = 1
-    let txt1 = ctx['iter'];
-    setContextValue(ctx, \\"iter\\", 'called');
-    let txt2 = ctx['iter'];
-    return block1([txt1, txt2]);
-  }
-}"
-`;
-
-exports[`t-set t-set can't alter in t-call body 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(\`sub\`);
   
   let block1 = createBlock(\`<div><p><block-text-0/></p><block-child-0/><p><block-text-1/></p></div>\`);
   
@@ -267,14 +215,29 @@ exports[`t-set t-set can't alter in t-call body 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"iter\\", 'source');
-    let txt1 = ctx['iter'];
+    let d1 = ctx['iter'];
+    let b2 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
+    let d2 = ctx['iter'];
+    return block1([d1, d2], [b2]);
+  }
+}"
+`;
+
+exports[`t-set t-set can't alter in t-call body 1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  
+  let block1 = createBlock(\`<div><block-text-0/><block-text-1/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    ctx[isBoundary] = 1;
+    ctx[isBoundary] = 1
-    setContextValue(ctx, \\"iter\\", 'inCall');
+    let d1 = ctx['iter'];
-    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    setContextValue(ctx, \\"iter\\", 'called');
-    ctx = ctx.__proto__;
+    let d2 = ctx['iter'];
-    let txt2 = ctx['iter'];
+    return block1([d1, d2]);
-    return block1([txt1, txt2], [b2]);
   }
 }"
 `;
@@ -282,18 +245,24 @@ exports[`t-set t-set can't alter in t-call body 1`] = `
 exports[`t-set t-set can't alter in t-call body 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
+  const callTemplate_2 = getTemplate(\`sub\`);
   
-  let block1 = createBlock(\`<div><block-text-0/><block-text-1/></div>\`);
+  let block1 = createBlock(\`<div><p><block-text-0/></p><block-child-0/><p><block-text-1/></p></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
-    let txt1 = ctx['iter'];
+    setContextValue(ctx, \\"iter\\", 'source');
-    setContextValue(ctx, \\"iter\\", 'called');
+    let d1 = ctx['iter'];
-    let txt2 = ctx['iter'];
+    ctx = Object.create(ctx);
-    return block1([txt1, txt2]);
+    ctx[isBoundary] = 1;
+    setContextValue(ctx, \\"iter\\", 'inCall');
+    let b2 = callTemplate_2.call(this, ctx, node, key + \`__1\`);
+    ctx = ctx.__proto__;
+    let d2 = ctx['iter'];
+    return block1([d1, d2], [b2]);
   }
 }"
 `;
@@ -301,8 +270,8 @@ exports[`t-set t-set can't alter in t-call body 2`] = `
 exports[`t-set t-set does not modify render context existing key values 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
@@ -310,8 +279,8 @@ exports[`t-set t-set does not modify render context existing key values 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"value\\", 35);
-    let txt1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -319,8 +288,8 @@ exports[`t-set t-set does not modify render context existing key values 1`] = `
 exports[`t-set t-set evaluates an expression only once 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/><block-text-1/></div>\`);
   
@@ -328,9 +297,9 @@ exports[`t-set t-set evaluates an expression only once 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"v\\", ctx['value']+' artois');
-    let txt1 = ctx['v'];
+    let d1 = ctx['v'];
-    let txt2 = ctx['v'];
+    let d2 = ctx['v'];
-    return block1([txt1, txt2]);
+    return block1([d1, d2]);
   }
 }"
 `;
@@ -338,8 +307,8 @@ exports[`t-set t-set evaluates an expression only once 1`] = `
 exports[`t-set t-set outside modified in t-foreach 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue, prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><p>EndLoop: <block-text-0/></p></div>\`);
   let block3 = createBlock(\`<p>InLoop: <block-text-0/></p>\`);
@@ -353,14 +322,14 @@ exports[`t-set t-set outside modified in t-foreach 1`] = `
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
       let key1 = ctx['val'];
-      let txt1 = ctx['iter'];
+      let d1 = ctx['iter'];
-      c_block2[i1] = withKey(block3([txt1]), key1);
+      c_block2[i1] = withKey(block3([d1]), key1);
       setContextValue(ctx, \\"iter\\", ctx['iter']+1);
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);
-    let txt2 = ctx['iter'];
+    let d2 = ctx['iter'];
-    return block1([txt2], [b2]);
+    return block1([d2], [b2]);
   }
 }"
 `;
@@ -368,8 +337,8 @@ exports[`t-set t-set outside modified in t-foreach 1`] = `
 exports[`t-set t-set outside modified in t-foreach increment-after operator 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue, prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><p>EndLoop: <block-text-0/></p></div>\`);
   let block3 = createBlock(\`<p>InLoop: <block-text-0/></p>\`);
@@ -383,14 +352,14 @@ exports[`t-set t-set outside modified in t-foreach increment-after operator 1`]
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
       let key1 = ctx['val'];
-      let txt1 = ctx['iter'];
+      let d1 = ctx['iter'];
-      c_block2[i1] = withKey(block3([txt1]), key1);
+      c_block2[i1] = withKey(block3([d1]), key1);
       setContextValue(ctx, \\"iter\\", ctx['iter']++);
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);
-    let txt2 = ctx['iter'];
+    let d2 = ctx['iter'];
-    return block1([txt2], [b2]);
+    return block1([d2], [b2]);
   }
 }"
 `;
@@ -398,8 +367,8 @@ exports[`t-set t-set outside modified in t-foreach increment-after operator 1`]
 exports[`t-set t-set outside modified in t-foreach increment-before operator 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue, prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><p>EndLoop: <block-text-0/></p></div>\`);
   let block3 = createBlock(\`<p>InLoop: <block-text-0/></p>\`);
@@ -413,14 +382,14 @@ exports[`t-set t-set outside modified in t-foreach increment-before operator 1`]
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
       let key1 = ctx['val'];
-      let txt1 = ctx['iter'];
+      let d1 = ctx['iter'];
-      c_block2[i1] = withKey(block3([txt1]), key1);
+      c_block2[i1] = withKey(block3([d1]), key1);
       setContextValue(ctx, \\"iter\\", ++ctx['iter']);
     }
     ctx = ctx.__proto__;
     let b2 = list(c_block2);
-    let txt2 = ctx['iter'];
+    let d2 = ctx['iter'];
-    return block1([txt2], [b2]);
+    return block1([d2], [b2]);
   }
 }"
 `;
@@ -428,8 +397,8 @@ exports[`t-set t-set outside modified in t-foreach increment-before operator 1`]
 exports[`t-set t-set should reuse variable if possible 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue, prepareList, withKey } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block3 = createBlock(\`<div><span>v<block-text-0/></span></div>\`);
@@ -444,9 +413,9 @@ exports[`t-set t-set should reuse variable if possible 1`] = `
       ctx[\`elem\`] = v_block2[i1];
       ctx[\`elem_index\`] = i1;
       let key1 = ctx['elem_index'];
-      let txt1 = ctx['v'];
+      let d1 = ctx['v'];
       setContextValue(ctx, \\"v\\", ctx['elem']);
-      c_block2[i1] = withKey(block3([txt1]), key1);
+      c_block2[i1] = withKey(block3([d1]), key1);
     }
     let b2 = list(c_block2);
     return block1([], [b2]);
@@ -457,23 +426,20 @@ exports[`t-set t-set should reuse variable if possible 1`] = `
 exports[`t-set t-set with content and sub t-esc 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, LazyValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    let b3 = text(ctx['beep']);
-    let b4 = text(\` boop\`);
-    return multi([b3, b4]);
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
-    ctx[\`setvar\`] = new LazyValue(value1, ctx, node);
+    let b3 = text(ctx['beep']);
-    let txt1 = ctx['setvar'];
+    let b4 = text(\` boop\`);
-    return block1([txt1]);
+    let b2 = multi([b3, b4]);
+    ctx[\`setvar\`] = b2;
+    let d1 = ctx['setvar'];
+    return block1([d1]);
   }
 }"
 `;
@@ -481,23 +447,20 @@ exports[`t-set t-set with content and sub t-esc 1`] = `
 exports[`t-set t-set with t-value (falsy) and body 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue, LazyValue, safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<span><block-text-0/></span>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    let txt1 = ctx['v1'];
-    return block2([txt1]);
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"v3\\", false);
     setContextValue(ctx, \\"v1\\", 'before');
-    ctx[\`v2\`] = withDefault(ctx['v3'], new LazyValue(value1, ctx, node));
+    let d1 = ctx['v1'];
+    let b2 = block2([d1]);
+    ctx[\`v2\`] = withDefault(ctx['v3'], b2);
     setContextValue(ctx, \\"v1\\", 'after');
     setContextValue(ctx, \\"v3\\", true);
     let b3 = safeOutput(ctx['v2']);
@@ -509,23 +472,20 @@ exports[`t-set t-set with t-value (falsy) and body 1`] = `
 exports[`t-set t-set with t-value (truthy) and body 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue, LazyValue, safeOutput } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   let block2 = createBlock(\`<span><block-text-0/></span>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    let txt1 = ctx['v1'];
-    return block2([txt1]);
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"v3\\", 'Truthy');
     setContextValue(ctx, \\"v1\\", 'before');
-    ctx[\`v2\`] = withDefault(ctx['v3'], new LazyValue(value1, ctx, node));
+    let d1 = ctx['v1'];
+    let b2 = block2([d1]);
+    ctx[\`v2\`] = withDefault(ctx['v3'], b2);
     setContextValue(ctx, \\"v1\\", 'after');
     setContextValue(ctx, \\"v3\\", false);
     let b3 = safeOutput(ctx['v2']);
@@ -537,8 +497,8 @@ exports[`t-set t-set with t-value (truthy) and body 1`] = `
 exports[`t-set t-set, t-if, and mix of expression/body lookup, 1 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-0/><block-text-0/></div>\`);
   
@@ -550,8 +510,8 @@ exports[`t-set t-set, t-if, and mix of expression/body lookup, 1 1`] = `
     } else {
       setContextValue(ctx, \\"ourvar\\", 0);
     }
-    let txt1 = ctx['ourvar'];
+    let d1 = ctx['ourvar'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -559,8 +519,8 @@ exports[`t-set t-set, t-if, and mix of expression/body lookup, 1 1`] = `
 exports[`t-set t-set, t-if, and mix of expression/body lookup, 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-0/><block-text-0/></div>\`);
   
@@ -572,8 +532,8 @@ exports[`t-set t-set, t-if, and mix of expression/body lookup, 2 1`] = `
     } else {
       setContextValue(ctx, \\"ourvar\\", \`0\`);
     }
-    let txt1 = ctx['ourvar'];
+    let d1 = ctx['ourvar'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;
@@ -581,8 +541,8 @@ exports[`t-set t-set, t-if, and mix of expression/body lookup, 2 1`] = `
 exports[`t-set t-set, t-if, and mix of expression/body lookup, 3 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -602,22 +562,19 @@ exports[`t-set t-set, t-if, and mix of expression/body lookup, 3 1`] = `
 exports[`t-set value priority (with non text body 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, LazyValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   let block2 = createBlock(\`<span>2</span>\`);
   
-  function value1(ctx, node, key = \\"\\") {
-    return block2();
-  }
-  
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
-    ctx[\`value\`] = withDefault(1, new LazyValue(value1, ctx, node));
+    let b2 = block2();
-    let txt1 = ctx['value'];
+    ctx[\`value\`] = withDefault(1, b2);
-    return block1([txt1]);
+    let d1 = ctx['value'];
+    return block1([d1]);
   }
 }"
 `;
@@ -625,8 +582,8 @@ exports[`t-set value priority (with non text body 1`] = `
 exports[`t-set value priority 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
-  let { isBoundary, withDefault, setContextValue } = helpers;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
@@ -634,8 +591,8 @@ exports[`t-set value priority 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"value\\", withDefault(1, \`2\`));
-    let txt1 = ctx['value'];
+    let d1 = ctx['value'];
-    return block1([txt1]);
+    return block1([d1]);
   }
 }"
 `;

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

@@ -3,7 +3,8 @@
 exports[`qweb t-tag can fallback if falsy tag 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = tag => createBlock(\`<\${tag || 'fallback'}/>\`);
   
@@ -17,7 +18,8 @@ exports[`qweb t-tag can fallback if falsy tag 1`] = `
 exports[`qweb t-tag can update 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = tag => createBlock(\`<\${tag || 't'}/>\`);
   
@@ -31,7 +33,8 @@ exports[`qweb t-tag can update 1`] = `
 exports[`qweb t-tag simple usecases 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = tag => createBlock(\`<\${tag || 't'}/>\`);
   
@@ -45,7 +48,8 @@ exports[`qweb t-tag simple usecases 1`] = `
 exports[`qweb t-tag simple usecases 2`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = tag => createBlock(\`<\${tag || 't'}>text</\${tag || 't'}>\`);
   
@@ -59,7 +63,8 @@ exports[`qweb t-tag simple usecases 2`] = `
 exports[`qweb t-tag with multiple attributes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = tag => createBlock(\`<\${tag || 't'} class=\\"blueberry\\" taste=\\"raspberry\\">gooseberry</\${tag || 't'}>\`);
   
@@ -73,7 +78,8 @@ exports[`qweb t-tag with multiple attributes 1`] = `
 exports[`qweb t-tag with multiple child nodes 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = tag => createBlock(\`<\${tag || 't'}> pear <span>apple</span> strawberry </\${tag || 't'}>\`);
   
@@ -87,7 +93,8 @@ exports[`qweb t-tag with multiple child nodes 1`] = `
 exports[`qweb t-tag with multiple t-tag in same template 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block1 = tag => createBlock(\`<\${tag || 't'}><block-child-0/></\${tag || 't'}>\`);
   let block2 = tag => createBlock(\`<\${tag || 't'}>baz</\${tag || 't'}>\`);
@@ -104,7 +111,8 @@ exports[`qweb t-tag with multiple t-tag in same template 1`] = `
 exports[`qweb t-tag with multiple t-tag in same template, part 2 1`] = `
 "function anonymous(bdom, helpers
 ) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  let { text, createBlock, list, multi, html, toggler, component } = bdom;
+  let { withDefault, getTemplate, prepareList, withKey, zero, call, callSlot, capture, isBoundary, shallowEqual, setContextValue, toNumber, safeOutput } = helpers;
   
   let block2 = tag => createBlock(\`<\${tag || 't'}>bar</\${tag || 't'}>\`);
   let block3 = tag => createBlock(\`<\${tag || 't'}>baz</\${tag || 't'}>\`);