[REL] v1.0.8

# v1.0.8 - qweb fix: do not override t-att-class with class attribute in some cases - component fix: refuse to mount a destroyed component - hooks type improvement: useRef is now generic, and can capture the type of a component - qweb fix: t-esc inside t-call using outside t-set
[FIX] qweb: t-esc inside t-call using outside t-set
2025-10-06 19:59:41 +07:00 · 2020-05-18 09:07:31 +02:00 · 2020-05-15 13:47:57 +02:00 · 2020-04-30 16:23:36 +02:00 · 2020-04-22 09:29:39 +02:00 · 2020-04-21 16:23:31 +02:00
107 changed files with 15157 additions and 5581 deletions
@@ -15,6 +15,7 @@ yarn-debug.log*
 yarn-error.log*

 package-lock.json
+yarn.lock

 #ide's
 .vscode
@@ -23,4 +24,6 @@ package-lock.json
 node_modules

 # Extras temp file
-/tools/owl.js
+/tools/owl.js
+
+release-notes.md
@@ -1,4 +1,4 @@
-<h1 align="center">🦉 <a href="https://odoo.github.io/owl/">Odoo Web Library</a> 🦉</h1>
+<h1 align="center">🦉 <a href="https://odoo.github.io/owl/">OWL Framework</a> 🦉</h1>

 _Class based components with hooks, reactive state and concurrent mode_

@@ -11,18 +11,31 @@ simple and consistent way. Owl's main features are:

 - a declarative component system,
 - a reactivity system based on hooks,
- a store implementation (for state management),
- a small frontend router
+- concurrent mode by default,
+- a store and a frontend router

-Owl components are defined with ES6 classes, they use QWeb templates, an underlying
-virtual dom, integrates beautifully with hooks, and the rendering is asynchronous.
+Owl components are defined with ES6 classes, they use QWeb templates, an
+underlying virtual DOM, integrates beautifully with hooks, and the rendering is
+asynchronous.

-**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.
+**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.

-Owl is currently mostly stable.  Possible future changes are explained in the
+Owl is currently stable.  Possible future changes are explained in the
 [roadmap](roadmap.md).

+## 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:
@@ -79,10 +92,9 @@ requirements are common and code needs to be maintained by large teams.

 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).
+one way to define components (with classes). There is no black magic. It just
+works.

-If you are interested in a comparison with React or Vue, you will
-find some more information [here](doc/comparison.md).

 ## Documentation

@@ -90,162 +102,27 @@ A complete documentation for Owl can be found here:

 - [Main documentation page](doc/readme.md).

-The most important sections are:
+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)
 - [QWeb templating language](doc/reference/qweb_templating_language.md)
 - [Component](doc/reference/component.md)
 - [Hooks](doc/reference/hooks.md)

-Found an issue in the documentation? A broken link? Some outdated information?
-Submit a PR!

-## Installing/Building
+## Installing Owl
+
+Owl is available on `npm` and can be installed with the following command:
+
+```
+npm install @odoo/owl
+```

 If you want to use a simple `<script>` tag, the last release can be downloaded here:

- [owl-1.0.0-beta2.js](https://github.com/odoo/owl/releases/download/v1.0.0-beta2/owl.js)
- [owl-1.0.0-beta2.min.js](https://github.com/odoo/owl/releases/download/v1.0.0-beta2/owl.min.js)
-
-Some npm scripts are available:
-
-| Command          | Description                                        |
-| ---------------- | -------------------------------------------------- |
-| `npm install`    | install every dependency required for this project |
-| `npm run build`  | build a bundle of _owl_ in the _/dist/_ folder     |
-| `npm run minify` | minify the prebuilt owl.js file                    |
-| `npm run test`   | run all (owl) tests                                |
-
-## 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: 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 section on [event handling](doc/reference/component.md#event-handling)
-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.
+- [owl-1.0.8.js](https://github.com/odoo/owl/releases/download/v1.0.8/owl.js)
+- [owl-1.0.8.min.js](https://github.com/odoo/owl/releases/download/v1.0.8/owl.min.js)

 ## License

@@ -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.
@@ -1,4 +1,4 @@
-# 🦉 Testing Owl components 🦉
+# 🦉 How to test Components 🦉

 ## Content

@@ -11,8 +11,7 @@ It is a good practice to test applications and components to ensure that they
 behave as expected. There are many ways to test a user interface: manual
 testing, integration testing, unit testing, ...

-In this section, we will discuss how to write unit tests for components, and
-how to debug them if necessary.
+In this section, we will discuss how to write unit tests for components.

 ## Unit Tests

@@ -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.
@@ -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: 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.
@@ -1,107 +1,411 @@
-# 🦉 Quick Start 🦉
+# 🦉 How to start an Owl project 🦉

-## Static Server
+## Content

-Let us assume that we have a static server running somewhere. Let us start by
-adding an html page with a few extra files:
+- [Overview](#overview)
+- [Simple html file](#simple-html-file)
+- [With a static server](#with-a-static-server)
+- [Standard Javascript project](#standard-javascript-project)
+
+## Overview
+
+Each software project has its specific needs. Many of these needs can be solved
+with some tooling: `webpack`, `gulp`, css preprocessor, bundlers, transpilers, ...
+
+Because of that, it is usually not simple to just start a project. Some
+frameworks provide their own tooling to help with that. But then, you have to
+integrate and learn how these applications work.
+
+Owl is designed to be used with no tooling at all. Because of that, Owl can
+"easily" be integrated in a modern build toolchain. In this section, we will
+discuss a few different setups to start a project. Each of these setups has
+advantages and disadvantages in different situations.
+
+## Simple html file
+
+The simplest possible setup is the following: a simple javascript file with your
+code. To do that, let us create the following file structure:

 ```
-my-app/
-    index.html
-    app.css
-    app.js
-    owl-X.Y.Z.js
-    templates.xml
+hello_owl/
+  index.html
+  owl.js
+  app.js
 ```

-### HTML and CSS
+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.

-In a file `index.html`:
+Now, `index.html` should contain the following:

 ```html
 <!DOCTYPE html>
 <html lang="en">
  <head>
-    <meta charset="UTF-8" />
-    <title>My OWL App</title>
-    <link href="app.css" rel="stylesheet" />
-    <script src="owl-X.Y.Z.js"></script>
+    <title>Hello Owl</title>
+    <script src="owl.js"></script>
+    <script src="app.js"></script>
  </head>
-  <body>
-    <div id="main"></div>
-    <script src="app.js" type="module"></script>
-  </body>
+  <body></body>
 </html>
 ```

-In `app.css`:
+And `app.js` should look like this:

-```css
-button {
-  color: darkred;
-  font-size: 30px;
-  width: 220px;
+```js
+const { Component } = owl;
+const { xml } = owl.tags;
+const { whenReady } = owl.utils;
+
+// Owl Components
+class App extends Component {
+  static template = xml`<div>Hello Owl</div>`;
+}
+
+// Setup code
+function setup() {
+  const app = new App();
+  app.mount(document.body);
+}
+
+whenReady(setup);
+```
+
+Now, simply loading this html file in a browser should display a welcome message.
+This setup is not fancy, but it is extremely simple. There are no tooling at
+all required. It can be slightly optimized by using the minified build of Owl.
+
+## With a static server
+
+The previous setup has a big disadvantage: the application code is located in a
+single file. Obviously, we could split it in several files and add multiple
+`<script>` tags in the html page, but then we need to make sure the script are
+inserted in the proper order, we need to export each file content in global
+variables and we lose autocompletion across files.
+
+There is a low tech solution to this issue: using native javascript modules.
+This however has a requirement: for security reasons, browsers will not accept
+modules on content served through the `file` protocol. This means that we need
+to use a static server.
+
+Let us start a new project with the following file structure:
+
+```
+hello_owl/
+  src/
+    app.js
+    index.html
+    main.js
+    owl.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).
+
+Now, `index.html` should contain the following:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Hello Owl</title>
+    <script src="owl.js"></script>
+    <script src="main.js" type="module"></script>
+  </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 `app.js` and `main.js`:
+
+```js
+// app.js ----------------------------------------------------------------------
+const { Component } = owl;
+const { xml } = owl.tags;
+
+export class App extends Component {
+  static template = xml`<div>Hello Owl</div>`;
+}
+
+// main.js ---------------------------------------------------------------------
+import { App } from "./app.js";
+
+function setup() {
+  const app = new App();
+  app.mount(document.body);
+}
+
+owl.utils.whenReady(setup);
+```
+
+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.
+
+Now, to execute this code, we need to serve the `src` folder statically. A low
+tech way to do that is to use for example the python `SimpleHTTPServer` feature:
+
+```
+$ cd src
+$ python -m SimpleHTTPServer 8022    # now content is available at localhost:8022
+```
+
+Another more "javascripty" way to do it is to create a `npm` application. To do
+that, we can add the following `package.json` file at the root of the project:
+
+```json
+{
+  "name": "hello_owl",
+  "version": "0.1.0",
+  "description": "Starting Owl app",
+  "main": "src/index.html",
+  "scripts": {
+    "serve": "serve src"
+  },
+  "author": "John",
+  "license": "ISC",
+  "devDependencies": {
+    "serve": "^11.3.0"
+  }
 }
 ```

-Also, let's not forget to add a release of OWL (`owl-X.Y.Z.js`)
+We can now install the `serve` tool with the command `npm install`, and then,
+start a static server with the simple `npm run serve` command.

-### XML
+## Standard Javascript project

-In `templates.xml`:
+The previous setup works, and is certainly good for some usecases, including
+quick prototyping. However, it lacks some useful features, such as livereload,
+a test suite, or bundling the code in a single file.

-```xml
-<templates>
-   <button t-name="clickcounter" t-on-click="increment">
-      Click Me! [<t t-esc="state.value"/>]
-    </button>
-</templates>
+Each of these features, and many others, can be done in many different ways.
+Since it is really not trivial to configure such a project, we provide here an
+example that can be used as a starting point.
+
+Our standard Owl project has the following file structure:
+
+```
+hello_owl/
+  public/
+    index.html
+  src/
+    components/
+      App.js
+    main.js
+  tests/
+    components/
+      App.test.js
+    helpers.js
+  .gitignore
+  package.json
+  webpack.config.js
 ```

-### JS
+This project as a `public` folder, meant to contain all static assets, such as
+images and styles. The `src` folder has the javascript source code, and finally,
+`tests` contains the test suite.

-To build an application (or a sub-part of an application), we need two things:
+Here is the content of `index.html`:

- an environment: it is the global context in which we are working. It needs to
-  contain a QWeb instance (preloaded with templates), and anything else that we
-  need. In practice, it could be used to contain some user session information, some
-  configuration keys (for example, isMobile = true/false if we are in mobile mode).
+```html
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Hello Owl</title>
+  </head>
+  <body></body>
+</html>
+```

- a description of the user interface: there should be a root component, which can
-  have sub components
+Note that there are no `<script>` tag here. They will be injected by webpack.
+Now, let's have a look at the javascript files:

-Here are a few steps that we may take to get started:
+```js
+// src/components/App.js -------------------------------------------------------
+import { Component, tags, useState } from "@odoo/owl";

- get the templates
- create a qweb engine, with the templates
- create an environment
- create an instance of the root component
- mount the root component to a DOM element
+const { xml } = tags;

-Let us now add the javascript to make it work, in `app.js`:
-
-```javascript
-const useState = owl.hooks.useState;
-
-class ClickCounter extends owl.Component {
-  static template = "clickcounter";
-  state = useState({ value: 0 });
-
-  increment() {
-    this.state.value++;
+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";
  }
 }

-//------------------------------------------------------------------------------
-// Application initialization
-//------------------------------------------------------------------------------
-async function start() {
-  const templates = await owl.utils.loadFile("templates.xml");
-  ClickCounter.env = { qweb: new owl.QWeb({ templates }) };
-  const counter = new ClickCounter();
-  const target = document.getElementById("main");
-  await counter.mount(target);
+// src/main.js -----------------------------------------------------------------
+import { utils } from "@odoo/owl";
+import { App } from "./components/App";
+
+function setup() {
+  const app = new App();
+  app.mount(document.body);
 }

-start();
+utils.whenReady(setup);
+
+// tests/components/App.test.js ------------------------------------------------
+import { App } from "../../src/components/App";
+import { makeTestFixture, nextTick, click } from "../helpers";
+
+let fixture;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+describe("App", () => {
+  test("Works as expected...", async () => {
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>Hello Owl</div>");
+
+    click(fixture, "div");
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div>Hello World</div>");
+  });
+});
+
+// tests/helpers.js ------------------------------------------------------------
+import { Component } from "@odoo/owl";
+import "regenerator-runtime/runtime";
+
+export async function nextTick() {
+  return new Promise(function (resolve) {
+    setTimeout(() => Component.scheduler.requestAnimationFrame(() => resolve()));
+  });
+}
+
+export function makeTestFixture() {
+  let fixture = document.createElement("div");
+  document.body.appendChild(fixture);
+  return fixture;
+}
+
+export function click(elem, selector) {
+  elem.querySelector(selector).dispatchEvent(new Event("click"));
+}
+```
+
+Finally, here is the configuration files `.gitignore`, `package.json` and
+`webpack.config.js`:
+
+```
+node_modules/
+package-lock.json
+dist/
+```
+
+```json
+{
+  "name": "hello_owl",
+  "version": "0.1.0",
+  "description": "Demo app",
+  "main": "src/index.html",
+  "scripts": {
+    "test": "jest",
+    "build": "webpack --mode production",
+    "dev": "webpack-dev-server --mode development"
+  },
+  "author": "Someone",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/core": "^7.8.4",
+    "@babel/plugin-proposal-class-properties": "^7.8.3",
+    "babel-jest": "^25.1.0",
+    "babel-loader": "^8.0.6",
+    "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
+    "html-webpack-plugin": "^3.2.0",
+    "jest": "^25.1.0",
+    "regenerator-runtime": "^0.13.3",
+    "serve": "^11.3.0",
+    "webpack": "^4.41.5",
+    "webpack-cli": "^3.3.10",
+    "webpack-dev-server": "^3.10.2"
+  },
+  "dependencies": {
+    "@odoo/owl": "^1.0.4"
+  },
+  "babel": {
+    "plugins": ["@babel/plugin-proposal-class-properties"],
+    "env": {
+      "test": {
+        "plugins": ["transform-es2015-modules-commonjs"]
+      }
+    }
+  },
+  "jest": {
+    "verbose": false,
+    "testRegex": "(/tests/.*(test|spec))\\.js?$",
+    "moduleFileExtensions": ["js"],
+    "transform": {
+      "^.+\\.[t|j]sx?$": "babel-jest"
+    }
+  }
+}
+```
+
+```js
+const path = require("path");
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+
+const host = process.env.HOST || "localhost";
+
+module.exports = function (env, argv) {
+  const mode = argv.mode || "development";
+  return {
+    mode: mode,
+    entry: "./src/main.js",
+    output: {
+      filename: "main.js",
+      path: path.resolve(__dirname, "dist"),
+    },
+    module: {
+      rules: [
+        {
+          test: /\.jsx?$/,
+          loader: "babel-loader",
+          exclude: /node_modules/,
+        },
+      ],
+    },
+    resolve: {
+      extensions: [".js", ".jsx"],
+    },
+    devServer: {
+      contentBase: path.resolve(__dirname, "public/index.html"),
+      compress: true,
+      hot: true,
+      host,
+      port: 3000,
+      publicPath: "/",
+    },
+    plugins: [
+      new HtmlWebpackPlugin({
+        inject: true,
+        template: path.resolve(__dirname, "public/index.html"),
+      }),
+    ],
+  };
+};
+```
+
+With this setup, we can now use the following script commands:
+
+```
+npm run build # build the full application in prod mode in dist/
+
+npm run dev # start a dev server with livereload
+
+npm run test # run the jest test suite
 ```
@@ -37,7 +37,7 @@ todoapp/
    index.html
    app.css
    app.js
-    owl.min.js
+    owl.js
 ```

 The entry point for this application is the file `index.html`, which should have
@@ -62,7 +62,7 @@ our application. `app.js` is where we will write all our code. For now, let's
 just put the following code:

 ```js
-(function() {
+(function () {
  console.log("hello owl", owl.__info__.version);
 })();
 ```
@@ -170,13 +170,13 @@ class App extends Component {
    {
      id: 1,
      title: "buy milk",
-      isCompleted: true
+      isCompleted: true,
    },
    {
      id: 2,
      title: "clean house",
-      isCompleted: false
-    }
+      isCompleted: false,
+    },
  ];
 }
 ```
@@ -446,7 +446,7 @@ Now, this is an interesting situation: the task is displayed by the `Task`
 component, but it is not the owner of its state, so it cannot modify it. Instead,
 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/component.md#event-handling) an event in `Task` and listen
+[trigger](../reference/event_handling.md) an event in `Task` and listen
 for it in `App`.

 In `Task`, change the `input` to:
@@ -562,23 +562,23 @@ const actions = {
      const task = {
        id: state.nextId++,
        title: title,
-        isCompleted: false
+        isCompleted: false,
      };
      state.tasks.push(task);
    }
  },
  toggleTask({ state }, id) {
-    const task = state.tasks.find(t => t.id === id);
+    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);
+    const index = state.tasks.findIndex((t) => t.id === id);
    state.tasks.splice(index, 1);
-  }
+  },
 };
 const initialState = {
  nextId: 1,
-  tasks: []
+  tasks: [],
 };

 // -------------------------------------------------------------------------
@@ -616,7 +616,7 @@ class App extends Component {
  static components = { Task };

  inputRef = useRef("add-input");
-  tasks = useStore(state => state.tasks);
+  tasks = useStore((state) => state.tasks);
  dispatch = useDispatch();

  mounted() {
@@ -811,7 +811,7 @@ For reference, here is the final code:
 ```

 ```js
-(function() {
+(function () {
  const { Component, Store } = owl;
  const { xml } = owl.tags;
  const { whenReady } = owl.utils;
@@ -827,24 +827,24 @@ For reference, here is the final code:
        const task = {
          id: state.nextId++,
          title: title,
-          isCompleted: false
+          isCompleted: false,
        };
        state.tasks.push(task);
      }
    },
    toggleTask({ state }, id) {
-      const task = state.tasks.find(t => t.id === id);
+      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);
+      const index = state.tasks.findIndex((t) => t.id === id);
      state.tasks.splice(index, 1);
-    }
+    },
  };

  const initialState = {
    nextId: 1,
-    tasks: []
+    tasks: [],
  };

  // -------------------------------------------------------------------------
@@ -897,7 +897,7 @@ For reference, here is the final code:
    static components = { Task };

    inputRef = useRef("add-input");
-    tasks = useStore(state => state.tasks);
+    tasks = useStore((state) => state.tasks);
    filter = useState({ value: "all" });
    dispatch = useDispatch();

@@ -916,9 +916,9 @@ For reference, here is the final code:
    get displayedTasks() {
      switch (this.filter.value) {
        case "active":
-          return this.tasks.filter(t => !t.isCompleted);
+          return this.tasks.filter((t) => !t.isCompleted);
        case "completed":
-          return this.tasks.filter(t => t.isCompleted);
+          return this.tasks.filter((t) => t.isCompleted);
        case "all":
          return this.tasks;
      }
@@ -79,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/tags.md#xml-tag) 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.
@@ -127,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/tags.md#xml-tag) tag helper:
+[`xml`](../reference/tags.md#xml-tag) tag helper:

 ```js
 class Clock extends Component {
@@ -251,17 +251,17 @@ keeps track of who get data, and retrigger a render when it was changed.
 Owl store is a little bit like a mix of redux and vuex: it has actions (but not
 mutations), and like VueX, it keeps track of the state changes. However, it does
 not notify a component when the state changes. Instead, components need to connect
-to the store like in redux, with the `useStore` hook (see the [store documentation](reference/store.md#connecting-a-component)).
+to the store like in redux, with the `useStore` hook (see the [store documentation](../reference/store.md#connecting-a-component)).

 ```javascript
 const actions = {
  increment({ state }, val) {
    state.counter.value += val;
-  }
+  },
 };

 const state = {
-  counter: { value: 0 }
+  counter: { value: 0 },
 };
 const store = new owl.Store({ state, actions });

@@ -270,7 +270,7 @@ class Counter extends Component {
      <button t-name="Counter" t-on-click="dispatch('increment')">
        Click Me! [<t t-esc="counter.value"/>]
      </button>`;
-  counter = useStore(state => state.counter);
+  counter = useStore((state) => state.counter);
  dispatch = useDispatch();
 }

@@ -315,7 +315,7 @@ This work is based on the new ideas introduced by React hooks.

 From the way React and Vue introduce their hooks, it may look like hooks are not
 compatible with class components. However, this is not the case, as shown by
-Owl [hooks](reference/hooks.md). They are inspired by both React and Vue. For example,
+Owl [hooks](../reference/hooks.md). They are inspired by both React and Vue. For example,
 the `useState` hook is named after React, but its API is closer to the `reactive`
 Vue hook.

@@ -0,0 +1,180 @@
+# 🦉 Why Owl ? 🦉
+
+The common wisdom is that one should not reinvent the wheel, because that would
+waste effort and resources. It is certainly true in many cases. A javascript
+framework is a considerable investment, so it is quite logical to ask the question:
+why did Odoo decide to make OWL instead of using a standard/well known framework,
+such as React or Vue?
+
+As you might expect, the answer to that question is not simple. But most of the
+reasons discussed in this page are a consequence from a single fact: Odoo is
+extremely modular.
+
+This means, for example, that the core parts of Odoo are not aware, before runtime,
+of what files will be loaded/executed, or what will be the state of the UI. Because
+of that, Odoo cannot rely on a standard build toolchain. Also, this implies that
+the core parts of Odoo need to be extremely generic. In other words, Odoo is not
+really an application with a user interface. It is an application which generates
+a dynamic user interface. And most frameworks are not up to the task.
+
+Betting on Owl was not an easy choice to make, because there certainly are a lot
+of conflicting needs that we want to carefully balance. Choosing anything other
+than a well known framework is bound to be controversial. This page will explain
+some of the reason why we still believe that building Owl is a worthwile
+endeavour.
+
+## Strategy
+
+It is true that we want to keep control of our technology, in the sense that we
+do not want to depend on Facebook or Google, or any other large (or small)
+company. If they decide to change their license, or to go in a direction that
+will not work for us, this may be a problem. This is even more true because
+Odoo is not a conventional javascript application, and our needs are probably
+quite different as most other applications.
+
+## Class components
+
+It is clear that the biggest frameworks are moving away from class components.
+There is an implicit assumption that class components are terrible, and that
+functional programming is the way to go. React even goes as far as to say that
+classes are confusing for developers.
+
+While there is some truth to that, and to the fact that composition is certainly
+a good mechanism for code reuse, we believe that classes and inheritance are
+important tools.
+
+Sharing code between generic components with inheritance is the way Odoo built
+its web client. And it is clear that inheritance is not the root of all evils.
+It is often a perfectly simple and appropriate solution. What matter most is
+the architectural decisions.
+
+Also, Odoo has another specific use out of class components: each method of a
+class provides an extension point for addons. This may not be a clean architecture
+pattern, but it is a pragmatic decision that served Odoo well: classes are
+sometimes monkey-patched to add behaviour from the outside. A little bit like
+mixins, but from the outside.
+
+Using React or Vue would make it significantly harder to monkey patch components,
+because a lot of the state is hidden in their internals.
+
+## Tooling
+
+React or Vue have a huge community, and a lot of effort have been made into their
+tooling. This is wonderful, but at the same time, a pretty big issue for Odoo:
+since the assets are totally dynamic (and could change whenever the user install
+or remove an addon), we need to have all that kind of tooling on the production
+servers. This is certainly not ideal.
+
+Also, this makes it very complicated to setup Vue or React tools: Odoo code is
+not a simple file that import other files. It changes all the time, assets
+are bundled differently in different contexts. This is the reason why Odoo has
+its own module system, which are resolve at runtime, by the browser. The
+dynamic nature of Odoo means that we often need to delay work as late as possible
+(in other word, we want a JIT user interface!)
+
+Our ideal framework has minimal (mandatory) tooling, which makes it easier to
+deploy. Using React without JSX, or Vue without vue file is not very appealing.
+
+At the same time, Owl is designed to solve this issue: it compiles templates
+by the browser, it doesn't need much code for that, since we use the XML parser
+built into each browser. Owl works with or without any additional tooling. It
+can use template strings to write single file component, and is easy to integrate
+in any html page, with a simple `<script>` tag.
+
+## Template based
+
+Odoo stores template as XML document in a database. This is very powerful, since
+this allow the use of xpaths to customize other templates. This is a very
+important feature of odoo, and one of the key to Odoo modularity.
+
+Because of that, we still expect to write our templates in an XML document.
+Weirdly enough, no major framework uses XML to store templates, even though it
+is extremely convenient.
+
+So, using React or Vue means that we need to make a template compiler. For React,
+that would be a compiler that would take a QWeb template, and convert it to a
+React render function. For Vue, it would convert it to a Vue template. Then
+we need to bundle the vue template compiler as well.
+
+Not only this would be complex (compiling a templating language into another is
+not an easy task), but it would negatively impact the developer experience as
+well. Writing Vue or React components in a QWeb template would certainly be
+awkward, and very confusing.
+
+## Developer Experience
+
+This brings us to the following point: developer experience. We see this choice
+as an investment for the future, and we want to make onboarding developer as
+easy as possible.
+
+While many javascript professionals clearly think that react/vue is not difficult
+(which is true to some extent), it is alsy true that many non js specialists are
+overwhelmed with the frontend world: functional component, hooks, and many other
+fancy words. Also, what is available in the compilation context may be difficult,
+there is a lot of black magic going on in pretty much every framework. Vue
+somehow join various namespaces into one, under the hood, and add various internal
+keys. Svelte transform the code. React require that state transformations are
+deep, and not shallow.
+
+Owl is trying very hard to have a simple and familiar API. It uses classes. Its
+reactivity system is explicit, not implicit. The scoping rules are obvious. In
+case of doubt, we err on the side of not implementing a feature.
+
+It is certainly different from React or Vue, but at the same time, kind of
+familiar for experienced developers.
+
+## JIT compilation
+
+There is also a clear trend in the frontend world to compile code
+as much as possible ahead of time. Most frameworks will compile templates ahead
+of time. And now Svelte is trying to compile the JS code away, so it can remove
+itself from the bundle.
+
+This is certainly reasonable for many usecases. However, this is not what Odoo
+needs: Odoo will fetch templates from the database and need to compile them only
+at the last possible moment, so we can apply all necessary xpaths.
+
+Even more: Odoo needs to be able to generate (and compile) templates at runtime.
+Currently, Odoo form views interpret a xml description. But the form view code
+then needs to do a lot of complicated operations. With Owl, we will be able to
+transform a view description into a QWeb template, then compile that and use it
+immediately.
+
+## Reactivity
+
+There are other design choices that we feel are not optimal in other frameworks.
+For example, the reactivity system. We like the way Vue did it, but it has a
+flaw: it is not really optional. There is actually a way to opt out of the reactivity
+system by freezing the state, but then, it is freezed.
+
+And there certainly are situations where we need a state, which is not readonly,
+and not observed. For example, imagine a spreadsheet component. It may have a
+very large internal state, and it knows exactly when it needs to be rendered
+(basically, whenever the user perform some action). Then, observing its state
+is a net performance loss, both for the CPU and the memory.
+
+## Concurrency
+
+Many applications are happy to simply display a spinner whenever a new asynchronous
+action is performed, but Odoo want a different user experience: most asynchronous
+state changes are not displayed until ready. This is sometimes called a concurrent
+mode: the UI is rendered in memory, and displayed only when it is ready (and
+only if it has not been cancelled by subsequent user actions).
+
+React has now an experimental concurrent mode, but it was not ready when Owl
+started. Vue has not really an equivalent API (suspense is not what we need).
+
+Also, React concurrent mode is complex to use. Concurrency was one of the rare
+strong point of the former Odoo js framework (widgets), and we feel that Owl has
+now a very strong concurrent mode, which is simple and powerful at the same time.
+
+## Conclusion
+
+This lengthy discussion showed that there are many small and not so small reasons
+that current standard frameworks are not tailored to our needs. It is perfectly
+fine, because they each chose a different set of tradeoffs.
+
+However, we feel that there is still room in the framework world for something
+that is different. For a framework that make choices compatible with Odoo.
+
+And that is why we built Owl 🦉.
@@ -1,14 +1,31 @@
 # 🦉 OWL Documentation 🦉

+## Learning Owl
+
+Are you new to Owl? This is the place to start!
+
+- [Tutorial: create a TodoList application](learning/tutorial_todoapp.md)
+- [Quick Overview](learning/overview.md)
+- [How to start an Owl project](learning/quick_start.md)
+- [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)
+
 ## Reference

+You will find here a complete reference of every feature, class or object
+provided by Owl.
+
 - [Animations](reference/animations.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)
 - [Miscellaneous Components](reference/misc.md)
 - [Observer](reference/observer.md)
@@ -18,60 +35,21 @@
 - [QWeb Engine](reference/qweb_engine.md)
 - [Router](reference/router.md)
 - [Store](reference/store.md)
+- [Slots](reference/slots.md)
 - [Tags](reference/tags.md)
 - [Utils](reference/utils.md)

-## Learning Resources
+## Other Topics

- [Quick Start: create an (almost) empty Owl application](learning/quick_start.md)
- [Tutorial: create a TodoList application](learning/tutorial_todoapp.md)
- [Testing Owl components](learning/testing_components.md)
+This section provides miscellaneous document that explains some topics
+which cannot be considered either a tutorial, or reference documentation.

-## Miscellaneous
+- [Owl architecture: the Virtual DOM](miscellaneous/vdom.md)
+- [Owl architecture: the rendering pipeline](miscellaneous/rendering.md)
+- [Comparison with React/Vue](miscellaneous/comparison.md)
+- [Why did Odoo built Owl?](miscellaneous/why_owl.md)

- [Comparison with React/Vue](comparison.md)
- [Tooling](tooling.md)
- [Templates to start Owl applications (external link)](https://github.com/ged-odoo/owl-templates)
+---

-## Architecture
-
-This section explains in more detail the inner workings of Owl. It is targeted
-for developers working on Owl itself.
-
- [Virtual DOM](architecture/vdom.md)
- [Rendering](architecture/rendering.md)
-
-## Owl Content
-
-Here is a complete visual representation of everything exported by the `owl`
-global object (so, for example, `Component` is available at `owl.Component`,
-and `EventBus` is exported as `owl.core.EventBus`):
-
-```
-Component                               misc
-Context                                     AsyncRoot
-QWeb                                        Portal
-Store                                   router
-useState                                    Link
-config                                      RouteComponent
-    mode                                    Router
-core                                    tags
-    EventBus                                xml
-    Observer                            utils
-hooks                                       debounce
-    onWillStart                             escape
-    onMounted                               loadJS
-    onWillUpdateProps                       loadFile
-    onWillPatch                             shallowEqual
-    onPatched                               whenReady
-    onWillUnmount
-    useContext
-    useState
-    useRef
-    useSubEnv
-    useStore
-    useDispatch
-    useGetters
-```
-
-Note that for convenience, the `useState` hook is also exported at the root of the `owl` object.
+Found an issue in the documentation? A broken link? Some outdated information?
+Please open an issue or submit a PR!
@@ -12,12 +12,9 @@
  - [Lifecycle](#lifecycle)
  - [Root Component](#root-component)
  - [Composition](#composition)
-  - [Event Handling](#event-handling)
  - [Form Input Bindings](#form-input-bindings)
  - [References](#references)
-  - [Slots](#slots)
  - [Dynamic sub components](#dynamic-sub-components)
-  - [Error Handling](#error-handling)
  - [Functional Components](#functional-components)
  - [SVG components](#svg-components)

@@ -207,7 +204,7 @@ to be called in the constructor.
  class Counter extends owl.Component {
    static props = {
      initialValue: Number,
-      optional: true
+      optional: true,
    };
  }
  ```
@@ -220,11 +217,15 @@ to be called in the constructor.
  ```js
  class Counter extends owl.Component {
    static defaultProps = {
-      initialValue: 0
+      initialValue: 0,
    };
  }
  ```

+- **`style`** (string, optional): it should be the return value of the [`css` tag](tags.md#css-tag),
+  which is used to inject stylesheet whenever the component is visible on the
+  screen.
+
 There is another static property defined on the `Component` class: `current`.
 This property is set to the currently being defined component (in the constructor).
 This is the way [hooks](hooks.md) are able to get a reference to the target
@@ -304,16 +305,16 @@ A solid and robust component system needs useful hooks/methods to help
 developers write components. Here is a complete description of the lifecycle of
 a owl component:

-| Method                                           | Description                                                  |
-| ------------------------------------------------ | ------------------------------------------------------------ |
-| **[constructor](#constructorparent-props)**      | constructor                                                  |
-| **[willStart](#willstart)**                      | async, before first rendering                                |
-| **[mounted](#mounted)**                          | just after component is rendered and added to the DOM        |
-| **[willUpdateProps](#willupdatepropsnextprops)** | async, before props update                                   |
-| **[willPatch](#willpatch)**                      | just before the DOM is patched                               |
-| **[patched](#patchedsnapshot)**                  | just after the DOM is patched                                |
-| **[willUnmount](#willunmount)**                  | just before removing component from DOM                      |
-| **[catchError](#catcherrorerror)**               | catch errors (see [error handling section](#error-handling)) |
+| Method                                           | Description                                                 |
+| ------------------------------------------------ | ----------------------------------------------------------- |
+| **[constructor](#constructorparent-props)**      | constructor                                                 |
+| **[willStart](#willstart)**                      | async, before first rendering                               |
+| **[mounted](#mounted)**                          | just after component is rendered and added to the DOM       |
+| **[willUpdateProps](#willupdatepropsnextprops)** | async, before props update                                  |
+| **[willPatch](#willpatch)**                      | just before the DOM is patched                              |
+| **[patched](#patchedsnapshot)**                  | just after the DOM is patched                               |
+| **[willUnmount](#willunmount)**                  | just before removing component from DOM                     |
+| **[catchError](#catcherrorerror)**               | catch errors (see [error handling page](error_handling.md)) |

 Notes:

@@ -421,7 +422,7 @@ likely via a change in its state/props or environment).

 This method is not called on the initial render. It is useful to interact
 with the DOM (for example, through an external library) whenever the
-component was patched. Note that this hook will not be called if the compoent is
+component was patched. Note that this hook will not be called if the component is
 not in the DOM.

 Updating the component state in this hook is possible, but not encouraged.
@@ -448,8 +449,8 @@ This is the opposite method of `mounted`.
 #### `catchError(error)`

 The `catchError` method is useful when we need to intercept and properly react
-to (rendering) errors that occur in some sub components. See the section on
-[error handling](#error-handling).
+to (rendering) errors that occur in some sub components. See the page on
+[error handling](error_handling.md).

 ### Root Component

@@ -548,128 +549,6 @@ with a class object:
 <MyComponent t-att-class="{a: state.flagA, b: state.flagB}" />
 ```

-### Event Handling
-
-In a component's template, it is useful to be able to register handlers on DOM
-elements to some specific events. This is what makes a template _alive_. There
-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>
-```
-
-This will be roughly translated in javascript like this:
-
-```js
-button.addEventListener("click", component.someMethod.bind(component));
-```
-
-The suffix (`click` in this example) is simply the name of the actual DOM
-event.
-
-A _business_ DOM event is triggered by a call to `trigger` on a component.
-
-```xml
-<MyComponent t-on-menu-loaded="someMethod" />
-```
-
-```js
- class MyComponent {
-     someWhere() {
-         const payload = ...;
-         this.trigger('menu-loaded', payload);
-     }
- }
-```
-
-The call to `trigger` generates an `OwlEvent`, a subclass of [_CustomEvent_](https://developer.mozilla.org/docs/Web/Guide/Events/Creating_and_triggering_events)
-with an additional attribute `originalComponent` (the component that triggered
-the event). The generated event is of type `menu-loaded` and dispatches it on
-the component's DOM element (`this.el`). The event bubbles and is cancelable.
-The parent component listening to event `menu-loaded` will receive the payload
-in its `someMethod` handler (in the `detail` property of the event), whenever
-the event is triggered.
-
-```js
- class ParentComponent {
-     someMethod(ev) {
-         const payload = ev.detail;
-         ...
-     }
- }
-```
-
-By convention, we use KebabCase for the name of _business_ events.
-
-The `t-on` directive allows to prebind its arguments. For example,
-
-```xml
-<button t-on-click="someMethod(expr)">Do something</button>
-```
-
-Here, `expr` is a valid Owl expression, so it could be `true` or some variable
-from the rendering context.
-
-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>
-```
-
-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                                                       |
-| ---------- | ----------------------------------------------------------------- |
-| `.stop`    | calls `event.stopPropagation()` 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 |
-
-```xml
-<button t-on-click.stop="someMethod">Do something</button>
-```
-
-Note that modifiers can be combined (ex: `t-on-click.stop.prevent`), and that
-the order may matter. For instance `t-on-click.prevent.self` will prevent all
-clicks while `t-on-click.self.prevent` will only prevent clicks on the element
-itself.
-
-Finally, empty handlers are tolerated as they could be defined only to apply
-modifiers. For example,
-
-```xml
-<button t-on-click.stop="">Do something</button>
-```
-
-This will simply stop the propagation of the event.
-
 ### Form Input Bindings

 It is very common to need to be able to read the value out of an html `input` (or
@@ -819,75 +698,6 @@ Note that these two examples uses the suffix `ref` to name the reference. This
 is not mandatory, but it is a useful convention, so we do not forget to access
 it with the `el` or `comp` suffix.

-### Slots
-
-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.
-
-This is what _slots_ are for.
-
-```xml
-<div t-name="Dialog" class="modal">
-  <div class="modal-title"><t t-esc="props.title"/></div>
-  <div class="modal-content">
-    <t t-slot="content"/>
-  </div>
-  <div class="modal-footer">
-    <t t-slot="footer"/>
-  </div>
-</div>
-```
-
-Slots are defined by the caller, with the `t-set` directive:
-
-```xml
-<div t-name="SomeComponent">
-  <div>some component</div>
-  <Dialog title="Some Dialog">
-    <t t-set="content">
-      <div>hey</div>
-    </t>
-    <t t-set="footer">
-      <button t-on-click="doSomething">ok</button>
-    </t>
-  </Dialog>
-</div>
-```
-
-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.
-
-Default slot: 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">
-  <Child>
-    <span>some content</span>
-  </Child>
-</div>
-
-<div t-name="Child">
-  <t t-slot="default"/>
-</div>
-```
-
-Slots can define a default content, in case the parent did not define them:
-
-```xml
-<div t-name="Parent">
-  <Child/>
-</div>
-
-<span t-name="Child">
-  <t t-slot="default">default content</t>
-</span>
-<!-- will be rendered as: <div><span>default content</span></div> -->
-```
-
 ### Dynamic sub components

 It is not common, but sometimes we need a dynamic component name. In this case,
@@ -933,65 +743,6 @@ component class.

 Note that the `t-component` directive can only be used on `<t>` nodes.

-### Error Handling
-
-By default, whenever an error occurs in the rendering of an Owl application, we
-destroy the whole application. Otherwise, we cannot offer any guarantee on the
-state of the resulting component tree. It might be hopelessly corrupted, but
-without any user-visible state.
-
-Clearly, it sometimes is a little bit extreme to destroy the application. This
-is why we have a builtin mechanism to handle rendering errors (and errors coming
-from lifecycle hooks): the `catchError` hook.
-
-Whenever the `catchError` lifecycle hook is implemented, all errors coming from
-sub components rendering and/or lifecycle method calls will be caught and given
-to the `catchError` method. This allows us to properly handle the error, and to
-not break the application.
-
-For example, here is how we could implement an `ErrorBoundary` component:
-
-```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, it may be useful to know that whenever an error is caught, it is then
-broadcasted to the application by an event on the `qweb` instance. It may be
-useful, for example, to log the error somewhere.
-
-```js
-env.qweb.on("error", null, function(error) {
-  // do something
-  // react to the error
-});
-```
-
 ### Functional Components

 Owl does not exactly have functional components. However, there is an extremely
@@ -1053,8 +804,8 @@ class RootNode extends Component {
    children: [
      { label: "b" },
      { label: "c", children: [{ label: "d" }, { label: "e" }] },
-      { label: "f", children: [{ label: "g" }] }
-    ]
+      { label: "f", children: [{ label: "g" }] },
+    ],
  };
 }
 ```
@@ -23,7 +23,7 @@ a rendering that is no longer relevant, restart it, reuse it in some cases.
 But even though using concurrency is quite simple (and is the default behaviour),
 asynchrony is difficult, because it introduces an additional dimension that
 vastly increase the complexity of an application. This section will explain
-how Owl manages this complexity, how concuurent rendering works in a general way.
+how Owl manages this complexity, how concurrent rendering works in a general way.

 ## Rendering Components

@@ -120,7 +120,7 @@ Here is what Owl will do:
     1. hook `willUpdateProps` is called on `D` (async)
     2. template `D` is rerendered
   - component `F` is created:
-     1. hook `willStart` is called on `E` (async)
+     1. hook `willStart` is called on `F` (async)
     2. template `F` is rendered

 3. `willPatch` hooks are called recursively on components `C`, `D` (not on `F`,
@@ -137,7 +137,7 @@ Here is what Owl will do:

 Tags are very small helpers to make it easy to write inline templates. There is
 only one currently available tag: `xml`, but we plan to add other tags later,
-such as a `css` tag, which will be used to write [single file components](../tooling.md#single-file-component).
+such as a `css` tag, which will be used to write [single file components](../learning/how_to_write_sfc.md).

 ### Asynchronous Rendering

@@ -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`.
+
+```
+Component                               misc
+Context                                     AsyncRoot
+QWeb                                        Portal
+Store                                   router
+useState                                    Link
+config                                      RouteComponent
+    mode                                    Router
+core                                    tags
+    EventBus                                css
+    Observer                                xml
+hooks                                   utils
+    onWillStart                             debounce
+    onMounted                               escape
+    onWillUpdateProps                       loadJS
+    onWillPatch                             loadFile
+    onPatched                               shallowEqual
+    onWillUnmount                           whenReady
+    useContext
+    useState
+    useRef
+    useSubEnv
+    useStore
+    useDispatch
+    useGetters
+```
+
+Note that for convenience, the `useState` hook is also exported at the root of the `owl` object.
@@ -6,6 +6,7 @@
 - [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

@@ -40,8 +41,8 @@ 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 explicitely setup,
-  this will be return the empty `env` object defined on `Component`)
+- 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
@@ -93,7 +94,7 @@ Some good use cases for additional keys in the environment are:

 - some configuration keys,
 - session information,
- generic services (such as doing rpcs, or accessing local storage).
+- generic services (such as doing rpcs).

 Doing it this way means that components are easily testable: we can simply
 create a test environment with mock services.
@@ -112,10 +113,10 @@ async function myEnv() {
    qweb: qweb,
    services: {
      localStorage: localStorage,
-      rpc: rpc
+      rpc: rpc,
    },
    debug: false,
-    inMobileMode: true
+    inMobileMode: true,
  };
 }

@@ -125,3 +126,26 @@ async function start() {
  await app.mount(document.body);
 }
 ```
+
+## 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. This is particularly useful when one want
+  to test more advanced components, and be able to mock those methods.
+
+More specifically, the `browser` object contains the following methods and objects:
+
+- `setTimeout`
+- `clearTimeout`
+- `setInterval`
+- `clearInterval`
+- `requestAnimationFrame`
+- `random`
+- `Date`
+- `fetch`
+- `localStorage`
@@ -0,0 +1,81 @@
+# 🦉 Error Handling 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Example](#example)
+- [Reference](#reference)
+
+## Overview
+
+By default, whenever an error occurs in the rendering of an Owl application, we
+destroy the whole application. Otherwise, we cannot offer any guarantee on the
+state of the resulting component tree. It might be hopelessly corrupted, but
+without any user-visible state.
+
+Clearly, it sometimes is a little bit extreme to destroy the application. This
+is why we have a builtin mechanism to handle rendering errors (and errors coming
+from lifecycle hooks): the `catchError` hook.
+
+## Example
+
+For example, here is how we could implement an `ErrorBoundary` component:
+
+```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 `catchError` method. This allows us to properly handle the error, and to
+not break the application.
+
+There are important things to know:
+
+- If an error that occured in the internal rendering cycle is not caught, then
+  Owl will destroy the full application. This is done on purpose, because Owl
+  cannot guarantee that the state is not corrupted from this point on.
+
+- errors coming from event handlers are NOT managed by `catchError` or any other
+  owl mechanism. This is up to the application developer to properly recover
+  from an error
+
+Also, it may be useful to know that whenever an error is caught, it is then
+broadcasted to the application by an event on the `qweb` instance. It may be
+useful, for example, to log the error somewhere.
+
+```js
+env.qweb.on("error", null, function (error) {
+  // do something
+  // react to the error
+});
+```
@@ -7,7 +7,7 @@ triggering events, and callbacks.
 ```js
 const bus = new owl.core.EventBus();

-bus.on("some-event", null, function(...args) {
+bus.on("some-event", null, function (...args) {
  console.log(...args);
 });

@@ -0,0 +1,137 @@
+# 🦉 Event Handling 🦉
+
+## Content
+
+- [Event Handling](#event-handling)
+- [Business DOM Events](#business-dom-events)
+- [Inline Event Handlers](#inline-event-handlers)
+- [Modifiers](#modifiers)
+
+## Event Handling
+
+In a component's template, it is useful to be able to register handlers on DOM
+elements to some specific events. This is what makes a template _alive_. There
+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>
+```
+
+This will be roughly translated in javascript like this:
+
+```js
+button.addEventListener("click", component.someMethod.bind(component));
+```
+
+The suffix (`click` in this example) is simply the name of the actual DOM
+event.
+
+## Business DOM Events
+
+A _business_ DOM event is triggered by a call to `trigger` on a component.
+
+```xml
+<MyComponent t-on-menu-loaded="someMethod" />
+```
+
+```js
+ class MyComponent {
+     someWhere() {
+         const payload = ...;
+         this.trigger('menu-loaded', payload);
+     }
+ }
+```
+
+The call to `trigger` generates an `OwlEvent`, a subclass of [_CustomEvent_](https://developer.mozilla.org/docs/Web/Guide/Events/Creating_and_triggering_events)
+with an additional attribute `originalComponent` (the component that triggered
+the event). The generated event is of type `menu-loaded` and dispatches it on
+the component's DOM element (`this.el`). The event bubbles and is cancelable.
+The parent component listening to event `menu-loaded` will receive the payload
+in its `someMethod` handler (in the `detail` property of the event), whenever
+the event is triggered.
+
+```js
+ class ParentComponent {
+     someMethod(ev) {
+         const payload = ev.detail;
+         ...
+     }
+ }
+```
+
+By convention, we use KebabCase for the name of _business_ events.
+
+The `t-on` directive allows to prebind its arguments. For example,
+
+```xml
+<button t-on-click="someMethod(expr)">Do something</button>
+```
+
+Here, `expr` is a valid Owl expression, so it could be `true` or some variable
+from the rendering context.
+
+## 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
+
+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                                                                                                              |
+| ---------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `.stop`    | calls `event.stopPropagation()` 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                                                        |
+| `.capture` | bind the event handler in [capture](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener) mode. |
+
+```xml
+<button t-on-click.stop="someMethod">Do something</button>
+```
+
+Note that modifiers can be combined (ex: `t-on-click.stop.prevent`), and that
+the order may matter. For instance `t-on-click.prevent.self` will prevent all
+clicks while `t-on-click.self.prevent` will only prevent clicks on the element
+itself.
+
+Finally, empty handlers are tolerated as they could be defined only to apply
+modifiers. For example,
+
+```xml
+<button t-on-click.stop="">Do something</button>
+```
+
+This will simply stop the propagation of the event.
@@ -17,6 +17,7 @@
  - [`useContext`](#usecontext)
  - [`useRef`](#useref)
  - [`useSubEnv`](#usesubenv)
+  - [`useExternalListener`](#useexternallistener)
  - [`useStore`](#usestore)
  - [`useDispatch`](#usedispatch)
  - [`useGetters`](#usegetters)
@@ -258,7 +259,7 @@ function useLoader() {
  }

  onWillStart(() => updateRecord(component.props.id));
-  onWillUpdateProps(nextProps => updateRecord(nextProps.id));
+  onWillUpdateProps((nextProps) => updateRecord(nextProps.id));

  return record;
 }
@@ -354,6 +355,17 @@ will be added to the parent environment. Note that it will extend, not replace
 the parent environment. And of course, the parent environment will not be
 affected.

+### `useExternalListener`
+
+The `useExternalListener` hook helps solve a very common problem: adding and removing
+a listener on some target whenever a component is mounted/unmounted. For example,
+a dropdown menu (or its parent) may need to listen to a `click` event on `window`
+to be closed:
+
+```js
+useExternalListener(window, "click", this.closeMenu);
+```
+
 ### `useStore`

 The `useStore` hook is the entry point for a component to connect to the store.
@@ -18,7 +18,7 @@ for modals (as in `bootstrap-modal`).
 ### Usage

 The content it will teleport is defined within the `<Portal>` node and
-internally uses the `default` [Slot](component.md#slots).
+internally uses the `default` [Slot](slots.md).

 This slot must contain only **one** node, which in turn can have as many children as necessary.

@@ -95,7 +95,7 @@ The teleported piece is updated as any other `Component`'s DOM and in the same s
 Namely the teleported piece will be updated in function of its parents components, and patched as
 a normal child.

-The [_business_ events](component.md#event-handling) triggered by a child component will be stopped
+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.

@@ -61,7 +61,7 @@ Its API is quite simple:
  ```

 - **`render(name, context, extra)`**: renders a template. This returns a `vnode`,
-  which is a virtual representation of the DOM (see [vdom doc](../architecture/vdom.md)).
+  which is a virtual representation of the DOM (see [vdom doc](../miscellaneous/vdom.md)).

  ```js
  const vnode = qweb.render("App", component);
@@ -114,9 +114,9 @@ For example:
 const translations = {
  hello: "bonjour",
  yes: "oui",
-  no: "non"
+  no: "non",
 };
-const translateFn = str => translations[str] || str;
+const translateFn = (str) => translations[str] || str;

 const qweb = new QWeb({ translateFn });
 ```
@@ -71,9 +71,9 @@ needs. Here is a list of all Owl specific directives:
 | `t-component`, `t-props` | [Defining a sub component](component.md#composition)                            |
 | `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-on-*`                 | [Event handling](component.md#event-handling)                                   |
+| `t-on-*`                 | [Event handling](event_handling.md)                                             |
 | `t-transition`           | [Defining an animation](animations.md#css-transitions)                          |
-| `t-slot`                 | [Rendering a slot](component.md#slots)                                          |
+| `t-slot`                 | [Rendering a slot](slots.md)                                                    |
 | `t-model`                | [Form input bindings](component.md#form-input-bindings)                         |

 ## Reference
@@ -532,7 +532,7 @@ The javascript QWeb implementation provides two useful debugging directives:

 ```xml
 <t t-if="a_test">
-    <t t-debug="">
+    <t t-debug=""/>
 </t>
 ```

@@ -0,0 +1,96 @@
+# 🦉 Slots 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Example](#example)
+- [Reference](#reference)
+
+## Overview
+
+Owl is a template based component system. There is therefore a need to be able
+to make generic components. For example, imagine a generic `Dialog`
+component, which is able to display some arbitrary content.
+
+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.
+
+```xml
+<div t-name="Dialog" class="modal">
+  <div class="modal-title"><t t-esc="props.title"/></div>
+  <div class="modal-content">
+    <t t-slot="content"/>
+  </div>
+  <div class="modal-footer">
+    <t t-slot="footer"/>
+  </div>
+</div>
+```
+
+Slots are defined by the caller, with the `t-set-slot` directive:
+
+```xml
+<div t-name="SomeComponent">
+  <div>some component</div>
+  <Dialog title="Some Dialog">
+    <t t-set-slot="content">
+      <div>hey</div>
+    </t>
+    <t t-set-slot="footer">
+      <button t-on-click="doSomething">ok</button>
+    </t>
+  </Dialog>
+</div>
+```
+
+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.
+
+Note: Owl previously used the `t-set` directive to define the content of a slot.
+This is deprecated and should no longer be used in new code.
+
+## Reference
+
+Default slot: 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">
+  <Child>
+    <span>some content</span>
+  </Child>
+</div>
+
+<div t-name="Child">
+  <t t-slot="default"/>
+</div>
+```
+
+Default content: slots can define a default content, in case the parent did not define them:
+
+```xml
+<div t-name="Parent">
+  <Child/>
+</div>
+
+<span t-name="Child">
+  <t t-slot="default">default content</t>
+</span>
+<!-- will be rendered as: <div><span>default content</span></div> -->
+```
+
+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).
@@ -40,14 +40,14 @@ const actions = {
    state.todos.push({
      id: state.nextId++,
      message,
-      isCompleted: false
+      isCompleted: false,
    });
-  }
+  },
 };

 const state = {
  todos: [],
-  nextId: 1
+  nextId: 1,
 };

 const store = new owl.Store({ state, actions });
@@ -90,7 +90,7 @@ const config = {
  state,
  actions,
  getters,
-  env
+  env,
 };
 const store = new Store(config);
 ```
@@ -110,7 +110,7 @@ const actions = {
    } catch (e) {
      state.loginState = "error";
    }
-  }
+  },
 };
 ```

@@ -144,7 +144,7 @@ const actions = {
    state.recordId = recordId;
    const data = await doSomeRPC("/read/", recordId);
    state.recordData = data;
-  }
+  },
 };
 ```

@@ -159,7 +159,7 @@ const actions = {
    const data = await doSomeRPC("/read/", recordId);
    state.recordId = recordId;
    state.recordData = data;
-  }
+  },
 };
 ```

@@ -187,14 +187,14 @@ transform the data contained in the store.
 ```js
 const getters = {
  getPost({ state }, id) {
-    const post = state.posts.find(p => p.id === id);
-    const author = state.authors.find(a => a.id === post.id);
+    const post = state.posts.find((p) => p.id === id);
+    const author = state.authors.find((a) => a.id === post.id);
    return {
      id,
      author,
-      content: post.content
+      content: post.content,
    };
-  }
+  },
 };

 // somewhere else
@@ -208,7 +208,11 @@ Note that getters are not cached.
 ### Connecting a Component

 At some point, we need a way to interact with the store from a component. This
-can be done with the help of the three store hooks:
+means that the component needs a reference to the store. By default, it looks
+for it in the `env.store` key. However, this can be configured with the `useStore`
+hook.
+
+Every component-store interactions are done with the help of the three store hooks:

 - [`useStore`](#usestore) to subscribe a component to some part of the store state,
 - [`useDispatch`](#usedispatch) to get a reference to a dispatch function,
@@ -220,20 +224,28 @@ Assume we have this store:
 const actions = {
  increment({ state }, val) {
    state.counter.value += val;
-  }
+  },
 };

 const state = {
-  counter: { value: 0 }
+  counter: { value: 0 },
 };
 const store = new owl.Store({ state, actions });
 ```

+To make it accessible to the complete application, we will put it in the
+environment:
+
+```js
+// in this example, the root component is App
+App.env.store = store;
+```
+
 A counter component can then select this value and dispatch an action like this:

 ```js
 class Counter extends Component {
-  counter = useStore(state => state.counter);
+  counter = useStore((state) => state.counter);
  dispatch = useDispatch();
 }

@@ -4,16 +4,19 @@

 - [Overview](#overview)
 - [`xml` tag](#xml-tag)
+- [`css` tag](#css-tag)

 ## Overview

-Tags are very small helpers to make it easy to write inline templates. There is
-only one currently available tag: `xml`, but we plan to add other tags later,
-such as a `css` tag, which will be used to write [single file components](../tooling.md#single-file-component).
+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

-Without tags, creating a standalone component would look like this:
+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'
@@ -52,3 +55,130 @@ class MyComponent extends Component {
    ...
 }
 ```
+
+## 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 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;
+        }
+    `;
+}
+```
@@ -19,7 +19,7 @@ not ready yet, resolved directly otherwise). If called with a callback as
 argument, it executes it as soon as the DOM ready (or directly).

 ```js
-Promise.all([loadFile("templates.xml"), owl.utils.whenReady()]).then(function([templates]) {
+Promise.all([loadFile("templates.xml"), owl.utils.whenReady()]).then(function ([templates]) {
  const qweb = new owl.QWeb({ templates });
  const app = new App({ qweb });
  app.mount(document.body);
@@ -29,7 +29,7 @@ Promise.all([loadFile("templates.xml"), owl.utils.whenReady()]).then(function([t
 or alternatively:

 ```js
-owl.utils.whenReady(function() {
+owl.utils.whenReady(function () {
  const qweb = new owl.QWeb();
  const app = new App({ qweb });
  app.mount(document.body);
@@ -1,106 +0,0 @@
-# 🦉 Tooling 🦉
-
-## Content
-
- [Overview](#overview)
- [Playground](#playground)
- [Benchmarks](#benchmarks)
- [Single File Component](#single-file-component)
- [Debugging Script](#debugging-script)
-
-## Overview
-
-To help work with/improve/learn OWL, there are a few extras tools/settings.
-
- development mode: enable better error reporting for the developer
- a playground application: a space to experiment and learn Owl.
- a benchmarks application: allow comparison with a few common frameworks
-
-The two applications are available in the `tools/` folder, and can be accessed
-by using a static http server. A simple python
-server is available in `server.py`. There is also a npm script to start it:
-`npm run tools` (and its version with a watcher: `npm run tools:watch`).
-
-## Playground
-
-The playground is an important application designed to help learning and
-experimenting with Owl. The last published version of Owl can be tested [online](https://odoo.github.io/owl/playground/).
-
-It is an application similar to `jsFiddle`, but specialized for Owl: there are
-three tabs (`js`, `css` and `xml`), and a simple button `Run` to execute that
-code in an iframe.
-
-## Benchmarks
-
-Note: This is more an internal tool, useful for people working on Owl.
-
-The benchmarks application is a very small application, implemented in different
-frameworks, and in different versions of Owl. This is a simple internal tool,
-useful to compare various performance metrics on some tasks.
-
-## Single File Component
-
-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 currently has a small helper that makes it easy to define a
-template inside a javascript (or typescript) file: the [`xml`](reference/tags.md#xml-tag)
-helper. With this, a template is automatically registered to [QWeb](reference/qweb_engine.md).
-
-This means that the template and the javascript code can be defined in the same
-file. It is not currently possible to add css to the same file, but Owl may
-get a `css` tag helper later.
-
-```js
-const { Component } = owl;
-const { xml } = owl.tags;
-
-// -----------------------------------------------------------------------------
-// TEMPLATE
-// -----------------------------------------------------------------------------
-const TEMPLATE = xml/* xml */ `
-	<div class="main two-columns">
-		<Sidebar/>
-		<Content />
-	</div>`;
-
-// -----------------------------------------------------------------------------
-// CODE
-// -----------------------------------------------------------------------------
-class MyComponent extends Component {
-  static template = TEMPLATE;
-  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.
-
-## Debugging Script
-
-## Debugging
-
-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,n){let e,o="[OWL_DEBUG]";function s(t){let n=JSON.stringify(t||{});return n.length>200&&(n=n.slice(0,200)+"..."),n}if(Object.defineProperty(t.Component,"current",{get:()=>e,set(i){e=i;const r=i.constructor.name;if(n.componentBlackList&&n.componentBlackList.test(r))return;if(n.componentWhiteList&&!n.componentWhiteList.test(r))return;let l;Object.defineProperty(e,"__owl__",{get:()=>l,set(e){!function(e,i,r){let l=`${i}<id=${r}>`,c=t=>console.log(`${o} ${l} ${t}`),u=t=>(!n.methodBlackList||!n.methodBlackList.includes(t))&&!(n.methodWhiteList&&!n.methodWhiteList.includes(t));u("constructor")&&c(`constructor, props=${s(e.props)}`);u("willStart")&&t.hooks.onWillStart(()=>{c("willStart")});u("mounted")&&t.hooks.onMounted(()=>{c("mounted")});u("willUpdateProps")&&t.hooks.onWillUpdateProps(t=>{c(`willUpdateProps, nextprops=${s(t)}`)});u("willPatch")&&t.hooks.onWillPatch(()=>{c("willPatch")});u("patched")&&t.hooks.onPatched(()=>{c("patched")});u("willUnmount")&&t.hooks.onWillUnmount(()=>{c("willUnmount")});const d=e.__render.bind(e);e.__render=function(...t){c("rendering template"),d(...t)};const h=e.render.bind(e);e.render=function(...t){const n=e.__owl__;let o="render";return n.isMounted||n.currentFiber||(o+=" (warning: component is not mounted, this render has no effect)"),c(o),h(...t)};const p=e.mount.bind(e);e.mount=function(...t){return c("mount"),p(...t)}}(i,r,(l=e).id)}})}}),n.logScheduler){let n=t.Component.scheduler.start,e=t.Component.scheduler.stop;t.Component.scheduler.start=function(){this.isRunning||console.log(`${o} scheduler: start running tasks queue`),n.call(this)},t.Component.scheduler.stop=function(){this.isRunning&&console.log(`${o} scheduler: stop running tasks queue`),e.call(this)}}if(n.logStore){let n=t.Store.prototype.dispatch;t.Store.prototype.dispatch=function(t,...e){return console.log(`${o} store: action '${t}' dispatched. Payload: '${s(e)}'`),n.call(this,t,...e)}}}
-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
-});
-```
-
-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.
@@ -1,8 +1,14 @@
 {
-  "name": "owl-framework",
-  "version": "1.0.0-beta2",
+  "name": "@odoo/owl",
+  "version": "1.0.8",
  "description": "Odoo Web Library (OWL)",
-  "main": "src/index.ts",
+  "main": "dist/owl.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist/types/",
+    "dist/owl.js",
+    "dist/owl-iife.js"
+  ],
  "engines": {
    "node": ">=10.15.3"
  },
@@ -18,14 +24,16 @@
    "tools": "npm run build && npm run tools:serve",
    "pretools:watch": "npm run build",
    "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"
+    "prettier": "prettier {src/*.ts,src/**/*.ts,tests/*.ts,tests/**/*.ts,doc/*.md,doc/**/*.md} --write",
+    "publish": "mv dist/owl.js dist/owl-iife.js && npm run buildcommonjs && npm publish",
+    "release": "node tools/release.js"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/odoo/owl.git"
  },
  "author": "Odoo",
-  "license": "LGPL",
+  "license": "LGPL-3.0-only",
  "bugs": {
    "url": "https://github.com/odoo/owl/issues"
  },
@@ -33,13 +41,15 @@
  "dependencies": {},
  "devDependencies": {
    "@types/jest": "^23.3.12",
+    "chalk": "^3.0.0",
    "cpx": "^1.5.0",
    "git-rev-sync": "^1.12.0",
+    "github-api": "^3.3.0",
    "jest": "^23.6.0",
    "jest-environment-jsdom": "^24.7.1",
    "live-server": "^1.2.1",
    "npm-run-all": "^4.1.5",
-    "prettier": "^1.19.1",
+    "prettier": "^2.0.4",
    "rollup": "^1.6.0",
    "rollup-plugin-typescript2": "^0.20.1",
    "sass": "^1.16.1",
@@ -68,6 +78,7 @@
    ]
  },
  "prettier": {
-    "printWidth": 100
+    "printWidth": 100,
+    "endOfLine": "auto"
  }
 }
@@ -1,35 +1,22 @@
 # 🦉 OWL Roadmap 🦉

- Current version: 1.0.0-beta2
- Status: mostly stable
+- Current version: 1.0.8
+- Status: stable

 This roadmap is only an attempt at predicting Owl's future.  Everything may
 change!


-
-### December 2019
-
-If all goes well, Owl is upgraded to beta status. From now on, no API change,
-even small, is expected (but it still could happen).
-
-### End of 2019
-
-Release v1.0
-
- API should be stable,
- we will use semantic versioning,
- we will maintain a changelog and an upgrade guide.
-
 ### 1.x

 - add chrome and firefox devtools,
- add support for single file components,
 - fix every bugs,
 - improve documentation,
 - small backward compatible improvements.

-### 2.x (2021? 2022?)
+### 2.x (2020? 2021? 2022?)
+
+- stop support for `t-set` directive to define the content of a slot

 Maybe:

@@ -0,0 +1,23 @@
+export interface Browser {
+  setTimeout: Window["setTimeout"];
+  clearTimeout: Window["clearTimeout"];
+  setInterval: Window["setInterval"];
+  clearInterval: Window["clearInterval"];
+  requestAnimationFrame: Window["requestAnimationFrame"];
+  random: Math["random"];
+  Date: typeof Date;
+  fetch: Window["fetch"];
+  localStorage: Window["localStorage"];
+}
+
+export const browser: Browser = {
+  setTimeout: window.setTimeout.bind(window),
+  clearTimeout: window.clearTimeout.bind(window),
+  setInterval: window.setInterval.bind(window),
+  clearInterval: window.clearInterval.bind(window),
+  requestAnimationFrame: window.requestAnimationFrame.bind(window),
+  random: Math.random,
+  Date: window.Date,
+  fetch: (window.fetch || (() => {})).bind(window),
+  localStorage: window.localStorage,
+};
@@ -6,6 +6,8 @@ import "./directive";
 import { Fiber } from "./fiber";
 import "./props_validation";
 import { Scheduler, scheduler } from "./scheduler";
+import { activateSheet } from "./styles";
+import { Browser, browser } from "../browser";

 /**
 * Owl Component System
@@ -33,11 +35,13 @@ import { Scheduler, scheduler } from "./scheduler";
 */
 export interface Env {
  qweb: QWeb;
-  [key: string]: any;
+  browser: Browser;
 }

+export type MountPosition = "first-child" | "last-child" | "self";
+
 interface MountOptions {
-  position?: "first-child" | "last-child" | "self";
+  position?: MountPosition;
 }

 /**
@@ -45,7 +49,7 @@ interface MountOptions {
 * useful to typecheck and describe the internal keys used by Owl to manage the
 * component tree.
 */
-interface Internal<T extends Env, Props> {
+interface Internal<T extends Env> {
  // each component has a unique id, useful mostly to handle parent/child
  // relationships
  readonly id: number;
@@ -57,8 +61,8 @@ interface Internal<T extends Env, Props> {

  // parent and children keys are obviously useful to setup the parent-children
  // relationship.
-  parent: Component<T, any> | null;
-  children: { [key: number]: Component<T, any> };
+  parent: Component<any, T> | null;
+  children: { [key: number]: Component<any, T> };
  // children mapping: from templateID to componentID. templateID identifies a
  // place in a template. The t-component directive needs it to be able to get
  // the component instance back whenever the template is rerendered.
@@ -84,7 +88,7 @@ interface Internal<T extends Env, Props> {
  willStartCB: Function | null;
  willUpdatePropsCB: Function | null;
  classObj: { [key: string]: boolean } | null;
-  refs: { [key: string]: Component<T, any> | HTMLElement | undefined } | null;
+  refs: { [key: string]: Component<any, T> | HTMLElement | undefined } | null;
 }

 export const portalSymbol = Symbol("portal"); // FIXME
@@ -94,18 +98,17 @@ export const portalSymbol = Symbol("portal"); // FIXME
 //------------------------------------------------------------------------------
 let nextId = 1;

-export class Component<T extends Env, Props extends {}> {
-  readonly __owl__: Internal<Env, Props>;
+export class Component<Props extends {} = any, T extends Env = Env> {
+  readonly __owl__: Internal<T>;
  static template?: string | null = null;
  static _template?: string | null = null;
-  static current: Component<any, any> | null = null;
+  static current: Component | null = null;
  static components = {};
  static props?: any;
  static defaultProps?: any;
  static env: any = {};
  // expose scheduler s.t. it can be mocked for testing purposes
  static scheduler: Scheduler = scheduler;
-  __target: HTMLElement | undefined;

  /**
   * The `el` is the root element of the component.  Note that it could be null:
@@ -129,7 +132,7 @@ export class Component<T extends Env, Props extends {}> {
   * hand.  Other components should be created automatically by the framework (with
   * the t-component directive in a template)
   */
-  constructor(parent?: Component<T, any> | null, props?: Props) {
+  constructor(parent?: Component<any, T> | null, props?: Props) {
    Component.current = this;

    let constr = this.constructor as any;
@@ -156,6 +159,9 @@ export class Component<T extends Env, Props extends {}> {
      if (!this.env.qweb) {
        this.env.qweb = new QWeb();
      }
+      if (!this.env.browser) {
+        this.env.browser = browser;
+      }
      this.env.qweb.on("update", this, () => {
        if (this.__owl__.isMounted) {
          this.render(true);
@@ -197,8 +203,11 @@ export class Component<T extends Env, Props extends {}> {
      renderFn: qweb.render.bind(qweb, template),
      classObj: null,
      refs: null,
-      scope: null
+      scope: null,
    };
+    if (constr.style) {
+      this.__applyStyles(constr);
+    }
  }

  /**
@@ -298,23 +307,32 @@ export class Component<T extends Env, Props extends {}> {
    const position = options.position || "last-child";
    const __owl__ = this.__owl__;
    if (__owl__.isMounted) {
-      return Promise.resolve();
+      if (position !== "self" && this.el!.parentNode !== target) {
+        // in this situation, we are trying to mount a component on a different
+        // target. In this case, we need to unmount first, otherwise it will
+        // not work.
+        this.unmount();
+      } else {
+        return Promise.resolve();
+      }
+    }
+    if (__owl__.isDestroyed) {
+      throw new Error("Cannot mount a destroyed component");
+    }
+    if (__owl__.currentFiber) {
+      const currentFiber = __owl__.currentFiber;
+      if (currentFiber.target === target && currentFiber.position === position) {
+        return scheduler.addFiber(currentFiber);
+      } else {
+        scheduler.rejectFiber(currentFiber, "Mounting operation cancelled");
+      }
    }
    if (!(target instanceof HTMLElement || target instanceof DocumentFragment)) {
      let message = `Component '${this.constructor.name}' cannot be mounted: the target is not a valid DOM node.`;
      message += `\nMaybe the DOM is not ready yet? (in that case, you can use owl.utils.whenReady)`;
      throw new Error(message);
    }
-    let inserter =
-      position === "last-child"
-        ? el => target.appendChild(el)
-        : position === "first-child"
-        ? el => target.prepend(el)
-        : el => {};
-    if (position === "self") {
-      this.__target = target as HTMLElement;
-    }
-    const fiber = new Fiber(null, this, false, inserter);
+    const fiber = new Fiber(null, this, false, target, position);
    fiber.shouldPatch = false;
    if (!__owl__.vnode) {
      this.__prepareAndRender(fiber, () => {});
@@ -346,22 +364,26 @@ export class Component<T extends Env, Props extends {}> {
   */
  async render(force: boolean = false): Promise<void> {
    const __owl__ = this.__owl__;
-    if (!__owl__.isMounted && !__owl__.currentFiber) {
+    const currentFiber = __owl__.currentFiber;
+    if (!__owl__.isMounted && !currentFiber) {
      // if we get here, this means that the component was either never mounted,
      // or was unmounted and some state change  triggered a render. Either way,
      // we do not want to actually render anything in this case.
      return;
    }
-    if (__owl__.currentFiber && !__owl__.currentFiber.isRendered) {
-      return scheduler.addFiber(__owl__.currentFiber.root);
+    if (currentFiber && !currentFiber.isRendered && !currentFiber.isCompleted) {
+      return scheduler.addFiber(currentFiber.root);
    }
    // if we aren't mounted at this point, it implies that there is a
    // currentFiber that is already rendered (isRendered is true), so we are
    // about to be mounted
    const isMounted = __owl__.isMounted;
-    const fiber = new Fiber(null, this, force, null);
+    const fiber = new Fiber(null, this, force, null, null);
    Promise.resolve().then(() => {
      if (__owl__.isMounted || !isMounted) {
+        if (fiber.isCompleted) {
+          return;
+        }
        // we are mounted (__owl__.isMounted), or if we are currently being
        // mounted (!isMounted), so we call __render
        this.__render(fiber);
@@ -430,7 +452,7 @@ export class Component<T extends Env, Props extends {}> {
   * Note that it does not call the __callWillUnmount method to avoid visiting
   * all children many times.
   */
-  __destroy(parent: Component<any, any> | null) {
+  __destroy(parent: Component | null) {
    const __owl__ = this.__owl__;
    const isMounted = __owl__.isMounted;
    if (isMounted) {
@@ -490,12 +512,12 @@ export class Component<T extends Env, Props extends {}> {
   * Private trigger method, allows to choose the component which triggered
   * the event in the first place
   */
-  __trigger(component: Component<any, any>, eventType: string, payload?: any) {
+  __trigger(component: Component, eventType: string, payload?: any) {
    if (this.el) {
      const ev = new OwlEvent(component, eventType, {
        bubbles: true,
        cancelable: true,
-        detail: payload
+        detail: payload,
      });
      const triggerHook = this.env[portalSymbol as any];
      if (triggerHook) {
@@ -513,7 +535,7 @@ export class Component<T extends Env, Props extends {}> {
    const shouldUpdate = parentFiber.force || this.shouldUpdate(nextProps);
    if (shouldUpdate) {
      const __owl__ = this.__owl__;
-      const fiber = new Fiber(parentFiber, this, parentFiber.force, null);
+      const fiber = new Fiber(parentFiber, this, parentFiber.force, null, null);
      if (!parentFiber.child) {
        parentFiber.child = fiber;
      } else {
@@ -530,7 +552,7 @@ export class Component<T extends Env, Props extends {}> {
      }
      await Promise.all([
        this.willUpdateProps(nextProps),
-        __owl__.willUpdatePropsCB && __owl__.willUpdatePropsCB(nextProps)
+        __owl__.willUpdatePropsCB && __owl__.willUpdatePropsCB(nextProps),
      ]);
      if (fiber.isCompleted) {
        return;
@@ -545,20 +567,8 @@ export class Component<T extends Env, Props extends {}> {
   * Main patching method. We call the virtual dom patch method here to convert
   * a virtual dom vnode into some actual dom.
   */
-  __patch(vnode: VNode) {
-    const __owl__ = this.__owl__;
-    if (this.__target) {
-      if (this.__target.tagName.toLowerCase() !== vnode.sel) {
-        throw new Error(
-          `Cannot attach '${this.constructor.name}' to target node (not same tag name)`
-        );
-      }
-      __owl__.vnode = patch(this.__target, vnode);
-      delete this.__target;
-    } else {
-      const target = __owl__.vnode || document.createElement(vnode.sel!);
-      __owl__.vnode = patch(target, vnode);
-    }
+  __patch(target: HTMLElement | VNode | DocumentFragment, vnode: VNode) {
+    this.__owl__.vnode = patch(target as any, vnode);
  }

  /**
@@ -568,7 +578,7 @@ export class Component<T extends Env, Props extends {}> {
   */
  __prepare(parentFiber: Fiber, scope: any, cb: CallableFunction): Fiber {
    this.__owl__.scope = scope;
-    const fiber = new Fiber(parentFiber, this, parentFiber.force, null);
+    const fiber = new Fiber(parentFiber, this, parentFiber.force, null, null);
    fiber.shouldPatch = false;
    if (!parentFiber.child) {
      parentFiber.child = fiber;
@@ -580,6 +590,20 @@ export class Component<T extends Env, Props extends {}> {
    return fiber;
  }

+  /**
+   * Apply the stylesheets defined by the component. Note that we need to make
+   * sure all inherited stylesheets are applied as well.  We then delete the
+   * `style` key from the constructor to make sure we do not apply it again.
+   */
+  private __applyStyles(constr) {
+    while (constr && constr.style) {
+      if (constr.hasOwnProperty("style")) {
+        activateSheet(constr.style, constr.name);
+        delete constr.style;
+      }
+      constr = constr.__proto__;
+    }
+  }
  __getTemplate(qweb: QWeb): string {
    let p = (<any>this).constructor;
    if (!p.hasOwnProperty("_template")) {
@@ -587,9 +611,10 @@ export class Component<T extends Env, Props extends {}> {
      // key. So we fall back on looking for a template matching its name (or
      // one of its subclass).

-      let template: string;
-      while ((template = p.name) && !(template in qweb.templates) && p !== Component) {
+      let template: string = p.name;
+      while (!(template in qweb.templates) && p !== Component) {
        p = p.__proto__;
+        template = p.name;
      }
      if (p === Component) {
        throw new Error(`Could not find template for component "${this.constructor.name}"`);
@@ -624,7 +649,7 @@ export class Component<T extends Env, Props extends {}> {
    try {
      let vnode = __owl__.renderFn!(this, {
        handlers: __owl__.boundHandlers,
-        fiber: fiber
+        fiber: fiber,
      });
      // we iterate over the children to detect those that no longer belong to the
      // current rendering: those ones, if not mounted yet, can (and have to) be
@@ -7,7 +7,7 @@ import { makeHandlerCode, MODS_CODE } from "../qweb/extensions";
 //------------------------------------------------------------------------------

 const T_COMPONENT_MODS_CODE = Object.assign({}, MODS_CODE, {
-  self: "if (e.target !== vn.elm) {return}"
+  self: "if (e.target !== vn.elm) {return}",
 });

 QWeb.utils.defineProxy = function defineProxy(target, source) {
@@ -18,11 +18,31 @@ QWeb.utils.defineProxy = function defineProxy(target, source) {
      },
      set(val) {
        source[k] = val;
-      }
+      },
    });
  }
 };

+QWeb.utils.assignHooks = function assignHooks(dataObj, hooks) {
+  if ("hook" in dataObj) {
+    const hookObject = dataObj.hook;
+    for (let name in hooks) {
+      const current = hookObject[name];
+      const fn = hooks[name];
+      if (current) {
+        hookObject[name] = (...args) => {
+          current(...args);
+          fn(...args);
+        };
+      } else {
+        hookObject[name] = fn;
+      }
+    }
+  } else {
+    dataObj.hook = hooks;
+  }
+};
+
 /**
 * The t-component directive is certainly a complicated and hard to maintain piece
 * of code.  To help you, fellow developer, if you have to maintain it, I offer
@@ -211,14 +231,14 @@ QWeb.addDirective({
      } else if (!name.startsWith("t-")) {
        if (name !== "class" && name !== "style") {
          // this is a prop!
-          props[name] = ctx.formatExpression(value);
+          props[name] = ctx.formatExpression(value) || "undefined";
        }
      }
    }

    // computing the props string representing the props object
    let propStr = Object.keys(props)
-      .map(k => k + ":" + props[k])
+      .map((k) => k + ":" + props[k])
      .join(",");
    let componentID = ctx.generateID();

@@ -260,7 +280,7 @@ QWeb.addDirective({
        let classDef = classAttr
          .trim()
          .split(/\s+/)
-          .map(a => `'${a}':true`)
+          .map((a) => `'${a}':true`)
          .join(",");
        classObj = `_${ctx.generateID()}`;
        ctx.addLine(`let ${classObj} = {${classDef}};`);
@@ -278,7 +298,9 @@ QWeb.addDirective({
        }
      }
      let eventsCode = events
-        .map(function([name, value]) {
+        .map(function ([name, value]) {
+          const capture = name.match(/\.capture/);
+          name = capture ? name.replace(/\.capture/, "") : name;
          const { event, handler } = makeHandlerCode(
            ctx,
            name,
@@ -286,12 +308,15 @@ QWeb.addDirective({
            false,
            T_COMPONENT_MODS_CODE
          );
+          if (capture) {
+            return `vn.elm.addEventListener('${event}', ${handler}, true);`;
+          }
          return `vn.elm.addEventListener('${event}', ${handler});`;
        })
        .join("");
      const styleExpr = tattStyle || (styleAttr ? `'${styleAttr}'` : false);
      const styleCode = styleExpr ? `vn.elm.style = ${styleExpr};` : "";
-      createHook = `vnode.data.hook = {create(_, vn){${styleCode}${eventsCode}}};`;
+      createHook = `utils.assignHooks(vnode.data, {create(_, vn){${styleCode}${eventsCode}}});`;
    }

    ctx.addLine(
@@ -368,22 +393,43 @@ QWeb.addDirective({
    if (transition) {
      ctx.addLine(`const __patch${componentID} = w${componentID}.__patch;`);
      ctx.addLine(
-        `w${componentID}.__patch = fiber => {__patch${componentID}.call(w${componentID}, fiber); if(!w${componentID}.__owl__.transitionInserted){w${componentID}.__owl__.transitionInserted = true;utils.transitionInsert(w${componentID}.__owl__.vnode, '${transition}');}};`
+        `w${componentID}.__patch = (t, vn) => {__patch${componentID}.call(w${componentID}, t, vn); if(!w${componentID}.__owl__.transitionInserted){w${componentID}.__owl__.transitionInserted = true;utils.transitionInsert(w${componentID}.__owl__.vnode, '${transition}');}};`
      );
    }
    ctx.addLine(`parent.__owl__.cmap[${templateKey}] = w${componentID}.__owl__.id;`);

    if (hasSlots) {
      const clone = <Element>node.cloneNode(true);
-      const slotNodes = clone.querySelectorAll("[t-set]");
+      const slotNodes = Array.from(clone.querySelectorAll("[t-set-slot]"));
+
+      // The next code is a fallback for compatibility reason. It accepts t-set
+      // elements that are direct children with a non empty body as nodes defining
+      // the content of a slot.
+      //
+      // This is wrong, but is necessary to prevent breaking all existing Owl
+      // code using slots. This will be removed in v2.0 someday. Meanwhile,
+      // please use t-set-slot everywhere you need to set the content of a
+      // slot.
+      for (let el of clone.children) {
+        if (el.getAttribute("t-set") && el.hasChildNodes()) {
+          slotNodes.push(el);
+        }
+      }
      const slotId = QWeb.nextSlotId++;
      ctx.addLine(`w${componentID}.__owl__.slotId = ${slotId};`);
      if (slotNodes.length) {
        for (let i = 0, length = slotNodes.length; i < length; i++) {
          const slotNode = slotNodes[i];
          slotNode.parentElement!.removeChild(slotNode);
-          const key = slotNode.getAttribute("t-set")!;
-          slotNode.removeAttribute("t-set");
+          let key = slotNode.getAttribute("t-set-slot")!;
+          slotNode.removeAttribute("t-set-slot");
+
+          // here again, this code should be removed when we stop supporting
+          // using t-set to define the content of named slots.
+          if (!key) {
+            key = slotNode.getAttribute("t-set")!;
+            slotNode.removeAttribute("t-set");
+          }
          const slotFn = qweb._compile(`slot_${key}_template`, slotNode, ctx);
          QWeb.slots[`${slotId}_${key}`] = slotFn;
        }
@@ -423,5 +469,5 @@ QWeb.addDirective({
    ctx.addLine(`w${componentID}.__owl__.parentLastFiberId = extra.fiber.id;`);

    return true;
-  }
+  },
 });
@@ -1,5 +1,5 @@
 import { h, VNode } from "../vdom/index";
-import { Component } from "./component";
+import { Component, MountPosition } from "./component";
 import { scheduler } from "./scheduler";

 /**
@@ -46,11 +46,12 @@ export class Fiber {
  // scheduler.
  counter: number = 0;

-  inserter: (el: HTMLElement) => void | null;
+  target: HTMLElement | DocumentFragment | null;
+  position: MountPosition | null;

  scope: any;

-  component: Component<any, any>;
+  component: Component;
  vnode: VNode | null = null;

  root: Fiber;
@@ -61,10 +62,17 @@ export class Fiber {

  error?: Error;

-  constructor(parent: Fiber | null, component: Component<any, any>, force, inserter) {
+  constructor(
+    parent: Fiber | null,
+    component: Component,
+    force: boolean,
+    target: HTMLElement | DocumentFragment | null,
+    position: MountPosition | null
+  ) {
    this.component = component;
    this.force = force;
-    this.inserter = inserter;
+    this.target = target;
+    this.position = position;

    const __owl__ = component.__owl__;
    this.scope = __owl__.scope;
@@ -179,13 +187,13 @@ export class Fiber {
  complete() {
    let component = this.component;
    this.isCompleted = true;
-    if (!this.inserter && !component.__owl__.isMounted) {
+    if (!this.target && !component.__owl__.isMounted) {
      return;
    }

    // build patchQueue
    const patchQueue: Fiber[] = [];
-    const doWork: (Fiber) => Fiber | null = function(f) {
+    const doWork: (Fiber) => Fiber | null = function (f) {
      patchQueue.push(f);
      return f.child;
    };
@@ -208,17 +216,47 @@ export class Fiber {
    for (let i = patchLen - 1; i >= 0; i--) {
      const fiber = patchQueue[i];
      component = fiber.component;
-      component.__patch(fiber.vnode!);
-      if (!fiber.shouldPatch && (!fiber.inserter || i !== 0)) {
-        component.__owl__.pvnode!.elm = component.__owl__.vnode!.elm;
+      if (fiber.target && i === 0) {
+        let target;
+        if (fiber.position === "self") {
+          target = fiber.target;
+          if ((target as HTMLElement).tagName.toLowerCase() !== fiber.vnode!.sel) {
+            throw new Error(
+              `Cannot attach '${component.constructor.name}' to target node (not same tag name)`
+            );
+          }
+          // In self mode, we *know* we are to take possession of the target
+          // Hence we manually create the corresponding VNode and copy the "key" in data
+          const selfVnodeData = fiber.vnode!.data ? { key: fiber.vnode!.data.key } : {};
+          const selfVnode = h(fiber.vnode!.sel, selfVnodeData);
+          selfVnode.elm = target;
+          target = selfVnode;
+        } else {
+          target = component.__owl__.vnode || document.createElement(fiber.vnode!.sel!);
+        }
+        component.__patch(target!, fiber.vnode!);
+      } else {
+        if (fiber.shouldPatch) {
+          component.__patch(component.__owl__.vnode!, fiber.vnode!);
+        } else {
+          component.__patch(document.createElement(fiber.vnode!.sel!), fiber.vnode!);
+          component.__owl__.pvnode!.elm = component.__owl__.vnode!.elm;
+        }
      }
      component.__owl__.currentFiber = null;
    }

    // insert into the DOM (mount case)
    let inDOM = false;
-    if (this.inserter) {
-      this.inserter(this.component.el!);
+    if (this.target) {
+      switch (this.position) {
+        case "first-child":
+          this.target.prepend(this.component.el!);
+          break;
+        case "last-child":
+          this.target.appendChild(this.component.el!);
+          break;
+      }
      inDOM = document.body.contains(this.component.el);
      this.component.env.qweb.trigger("dom-appended");
    }
@@ -227,12 +265,12 @@ export class Fiber {
    for (let i = patchLen - 1; i >= 0; i--) {
      const fiber = patchQueue[i];
      component = fiber.component;
-      if (fiber.shouldPatch && !this.inserter) {
+      if (fiber.shouldPatch && !this.target) {
        component.patched();
        if (component.__owl__.patchedCB) {
          component.__owl__.patchedCB();
        }
-      } else if (this.inserter ? inDOM : true) {
+      } else if (this.target ? inDOM : true) {
        component.__callMounted();
      }
    }
@@ -242,7 +280,7 @@ export class Fiber {
   * Cancel a fiber and all its children.
   */
  cancel() {
-    this._walk(f => {
+    this._walk((f) => {
      if (!f.isRendered) {
        f.root.counter--;
      }
@@ -11,7 +11,7 @@ import { QWeb } from "../qweb/index";
 * This is why it is only done in 'dev' mode.
 */

-QWeb.utils.validateProps = function(Widget, props: Object) {
+QWeb.utils.validateProps = function (Widget, props: Object) {
  const propsDef = (<any>Widget).props;
  if (propsDef instanceof Array) {
    // list of strings (prop names)
@@ -1,4 +1,5 @@
 import { Fiber } from "./fiber";
+import { browser } from "../browser";

 /**
 * Owl Scheduler Class
@@ -19,9 +20,9 @@ interface Task {
 export class Scheduler {
  tasks: Task[] = [];
  isRunning: boolean = false;
-  requestAnimationFrame: typeof window.requestAnimationFrame;
+  requestAnimationFrame: Window["requestAnimationFrame"];

-  constructor(requestAnimationFrame) {
+  constructor(requestAnimationFrame: Window["requestAnimationFrame"]) {
    this.requestAnimationFrame = requestAnimationFrame;
  }

@@ -34,7 +35,7 @@ export class Scheduler {
    this.isRunning = false;
  }

-  addFiber(fiber): Promise<void> {
+  addFiber(fiber: Fiber): Promise<void> {
    // if the fiber was remapped into a larger rendering fiber, it may not be a
    // root fiber.  But we only want to register root fibers
    fiber = fiber.root;
@@ -49,7 +50,7 @@ export class Scheduler {
            return reject(fiber.error);
          }
          resolve();
-        }
+        },
      });
      if (!this.isRunning) {
        this.start();
@@ -57,6 +58,17 @@ export class Scheduler {
    });
  }

+  rejectFiber(fiber: Fiber, reason: string) {
+    fiber = fiber.root;
+    const index = this.tasks.findIndex((t) => t.fiber === fiber);
+    if (index >= 0) {
+      const [task] = this.tasks.splice(index, 1);
+      fiber.cancel();
+      fiber.error = new Error(reason);
+      task.callback();
+    }
+  }
+
  /**
   * Process all current tasks. This only applies to the fibers that are ready.
   * Other tasks are left unchanged.
@@ -64,7 +76,7 @@ export class Scheduler {
  flush() {
    let tasks = this.tasks;
    this.tasks = [];
-    tasks = tasks.filter(task => {
+    tasks = tasks.filter((task) => {
      if (task.fiber.isCompleted) {
        task.callback();
        return false;
@@ -98,5 +110,4 @@ export class Scheduler {
  }
 }

-const raf = window.requestAnimationFrame.bind(window);
-export const scheduler = new Scheduler(raf);
+export const scheduler = new Scheduler(browser.requestAnimationFrame);
@@ -0,0 +1,70 @@
+/**
+ * Owl Style System
+ *
+ * This files contains the Owl code related to processing (extended) css strings
+ * and creating/adding <style> tags to the document head.
+ */
+
+export const STYLESHEETS: { [id: string]: HTMLStyleElement } = {};
+
+export 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");
+}
+export function registerSheet(id: string, css: string) {
+  const sheet = document.createElement("style");
+  sheet.innerHTML = processSheet(css);
+  STYLESHEETS[id] = sheet;
+}
+
+export function activateSheet(id, name) {
+  const sheet = STYLESHEETS[id];
+  if (!sheet) {
+    throw new Error(
+      `Invalid css stylesheet for component '${name}'. Did you forget to use the 'css' tag helper?`
+    );
+  }
+  sheet.setAttribute("component", name);
+  document.head.appendChild(sheet);
+}
@@ -26,5 +26,5 @@ Object.defineProperty(config, "mode", {
    } else {
      console.log(`Owl is now running in 'prod' mode.`);
    }
-  }
+  },
 });
@@ -79,9 +79,9 @@ export class Context extends EventBus {
  async __notifyComponents() {
    const rev = ++this.rev;
    const subscriptions = this.subscriptions.update;
-    const groups = partitionBy(subscriptions, s => (s.owner ? s.owner.__owl__.depth : -1));
+    const groups = partitionBy(subscriptions, (s) => (s.owner ? s.owner.__owl__.depth : -1));
    for (let group of groups) {
-      const proms = group.map(sub => sub.callback.call(sub.owner, rev));
+      const proms = group.map((sub) => sub.callback.call(sub.owner, rev));
      // at this point, each component in the current group has registered a
      // top level fiber in the scheduler. It could happen that rendering these
      // components is done (if they have no children).  This is why we manually
@@ -100,11 +100,11 @@ export class Context extends EventBus {
 * to context state changes. The `useContext` method returns the context state
 */
 export function useContext(ctx: Context): any {
-  const component: Component<any, any> = Component.current!;
+  const component: Component = Component.current!;
  return useContextWithCB(ctx, component, component.render.bind(component));
 }

-export function useContextWithCB(ctx: Context, component: Component<any, any>, method): any {
+export function useContextWithCB(ctx: Context, component: Component, method): any {
  const __owl__ = component.__owl__;
  const id = __owl__.id;
  const mapping = ctx.mapping;
@@ -116,7 +116,7 @@ export function useContextWithCB(ctx: Context, component: Component<any, any>, m
    __owl__.observer.notifyCB = component.render.bind(component);
  }
  const currentCB = __owl__.observer.notifyCB;
-  __owl__.observer.notifyCB = function() {
+  __owl__.observer.notifyCB = function () {
    if (ctx.rev > mapping[id]) {
      // in this case, the context has been updated since we were rendering
      // last, and we do not need to render here with the observer. A
@@ -128,18 +128,18 @@ export function useContextWithCB(ctx: Context, component: Component<any, any>, m

  mapping[id] = 0;
  const renderFn = __owl__.renderFn;
-  __owl__.renderFn = function(comp, params) {
+  __owl__.renderFn = function (comp, params) {
    mapping[id] = ctx.rev;
    return renderFn(comp, params);
  };
-  ctx.on("update", component, async contextRev => {
+  ctx.on("update", component, async (contextRev) => {
    if (mapping[id] < contextRev) {
      mapping[id] = contextRev;
      await method();
    }
  });
  const __destroy = component.__destroy;
-  component.__destroy = parent => {
+  component.__destroy = (parent) => {
    ctx.off("update", component);
    delete mapping[id];
    __destroy.call(component, parent);
@@ -44,7 +44,7 @@ export class EventBus {
    }
    this.subscriptions[eventType].push({
      owner,
-      callback
+      callback,
    });
  }

@@ -54,7 +54,7 @@ export class EventBus {
  off(eventType: string, owner: any) {
    const subs = this.subscriptions[eventType];
    if (subs) {
-      this.subscriptions[eventType] = subs.filter(s => s.owner !== owner);
+      this.subscriptions[eventType] = subs.filter((s) => s.owner !== owner);
    }
  }

@@ -67,14 +67,14 @@ export class Observer {
          self.notifyCB();
        }
        return true;
-      }
+      },
    });

    const metadata = {
      value,
      proxy,
      rev: this.rev,
-      parent
+      parent,
    };

    this.weakMap.set(value, metadata);
@@ -7,7 +7,7 @@ import { Component } from "../component/component";
 */

 export class OwlEvent<T> extends CustomEvent<T> {
-  originalComponent: Component<any, any>;
+  originalComponent: Component;
  constructor(component, eventType, options) {
    super(eventType, options);
    this.originalComponent = component;
@@ -22,7 +22,7 @@ import { Observer } from "./core/observer";
 * trigger a rerendering of the current component.
 */
 export function useState<T>(state: T): T {
-  const component: Component<any, any> = Component.current!;
+  const component: Component = Component.current!;
  const __owl__ = component.__owl__;
  if (!__owl__.observer) {
    __owl__.observer = new Observer();
@@ -36,11 +36,11 @@ export function useState<T>(state: T): T {
 // -----------------------------------------------------------------------------
 function makeLifecycleHook(method: string, reverse: boolean = false) {
  if (reverse) {
-    return function(cb) {
-      const component: Component<any, any> = Component.current!;
+    return function (cb) {
+      const component: Component = Component.current!;
      if (component.__owl__[method]) {
        const current = component.__owl__[method];
-        component.__owl__[method] = function() {
+        component.__owl__[method] = function () {
          current.call(component);
          cb.call(component);
        };
@@ -49,11 +49,11 @@ function makeLifecycleHook(method: string, reverse: boolean = false) {
      }
    };
  } else {
-    return function(cb) {
-      const component: Component<any, any> = Component.current!;
+    return function (cb) {
+      const component: Component = Component.current!;
      if (component.__owl__[method]) {
        const current = component.__owl__[method];
-        component.__owl__[method] = function() {
+        component.__owl__[method] = function () {
          cb.call(component);
          current.call(component);
        };
@@ -65,12 +65,12 @@ function makeLifecycleHook(method: string, reverse: boolean = false) {
 }

 function makeAsyncHook(method: string) {
-  return function(cb) {
-    const component: Component<any, any> = Component.current!;
+  return function (cb) {
+    const component: Component = Component.current!;
    if (component.__owl__[method]) {
      const current = component.__owl__[method];
-      component.__owl__[method] = function(...args) {
-        return Promise.all[(current.call(component, ...args), cb.call(component, ...args))];
+      component.__owl__[method] = function (...args) {
+        return Promise.all([current.call(component, ...args), cb.call(component, ...args)]);
      };
    } else {
      component.__owl__[method] = cb;
@@ -94,12 +94,12 @@ export const onWillUpdateProps = makeAsyncHook("willUpdatePropsCB");
 * The purpose of this hook is to allow components to get a reference to a sub
 * html node or component.
 */
-interface Ref {
+interface Ref<C extends Component = Component> {
  el: HTMLElement | null;
-  comp: Component<any, any> | null;
+  comp: C | null;
 }

-export function useRef(name: string): Ref {
+export function useRef<C extends Component = Component>(name: string): Ref<C> {
  const __owl__ = Component.current!.__owl__;
  return {
    get el(): HTMLElement | null {
@@ -111,10 +111,10 @@ export function useRef(name: string): Ref {
      }
      return null;
    },
-    get comp(): Component<any, any> | null {
+    get comp(): C | null {
      const val = __owl__.refs && __owl__.refs[name];
-      return val instanceof Component ? val : null;
-    }
+      return val instanceof Component ? (val as C) : null;
+    },
  };
 }

@@ -131,3 +131,32 @@ export function useSubEnv(nextEnv) {
  const component = Component.current!;
  component.env = Object.assign(Object.create(component.env), nextEnv);
 }
+
+// -----------------------------------------------------------------------------
+// useExternalListener
+// -----------------------------------------------------------------------------
+
+/**
+ * When a component needs to listen to DOM Events on element(s) that are not
+ * part of his hierarchy, we can use the `useExternalListener` hook.
+ * It will correctly add and remove the event listener, whenever the
+ * component is mounted and unmounted.
+ *
+ * Example:
+ *  a menu needs to listen to the click on window to be closed automatically
+ *
+ * Usage:
+ *  in the constructor of the OWL component that needs to be notified,
+ *  `useExternalListener(window, 'click', this._doSomething);`
+ * */
+export function useExternalListener(
+  target: HTMLElement | typeof window,
+  eventName: string,
+  handler,
+  eventParams?
+) {
+  const boundHandler = handler.bind(Component.current);
+
+  onMounted(() => target.addEventListener(eventName, boundHandler, eventParams));
+  onWillUnmount(() => target.removeEventListener(eventName, boundHandler, eventParams));
+}
@@ -35,6 +35,6 @@ export const hooks = Object.assign({}, _hooks, {
  useContext: _context.useContext,
  useDispatch: _store.useDispatch,
  useGetters: _store.useGetters,
-  useStore: _store.useStore
+  useStore: _store.useStore,
 });
 export const __info__ = {};
@@ -10,7 +10,7 @@ import { xml } from "../tags";
 * from this coordination.  This is the goal of the AsyncRoot component.
 */

-export class AsyncRoot extends Component<any, any> {
+export class AsyncRoot extends Component {
  static template = xml`<t t-slot="default"/>`;

  async __updateProps(nextProps, parentFiber) {
@@ -18,12 +18,16 @@ import { useSubEnv } from "../hooks";
 * are re-triggered on an empty <portal> node located in the parent's DOM.
 */

-export class Portal extends Component<any, any> {
+interface Props {
+  target: string;
+}
+
+export class Portal extends Component<Props> {
  static template = xml`<portal><t t-slot="default"/></portal>`;
  static props = {
    target: {
-      type: String
-    }
+      type: String,
+    },
  };

  // boolean to indicate whether or not we must listen to 'dom-appended' event
@@ -43,7 +47,7 @@ export class Portal extends Component<any, any> {
  // represents the element that is moved somewhere else
  portal: VNode | null = null;
  // the target where we will move `portal`
-  target: HTMLElement | null = null;
+  target: Element | null = null;

  constructor(parent, props) {
    super(parent, props);
@@ -51,12 +55,12 @@ export class Portal extends Component<any, any> {
    // put a callback in the env that is propagated to children s.t. portal can
    // register an handler to those events just before children will trigger them
    useSubEnv({
-      [portalSymbol]: ev => {
+      [portalSymbol]: (ev) => {
        if (!this._handledEvents.has(ev.type)) {
          this.portal!.elm!.addEventListener(ev.type, this._handlerTunnel);
          this._handledEvents.add(ev.type);
        }
-      }
+      },
    });
  }
  /**
@@ -120,7 +124,7 @@ export class Portal extends Component<any, any> {
   *
   * @override
   */
-  __patch(vnode) {
+  __patch(target, vnode) {
    if (this.doTargetLookUp) {
      const target = document.querySelector(this.props.target);
      if (!target) {
@@ -149,7 +153,7 @@ export class Portal extends Component<any, any> {
    this.portal = patch(portalPatch, vnode.children![0] as VNode);
    vnode.children = [];

-    super.__patch(vnode);
+    super.__patch(target, vnode);

    if (shouldDeploy) {
      this.__deployPortal();
@@ -158,7 +162,7 @@ export class Portal extends Component<any, any> {
  /**
   * Override to set the env
   */
-  __trigger(component: Component<any, any>, eventType: string, payload?: any) {
+  __trigger(component: Component, eventType: string, payload?: any) {
    const env = this.env;
    this.env = this.parentEnv;
    super.__trigger(component, eventType, payload);
@@ -1,6 +1,7 @@
 import { CompilationContext } from "./compilation_context";
 import { QWeb } from "./qweb";
 import { htmlToVDOM } from "../vdom/html_to_vdom";
+import { QWebVar } from "./expression_parser";

 /**
 * Owl QWeb Directives
@@ -39,15 +40,16 @@ function compileValueNode(value: any, node: Element, qweb: QWeb, ctx: Compilatio
  let exprID: string;
  if (typeof value === "string") {
    exprID = `_${ctx.generateID()}`;
-    ctx.addLine(`var ${exprID} = ${ctx.formatExpression(value)};`);
+    ctx.addLine(`let ${exprID} = ${ctx.formatExpression(value)};`);
  } else {
    exprID = `scope.${value.id}`;
  }
-  ctx.addIf(`${exprID} || ${exprID} === 0`);
+  ctx.addIf(`${exprID} != null`);

  if (ctx.escaping) {
    let protectID;
    if (value.hasBody) {
+      ctx.rootContext.shouldDefineUtils = true;
      protectID = ctx.startProtectScope();
      ctx.addLine(
        `${exprID} = ${exprID} instanceof utils.VDomArray ? utils.vDomToString(${exprID}) : ${exprID};`
@@ -61,7 +63,7 @@ function compileValueNode(value: any, node: Element, qweb: QWeb, ctx: Compilatio
      let nodeID = ctx.generateID();
      ctx.rootContext.rootNode = nodeID;
      ctx.rootContext.parentTextNode = nodeID;
-      ctx.addLine(`var vn${nodeID} = {text: ${exprID}};`);
+      ctx.addLine(`let vn${nodeID} = {text: ${exprID}};`);
      if (ctx.rootContext.shouldDefineResult) {
        ctx.addLine(`result = vn${nodeID}`);
      }
@@ -95,7 +97,7 @@ QWeb.addDirective({
    let value = ctx.getValue(node.getAttribute("t-esc")!);
    compileValueNode(value, node, qweb, ctx.subContext("escaping", true));
    return true;
-  }
+  },
 });

 QWeb.addDirective({
@@ -105,7 +107,7 @@ QWeb.addDirective({
    let value = ctx.getValue(node.getAttribute("t-raw")!);
    compileValueNode(value, node, qweb, ctx);
    return true;
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -119,7 +121,7 @@ QWeb.addDirective({
    ctx.rootContext.shouldDefineScope = true;
    const variable = node.getAttribute("t-set")!;
    let value = node.getAttribute("t-value")!;
-    ctx.variables[variable] = ctx.variables[variable] || {};
+    ctx.variables[variable] = ctx.variables[variable] || ({} as QWebVar);
    let qwebvar = ctx.variables[variable];
    const hasBody = node.hasChildNodes();

@@ -127,7 +129,12 @@ QWeb.addDirective({
    qwebvar.expr = `scope.${variable}`;
    if (value) {
      const formattedValue = ctx.formatExpression(value);
-      ctx.addLine(`${qwebvar.expr} = ${formattedValue};`);
+      let scopeExpr = `scope`;
+      if (ctx.protectedScopeNumber) {
+        ctx.rootContext.shouldDefineUtils = true;
+        scopeExpr = `utils.getScope(scope, '${variable}')`;
+      }
+      ctx.addLine(`${scopeExpr}.${variable} = ${formattedValue};`);
      qwebvar.value = formattedValue;
    }

@@ -140,7 +147,7 @@ QWeb.addDirective({
      const _parentNode = ctx.parentNode;
      ctx.parentNode = tempParentNodeID;

-      ctx.addLine(`const c${tempParentNodeID} = new utils.VDomArray();`);
+      ctx.addLine(`let c${tempParentNodeID} = new utils.VDomArray();`);
      const nodeCopy = node.cloneNode(true) as Element;
      for (let attr of ["t-set", "t-value", "t-if", "t-else", "t-elif"]) {
        nodeCopy.removeAttribute(attr);
@@ -157,7 +164,7 @@ QWeb.addDirective({
      }
    }
    return true;
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -173,7 +180,7 @@ QWeb.addDirective({
  },
  finalize({ ctx }) {
    ctx.closeIf();
-  }
+  },
 });

 QWeb.addDirective({
@@ -189,7 +196,7 @@ QWeb.addDirective({
  },
  finalize({ ctx }) {
    ctx.closeIf();
-  }
+  },
 });

 QWeb.addDirective({
@@ -202,7 +209,7 @@ QWeb.addDirective({
  },
  finalize({ ctx }) {
    ctx.closeIf();
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -215,6 +222,7 @@ QWeb.addDirective({
    // Step 1: sanity checks
    // ------------------------------------------------
    ctx.rootContext.shouldDefineScope = true;
+    ctx.rootContext.shouldDefineUtils = true;
    if (node.nodeName !== "t") {
      throw new Error("Invalid tag for t-call directive (should be 't')");
    }
@@ -228,7 +236,7 @@ QWeb.addDirective({
    // ------------------------------------------------
    if (!qweb.subTemplates[subTemplate]) {
      qweb.subTemplates[subTemplate] = true;
-      const subTemplateFn = qweb._compile(subTemplate, nodeTemplate.elem, ctx);
+      const subTemplateFn = qweb._compile(subTemplate, nodeTemplate.elem, ctx, true);
      qweb.subTemplates[subTemplate] = subTemplateFn;
    }

@@ -262,17 +270,17 @@ QWeb.addDirective({
    // Step 4: add the appropriate function call to current component
    // ------------------------------------------------
    const callingScope = hasBody ? "scope" : "Object.assign(Object.create(context), scope)";
+    const parentComponent = `utils.getComponent(context)`;
+    const key = ctx.generateTemplateKey();
+    const parentNode = ctx.parentNode ? `c${ctx.parentNode}` : "result";
+    const extra = `Object.assign({}, extra, {parentNode: ${parentNode}, parent: ${parentComponent}, key: ${key}})`;
    if (ctx.parentNode) {
-      ctx.addLine(
-        `this.subTemplates['${subTemplate}'].call(this, ${callingScope}, Object.assign({}, extra, {parentNode: c${ctx.parentNode}}));`
-      );
+      ctx.addLine(`this.subTemplates['${subTemplate}'].call(this, ${callingScope}, ${extra});`);
    } else {
      // this is a t-call with no parentnode, we need to extract the result
      ctx.rootContext.shouldDefineResult = true;
      ctx.addLine(`result = []`);
-      ctx.addLine(
-        `this.subTemplates['${subTemplate}'].call(this, ${callingScope}, Object.assign({}, extra, {parentNode: result}));`
-      );
+      ctx.addLine(`this.subTemplates['${subTemplate}'].call(this, ${callingScope}, ${extra});`);
      ctx.addLine(`result = result[0]`);
    }

@@ -285,7 +293,7 @@ QWeb.addDirective({
    }

    return true;
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -301,17 +309,17 @@ QWeb.addDirective({
    const elems = node.getAttribute("t-foreach")!;
    const name = node.getAttribute("t-as")!;
    let arrayID = ctx.generateID();
-    ctx.addLine(`var _${arrayID} = ${ctx.formatExpression(elems)};`);
+    ctx.addLine(`let _${arrayID} = ${ctx.formatExpression(elems)};`);
    ctx.addLine(`if (!_${arrayID}) { throw new Error('QWeb error: Invalid loop expression')}`);
    let keysID = ctx.generateID();
    let valuesID = ctx.generateID();
-    ctx.addLine(`var _${keysID} = _${valuesID} = _${arrayID};`);
+    ctx.addLine(`let _${keysID} = _${valuesID} = _${arrayID};`);
    ctx.addIf(`!(_${arrayID} instanceof Array)`);
    ctx.addLine(`_${keysID} = Object.keys(_${arrayID});`);
    ctx.addLine(`_${valuesID} = Object.values(_${arrayID});`);
    ctx.closeIf();
-    ctx.addLine(`var _length${keysID} = _${keysID}.length;`);
-    let varsID = ctx.startProtectScope();
+    ctx.addLine(`let _length${keysID} = _${keysID}.length;`);
+    let varsID = ctx.startProtectScope(true);
    const loopVar = `i${ctx.loopNumber}`;
    ctx.addLine(`for (let ${loopVar} = 0; ${loopVar} < _length${keysID}; ${loopVar}++) {`);
    ctx.indent();
@@ -332,6 +340,13 @@ QWeb.addDirective({
        `Directive t-foreach should always be used with a t-key! (in template: '${ctx.templateName}')`
      );
    }
+    if (nodeCopy.hasAttribute("t-key")) {
+      const expr = ctx.formatExpression(nodeCopy.getAttribute("t-key")!);
+      ctx.addLine(`let key${ctx.loopNumber} = ${expr};`);
+      nodeCopy.removeAttribute("t-key");
+    } else {
+      ctx.addLine(`let key${ctx.loopNumber} = i${ctx.loopNumber};`);
+    }

    nodeCopy.removeAttribute("t-foreach");
    qweb._compileNode(nodeCopy, ctx);
@@ -339,7 +354,7 @@ QWeb.addDirective({
    ctx.addLine("}");
    ctx.stopProtectScope(varsID);
    return true;
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -350,7 +365,7 @@ QWeb.addDirective({
  priority: 1,
  atNodeEncounter({ ctx }) {
    ctx.addLine("debugger;");
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -362,5 +377,5 @@ QWeb.addDirective({
  atNodeEncounter({ ctx, value }) {
    const expr = ctx.formatExpression(value);
    ctx.addLine(`console.log(${expr})`);
-  }
+  },
 });
@@ -1,4 +1,4 @@
-import { compileExpr, QWebVar } from "./expression_parser";
+import { compileExpr, compileExprToArray, QWebVar } from "./expression_parser";

 export const INTERP_REGEXP = /\{\{.*?\}\}/g;
 //------------------------------------------------------------------------------
@@ -17,6 +17,7 @@ export class CompilationContext {
  rootContext: CompilationContext;
  shouldDefineParent: boolean = false;
  shouldDefineScope: boolean = false;
+  protectedScopeNumber: number = 0;
  shouldDefineQWeb: boolean = false;
  shouldDefineUtils: boolean = false;
  shouldDefineRefs: boolean = false;
@@ -26,12 +27,13 @@ export class CompilationContext {
  templateName: string;
  allowMultipleRoots: boolean = false;
  hasParentWidget: boolean = false;
-  currentKey: string = "";
+  hasKey0: boolean = false;
+  keyStack: boolean[] = [];

  constructor(name?: string) {
    this.rootContext = this;
    this.templateName = name || "noname";
-    this.addLine("var h = this.h;");
+    this.addLine("let h = this.h;");
  }

  generateID(): number {
@@ -48,20 +50,15 @@ export class CompilationContext {
   */
  generateTemplateKey(prefix: string = ""): string {
    const id = this.generateID();
-    if (this.loopNumber === 0 && !this.currentKey) {
+    if (this.loopNumber === 0 && !this.hasKey0) {
      return `'${prefix}__${id}__'`;
    }
-    let locationExpr = `\`${prefix}__${id}__`;
-    for (let i = 0; i < this.loopNumber - 1; i++) {
-      locationExpr += `\${i${i + 1}}__`;
-    }
-    if (this.currentKey) {
-      const k = this.currentKey;
-      this.addLine(`let k${id} = ${locationExpr}\` + ${k};`);
-    } else {
-      locationExpr += this.loopNumber ? `\${i${this.loopNumber}}__\`` : "`";
-      this.addLine(`let k${id} = ${locationExpr};`);
+    let key = `\`${prefix}__${id}__`;
+    let start = this.hasKey0 ? 0 : 1;
+    for (let i = start; i < this.loopNumber + 1; i++) {
+      key += `\${key${i}}__`;
    }
+    this.addLine(`let k${id} = ${key}\`;`);
    return `k${id}`;
  }

@@ -116,11 +113,11 @@ export class CompilationContext {
  }

  indent() {
-    this.indentLevel++;
+    this.rootContext.indentLevel++;
  }

  dedent() {
-    this.indentLevel--;
+    this.rootContext.indentLevel--;
  }

  addLine(line: string): number {
@@ -159,6 +156,24 @@ export class CompilationContext {
    this.rootContext.shouldDefineScope = true;
    return compileExpr(expr, this.variables);
  }
+  captureExpression(expr: string): string {
+    this.rootContext.shouldDefineScope = true;
+    const argId = this.generateID();
+    const tokens = compileExprToArray(expr, this.variables);
+    const done = new Set();
+    return tokens
+      .map((tok) => {
+        if (tok.varName) {
+          if (!done.has(tok.varName)) {
+            done.add(tok.varName);
+            this.addLine(`const ${tok.varName}_${argId} = ${tok.value};`);
+          }
+          tok.value = `${tok.varName}_${argId}`;
+        }
+        return tok.value;
+      })
+      .join("");
+  }

  /**
   * Perform string interpolation on the given string. Note that if the whole
@@ -174,17 +189,23 @@ export class CompilationContext {
      return `(${this.formatExpression(s.slice(2, -2))})`;
    }

-    let r = s.replace(/\{\{.*?\}\}/g, s => "${" + this.formatExpression(s.slice(2, -2)) + "}");
+    let r = s.replace(/\{\{.*?\}\}/g, (s) => "${" + this.formatExpression(s.slice(2, -2)) + "}");
    return "`" + r + "`";
  }
-  startProtectScope(): number {
+  startProtectScope(codeBlock?: boolean): number {
    const protectID = this.generateID();
+    this.rootContext.protectedScopeNumber++;
    this.rootContext.shouldDefineScope = true;
-    this.addLine(`const _origScope${protectID} = scope;`);
-    this.addLine(`scope = Object.assign(Object.create(context), scope);`);
+    const scopeExpr = `Object.create(scope);`;
+    this.addLine(`let _origScope${protectID} = scope;`);
+    this.addLine(`scope = ${scopeExpr}`);
+    if (!codeBlock) {
+      this.addLine(`scope.__access_mode__ = 'ro';`);
+    }
    return protectID;
  }
  stopProtectScope(protectID: number) {
+    this.rootContext.protectedScopeNumber--;
    this.addLine(`scope = _origScope${protectID};`);
  }
 }
@@ -35,7 +35,7 @@ const WORD_REPLACEMENT = {
  gt: ">",
  gte: ">=",
  lt: "<",
-  lte: "<="
+  lte: "<=",
 };

 export interface QWebVar {
@@ -66,6 +66,7 @@ interface Token {
  value: string;
  originalValue?: string;
  size?: number;
+  varName?: string;
 }

 const STATIC_TOKEN_MAP: { [key: string]: TKind } = {
@@ -76,16 +77,16 @@ const STATIC_TOKEN_MAP: { [key: string]: TKind } = {
  ":": "COLON",
  ",": "COMMA",
  "(": "LEFT_PAREN",
-  ")": "RIGHT_PAREN"
+  ")": "RIGHT_PAREN",
 };

 // note that the space after typeof is relevant. It makes sure that the formatted
 // expression has a space after typeof
-const OPERATORS = ".,===,==,+,!==,!=,!,||,&&,>=,>,<=,<,?,-,*,/,%,typeof ,=>,=,;".split(",");
+const OPERATORS = "...,.,===,==,+,!==,!=,!,||,&&,>=,>,<=,<,?,-,*,/,%,typeof ,=>,=,;,in ".split(",");

 type Tokenizer = (expr: string) => Token | false;

-let tokenizeString: Tokenizer = function(expr) {
+let tokenizeString: Tokenizer = function (expr) {
  let s = expr[0];
  let start = s;
  if (s !== "'" && s !== '"') {
@@ -113,7 +114,7 @@ let tokenizeString: Tokenizer = function(expr) {
  return { type: "VALUE", value: s };
 };

-let tokenizeNumber: Tokenizer = function(expr) {
+let tokenizeNumber: Tokenizer = function (expr) {
  let s = expr[0];
  if (s && s.match(/[0-9]/)) {
    let i = 1;
@@ -127,7 +128,7 @@ let tokenizeNumber: Tokenizer = function(expr) {
  }
 };

-let tokenizeSymbol: Tokenizer = function(expr) {
+let tokenizeSymbol: Tokenizer = function (expr) {
  let s = expr[0];
  if (s && s.match(/[a-zA-Z_\$]/)) {
    let i = 1;
@@ -144,7 +145,7 @@ let tokenizeSymbol: Tokenizer = function(expr) {
  }
 };

-const tokenizeStatic: Tokenizer = function(expr) {
+const tokenizeStatic: Tokenizer = function (expr) {
  const char = expr[0];
  if (char && char in STATIC_TOKEN_MAP) {
    return { type: STATIC_TOKEN_MAP[char], value: char };
@@ -152,7 +153,7 @@ const tokenizeStatic: Tokenizer = function(expr) {
  return false;
 };

-const tokenizeOperator: Tokenizer = function(expr) {
+const tokenizeOperator: Tokenizer = function (expr) {
  for (let op of OPERATORS) {
    if (expr.startsWith(op)) {
      return { type: "OPERATOR", value: op };
@@ -166,7 +167,7 @@ const TOKENIZERS = [
  tokenizeNumber,
  tokenizeOperator,
  tokenizeSymbol,
-  tokenizeStatic
+  tokenizeStatic,
 ];

 /**
@@ -234,7 +235,7 @@ export function tokenize(expr: string): Token[] {
 * the arrow operator, then we add the current (or some previous tokens) token to
 * the list of variables so it does not get replaced by a lookup in the context
 */
-export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): string {
+export function compileExprToArray(expr: string, scope: { [key: string]: QWebVar }): Token[] {
  scope = Object.create(scope);
  const tokens = tokenize(expr);
  for (let i = 0; i < tokens.length; i++) {
@@ -269,6 +270,7 @@ export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): st
    }

    if (isVar) {
+      token.varName = token.value;
      if (token.value in scope && "id" in scope[token.value]) {
        token.value = scope[token.value].expr!;
      } else {
@@ -277,5 +279,11 @@ export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): st
      }
    }
  }
-  return tokens.map(t => t.value).join("");
+  return tokens;
+}
+
+export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): string {
+  return compileExprToArray(expr, scope)
+    .map((t) => t.value)
+    .join("");
 }
@@ -23,7 +23,7 @@ import { QWeb } from "./qweb";
 export const MODS_CODE = {
  prevent: "e.preventDefault();",
  self: "if (e.target !== this.elm) {return}",
-  stop: "e.stopPropagation();"
+  stop: "e.stopPropagation();",
 };

 interface HandlerInfo {
@@ -40,14 +40,17 @@ export function makeHandlerCode(
  putInCache: boolean,
  modcodes = MODS_CODE
 ): HandlerInfo {
-  const [event, ...mods] = fullName.slice(5).split(".");
+  let [event, ...mods] = fullName.slice(5).split(".");
+  if (mods.includes("capture")) {
+    event = "!" + event;
+  }
  if (!event) {
    throw new Error("Missing event name with t-on directive");
  }
  let code: string;
  // check if it is a method with no args, a method with args or an expression
  let args: string = "";
-  const name: string = value.replace(/\(.*\)/, function(_args) {
+  const name: string = value.replace(/\(.*\)/, function (_args) {
    args = _args.slice(1, -1);
    return "";
  });
@@ -58,7 +61,7 @@ export function makeHandlerCode(
    ctx.rootContext.shouldDefineUtils = true;
    const comp = `utils.getComponent(context)`;
    if (args) {
-      let argId = ctx.generateID();
+      const argId = ctx.generateID();
      ctx.addLine(`let args${argId} = [${ctx.formatExpression(args)}];`);
      code = `${comp}['${name}'](...args${argId}, e);`;
      putInCache = false;
@@ -67,10 +70,11 @@ export function makeHandlerCode(
    }
  } else {
    // if we get here, then it is an expression
+    // we need to capture every variable in it
    putInCache = false;
-    code = ctx.formatExpression(value);
+    code = ctx.captureExpression(value);
  }
-  const modCode = mods.map(mod => modcodes[mod]).join("");
+  const modCode = mods.map((mod) => modcodes[mod]).join("");
  let handler = `function (e) {if (!context.__owl__.isMounted){return}${modCode}${code}}`;
  if (putInCache) {
    const key = ctx.generateTemplateKey(event);
@@ -86,7 +90,7 @@ QWeb.addDirective({
  atNodeCreation({ ctx, fullName, value, nodeID }) {
    const { event, handler } = makeHandlerCode(ctx, fullName, value, true);
    ctx.addLine(`p${nodeID}.on['${event}'] = ${handler};`);
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -101,17 +105,17 @@ QWeb.addDirective({
    ctx.addLine(`const ${refKey} = ${ctx.interpolate(value)};`);
    addNodeHook("create", `context.__owl__.refs[${refKey}] = n.elm;`);
    addNodeHook("destroy", `delete context.__owl__.refs[${refKey}];`);
-  }
+  },
 });

 //------------------------------------------------------------------------------
 // t-transition
 //------------------------------------------------------------------------------
-QWeb.utils.nextFrame = function(cb: () => void) {
+QWeb.utils.nextFrame = function (cb: () => void) {
  requestAnimationFrame(() => requestAnimationFrame(cb));
 };

-QWeb.utils.transitionInsert = function(vn: VNode, name: string) {
+QWeb.utils.transitionInsert = function (vn: VNode, name: string) {
  const elm = <HTMLElement>vn.elm;
  // remove potential duplicated vnode that is currently being removed, to
  // prevent from having twice the same node in the DOM during an animation
@@ -135,7 +139,7 @@ QWeb.utils.transitionInsert = function(vn: VNode, name: string) {
  });
 };

-QWeb.utils.transitionRemove = function(vn: VNode, name: string, rm: () => void) {
+QWeb.utils.transitionRemove = function (vn: VNode, name: string, rm: () => void) {
  const elm = <HTMLElement>vn.elm;
  elm.setAttribute("data-owl-key", vn.key!);

@@ -179,6 +183,13 @@ function toMs(s: string): number {
 }

 function whenTransitionEnd(elm: HTMLElement, cb) {
+  if (!elm.parentNode) {
+    // if we get here, this means that the element was removed for some other
+    // reasons, and in that case, we don't want to work on animation since nothing
+    // will be displayed anyway.
+    return;
+  }
+
  const styles = window.getComputedStyle(elm);
  const delays: Array<string> = (styles.transitionDelay || "").split(", ");
  const durations: Array<string> = (styles.transitionDuration || "").split(", ");
@@ -198,12 +209,12 @@ QWeb.addDirective({
    let name = value;
    const hooks = {
      insert: `utils.transitionInsert(vn, '${name}');`,
-      remove: `utils.transitionRemove(vn, '${name}', rm);`
+      remove: `utils.transitionRemove(vn, '${name}', rm);`,
    };
    for (let hookName in hooks) {
      addNodeHook(hookName, hooks[hookName]);
    }
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -240,13 +251,13 @@ QWeb.addDirective({
    }
    ctx.closeIf();
    return true;
-  }
+  },
 });

 //------------------------------------------------------------------------------
 // t-model
 //------------------------------------------------------------------------------
-QWeb.utils.toNumber = function(val: string): number | string {
+QWeb.utils.toNumber = function (val: string): number | string {
  const n = parseFloat(val);
  return isNaN(n) ? val : n;
 };
@@ -294,7 +305,7 @@ QWeb.addDirective({
    }
    ctx.addLine(`extra.handlers[${key}] = extra.handlers[${key}] || (${handler});`);
    ctx.addLine(`p${nodeID}.on['${event}'] = extra.handlers[${key}];`);
-  }
+  },
 });

 //------------------------------------------------------------------------------
@@ -303,9 +314,20 @@ QWeb.addDirective({
 QWeb.addDirective({
  name: "key",
  priority: 45,
-  atNodeEncounter({ ctx, value }) {
-    let id = ctx.generateID();
-    ctx.addLine(`const nodeKey${id} = ${ctx.formatExpression(value)};`);
-    ctx.currentKey = `nodeKey${id}`;
-  }
+  atNodeEncounter({ ctx, value, node }) {
+    if (ctx.loopNumber === 0) {
+      ctx.keyStack.push(ctx.rootContext.hasKey0);
+      ctx.rootContext.hasKey0 = true;
+    }
+    ctx.addLine("{");
+    ctx.indent();
+    ctx.addLine(`let key${ctx.loopNumber} = ${ctx.formatExpression(value)};`);
+  },
+  finalize({ ctx }) {
+    ctx.dedent();
+    ctx.addLine("}");
+    if (ctx.loopNumber === 0) {
+      ctx.rootContext.hasKey0 = ctx.keyStack.pop() as boolean;
+    }
+  },
 });
@@ -77,7 +77,7 @@ const NODE_HOOKS_PARAMS = {
  create: "(_, n)",
  insert: "vn",
  remove: "(vn, rm)",
-  destroy: "()"
+  destroy: "()",
 };

 interface Utils {
@@ -86,6 +86,10 @@ interface Utils {
  [key: string]: any;
 }

+function isComponent(obj) {
+  return obj && obj.hasOwnProperty("__owl__");
+}
+
 const UTILS: Utils = {
  zero: Symbol("zero"),
  toObj(expr) {
@@ -108,9 +112,9 @@ const UTILS: Utils = {
    addNS(vnode.data, vnode.children, vnode.sel);
  },
  VDomArray: class VDomArray extends Array {},
-  vDomToString: function(vdom: VNode[]): string {
+  vDomToString: function (vdom: VNode[]): string {
    return vdom
-      .map(vnode => {
+      .map((vnode) => {
        if (vnode.sel) {
          const node = document.createElement(vnode.sel);
          const result = patch(node, vnode);
@@ -119,14 +123,29 @@ const UTILS: Utils = {
          return vnode.text;
        }
      })
-      .join();
+      .join("");
  },
  getComponent(obj) {
-    while (obj && !obj.hasOwnProperty("__owl__")) {
+    while (obj && !isComponent(obj)) {
      obj = obj.__proto__;
    }
    return obj;
-  }
+  },
+  getScope(obj, property: string) {
+    const obj0 = obj;
+    while (
+      obj &&
+      !obj.hasOwnProperty(property) &&
+      !(obj.hasOwnProperty("__access_mode__") && obj.__access_mode__ === "ro")
+    ) {
+      const newObj = obj.__proto__;
+      if (!newObj || isComponent(newObj)) {
+        return obj0;
+      }
+      obj = newObj;
+    }
+    return obj;
+  },
 };

 function parseXML(xml: string): Document {
@@ -159,6 +178,10 @@ function parseXML(xml: string): Document {
  return doc;
 }

+function escapeQuotes(str: string): string {
+  return str.replace(/\'/g, "\\'");
+}
+
 //------------------------------------------------------------------------------
 // QWeb rendering engine
 //------------------------------------------------------------------------------
@@ -172,7 +195,7 @@ export class QWeb extends EventBus {
    name: 1,
    att: 1,
    attf: 1,
-    translation: 1
+    translation: 1,
  };
  static DIRECTIVES: Directive[] = [];

@@ -216,7 +239,7 @@ export class QWeb extends EventBus {
    QWeb.DIRECTIVE_NAMES[directive.name] = 1;
    QWeb.DIRECTIVES.sort((d1, d2) => d1.priority - d2.priority);
    if (directive.extraNames) {
-      directive.extraNames.forEach(n => (QWeb.DIRECTIVE_NAMES[n] = 1));
+      directive.extraNames.forEach((n) => (QWeb.DIRECTIVE_NAMES[n] = 1));
    }
  }

@@ -280,11 +303,11 @@ export class QWeb extends EventBus {
    this._processTemplate(elem);
    const template = {
      elem,
-      fn: function(this: QWeb, context, extra) {
+      fn: function (this: QWeb, context, extra) {
        const compiledFunction = this._compile(name, elem);
        template.fn = compiledFunction;
        return compiledFunction.call(this, context, extra);
-      }
+      },
    };
    this.templates[name] = template;
  }
@@ -294,10 +317,10 @@ export class QWeb extends EventBus {
    for (let i = 0, ilen = tbranch.length; i < ilen; i++) {
      let node = tbranch[i];
      let prevElem = node.previousElementSibling!;
-      let pattr = function(name) {
+      let pattr = function (name) {
        return prevElem.getAttribute(name);
      };
-      let nattr = function(name) {
+      let nattr = function (name) {
        return +!!node.getAttribute(name);
      };
      if (prevElem && (pattr("t-if") || pattr("t-elif"))) {
@@ -307,16 +330,17 @@ export class QWeb extends EventBus {
          );
        }
        if (
-          ["t-if", "t-elif", "t-else"].map(nattr).reduce(function(a, b) {
+          ["t-if", "t-elif", "t-else"].map(nattr).reduce(function (a, b) {
            return a + b;
          }) > 1
        ) {
          throw new Error("Only one conditional branching directive is allowed per node");
        }
-        // All text nodes between branch nodes are removed
+        // All text (with only spaces) and comment nodes (nodeType 8) between
+        // branch nodes are removed
        let textNode;
        while ((textNode = node.previousSibling) !== prevElem) {
-          if (textNode.nodeValue.trim().length) {
+          if (textNode.nodeValue.trim().length && textNode.nodeType !== 8) {
            throw new Error("text is not allowed between branching directives");
          }
          textNode.remove();
@@ -383,7 +407,12 @@ export class QWeb extends EventBus {
    });
  }

-  _compile(name: string, elem: Element, parentContext?: CompilationContext): CompiledTemplate {
+  _compile(
+    name: string,
+    elem: Element,
+    parentContext?: CompilationContext,
+    defineKey?: boolean
+  ): CompiledTemplate {
    const isDebug = elem.attributes.hasOwnProperty("t-debug");
    const ctx = new CompilationContext(name);
    if (elem.tagName !== "t") {
@@ -396,6 +425,10 @@ export class QWeb extends EventBus {
      ctx.hasParentWidget = true;
      ctx.shouldDefineResult = false;
      ctx.addLine(`let c${ctx.parentNode} = extra.parentNode;`);
+      if (defineKey) {
+        ctx.addLine(`let key0 = extra.key || "";`);
+        ctx.hasKey0 = true;
+      }
    }
    this._compileNode(elem, ctx);

@@ -466,16 +499,13 @@ export class QWeb extends EventBus {
        // this is an unusual situation: this text node is the result of the
        // template rendering.
        let nodeID = ctx.generateID();
-        ctx.addLine(`var vn${nodeID} = {text: \`${text}\`};`);
+        ctx.addLine(`let vn${nodeID} = {text: \`${text}\`};`);
        ctx.addLine(`result = vn${nodeID};`);
        ctx.rootContext.rootNode = nodeID;
        ctx.rootContext.parentTextNode = nodeID;
      }
      return;
    }
-    if (ctx !== ctx.rootContext) {
-      ctx = ctx.subContext("currentKey", ctx.currentKey);
-    }

    const firstLetter = node.tagName[0];
    if (firstLetter === firstLetter.toUpperCase()) {
@@ -552,7 +582,7 @@ export class QWeb extends EventBus {
          qweb: this,
          ctx,
          fullName,
-          value
+          value,
        });
        if (isDone) {
          for (let { directive, value, fullName } of finalizers) {
@@ -567,7 +597,7 @@ export class QWeb extends EventBus {
      let nodeID = this._compileGenericNode(node, ctx, withHandlers);
      ctx = ctx.withParent(nodeID);
      let nodeHooks = {};
-      let addNodeHook = function(hook, handler) {
+      let addNodeHook = function (hook, handler) {
        nodeHooks[hook] = nodeHooks[hook] || [];
        nodeHooks[hook].push(handler);
      };
@@ -581,7 +611,7 @@ export class QWeb extends EventBus {
            fullName,
            value,
            nodeID,
-            addNodeHook
+            addNodeHook,
          });
        }
      }
@@ -672,13 +702,17 @@ export class QWeb extends EventBus {
          if ((value = value.trim())) {
            let classDef = value
              .split(/\s+/)
-              .map(a => `'${a}':true`)
+              .map((a) => `'${escapeQuotes(a)}':true`)
              .join(",");
-            classObj = `_${ctx.generateID()}`;
-            ctx.addLine(`let ${classObj} = {${classDef}};`);
+            if (classObj) {
+              ctx.addLine(`Object.assign(${classObj}, {${classDef}})`);
+            } else {
+              classObj = `_${ctx.generateID()}`;
+              ctx.addLine(`let ${classObj} = {${classDef}};`);
+            }
          }
        } else {
-          ctx.addLine(`var _${attID} = '${value}';`);
+          ctx.addLine(`let _${attID} = '${escapeQuotes(value)}';`);
          if (!name.match(/^[a-zA-Z]+$/)) {
            // attribute contains 'non letters' => we want to quote it
            name = '"' + name + '"';
@@ -714,12 +748,12 @@ export class QWeb extends EventBus {
          const attValue = (<Element>node).getAttribute(attName);
          if (attValue) {
            const attValueID = ctx.generateID();
-            ctx.addLine(`var _${attValueID} = ${formattedValue};`);
+            ctx.addLine(`let _${attValueID} = ${formattedValue};`);
            formattedValue = `'${attValue}' + (_${attValueID} ? ' ' + _${attValueID} : '')`;
-            const attrIndex = attrs.findIndex(att => att.startsWith(attName + ":"));
+            const attrIndex = attrs.findIndex((att) => att.startsWith(attName + ":"));
            attrs.splice(attrIndex, 1);
          }
-          ctx.addLine(`var _${attID} = ${formattedValue};`);
+          ctx.addLine(`let _${attID} = ${formattedValue};`);
          attrs.push(`${attName}: _${attID}`);
          handleBooleanProps(attName, attID);
        }
@@ -735,9 +769,9 @@ export class QWeb extends EventBus {
        const attID = ctx.generateID();
        let staticVal = (<Element>node).getAttribute(attName);
        if (staticVal) {
-          ctx.addLine(`var _${attID} = '${staticVal} ' + ${formattedExpr};`);
+          ctx.addLine(`let _${attID} = '${staticVal} ' + ${formattedExpr};`);
        } else {
-          ctx.addLine(`var _${attID} = ${formattedExpr};`);
+          ctx.addLine(`let _${attID} = ${formattedExpr};`);
        }
        attrs.push(`${attName}: _${attID}`);
      }
@@ -745,13 +779,13 @@ export class QWeb extends EventBus {
      // t-att= attributes
      if (name === "t-att") {
        let id = ctx.generateID();
-        ctx.addLine(`var _${id} = ${ctx.formatExpression(value!)};`);
+        ctx.addLine(`let _${id} = ${ctx.formatExpression(value!)};`);
        tattrs.push(id);
      }
    }
    let nodeID = ctx.generateID();
-    let nodeKey = ctx.currentKey || nodeID;
-    const parts = [`key:${nodeKey}`];
+    let key = ctx.loopNumber || ctx.hasKey0 ? `\`\${key${ctx.loopNumber}}_${nodeID}\`` : nodeID;
+    const parts = [`key:${key}`];
    if (attrs.length + tattrs.length > 0) {
      parts.push(`attrs:{${attrs.join(",")}}`);
    }
@@ -777,9 +811,12 @@ export class QWeb extends EventBus {
      ctx.addLine(`}`);
      ctx.closeIf();
    }
-    ctx.addLine(`var vn${nodeID} = h('${node.nodeName}', p${nodeID}, c${nodeID});`);
+    ctx.addLine(`let vn${nodeID} = h('${node.nodeName}', p${nodeID}, c${nodeID});`);
    if (ctx.parentNode) {
      ctx.addLine(`c${ctx.parentNode}.push(vn${nodeID});`);
+    } else if (ctx.loopNumber || ctx.hasKey0) {
+      ctx.rootContext.shouldDefineResult = true;
+      ctx.addLine(`result = vn${nodeID};`);
    }

    return nodeID;
@@ -4,7 +4,7 @@ import { Destination, RouterEnv } from "./router";

 type Props = Destination;

-export class Link<Env extends RouterEnv> extends Component<Env, Props> {
+export class Link<Env extends RouterEnv> extends Component<Props, Env> {
  static template = xml`
    <a  t-att-class="{'router-link-active': isActive }"
        t-att-href="href"
@@ -1,7 +1,8 @@
 import { Component } from "../component/component";
 import { xml } from "../tags";
+import { EnvWithRouter } from "./router";

-export class RouteComponent extends Component<any, {}> {
+export class RouteComponent extends Component<{}, EnvWithRouter> {
  static template = xml`
    <t>
        <t
@@ -49,6 +49,10 @@ interface Options {
  mode: Router["mode"];
 }

+export interface EnvWithRouter extends Env {
+  router: Router;
+}
+
 const paramRegexp = /\{\{(.*?)\}\}/;

 export class Router {
@@ -60,7 +64,11 @@ export class Router {
  routeIds: string[];
  env: RouterEnv;

-  constructor(env: Env, routes: Partial<Route>[], options: Options = { mode: "history" }) {
+  constructor(
+    env: Partial<EnvWithRouter>,
+    routes: Partial<Route>[],
+    options: Options = { mode: "history" }
+  ) {
    env.router = this;
    this.mode = options.mode;
    this.env = env as RouterEnv;
@@ -89,7 +97,7 @@ export class Router {
  //--------------------------------------------------------------------------

  async start() {
-    (this as any)._listener = ev => this._navigate(this.currentPath(), ev);
+    (this as any)._listener = (ev) => this._navigate(this.currentPath(), ev);
    window.addEventListener("popstate", (this as any)._listener);
    if (this.mode === "hash") {
      window.addEventListener("hashchange", (this as any)._listener);
@@ -190,7 +198,7 @@ export class Router {
        return {
          type: "match",
          route: route,
-          params: params
+          params: params,
        };
      }
    }
@@ -215,7 +223,7 @@ export class Router {
      const result = await route.beforeRouteEnter({
        env: this.env,
        from: this.currentRoute,
-        to: route
+        to: route,
      });
      if (result === false) {
        return { type: "cancelled" };
@@ -24,6 +24,10 @@ import { onWillUpdateProps } from "./hooks";
 // Store Definition
 //------------------------------------------------------------------------------

+export interface EnvWithStore extends Env {
+  store: Store;
+}
+
 export type Action = ({ state, dispatch, env, getters }, ...payload: any) => any;
 export type Getter = ({ state: any, getters }, payload?) => any;

@@ -49,7 +53,7 @@ export class Store extends Context {
    if (config.getters) {
      const firstArg = {
        state: this.state,
-        getters: this.getters
+        getters: this.getters,
      };
      for (let g in config.getters) {
        this.getters[g] = config.getters[g].bind(this, firstArg);
@@ -66,7 +70,7 @@ export class Store extends Context {
        dispatch: this.dispatch.bind(this),
        env: this.env,
        state: this.state,
-        getters: this.getters
+        getters: this.getters,
      },
      ...payload
    );
@@ -83,7 +87,7 @@ interface SelectorOptions {
 const isStrictEqual = (a, b) => a === b;

 export function useStore(selector, options: SelectorOptions = {}): any {
-  const component: Component<any, any> = Component.current!;
+  const component = Component.current as Component<any, EnvWithStore>;
  const componentId = component.__owl__.id;
  const store = options.store || (component.env.store as Store);
  if (!(store instanceof Store)) {
@@ -109,11 +113,11 @@ export function useStore(selector, options: SelectorOptions = {}): any {
    }
    return false;
  }
-  store.updateFunctions[componentId].push(function(): boolean {
+  store.updateFunctions[componentId].push(function (): boolean {
    return selectCompareUpdate(store!.state, component.props);
  });

-  useContextWithCB(store, component, function(): Promise<void> | void {
+  useContextWithCB(store, component, function (): Promise<void> | void {
    let shouldRender = false;
    for (let fn of store.updateFunctions[componentId]) {
      shouldRender = fn() || shouldRender;
@@ -122,17 +126,17 @@ export function useStore(selector, options: SelectorOptions = {}): any {
      return component.render();
    }
  });
-  onWillUpdateProps(props => {
+  onWillUpdateProps((props) => {
    selectCompareUpdate(store.state, props);
  });

  const __destroy = component.__destroy;
-  component.__destroy = parent => {
+  component.__destroy = (parent) => {
    delete store.updateFunctions[componentId];
    __destroy.call(component, parent);
  };

-  if (typeof result !== "object") {
+  if (typeof result !== "object" || result === null) {
    return result;
  }
  return new Proxy(result, {
@@ -141,16 +145,19 @@ export function useStore(selector, options: SelectorOptions = {}): any {
    },
    set(target, k, v) {
      throw new Error("Store state should only be modified through actions");
-    }
+    },
+    has(target, k) {
+      return k in result;
+    },
  });
 }

 export function useDispatch(store?: Store): Store["dispatch"] {
-  store = store || (Component.current!.env.store as Store);
+  store = store || (Component.current!.env as EnvWithStore).store;
  return store.dispatch.bind(store);
 }

 export function useGetters(store?: Store): Store["getters"] {
-  store = store || (Component.current!.env.store as Store);
+  store = store || (Component.current!.env as EnvWithStore).store;
  return store.getters;
 }
@@ -1,4 +1,5 @@
 import { QWeb } from "./qweb/index";
+import { registerSheet } from "./component/styles";

 /**
 * Owl Tags
@@ -25,3 +26,19 @@ export function xml(strings, ...args) {
  QWeb.registerTemplate(name, value);
  return name;
 }
+
+/**
+ * CSS tag helper for defining inline stylesheets.  With this, one can simply define
+ * an inline stylesheet with just the following code:
+ * ```js
+ *   class A extends Component {
+ *     static style = css`.component-a { color: red; }`;
+ *   }
+ * ```
+ */
+export function css(strings, ...args) {
+  const name = `__sheet__${QWeb.nextId++}`;
+  const value = String.raw(strings, ...args);
+  registerSheet(name, value);
+  return name;
+}
@@ -10,14 +10,16 @@
 * - debounce
 */

+import { browser } from "./browser";
+
 export function whenReady(fn?: any) {
-  return new Promise(function(resolve) {
+  return new Promise(function (resolve) {
    if (document.readyState !== "loading") {
      resolve();
    } else {
      document.addEventListener("DOMContentLoaded", resolve, false);
    }
-  }).then(fn || function() {});
+  }).then(fn || function () {});
 }

 const loadedScripts: { [key: string]: Promise<void> } = {};
@@ -26,14 +28,14 @@ export function loadJS(url: string): Promise<void> {
  if (url in loadedScripts) {
    return loadedScripts[url];
  }
-  const promise: Promise<void> = new Promise(function(resolve, reject) {
+  const promise: Promise<void> = new Promise(function (resolve, reject) {
    const script = document.createElement("script");
    script.type = "text/javascript";
    script.src = url;
-    script.onload = function() {
+    script.onload = function () {
      resolve();
    };
-    script.onerror = function() {
+    script.onerror = function () {
      reject(`Error loading file '${url}'`);
    };
    const head = document.head || document.getElementsByTagName("head")[0];
@@ -44,7 +46,7 @@ export function loadJS(url: string): Promise<void> {
 }

 export async function loadFile(url: string): Promise<string> {
-  const result = await fetch(url);
+  const result = await browser.fetch(url);
  if (!result.ok) {
    throw new Error("Error while fetching xml templates");
  }
@@ -73,7 +75,7 @@ export function escape(str: string | number | undefined): string {
 */
 export function debounce(func: Function, wait: number, immediate?: boolean): Function {
  let timeout;
-  return function(this: any) {
+  return function (this: any) {
    const context = this;
    const args = arguments;
    function later() {
@@ -83,8 +85,8 @@ export function debounce(func: Function, wait: number, immediate?: boolean): Fun
      }
    }
    const callNow = immediate && !timeout;
-    clearTimeout(timeout);
-    timeout = setTimeout(later, wait);
+    browser.clearTimeout(timeout);
+    timeout = browser.setTimeout(later, wait);
    if (callNow) {
      func.apply(context, args);
    }
@@ -33,7 +33,7 @@ function updateProps(oldVnode: VNode, vnode: VNode): void {

 export const propsModule = {
  create: updateProps,
-  update: updateProps
+  update: updateProps,
 } as Module;

 //------------------------------------------------------------------------------
@@ -70,8 +70,12 @@ function handleEvent(event: Event, vnode: VNode) {
    on = (vnode.data as VNodeData).on;

  // call event handler(s) if exists
-  if (on && on[name]) {
-    invokeHandler(on[name], vnode, event);
+  if (on) {
+    if (on[name]) {
+      invokeHandler(on[name], vnode, event);
+    } else if (on["!" + name]) {
+      invokeHandler(on["!" + name], vnode, event);
+    }
  }
 }

@@ -100,13 +104,17 @@ function updateEventListeners(oldVnode: VNode, vnode?: VNode): void {
    if (!on) {
      for (name in oldOn) {
        // remove listener if element was changed or existing listeners removed
-        oldElm.removeEventListener(name, oldListener, false);
+        const capture = name.charAt(0) === "!";
+        name = capture ? name.slice(1) : name;
+        oldElm.removeEventListener(name, oldListener, capture);
      }
    } else {
      for (name in oldOn) {
        // remove listener if existing listener removed
        if (!on[name]) {
-          oldElm.removeEventListener(name, oldListener, false);
+          const capture = name.charAt(0) === "!";
+          name = capture ? name.slice(1) : name;
+          oldElm.removeEventListener(name, oldListener, capture);
        }
      }
    }
@@ -123,13 +131,17 @@ function updateEventListeners(oldVnode: VNode, vnode?: VNode): void {
    if (!oldOn) {
      for (name in on) {
        // add listener if element was changed or new listeners added
-        elm.addEventListener(name, listener, false);
+        const capture = name.charAt(0) === "!";
+        name = capture ? name.slice(1) : name;
+        elm.addEventListener(name, listener, capture);
      }
    } else {
      for (name in on) {
        // add listener if new listener added
        if (!oldOn[name]) {
-          elm.addEventListener(name, listener, false);
+          const capture = name.charAt(0) === "!";
+          name = capture ? name.slice(1) : name;
+          elm.addEventListener(name, listener, capture);
        }
      }
    }
@@ -139,7 +151,7 @@ function updateEventListeners(oldVnode: VNode, vnode?: VNode): void {
 export const eventListenersModule = {
  create: updateEventListeners,
  update: updateEventListeners,
-  destroy: updateEventListeners
+  destroy: updateEventListeners,
 } as Module;

 //------------------------------------------------------------------------------
@@ -198,7 +210,7 @@ function updateAttrs(oldVnode: VNode, vnode: VNode): void {

 export const attrsModule = {
  create: updateAttrs,
-  update: updateAttrs
+  update: updateAttrs,
 } as Module;

 //------------------------------------------------------------------------------
@@ -520,7 +520,7 @@ const htmlDomApi = {
  parentNode,
  nextSibling,
  tagName,
-  setTextContent
+  setTextContent,
 } as DOMAPI;

 //------------------------------------------------------------------------------
@@ -8,9 +8,9 @@ exports[`animations t-transition combined with component 1`] = `
    let QWeb = this.constructor;
    let parent = context;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
+    let vn1 = h('div', p1, c1);
    // Component 'Child'
    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
    let props2 = {};
@@ -28,7 +28,7 @@ exports[`animations t-transition combined with component 1`] = `
        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
        w2 = new W2(parent, props2);
        const __patch2 = w2.__patch;
-        w2.__patch = fiber => {__patch2.call(w2, fiber); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
+        w2.__patch = (t, vn) => {__patch2.call(w2, t, vn); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
        let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {let finalize = () => {
@@ -52,9 +52,9 @@ exports[`animations t-transition combined with t-component and t-if 1`] = `
    let QWeb = this.constructor;
    let parent = context;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
+    let vn1 = h('div', p1, c1);
    if (scope['state'].display) {
        // Component 'Child'
        let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
@@ -73,7 +73,7 @@ exports[`animations t-transition combined with t-component and t-if 1`] = `
            if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
            w2 = new W2(parent, props2);
            const __patch2 = w2.__patch;
-            w2.__patch = fiber => {__patch2.call(w2, fiber); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
+            w2.__patch = (t, vn) => {__patch2.call(w2, t, vn); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
            parent.__owl__.cmap['__3__'] = w2.__owl__.id;
            let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
            let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {let finalize = () => {
@@ -98,9 +98,9 @@ exports[`animations t-transition combined with t-component, remove and re-add be
    let QWeb = this.constructor;
    let parent = context;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
+    let vn1 = h('div', p1, c1);
    if (scope['state'].flag) {
        // Component 'Child'
        let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
@@ -119,7 +119,7 @@ exports[`animations t-transition combined with t-component, remove and re-add be
            if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
            w2 = new W2(parent, props2);
            const __patch2 = w2.__patch;
-            w2.__patch = fiber => {__patch2.call(w2, fiber); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
+            w2.__patch = (t, vn) => {__patch2.call(w2, t, vn); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
            parent.__owl__.cmap['__3__'] = w2.__owl__.id;
            let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
            let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {let finalize = () => {
@@ -141,9 +141,9 @@ exports[`animations t-transition with no delay/duration 1`] = `
 ) {
    // Template name: \\"test\\"
    let utils = this.constructor.utils;
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('span', p1, c1);
+    let vn1 = h('span', p1, c1);
    p1.hook = {
      insert: vn => {
        utils.transitionInsert(vn, 'jupiler');
@@ -162,9 +162,30 @@ exports[`animations t-transition, on a simple node (insert) 1`] = `
 ) {
    // Template name: \\"test\\"
    let utils = this.constructor.utils;
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('span', p1, c1);
+    let vn1 = h('span', p1, c1);
+    p1.hook = {
+      insert: vn => {
+        utils.transitionInsert(vn, 'chimay');
+      },
+      remove: (vn, rm) => {
+        utils.transitionRemove(vn, 'chimay', rm);
+      },
+    };
+    c1.push({text: \`blue\`});
+    return vn1;
+}"
+`;
+
+exports[`animations t-transition, on a simple node, not in the DOM 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let utils = this.constructor.utils;
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('span', p1, c1);
    p1.hook = {
      insert: vn => {
        utils.transitionInsert(vn, 'chimay');
@@ -9,7 +9,7 @@ import {
  patchNextFrame,
  renderToDOM,
  unpatchNextFrame,
-  nextTick
+  nextTick,
 } from "./helpers";

 //------------------------------------------------------------------------------
@@ -71,7 +71,27 @@ describe("animations", () => {
    qweb.addTemplate("test", `<span t-transition="chimay">blue</span>`);

    let def = makeDeferred();
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
+      expect(node.className).toBe("chimay-enter chimay-enter-active");
+      cb();
+      expect(node.className).toBe("chimay-enter-active chimay-enter-to");
+      def.resolve();
+    });
+    let node: HTMLElement = <HTMLElement>renderToDOM(qweb, "test");
+    fixture.appendChild(node);
+
+    expect(node.className).toBe("chimay-enter chimay-enter-active");
+    await def; // wait for the mocked repaint to be done
+    node.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(node.className).toBe("");
+  });
+
+  test("t-transition, on a simple node, not in the DOM", async () => {
+    expect.assertions(5);
+    qweb.addTemplate("test", `<span t-transition="chimay">blue</span>`);
+
+    let def = makeDeferred();
+    patchNextFrame((cb) => {
      expect(node.className).toBe("chimay-enter chimay-enter-active");
      cb();
      expect(node.className).toBe("chimay-enter-active chimay-enter-to");
@@ -81,8 +101,10 @@ describe("animations", () => {

    expect(node.className).toBe("chimay-enter chimay-enter-active");
    await def; // wait for the mocked repaint to be done
-    node.dispatchEvent(new Event("transitionend")); // mock end of css transition
-    expect(node.className).toBe("");
+    node.dispatchEvent(new Event("transitionend"));
+    // we check here that the css classes have not been removed, since the
+    // element is not in the dom, we actually do not want to do anything.
+    expect(node.className).toBe("chimay-enter-active chimay-enter-to");
  });

  test("t-transition with no delay/duration", async () => {
@@ -90,13 +112,14 @@ describe("animations", () => {
    qweb.addTemplate("test", `<span t-transition="jupiler">blue</span>`);

    let def = makeDeferred();
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      expect(node.className).toBe("jupiler-enter jupiler-enter-active");
      cb();
      expect(node.className).toBe("");
      def.resolve();
    });
    let node: HTMLElement = <HTMLElement>renderToDOM(qweb, "test");
+    fixture.appendChild(node);
    expect(node.className).toBe("jupiler-enter jupiler-enter-active");
    await def;
  });
@@ -116,7 +139,7 @@ describe("animations", () => {
    // insert widget into the DOM
    let def = makeDeferred();
    var spanNode;
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      expect(spanNode.className).toBe("chimay-enter chimay-enter-active");
      cb();
      expect(spanNode.className).toBe("chimay-enter-active chimay-enter-to");
@@ -132,7 +155,7 @@ describe("animations", () => {
    // remove span from the DOM
    def = makeDeferred();
    widget.state.hide = true;
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      expect(spanNode.className).toBe("chimay-leave chimay-leave-active");
      cb();
      expect(spanNode.className).toBe("chimay-leave-active chimay-leave-to");
@@ -159,7 +182,7 @@ describe("animations", () => {
    // insert widget into the DOM
    let def = makeDeferred();
    var spanNode;
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      expect(spanNode.className).toBe("chimay-enter chimay-enter-active");
      cb();
      expect(spanNode.className).toBe("chimay-enter-active chimay-enter-to");
@@ -187,7 +210,7 @@ describe("animations", () => {

    let def = makeDeferred();
    var spanNode;
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      expect(fixture.innerHTML).toBe(
        '<div><span class="chimay-enter chimay-enter-active">blue</span></div>'
      );
@@ -227,7 +250,7 @@ describe("animations", () => {

    let def = makeDeferred();
    var spanNode;
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      expect(fixture.innerHTML).toBe(
        '<div><span class="chimay-enter chimay-enter-active">blue</span></div>'
      );
@@ -252,7 +275,7 @@ describe("animations", () => {
    // remove span from the DOM
    def = makeDeferred();
    widget.state.display = false;
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      expect(fixture.innerHTML).toBe(
        '<div><span class="chimay-leave chimay-leave-active" data-owl-key="__3__">blue</span></div>'
      );
@@ -292,7 +315,7 @@ describe("animations", () => {

    let def = makeDeferred();
    let phase = "enter";
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      let spans = fixture.querySelectorAll("span");
      expect(spans.length).toBe(1);
      expect(spans[0].className).toBe(`chimay-${phase} chimay-${phase}-active`);
@@ -343,7 +366,7 @@ describe("animations", () => {

    let def = makeDeferred();
    let phase = "enter";
-    patchNextFrame(cb => {
+    patchNextFrame((cb) => {
      let spans = fixture.querySelectorAll("span");
      expect(spans.length).toBe(1);
      expect(spans[0].className).toBe(`chimay-${phase} chimay-${phase}-active`);
@@ -390,7 +413,7 @@ describe("animations", () => {
      state = useState({ flag: false });
    }

-    patchNextFrame(cb => cb());
+    patchNextFrame((cb) => cb());

    const widget = new Parent();
    await widget.mount(fixture);
@@ -0,0 +1,156 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`class and style attributes with t-component dynamic t-att-style is properly added and updated on widget root el 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"ParentWidget\\"
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    // Component 'child'
+    const _4 = scope['state'].style;
+    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let props2 = {};
+    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+        w2.destroy();
+        w2 = false;
+    }
+    if (w2) {
+        w2.__updateProps(props2, extra.fiber, undefined).then(()=>{if (w2.__owl__.isDestroyed) {return};w2.el.style=_4;});;
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`child\`;
+        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.style = _4;}});});
+        let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
+        c1.push(pvnode);
+        w2.__owl__.pvnode = pvnode;
+    }
+    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
+exports[`class and style attributes with t-component t-att-class is properly added/removed on widget root el (v2) 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"ParentWidget\\"
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    context.__owl__.refs = context.__owl__.refs || {};
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    // Component 'Child'
+    const ref4 = \`child\`;
+    let _5 = {'a':true};
+    Object.assign(_5, {b:scope['state'].b})
+    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let props2 = {};
+    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+        w2.destroy();
+        w2 = false;
+    }
+    if (w2) {
+        w2.__updateProps(props2, extra.fiber, undefined);
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`Child\`;
+        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){}});});
+        let pvnode = h('dummy', {key: '__3__', hook: {insert(vn) {context.__owl__.refs[ref4] = w2;},remove() {},destroy(vn) {w2.destroy();delete context.__owl__.refs[ref4];}}});
+        c1.push(pvnode);
+        w2.__owl__.pvnode = pvnode;
+    }
+    w2.__owl__.classObj=_5;
+    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
+exports[`class and style attributes with t-component t-att-class is properly added/removed on widget root el (v2) 2`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"Child\\"
+    let utils = this.constructor.utils;
+    let scope = Object.create(context);
+    let h = this.h;
+    let _7 = {'c':true};
+    Object.assign(_7, utils.toObj({d:scope['state'].d}))
+    let c8 = [], p8 = {key:8,class:_7};
+    let vn8 = h('span', p8, c8);
+    return vn8;
+}"
+`;
+
+exports[`class and style attributes with t-component t-att-class is properly added/removed on widget root el (v3) 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"ParentWidget\\"
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    context.__owl__.refs = context.__owl__.refs || {};
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    // Component 'Child'
+    const ref4 = \`child\`;
+    let _5 = {'a':true};
+    Object.assign(_5, utils.toObj(scope['state'].b?'b':''))
+    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let props2 = {};
+    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+        w2.destroy();
+        w2 = false;
+    }
+    if (w2) {
+        w2.__updateProps(props2, extra.fiber, undefined);
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`Child\`;
+        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){}});});
+        let pvnode = h('dummy', {key: '__3__', hook: {insert(vn) {context.__owl__.refs[ref4] = w2;},remove() {},destroy(vn) {w2.destroy();delete context.__owl__.refs[ref4];}}});
+        c1.push(pvnode);
+        w2.__owl__.pvnode = pvnode;
+    }
+    w2.__owl__.classObj=_5;
+    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
+exports[`class and style attributes with t-component t-att-class is properly added/removed on widget root el (v3) 2`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"Child\\"
+    let utils = this.constructor.utils;
+    let scope = Object.create(context);
+    let h = this.h;
+    let _7 = {'c':true};
+    Object.assign(_7, utils.toObj(scope['state'].d?'d':''))
+    let c8 = [], p8 = {key:8,class:_7};
+    let vn8 = h('span', p8, c8);
+    return vn8;
+}"
+`;
@@ -8,9 +8,9 @@ exports[`props validation props are validated in dev mode (code snapshot) 1`] =
    let QWeb = this.constructor;
    let parent = context;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
+    let vn1 = h('div', p1, c1);
    // Component 'Child'
    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
    let props2 = {message:1};
@@ -8,9 +8,9 @@ exports[`t-slot directive can define and call slots 1`] = `
    let QWeb = this.constructor;
    let parent = context;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
+    let vn1 = h('div', p1, c1);
    // Component 'Dialog'
    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
    let props2 = {};
@@ -43,18 +43,18 @@ exports[`t-slot directive can define and call slots 2`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"Dialog\\"
-    var h = this.h;
+    let h = this.h;
    let c6 = [], p6 = {key:6};
-    var vn6 = h('div', p6, c6);
+    let vn6 = h('div', p6, c6);
    let c7 = [], p7 = {key:7};
-    var vn7 = h('div', p7, c7);
+    let vn7 = h('div', p7, c7);
    c6.push(vn7);
    const slot8 = this.constructor.slots[context.__owl__.slotId + '_' + 'header'];
    if (slot8) {
        slot8.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c7, parent: extra.parent || context}));
    }
    let c9 = [], p9 = {key:9};
-    var vn9 = h('div', p9, c9);
+    let vn9 = h('div', p9, c9);
    c6.push(vn9);
    const slot10 = this.constructor.slots[context.__owl__.slotId + '_' + 'footer'];
    if (slot10) {
@@ -68,10 +68,10 @@ exports[`t-slot directive can define and call slots 3`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"slot_header_template\\"
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
    let c4 = [], p4 = {key:4};
-    var vn4 = h('span', p4, c4);
+    let vn4 = h('span', p4, c4);
    c1.push(vn4);
    c4.push({text: \`header\`});
 }"
@@ -81,10 +81,100 @@ exports[`t-slot directive can define and call slots 4`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"slot_footer_template\\"
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
    let c5 = [], p5 = {key:5};
-    var vn5 = h('span', p5, c5);
+    let vn5 = h('span', p5, c5);
+    c1.push(vn5);
+    c5.push({text: \`footer\`});
+}"
+`;
+
+exports[`t-slot directive can define and call slots using old t-set keyword 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__2\\"
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    // Component 'Dialog'
+    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let props2 = {};
+    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+        w2.destroy();
+        w2 = false;
+    }
+    if (w2) {
+        w2.__updateProps(props2, extra.fiber, Object.assign(Object.create(context), scope));
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`Dialog\`;
+        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Dialog'];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        w2.__owl__.slotId = 1;
+        let fiber = w2.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
+        c1.push(pvnode);
+        w2.__owl__.pvnode = pvnode;
+    }
+    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
+exports[`t-slot directive can define and call slots using old t-set keyword 2`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__1\\"
+    let h = this.h;
+    let c6 = [], p6 = {key:6};
+    let vn6 = h('div', p6, c6);
+    let c7 = [], p7 = {key:7};
+    let vn7 = h('div', p7, c7);
+    c6.push(vn7);
+    const slot8 = this.constructor.slots[context.__owl__.slotId + '_' + 'header'];
+    if (slot8) {
+        slot8.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c7, parent: extra.parent || context}));
+    }
+    let c9 = [], p9 = {key:9};
+    let vn9 = h('div', p9, c9);
+    c6.push(vn9);
+    const slot10 = this.constructor.slots[context.__owl__.slotId + '_' + 'footer'];
+    if (slot10) {
+        slot10.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c9, parent: extra.parent || context}));
+    }
+    return vn6;
+}"
+`;
+
+exports[`t-slot directive can define and call slots using old t-set keyword 3`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_header_template\\"
+    let h = this.h;
+    let c1 = extra.parentNode;
+    let c4 = [], p4 = {key:4};
+    let vn4 = h('span', p4, c4);
+    c1.push(vn4);
+    c4.push({text: \`header\`});
+}"
+`;
+
+exports[`t-slot directive can define and call slots using old t-set keyword 4`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_footer_template\\"
+    let h = this.h;
+    let c1 = extra.parentNode;
+    let c5 = [], p5 = {key:5};
+    let vn5 = h('span', p5, c5);
    c1.push(vn5);
    c5.push({text: \`footer\`});
 }"
@@ -94,10 +184,10 @@ exports[`t-slot directive content is the default slot 1`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"slot_default_template\\"
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
    let c4 = [], p4 = {key:4};
-    var vn4 = h('span', p4, c4);
+    let vn4 = h('span', p4, c4);
    c1.push(vn4);
    c4.push({text: \`sts rocks\`});
 }"
@@ -107,9 +197,9 @@ exports[`t-slot directive dafault slots can define a default content 1`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"__template__1\\"
-    var h = this.h;
+    let h = this.h;
    let c4 = [], p4 = {key:4};
-    var vn4 = h('span', p4, c4);
+    let vn4 = h('span', p4, c4);
    const slot5 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
    if (slot5) {
        slot5.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c4, parent: extra.parent || context}));
@@ -124,7 +214,7 @@ exports[`t-slot directive default slot work with text nodes 1`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"slot_default_template\\"
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
    c1.push({text: \`sts rocks\`});
 }"
@@ -134,14 +224,14 @@ exports[`t-slot directive multiple roots are allowed in a default slot 1`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"slot_default_template\\"
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
    let c4 = [], p4 = {key:4};
-    var vn4 = h('span', p4, c4);
+    let vn4 = h('span', p4, c4);
    c1.push(vn4);
    c4.push({text: \`sts\`});
    let c5 = [], p5 = {key:5};
-    var vn5 = h('span', p5, c5);
+    let vn5 = h('span', p5, c5);
    c1.push(vn5);
    c5.push({text: \`rocks\`});
 }"
@@ -151,14 +241,14 @@ exports[`t-slot directive multiple roots are allowed in a named slot 1`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"slot_content_template\\"
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
    let c4 = [], p4 = {key:4};
-    var vn4 = h('span', p4, c4);
+    let vn4 = h('span', p4, c4);
    c1.push(vn4);
    c4.push({text: \`sts\`});
    let c5 = [], p5 = {key:5};
-    var vn5 = h('span', p5, c5);
+    let vn5 = h('span', p5, c5);
    c1.push(vn5);
    c5.push({text: \`rocks\`});
 }"
@@ -168,9 +258,9 @@ exports[`t-slot directive named slots can define a default content 1`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"__template__1\\"
-    var h = this.h;
+    let h = this.h;
    let c4 = [], p4 = {key:4};
-    var vn4 = h('span', p4, c4);
+    let vn4 = h('span', p4, c4);
    const slot5 = this.constructor.slots[context.__owl__.slotId + '_' + 'header'];
    if (slot5) {
        slot5.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c4, parent: extra.parent || context}));
@@ -187,10 +277,10 @@ exports[`t-slot directive refs are properly bound in slots 1`] = `
    // Template name: \\"slot_footer_template\\"
    let utils = this.constructor.utils;
    context.__owl__.refs = context.__owl__.refs || {};
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
    let c8 = [], p8 = {key:8,on:{}};
-    var vn8 = h('button', p8, c8);
+    let vn8 = h('button', p8, c8);
    c1.push(vn8);
    extra.handlers['click__9__'] = extra.handlers['click__9__'] || function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['doSomething'](e);};
    p8.on['click'] = extra.handlers['click__9__'];
@@ -212,10 +302,10 @@ exports[`t-slot directive slots are rendered with proper context 1`] = `
 ) {
    // Template name: \\"slot_footer_template\\"
    let utils = this.constructor.utils;
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
    let c8 = [], p8 = {key:8,on:{}};
-    var vn8 = h('button', p8, c8);
+    let vn8 = h('button', p8, c8);
    c1.push(vn8);
    extra.handlers['click__9__'] = extra.handlers['click__9__'] || function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['doSomething'](e);};
    p8.on['click'] = extra.handlers['click__9__'];
@@ -228,15 +318,15 @@ exports[`t-slot directive slots are rendered with proper context, part 2 1`] = `
 ) {
    // Template name: \\"Link\\"
    let scope = Object.create(context);
-    var h = this.h;
-    var _12 = scope['props'].to;
-    let c13 = [], p13 = {key:13,attrs:{href: _12}};
-    var vn13 = h('a', p13, c13);
-    const slot14 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
-    if (slot14) {
-        slot14.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c13, parent: extra.parent || context}));
+    let h = this.h;
+    let _11 = scope['props'].to;
+    let c12 = [], p12 = {key:12,attrs:{href: _11}};
+    let vn12 = h('a', p12, c12);
+    const slot13 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
+    if (slot13) {
+        slot13.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c12, parent: extra.parent || context}));
    }
-    return vn13;
+    return vn12;
 }"
 `;

@@ -248,57 +338,57 @@ exports[`t-slot directive slots are rendered with proper context, part 2 2`] = `
    let QWeb = this.constructor;
    let parent = context;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
+    let vn1 = h('div', p1, c1);
    let c2 = [], p2 = {key:2};
-    var vn2 = h('u', p2, c2);
+    let vn2 = h('u', p2, c2);
    c1.push(vn2);
-    var _3 = scope['state'].users;
+    let _3 = scope['state'].users;
    if (!_3) { throw new Error('QWeb error: Invalid loop expression')}
-    var _4 = _5 = _3;
+    let _4 = _5 = _3;
    if (!(_3 instanceof Array)) {
        _4 = Object.keys(_3);
        _5 = Object.values(_3);
    }
-    var _length4 = _4.length;
-    const _origScope6 = scope;
-    scope = Object.assign(Object.create(context), scope);
+    let _length4 = _4.length;
+    let _origScope6 = scope;
+    scope = Object.create(scope);
    for (let i1 = 0; i1 < _length4; i1++) {
        scope.user_first = i1 === 0
        scope.user_last = i1 === _length4 - 1
        scope.user_index = i1
        scope.user = _4[i1]
        scope.user_value = _5[i1]
-        const nodeKey7 = scope['user'].id;
-        let c8 = [], p8 = {key:nodeKey7};
-        var vn8 = h('li', p8, c8);
-        c2.push(vn8);
+        let key1 = scope['user'].id;
+        let c7 = [], p7 = {key:\`\${key1}_7\`};
+        let vn7 = h('li', p7, c7);
+        c2.push(vn7);
        // Component 'Link'
-        let k10 = \`__10__\` + nodeKey7;
-        let w9 = k10 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k10]] : false;
-        let props9 = {to:'/user/'+scope['user'].id};
-        if (w9 && w9.__owl__.currentFiber && !w9.__owl__.vnode) {
-            w9.destroy();
-            w9 = false;
+        let k9 = \`__9__\${key1}__\`;
+        let w8 = k9 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k9]] : false;
+        let props8 = {to:'/user/'+scope['user'].id};
+        if (w8 && w8.__owl__.currentFiber && !w8.__owl__.vnode) {
+            w8.destroy();
+            w8 = false;
        }
-        if (w9) {
-            w9.__updateProps(props9, extra.fiber, Object.assign(Object.create(context), scope));
-            let pvnode = w9.__owl__.pvnode;
-            c8.push(pvnode);
+        if (w8) {
+            w8.__updateProps(props8, extra.fiber, Object.assign(Object.create(context), scope));
+            let pvnode = w8.__owl__.pvnode;
+            c7.push(pvnode);
        } else {
-            let componentKey9 = \`Link\`;
-            let W9 = context.constructor.components[componentKey9] || QWeb.components[componentKey9]|| scope['Link'];
-            if (!W9) {throw new Error('Cannot find the definition of component \\"' + componentKey9 + '\\"')}
-            w9 = new W9(parent, props9);
-            parent.__owl__.cmap[k10] = w9.__owl__.id;
-            w9.__owl__.slotId = 1;
-            let fiber = w9.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
-            let pvnode = h('dummy', {key: k10, hook: {remove() {},destroy(vn) {w9.destroy();}}});
-            c8.push(pvnode);
-            w9.__owl__.pvnode = pvnode;
+            let componentKey8 = \`Link\`;
+            let W8 = context.constructor.components[componentKey8] || QWeb.components[componentKey8]|| scope['Link'];
+            if (!W8) {throw new Error('Cannot find the definition of component \\"' + componentKey8 + '\\"')}
+            w8 = new W8(parent, props8);
+            parent.__owl__.cmap[k9] = w8.__owl__.id;
+            w8.__owl__.slotId = 1;
+            let fiber = w8.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+            let pvnode = h('dummy', {key: k9, hook: {remove() {},destroy(vn) {w8.destroy();}}});
+            c7.push(pvnode);
+            w8.__owl__.pvnode = pvnode;
        }
-        w9.__owl__.parentLastFiberId = extra.fiber.id;
+        w8.__owl__.parentLastFiberId = extra.fiber.id;
    }
    scope = _origScope6;
    return vn1;
@@ -310,12 +400,12 @@ exports[`t-slot directive slots are rendered with proper context, part 2 3`] = `
 ) {
    // Template name: \\"slot_default_template\\"
    let scope = Object.create(context);
-    var h = this.h;
-    let c8 = extra.parentNode;
-    c8.push({text: \`User \`});
-    var _11 = scope['user'].name;
-    if (_11 || _11 === 0) {
-        c8.push({text: _11});
+    let h = this.h;
+    let c7 = extra.parentNode;
+    c7.push({text: \`User \`});
+    let _10 = scope['user'].name;
+    if (_10 != null) {
+        c7.push({text: _10});
    }
 }"
 `;
@@ -325,15 +415,15 @@ exports[`t-slot directive slots are rendered with proper context, part 3 1`] = `
 ) {
    // Template name: \\"Link\\"
    let scope = Object.create(context);
-    var h = this.h;
-    var _11 = scope['props'].to;
-    let c12 = [], p12 = {key:12,attrs:{href: _11}};
-    var vn12 = h('a', p12, c12);
-    const slot13 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
-    if (slot13) {
-        slot13.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c12, parent: extra.parent || context}));
+    let h = this.h;
+    let _10 = scope['props'].to;
+    let c11 = [], p11 = {key:11,attrs:{href: _10}};
+    let vn11 = h('a', p11, c11);
+    const slot12 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
+    if (slot12) {
+        slot12.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c11, parent: extra.parent || context}));
    }
-    return vn12;
+    return vn11;
 }"
 `;

@@ -345,58 +435,58 @@ exports[`t-slot directive slots are rendered with proper context, part 3 2`] = `
    let QWeb = this.constructor;
    let parent = context;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
+    let vn1 = h('div', p1, c1);
    let c2 = [], p2 = {key:2};
-    var vn2 = h('u', p2, c2);
+    let vn2 = h('u', p2, c2);
    c1.push(vn2);
-    var _3 = scope['state'].users;
+    let _3 = scope['state'].users;
    if (!_3) { throw new Error('QWeb error: Invalid loop expression')}
-    var _4 = _5 = _3;
+    let _4 = _5 = _3;
    if (!(_3 instanceof Array)) {
        _4 = Object.keys(_3);
        _5 = Object.values(_3);
    }
-    var _length4 = _4.length;
-    const _origScope6 = scope;
-    scope = Object.assign(Object.create(context), scope);
+    let _length4 = _4.length;
+    let _origScope6 = scope;
+    scope = Object.create(scope);
    for (let i1 = 0; i1 < _length4; i1++) {
        scope.user_first = i1 === 0
        scope.user_last = i1 === _length4 - 1
        scope.user_index = i1
        scope.user = _4[i1]
        scope.user_value = _5[i1]
-        const nodeKey7 = scope['user'].id;
-        let c8 = [], p8 = {key:nodeKey7};
-        var vn8 = h('li', p8, c8);
-        c2.push(vn8);
-        scope.userdescr = 'User '+scope['user'].name;
+        let key1 = scope['user'].id;
+        let c7 = [], p7 = {key:\`\${key1}_7\`};
+        let vn7 = h('li', p7, c7);
+        c2.push(vn7);
+        utils.getScope(scope, 'userdescr').userdescr = 'User '+scope['user'].name;
        // Component 'Link'
-        let k10 = \`__10__\` + nodeKey7;
-        let w9 = k10 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k10]] : false;
-        let props9 = {to:'/user/'+scope['user'].id};
-        if (w9 && w9.__owl__.currentFiber && !w9.__owl__.vnode) {
-            w9.destroy();
-            w9 = false;
+        let k9 = \`__9__\${key1}__\`;
+        let w8 = k9 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k9]] : false;
+        let props8 = {to:'/user/'+scope['user'].id};
+        if (w8 && w8.__owl__.currentFiber && !w8.__owl__.vnode) {
+            w8.destroy();
+            w8 = false;
        }
-        if (w9) {
-            w9.__updateProps(props9, extra.fiber, Object.assign(Object.create(context), scope));
-            let pvnode = w9.__owl__.pvnode;
-            c8.push(pvnode);
+        if (w8) {
+            w8.__updateProps(props8, extra.fiber, Object.assign(Object.create(context), scope));
+            let pvnode = w8.__owl__.pvnode;
+            c7.push(pvnode);
        } else {
-            let componentKey9 = \`Link\`;
-            let W9 = context.constructor.components[componentKey9] || QWeb.components[componentKey9]|| scope['Link'];
-            if (!W9) {throw new Error('Cannot find the definition of component \\"' + componentKey9 + '\\"')}
-            w9 = new W9(parent, props9);
-            parent.__owl__.cmap[k10] = w9.__owl__.id;
-            w9.__owl__.slotId = 1;
-            let fiber = w9.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
-            let pvnode = h('dummy', {key: k10, hook: {remove() {},destroy(vn) {w9.destroy();}}});
-            c8.push(pvnode);
-            w9.__owl__.pvnode = pvnode;
+            let componentKey8 = \`Link\`;
+            let W8 = context.constructor.components[componentKey8] || QWeb.components[componentKey8]|| scope['Link'];
+            if (!W8) {throw new Error('Cannot find the definition of component \\"' + componentKey8 + '\\"')}
+            w8 = new W8(parent, props8);
+            parent.__owl__.cmap[k9] = w8.__owl__.id;
+            w8.__owl__.slotId = 1;
+            let fiber = w8.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+            let pvnode = h('dummy', {key: k9, hook: {remove() {},destroy(vn) {w8.destroy();}}});
+            c7.push(pvnode);
+            w8.__owl__.pvnode = pvnode;
        }
-        w9.__owl__.parentLastFiberId = extra.fiber.id;
+        w8.__owl__.parentLastFiberId = extra.fiber.id;
    }
    scope = _origScope6;
    return vn1;
@@ -408,10 +498,10 @@ exports[`t-slot directive slots are rendered with proper context, part 3 3`] = `
 ) {
    // Template name: \\"slot_default_template\\"
    let scope = Object.create(context);
-    var h = this.h;
-    let c8 = extra.parentNode;
-    if (scope.userdescr || scope.userdescr === 0) {
-        c8.push({text: scope.userdescr});
+    let h = this.h;
+    let c7 = extra.parentNode;
+    if (scope.userdescr != null) {
+        c7.push({text: scope.userdescr});
    }
 }"
 `;
@@ -424,9 +514,9 @@ exports[`t-slot directive slots are rendered with proper context, part 4 1`] = `
    let QWeb = this.constructor;
    let parent = context;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
+    let vn1 = h('div', p1, c1);
    scope.userdescr = 'User '+scope['state'].user.name;
    // Component 'Link'
    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
@@ -461,21 +551,36 @@ exports[`t-slot directive slots are rendered with proper context, part 4 2`] = `
 ) {
    // Template name: \\"slot_default_template\\"
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let c1 = extra.parentNode;
-    if (scope.userdescr || scope.userdescr === 0) {
+    if (scope.userdescr != null) {
        c1.push({text: scope.userdescr});
    }
 }"
 `;

+exports[`t-slot directive t-set t-value in a slot 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__1\\"
+    let h = this.h;
+    let c4 = [], p4 = {key:4};
+    let vn4 = h('span', p4, c4);
+    const slot5 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
+    if (slot5) {
+        slot5.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c4, parent: extra.parent || context}));
+    }
+    return vn4;
+}"
+`;
+
 exports[`t-slot directive template can just return a slot 1`] = `
 "function anonymous(context, extra
 ) {
    // Template name: \\"__template__2\\"
    let utils = this.constructor.utils;
    let result;
-    var h = this.h;
+    let h = this.h;
    const slot6 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
    if (slot6) {
        let children7= []
@@ -0,0 +1,271 @@
+import { Component, Env } from "../../src/component/component";
+import { QWeb } from "../../src/qweb/qweb";
+import { xml } from "../../src/tags";
+import { useState, useRef } from "../../src/hooks";
+import { makeTestFixture, makeTestEnv, nextTick } from "../helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - env: a WEnv, necessary to create new components
+
+let fixture: HTMLElement;
+let env: Env;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+describe("class and style attributes with t-component", () => {
+  test("class is properly added on widget root el", async () => {
+    class Child extends Component {
+      static template = xml`<div class="c"/>`;
+    }
+    class ParentWidget extends Component {
+      static template = xml`<div><Child class="a b"/></div>`;
+      static components = { Child };
+    }
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe(`<div><div class="c a b"></div></div>`);
+  });
+
+  test("empty class attribute is not added on widget root el", async () => {
+    class Child extends Component {
+      static template = xml`<span/>`;
+    }
+    class Parent extends Component {
+      static template = xml`<div><Child class=""/></div>`;
+      static components = { Child };
+    }
+    const widget = new Parent();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe(`<div><span></span></div>`);
+  });
+
+  test("t-att-class is properly added/removed on widget root el", async () => {
+    class Child extends Component {
+      static template = xml`<div class="c"/>`;
+    }
+    class ParentWidget extends Component {
+      static template = xml`<div><Child t-att-class="{a:state.a, b:state.b}"/></div>`;
+      static components = { Child };
+      state = useState({ a: true, b: false });
+    }
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe(`<div><div class="c a"></div></div>`);
+    expect(QWeb.TEMPLATES[ParentWidget.template].fn.toString());
+
+    widget.state.a = false;
+    widget.state.b = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe(`<div><div class="c b"></div></div>`);
+  });
+
+  test("class with extra whitespaces", async () => {
+    env.qweb.addTemplate(
+      "ParentWidget",
+      `<div>
+              <Child class="a  b c   d"/>
+        </div>`
+    );
+    class Child extends Component {}
+    class ParentWidget extends Component {
+      static components = { Child };
+    }
+    env.qweb.addTemplate("Child", `<div/>`);
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe(`<div><div class="a b c d"></div></div>`);
+  });
+
+  test("t-att-class is properly added/removed on widget root el (v2)", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+          <div t-name="ParentWidget">
+            <Child class="a" t-att-class="{ b: state.b }" t-ref="child"/>
+          </div>
+          <span t-name="Child" class="c" t-att-class="{ d: state.d }"/>
+        </templates>`);
+
+    class Child extends Component {
+      state = useState({ d: true });
+    }
+    class ParentWidget extends Component {
+      static components = { Child };
+      state = useState({ b: true });
+      child = useRef("child");
+    }
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+
+    const span = fixture.querySelector("span")!;
+    expect(span.className).toBe("c d a b");
+
+    widget.state.b = false;
+    await nextTick();
+    expect(span.className).toBe("c d a");
+
+    (widget.child.comp as Child).state.d = false;
+    await nextTick();
+    expect(span.className).toBe("c a");
+
+    widget.state.b = true;
+    await nextTick();
+    expect(span.className).toBe("c a b");
+
+    (widget.child.comp as Child).state.d = true;
+    await nextTick();
+    expect(span.className).toBe("c a b d");
+    expect(env.qweb.templates.ParentWidget.fn.toString()).toMatchSnapshot();
+    expect(env.qweb.templates.Child.fn.toString()).toMatchSnapshot();
+  });
+
+  test("t-att-class is properly added/removed on widget root el (v3)", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+          <div t-name="ParentWidget">
+            <Child class="a" t-att-class="state.b ? 'b' : ''" t-ref="child"/>
+          </div>
+          <span t-name="Child" class="c" t-att-class="state.d ? 'd' : ''"/>
+        </templates>`);
+
+    class Child extends Component {
+      state = useState({ d: true });
+    }
+    class ParentWidget extends Component {
+      static components = { Child };
+      state = useState({ b: true });
+      child = useRef("child");
+    }
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+
+    const span = fixture.querySelector("span")!;
+    expect(span.className).toBe("c d a b");
+
+    widget.state.b = false;
+    await nextTick();
+    expect(span.className).toBe("c d a");
+
+    (widget.child.comp as Child).state.d = false;
+    await nextTick();
+    expect(span.className).toBe("c a");
+
+    widget.state.b = true;
+    await nextTick();
+    expect(span.className).toBe("c a b");
+
+    (widget.child.comp as Child).state.d = true;
+    await nextTick();
+    expect(span.className).toBe("c a b d");
+    expect(env.qweb.templates.ParentWidget.fn.toString()).toMatchSnapshot();
+    expect(env.qweb.templates.Child.fn.toString()).toMatchSnapshot();
+  });
+
+  test("class on components do not interfere with user defined classes", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+          <div t-name="App" t-att-class="{ c: state.c }" />
+        </templates>`);
+
+    class App extends Component {
+      state = useState({ c: true });
+      mounted() {
+        this.el!.classList.add("user");
+      }
+    }
+
+    const widget = new App();
+    await widget.mount(fixture);
+
+    expect(fixture.innerHTML).toBe('<div class="c user"></div>');
+
+    widget.state.c = false;
+    await nextTick();
+
+    expect(fixture.innerHTML).toBe('<div class="user"></div>');
+  });
+
+  test("style is properly added on widget root el", async () => {
+    env.qweb.addTemplate(
+      "ParentWidget",
+      `
+          <div>
+              <t t-component="child" style="font-weight: bold;"/>
+          </div>`
+    );
+
+    class SomeComponent extends Component {
+      static template = xml`<div/>`;
+    }
+
+    class ParentWidget extends Component {
+      static components = { child: SomeComponent };
+    }
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe(`<div><div style="font-weight: bold;"></div></div>`);
+  });
+
+  test("dynamic t-att-style is properly added and updated on widget root el", async () => {
+    env.qweb.addTemplate(
+      "ParentWidget",
+      `
+          <div>
+              <t t-component="child" t-att-style="state.style"/>
+          </div>`
+    );
+
+    class SomeComponent extends Component {
+      static template = xml`<div/>`;
+    }
+
+    class ParentWidget extends Component {
+      static components = { child: SomeComponent };
+      state = useState({ style: "font-size: 20px" });
+    }
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+
+    expect(env.qweb.templates.ParentWidget.fn.toString()).toMatchSnapshot();
+
+    expect(fixture.innerHTML).toBe(`<div><div style="font-size: 20px;"></div></div>`);
+
+    widget.state.style = "font-size: 30px";
+    await nextTick();
+
+    expect(fixture.innerHTML).toBe(`<div><div style="font-size: 30px;"></div></div>`);
+  });
+
+  test("error in subcomponent with class", async () => {
+    class Child extends Component {
+      static template = xml`<div t-esc="this.will.crash"/>`;
+    }
+    class ParentWidget extends Component {
+      static template = xml`<div><Child class="a"/></div>`;
+      static components = { Child };
+    }
+    const widget = new ParentWidget();
+    let error;
+    try {
+      await widget.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Cannot read property 'crash' of undefined");
+    expect(fixture.innerHTML).toBe("");
+  });
+});
@@ -0,0 +1,523 @@
+import { Component, Env } from "../../src/component/component";
+import { useState } from "../../src/hooks";
+import { xml } from "../../src/tags";
+import { makeTestEnv, makeTestFixture, nextTick } from "../helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - env: a WEnv, necessary to create new components
+
+let fixture: HTMLElement;
+let env: Env;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+describe("component error handling (catchError)", () => {
+  /**
+   * This test suite requires often to wait for 3 ticks. Here is why:
+   * - First tick is to let the app render and crash.
+   * - When we crash, we call the catchError handler in a setTimeout (because we
+   *   need to wait for the previous rendering to be completely stopped). So, we
+   *   need to wait for the second tick.
+   * - Then, when the handler changes the state, we need to wait for the interface
+   *   to be rerendered.
+   *  */
+
+  test("can catch an error in a component render function", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn();
+    const handler = jest.fn();
+    env.qweb.on("error", null, handler);
+    class ErrorComponent extends Component {
+      static template = xml`<div>hey<t t-esc="props.flag and state.this.will.crash"/></div>`;
+    }
+    class ErrorBoundary extends Component {
+      static template = xml`
+          <div>
+            <t t-if="state.error">Error handled</t>
+            <t t-else=""><t t-slot="default" /></t>
+          </div>`;
+      state = useState({ error: false });
+
+      catchError() {
+        this.state.error = true;
+      }
+    }
+    class App extends Component {
+      static template = xml`
+          <div>
+            <ErrorBoundary><ErrorComponent flag="state.flag"/></ErrorBoundary>
+          </div>`;
+      state = useState({ flag: false });
+      static components = { ErrorBoundary, ErrorComponent };
+    }
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div><div>heyfalse</div></div></div>");
+    app.state.flag = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div>Error handled</div></div>");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+    expect(handler).toBeCalledTimes(1);
+  });
+
+  test("no component catching error lead to full app destruction", async () => {
+    expect.assertions(6);
+    const handler = jest.fn();
+    env.qweb.on("error", null, handler);
+    const consoleError = console.error;
+    console.error = jest.fn();
+
+    class ErrorComponent extends Component {
+      static template = xml`<div>hey<t t-esc="props.flag and state.this.will.crash"/></div>`;
+    }
+
+    class App extends Component {
+      static template = xml`<div><ErrorComponent flag="state.flag"/></div>`;
+      static components = { ErrorComponent };
+      state = useState({ flag: false });
+      async render() {
+        try {
+          await super.render();
+        } catch (e) {
+          expect(e.message).toBe("Cannot read property 'this' of undefined");
+        }
+      }
+    }
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>heyfalse</div></div>");
+    app.state.flag = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+    expect(app.__owl__.isDestroyed).toBe(true);
+    expect(handler).toBeCalledTimes(1);
+  });
+
+  test("can catch an error in the initial call of a component render function (parent mounted)", async () => {
+    const handler = jest.fn();
+    env.qweb.on("error", null, handler);
+    const consoleError = console.error;
+    console.error = jest.fn();
+    class ErrorComponent extends Component {
+      static template = xml`<div>hey<t t-esc="state.this.will.crash"/></div>`;
+    }
+    class ErrorBoundary extends Component {
+      static template = xml`
+          <div>
+            <t t-if="state.error">Error handled</t>
+            <t t-else=""><t t-slot="default" /></t>
+          </div>`;
+      state = useState({ error: false });
+
+      catchError() {
+        this.state.error = true;
+      }
+    }
+    class App extends Component {
+      static template = xml`
+          <div>
+              <ErrorBoundary><ErrorComponent /></ErrorBoundary>
+          </div>`;
+      static components = { ErrorBoundary, ErrorComponent };
+    }
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>Error handled</div></div>");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+    expect(handler).toBeCalledTimes(1);
+  });
+
+  test("can catch an error in the initial call of a component render function (parent updated)", async () => {
+    const handler = jest.fn();
+    env.qweb.on("error", null, handler);
+    const consoleError = console.error;
+    console.error = jest.fn();
+    class ErrorComponent extends Component {
+      static template = xml`<div>hey<t t-esc="state.this.will.crash"/></div>`;
+    }
+    class ErrorBoundary extends Component {
+      static template = xml`
+          <div>
+            <t t-if="state.error">Error handled</t>
+            <t t-else=""><t t-slot="default" /></t>
+          </div>`;
+      state = useState({ error: false });
+
+      catchError() {
+        this.state.error = true;
+      }
+    }
+    class App extends Component {
+      static template = xml`
+          <div>
+              <ErrorBoundary t-if="state.flag"><ErrorComponent /></ErrorBoundary>
+          </div>`;
+      state = useState({ flag: false });
+      static components = { ErrorBoundary, ErrorComponent };
+    }
+    const app = new App();
+    await app.mount(fixture);
+    app.state.flag = true;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div>Error handled</div></div>");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+    expect(handler).toBeCalledTimes(1);
+  });
+
+  test("can catch an error in the constructor call of a component render function", async () => {
+    const handler = jest.fn();
+    env.qweb.on("error", null, handler);
+    const consoleError = console.error;
+    console.error = jest.fn();
+    env.qweb.addTemplates(`
+        <templates>
+          <div t-name="ErrorBoundary">
+              <t t-if="state.error">Error handled</t>
+              <t t-else=""><t t-slot="default" /></t>
+          </div>
+          <div t-name="ErrorComponent">Some text</div>
+          <div t-name="App">
+              <ErrorBoundary><ErrorComponent /></ErrorBoundary>
+          </div>
+        </templates>`);
+    class ErrorComponent extends Component {
+      constructor(parent) {
+        super(parent);
+        throw new Error("NOOOOO");
+      }
+    }
+    class ErrorBoundary extends Component {
+      state = useState({ error: false });
+
+      catchError() {
+        this.state.error = true;
+      }
+    }
+    class App extends Component {
+      static components = { ErrorBoundary, ErrorComponent };
+    }
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>Error handled</div></div>");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+    expect(handler).toBeCalledTimes(1);
+  });
+
+  test("can catch an error in the willStart call", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn();
+    class ErrorComponent extends Component {
+      static template = xml`<div t-name="ErrorComponent">Some text</div>`;
+      async willStart() {
+        // we wait a little bit to be in a different stack frame
+        await nextTick();
+        throw new Error("NOOOOO");
+      }
+    }
+    class ErrorBoundary extends Component {
+      static template = xml`
+          <div>
+            <t t-if="state.error">Error handled</t>
+            <t t-else=""><t t-slot="default" /></t>
+          </div>`;
+      state = useState({ error: false });
+
+      catchError() {
+        this.state.error = true;
+      }
+    }
+    class App extends Component {
+      static template = xml`<div><ErrorBoundary><ErrorComponent /></ErrorBoundary></div>`;
+      static components = { ErrorBoundary, ErrorComponent };
+    }
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>Error handled</div></div>");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+  });
+
+  test.skip("can catch an error in the mounted call", async () => {
+    // we do not catch error in mounted anymore
+    console.error = jest.fn();
+    env.qweb.addTemplates(`
+        <templates>
+          <div t-name="ErrorBoundary">
+              <t t-if="state.error">Error handled</t>
+              <t t-else=""><t t-slot="default" /></t>
+          </div>
+          <div t-name="ErrorComponent">Some text</div>
+          <div t-name="App">
+              <ErrorBoundary><ErrorComponent /></ErrorBoundary>
+          </div>
+        </templates>`);
+    class ErrorComponent extends Component {
+      mounted() {
+        throw new Error("NOOOOO");
+      }
+    }
+    class ErrorBoundary extends Component {
+      state = useState({ error: false });
+
+      catchError() {
+        this.state.error = true;
+      }
+    }
+    class App extends Component {
+      static components = { ErrorBoundary, ErrorComponent };
+    }
+    const app = new App();
+    await app.mount(fixture);
+    await nextTick();
+    await nextTick();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div>Error handled</div></div>");
+  });
+
+  test.skip("can catch an error in the willPatch call", async () => {
+    // we do not catch error in willPatch anymore
+    const consoleError = console.error;
+    console.error = jest.fn();
+    class ErrorComponent extends Component {
+      static template = xml`<div><t t-esc="props.message"/></div>`;
+      willPatch() {
+        throw new Error("NOOOOO");
+      }
+    }
+    class ErrorBoundary extends Component {
+      static template = xml`
+          <div>
+            <t t-if="state.error">Error handled</t>
+            <t t-else=""><t t-slot="default" /></t>
+          </div>`;
+      state = useState({ error: false });
+
+      catchError() {
+        this.state.error = true;
+      }
+    }
+    class App extends Component {
+      static template = xml`
+          <div>
+              <span><t t-esc="state.message"/></span>
+            <ErrorBoundary><ErrorComponent message="state.message" /></ErrorBoundary>
+          </div>`;
+      state = useState({ message: "abc" });
+      static components = { ErrorBoundary, ErrorComponent };
+    }
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>abc</span><div><div>abc</div></div></div>");
+    app.state.message = "def";
+    await nextTick();
+    await nextTick();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>def</span><div>Error handled</div></div>");
+    expect(console.error).toHaveBeenCalledTimes(1);
+    console.error = consoleError;
+  });
+
+  test("a rendering error will reject the mount promise", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+    // we do not catch error in willPatch anymore
+    class App extends Component {
+      static template = xml`<div><t t-esc="this.will.crash"/></div>`;
+    }
+
+    const app = new App();
+    let error;
+    try {
+      await app.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Cannot read property 'crash' of undefined");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+  });
+
+  test("an error in mounted call will reject the mount promise", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+
+    class App extends Component {
+      static template = xml`<div>abc</div>`;
+      mounted() {
+        throw new Error("boom");
+      }
+    }
+
+    const app = new App();
+    let error;
+    try {
+      await app.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("boom");
+    expect(fixture.innerHTML).toBe("");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+  });
+
+  test("an error in willPatch call will reject the render promise", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+
+    class App extends Component {
+      static template = xml`<div><t t-esc="val"/></div>`;
+      val = 3;
+      willPatch() {
+        throw new Error("boom");
+      }
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+    app.val = 4;
+    let error;
+    try {
+      await app.render();
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("boom");
+    expect(fixture.innerHTML).toBe("");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+  });
+
+  test("an error in patched call will reject the render promise", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+
+    class App extends Component {
+      static template = xml`<div><t t-esc="val"/></div>`;
+      val = 3;
+      patched() {
+        throw new Error("boom");
+      }
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+    app.val = 4;
+    let error;
+    try {
+      await app.render();
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("boom");
+    expect(fixture.innerHTML).toBe("");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+  });
+
+  test("a rendering error in a sub component will reject the mount promise", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+    // we do not catch error in willPatch anymore
+    class Child extends Component {
+      static template = xml`<div><t t-esc="this.will.crash"/></div>`;
+    }
+    class App extends Component {
+      static template = xml`<div><Child/></div>`;
+      static components = { Child };
+    }
+
+    const app = new App();
+    let error;
+    try {
+      await app.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Cannot read property 'crash' of undefined");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+  });
+
+  test("a rendering error will reject the render promise", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+    // we do not catch error in willPatch anymore
+    class App extends Component {
+      static template = xml`<div><t t-if="flag" t-esc="this.will.crash"/></div>`;
+      flag = false;
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div></div>");
+    app.flag = true;
+    let error;
+    try {
+      await app.render();
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Cannot read property 'crash' of undefined");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+  });
+
+  test("a rendering error will reject the render promise (with sub components)", async () => {
+    class Child extends Component {
+      static template = xml`<span></span>`;
+    }
+    class Parent extends Component {
+      static template = xml`<div><Child/><t t-esc="x.y"/></div>`;
+      static components = { Child };
+    }
+
+    let error;
+    try {
+      const parent = new Parent();
+      await parent.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Cannot read property 'y' of undefined");
+  });
+});
@@ -25,7 +25,7 @@ afterEach(() => {
  QWeb.dev = dev;
 });

-class Widget extends Component<any, any> {}
+class Widget extends Component {}

 //------------------------------------------------------------------------------
 // Tests
@@ -92,11 +92,11 @@ describe("props validation", () => {
      { type: String, ok: "1", ko: 1 },
      { type: Object, ok: {}, ko: "1" },
      { type: Date, ok: new Date(), ko: "1" },
-      { type: Function, ok: () => {}, ko: "1" }
+      { type: Function, ok: () => {}, ko: "1" },
    ];

    let props;
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="p"/></div>`;
      get p() {
        return props.p;
@@ -149,18 +149,18 @@ describe("props validation", () => {
      { type: String, ok: "1", ko: 1 },
      { type: Object, ok: {}, ko: "1" },
      { type: Date, ok: new Date(), ko: "1" },
-      { type: Function, ok: () => {}, ko: "1" }
+      { type: Function, ok: () => {}, ko: "1" },
    ];

    let props;
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="p"/></div>`;
      get p() {
        return props.p;
      }
    }
    for (let test of Tests) {
-      let TestWidget = class extends Component<any, any> {
+      let TestWidget = class extends Component {
        static props = { p: { type: test.type } };
        static template = xml`<div>hey</div>`;
      };
@@ -200,11 +200,11 @@ describe("props validation", () => {
  });

  test("can validate a prop with multiple types", async () => {
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static template = xml`<div>hey</div>`;
      static props = { p: [String, Boolean] };
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="p"/></div>`;
      static components = { TestWidget };
      get p() {
@@ -244,11 +244,11 @@ describe("props validation", () => {
  });

  test("can validate an optional props", async () => {
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static template = xml`<div>hey</div>`;
      static props = { p: { type: String, optional: true } };
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="p"/></div>`;
      static components = { TestWidget };
      get p() {
@@ -288,11 +288,11 @@ describe("props validation", () => {
  });

  test("can validate an array with given primitive type", async () => {
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static template = xml`<div>hey</div>`;
      static props = { p: { type: Array, element: String } };
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="p"/></div>`;
      static components = { TestWidget };
      get p() {
@@ -340,11 +340,11 @@ describe("props validation", () => {
  });

  test("can validate an array with multiple sub element types", async () => {
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static template = xml`<div>hey</div>`;
      static props = { p: { type: Array, element: [String, Boolean] } };
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="p"/></div>`;
      static components = { TestWidget };
      get p() {
@@ -393,13 +393,13 @@ describe("props validation", () => {
  });

  test("can validate an object with simple shape", async () => {
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static template = xml`<div>hey</div>`;
      static props = {
-        p: { type: Object, shape: { id: Number, url: String } }
+        p: { type: Object, shape: { id: Number, url: String } },
      };
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="p"/></div>`;
      static components = { TestWidget };
      get p() {
@@ -451,19 +451,19 @@ describe("props validation", () => {
  });

  test("can validate recursively complicated prop def", async () => {
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static template = xml`<div>hey</div>`;
      static props = {
        p: {
          type: Object,
          shape: {
            id: Number,
-            url: [Boolean, { type: Array, element: Number }]
-          }
-        }
+            url: [Boolean, { type: Array, element: Number }],
+          },
+        },
      };
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="p"/></div>`;
      static components = { TestWidget };
      get p() {
@@ -503,17 +503,17 @@ describe("props validation", () => {
  });

  test("can validate optional attributes in nested sub props", () => {
-    class TestComponent extends Component<any, any> {
+    class TestComponent extends Component {
      static props = {
        myprop: {
          type: Array,
          element: {
            type: Object,
            shape: {
-              num: { type: Number, optional: true }
-            }
-          }
-        }
+              num: { type: Number, optional: true },
+            },
+          },
+        },
      };
    }
    let error;
@@ -536,11 +536,11 @@ describe("props validation", () => {
  });

  test("can validate with a custom validator", () => {
-    class TestComponent extends Component<any, any> {
+    class TestComponent extends Component {
      static props = {
        size: {
-          validate: e => ["small", "medium", "large"].includes(e)
-        }
+          validate: (e) => ["small", "medium", "large"].includes(e),
+        },
      };
    }
    let error;
@@ -561,13 +561,13 @@ describe("props validation", () => {
  });

  test("can validate with a custom validator, and a type", () => {
-    const validator = jest.fn(n => 0 <= n && n <= 10);
-    class TestComponent extends Component<any, any> {
+    const validator = jest.fn((n) => 0 <= n && n <= 10);
+    class TestComponent extends Component {
      static props = {
        n: {
          type: Number,
-          validate: validator
-        }
+          validate: validator,
+        },
      };
    }
    let error;
@@ -738,7 +738,7 @@ describe("props validation", () => {

  test("props are validated whenever component is updated", async () => {
    let error;
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static props = { p: { type: Number } };
      static template = xml`<div><t t-esc="props.p"/></div>`;

@@ -750,7 +750,7 @@ describe("props validation", () => {
        }
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="state.p"/></div>`;
      static components = { TestWidget };
      state: any = useState({ p: 1 });
@@ -767,12 +767,12 @@ describe("props validation", () => {
  });

  test("default values are applied before validating props at update", async () => {
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static props = { p: { type: Number } };
      static template = xml`<div><t t-esc="props.p"/></div>`;
      static defaultProps = { p: 4 };
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget p="state.p"/></div>`;
      static components = { TestWidget };
      state: any = useState({ p: 1 });
@@ -790,11 +790,11 @@ describe("props validation", () => {

 describe("default props", () => {
  test("can set default values", async () => {
-    class TestWidget extends Component<any, any> {
+    class TestWidget extends Component {
      static defaultProps = { p: 4 };
      static template = xml`<div><t t-esc="props.p"/></div>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><TestWidget /></div>`;
      static components = { TestWidget };
    }
@@ -19,13 +19,6 @@ let env: Env;
 beforeEach(() => {
  fixture = makeTestFixture();
  env = makeTestEnv();
-  env.qweb.addTemplate("Component<any,any>", "<div></div>");
-  env.qweb.addTemplate(
-    "Counter",
-    `<div><t t-esc="state.counter"/><button t-on-click="inc">Inc</button></div>`
-  );
-  env.qweb.addTemplate("WidgetA", `<div>Hello<t t-component="b"/></div>`);
-  env.qweb.addTemplate("WidgetB", `<div>world</div>`);
  Component.env = env;
 });

@@ -33,9 +26,9 @@ afterEach(() => {
  fixture.remove();
 });

-function children(w: Component<any, any>): Component<any, any>[] {
+function children(w: Component): Component[] {
  const childrenMap = w.__owl__.children;
-  return Object.keys(childrenMap).map(id => childrenMap[id]);
+  return Object.keys(childrenMap).map((id) => childrenMap[id]);
 }

 //------------------------------------------------------------------------------
@@ -48,8 +41,8 @@ describe("t-slot directive", () => {
          <templates>
            <div t-name="Parent">
               <Dialog>
-                  <t t-set="header"><span>header</span></t>
-                  <t t-set="footer"><span>footer</span></t>
+                  <t t-set-slot="header"><span>header</span></t>
+                  <t t-set-slot="footer"><span>footer</span></t>
               </Dialog>
            </div>
            <div t-name="Dialog">
@@ -58,8 +51,8 @@ describe("t-slot directive", () => {
            </div>
          </templates>
      `);
-    class Dialog extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Dialog extends Component {}
+    class Parent extends Component {
      static components = { Dialog };
    }
    const parent = new Parent();
@@ -74,14 +67,46 @@ describe("t-slot directive", () => {
    expect(QWeb.slots["1_footer"].toString()).toMatchSnapshot();
  });

+  test("can define and call slots using old t-set keyword", async () => {
+    // NOTE: this test should be removed once we stop supporting the t-set directive
+    // for defining slot content.
+    class Dialog extends Component {
+      static template = xml`
+        <div>
+          <div><t t-slot="header"/></div>
+          <div><t t-slot="footer"/></div>
+        </div>`;
+    }
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <Dialog>
+            <t t-set="header"><span>header</span></t>
+            <t t-set="footer"><span>footer</span></t>
+          </Dialog>
+        </div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(
+      "<div><div><div><span>header</span></div><div><span>footer</span></div></div></div>"
+    );
+    expect(env.qweb.templates[Parent.template].fn.toString()).toMatchSnapshot();
+    expect(env.qweb.templates[Dialog.template].fn.toString()).toMatchSnapshot();
+    expect(QWeb.slots["1_header"].toString()).toMatchSnapshot();
+    expect(QWeb.slots["1_footer"].toString()).toMatchSnapshot();
+  });
+
  test("named slots can define a default content", async () => {
-    class Dialog extends Component<any, any> {
+    class Dialog extends Component {
      static template = xml`
          <span>
            <t t-slot="header">default content</t>
          </span>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Dialog/></div>`;
      static components = { Dialog };
    }
@@ -93,13 +118,13 @@ describe("t-slot directive", () => {
  });

  test("dafault slots can define a default content", async () => {
-    class Dialog extends Component<any, any> {
+    class Dialog extends Component {
      static template = xml`
          <span>
            <t t-slot="default">default content</t>
          </span>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Dialog/></div>`;
      static components = { Dialog };
    }
@@ -111,13 +136,13 @@ describe("t-slot directive", () => {
  });

  test("default content is not rendered if slot is provided", async () => {
-    class Dialog extends Component<any, any> {
+    class Dialog extends Component {
      static template = xml`
          <span>
            <t t-slot="default">default content</t>
          </span>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Dialog>hey</Dialog></div>`;
      static components = { Dialog };
    }
@@ -128,14 +153,14 @@ describe("t-slot directive", () => {
  });

  test("default content is not rendered if named slot is provided", async () => {
-    class Dialog extends Component<any, any> {
+    class Dialog extends Component {
      static template = xml`
          <span>
            <t t-slot="header">default content</t>
          </span>`;
    }
-    class Parent extends Component<any, any> {
-      static template = xml`<div><Dialog><t t-set="header">hey</t></Dialog></div>`;
+    class Parent extends Component {
+      static template = xml`<div><Dialog><t t-set-slot="header">hey</t></Dialog></div>`;
      static components = { Dialog };
    }
    const parent = new Parent();
@@ -150,14 +175,14 @@ describe("t-slot directive", () => {
            <div t-name="Parent">
              <span class="counter"><t t-esc="state.val"/></span>
              <Dialog>
-                <t t-set="footer"><button t-on-click="doSomething">do something</button></t>
+                <t t-set-slot="footer"><button t-on-click="doSomething">do something</button></t>
              </Dialog>
            </div>
            <span t-name="Dialog"><t t-slot="footer"/></span>
          </templates>
      `);
-    class Dialog extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Dialog extends Component {}
+    class Parent extends Component {
      static components = { Dialog };
      state = useState({ val: 0 });
      doSomething() {
@@ -193,14 +218,14 @@ describe("t-slot directive", () => {
              </div>
          </templates>
      `);
-    class Link extends Component<any, any> {}
+    class Link extends Component {}

-    class App extends Component<any, any> {
+    class App extends Component {
      state = useState({
        users: [
          { id: 1, name: "Aaron" },
-          { id: 2, name: "David" }
-        ]
+          { id: 2, name: "David" },
+        ],
      });
      static components = { Link };
    }
@@ -237,14 +262,14 @@ describe("t-slot directive", () => {
              </div>
          </templates>
      `);
-    class Link extends Component<any, any> {}
+    class Link extends Component {}

-    class App extends Component<any, any> {
+    class App extends Component {
      state = useState({
        users: [
          { id: 1, name: "Aaron" },
-          { id: 2, name: "David" }
-        ]
+          { id: 2, name: "David" },
+        ],
      });
      static components = { Link };
    }
@@ -279,9 +304,9 @@ describe("t-slot directive", () => {
              </div>
          </templates>
      `);
-    class Link extends Component<any, any> {}
+    class Link extends Component {}

-    class App extends Component<any, any> {
+    class App extends Component {
      state = useState({ user: { id: 1, name: "Aaron" } });
      static components = { Link };
    }
@@ -301,15 +326,15 @@ describe("t-slot directive", () => {
  });

  test("refs are properly bound in slots", async () => {
-    class Dialog extends Component<any, any> {
+    class Dialog extends Component {
      static template = xml`<span><t t-slot="footer"/></span>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`
            <div>
              <span class="counter"><t t-esc="state.val"/></span>
              <Dialog>
-                <t t-set="footer"><button t-ref="myButton" t-on-click="doSomething">do something</button></t>
+                <t t-set-slot="footer"><button t-ref="myButton" t-on-click="doSomething">do something</button></t>
              </Dialog>
            </div>
          `;
@@ -347,8 +372,8 @@ describe("t-slot directive", () => {
            <div t-name="Dialog"><t t-slot="default"/></div>
          </templates>
      `);
-    class Dialog extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Dialog extends Component {}
+    class Parent extends Component {
      static components = { Dialog };
    }
    const parent = new Parent();
@@ -367,8 +392,8 @@ describe("t-slot directive", () => {
            <div t-name="Dialog"><t t-slot="default"/></div>
          </templates>
      `);
-    class Dialog extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Dialog extends Component {}
+    class Parent extends Component {
      static components = { Dialog };
    }
    const parent = new Parent();
@@ -383,7 +408,7 @@ describe("t-slot directive", () => {
          <templates>
            <div t-name="Parent">
               <Dialog>
-                  <t t-set="content">
+                  <t t-set-slot="content">
                      <span>sts</span>
                      <span>rocks</span>
                  </t>
@@ -392,8 +417,8 @@ describe("t-slot directive", () => {
            <div t-name="Dialog"><t t-slot="content"/></div>
          </templates>
      `);
-    class Dialog extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Dialog extends Component {}
+    class Parent extends Component {
      static components = { Dialog };
    }
    const parent = new Parent();
@@ -415,8 +440,8 @@ describe("t-slot directive", () => {
            <div t-name="Dialog"><t t-slot="default"/></div>
          </templates>
      `);
-    class Dialog extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Dialog extends Component {}
+    class Parent extends Component {
      static components = { Dialog };
    }
    const parent = new Parent();
@@ -439,8 +464,8 @@ describe("t-slot directive", () => {
            </span>
          </templates>
      `);
-    class Dialog extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Dialog extends Component {}
+    class Parent extends Component {
      static components = { Dialog };
    }
    const parent = new Parent();
@@ -449,22 +474,22 @@ describe("t-slot directive", () => {
    expect(fixture.innerHTML).toBe("<div><span><span>some content</span></span></div>");
  });

-  test("t-debug on a t-set (defining a slot)", async () => {
+  test("t-debug on a t-set-slot (defining a slot)", async () => {
    const consoleLog = console.log;
    console.log = jest.fn();

    env.qweb.addTemplates(`
          <templates>
            <div t-name="Parent">
-              <Dialog><t t-set="content" t-debug="">abc</t></Dialog>
+              <Dialog><t t-set-slot="content" t-debug="">abc</t></Dialog>
            </div>
            <span t-name="Dialog">
              <t t-slot="content"/>
            </span>
          </templates>
      `);
-    class Dialog extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Dialog extends Component {}
+    class Parent extends Component {
      static components = { Dialog };
    }
    const parent = new Parent();
@@ -485,9 +510,9 @@ describe("t-slot directive", () => {
            <div t-name="GrandChild">Grand Child</div>
          </templates>
      `);
-    class Child extends Component<any, any> {}
-    class GrandChild extends Component<any, any> {}
-    class Parent extends Component<any, any> {
+    class Child extends Component {}
+    class GrandChild extends Component {}
+    class Parent extends Component {
      static components = { Child, GrandChild };
    }
    const parent = new Parent();
@@ -506,24 +531,24 @@ describe("t-slot directive", () => {

  test("nested slots: evaluation context and parented relationship", async () => {
    let slot;
-    class Slot extends Component<any, any> {
+    class Slot extends Component {
      static template = xml`<span t-esc="props.val"/>`;
      constructor(parent, props) {
        super(parent, props);
        slot = this;
      }
    }
-    class GrandChild extends Component<any, any> {
+    class GrandChild extends Component {
      static template = xml`<div><t t-slot="default"/></div>`;
    }
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static components = { GrandChild };
      static template = xml`
          <GrandChild>
            <t t-slot="default"/>
          </GrandChild>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Child, Slot };
      static template = xml`<Child><Slot val="state.val"/></Child>`;
      state = useState({ val: 3 });
@@ -555,9 +580,9 @@ describe("t-slot directive", () => {
          </div>
      </templates>
      `);
-    class SomeComponent extends Component<any, any> {}
-    class GenericComponent extends Component<any, any> {}
-    class App extends Component<any, any> {
+    class SomeComponent extends Component {}
+    class GenericComponent extends Component {}
+    class App extends Component {
      static components = { GenericComponent, SomeComponent };
      state = useState({ val: 4 });

@@ -575,14 +600,14 @@ describe("t-slot directive", () => {
  });

  test("slots and wrapper components", async () => {
-    class Link extends Component<any, any> {
+    class Link extends Component {
      static template = xml`
          <a href="abc">
              <t t-slot="default"/>
          </a>`;
    }

-    class A extends Component<any, any> {
+    class A extends Component {
      static template = xml`<Link>hey</Link>`;
      static components = { Link: Link };
    }
@@ -594,14 +619,14 @@ describe("t-slot directive", () => {
  });

  test("template can just return a slot", async () => {
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="props.value"/></span>`;
    }
-    class SlotComponent extends Component<any, any> {
+    class SlotComponent extends Component {
      static template = xml`<t t-slot="default"/>`;
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`
          <div>
              <SlotComponent><Child value="state.value"/></SlotComponent>
@@ -621,17 +646,17 @@ describe("t-slot directive", () => {
  });

  test("multiple slots containing components", async () => {
-    class C extends Component<any, any> {
+    class C extends Component {
      static template = xml`<span><t t-esc="props.val"/></span>`;
    }
-    class B extends Component<any, any> {
+    class B extends Component {
      static template = xml`<div><t t-slot="s1"/><t t-slot="s2"/></div>`;
    }
-    class A extends Component<any, any> {
+    class A extends Component {
      static template = xml`
          <B>
-            <t t-set="s1"><C val="1"/></t>
-            <t t-set="s2"><C val="2"/></t>
+            <t t-set-slot="s1"><C val="1"/></t>
+            <t t-set-slot="s2"><C val="2"/></t>
          </B>`;
      static components = { B, C };
    }
@@ -643,14 +668,14 @@ describe("t-slot directive", () => {
  });

  test("slots in t-foreach and re-rendering", async () => {
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="state.val"/><t t-slot="default"/></span>`;
      state = useState({ val: "A" });
      mounted() {
        this.state.val = "B";
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Child };
      static template = xml`
          <div>
@@ -668,7 +693,7 @@ describe("t-slot directive", () => {
  });

  test("slots in t-foreach with t-set and re-rendering", async () => {
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`
          <span>
            <t t-esc="state.val"/>
@@ -679,7 +704,7 @@ describe("t-slot directive", () => {
        this.state.val = "B";
      }
    }
-    class ParentWidget extends Component<any, any> {
+    class ParentWidget extends Component {
      static components = { Child };
      static template = xml`
          <div>
@@ -700,7 +725,7 @@ describe("t-slot directive", () => {

  test("nested slots in same template", async () => {
    let child, child2, child3;
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`
          <span id="c1">
            <div>
@@ -712,7 +737,7 @@ describe("t-slot directive", () => {
        child = this;
      }
    }
-    class Child2 extends Component<any, any> {
+    class Child2 extends Component {
      static template = xml`
          <span id="c2">
            <t t-slot="default"/>
@@ -722,7 +747,7 @@ describe("t-slot directive", () => {
        child2 = this;
      }
    }
-    class Child3 extends Component<any, any> {
+    class Child3 extends Component {
      static template = xml`
          <span>Child 3</span>`;
      constructor(parent, props) {
@@ -730,7 +755,7 @@ describe("t-slot directive", () => {
        child3 = this;
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Child, Child2, Child3 };
      static template = xml`
          <span id="parent">
@@ -755,7 +780,7 @@ describe("t-slot directive", () => {

  test("t-slot nested within another slot", async () => {
    let portal, modal, child3;
-    class Child3 extends Component<any, any> {
+    class Child3 extends Component {
      static template = xml`
          <span>Child 3</span>`;
      constructor(parent, props) {
@@ -763,7 +788,7 @@ describe("t-slot directive", () => {
        child3 = this;
      }
    }
-    class Modal extends Component<any, any> {
+    class Modal extends Component {
      static template = xml`
          <span id="modal">
            <t t-slot="default"/>
@@ -773,7 +798,7 @@ describe("t-slot directive", () => {
        modal = this;
      }
    }
-    class Portal extends Component<any, any> {
+    class Portal extends Component {
      static template = xml`
          <span id="portal">
            <t t-slot="default"/>
@@ -783,7 +808,7 @@ describe("t-slot directive", () => {
        portal = this;
      }
    }
-    class Dialog extends Component<any, any> {
+    class Dialog extends Component {
      static components = { Modal, Portal };
      static template = xml`
          <span id="c2">
@@ -794,7 +819,7 @@ describe("t-slot directive", () => {
             </Modal>
          </span>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Child3, Dialog };
      static template = xml`
          <span id="c1">
@@ -816,7 +841,7 @@ describe("t-slot directive", () => {

  test("t-slot supports many instances", async () => {
    let child3;
-    class Child3 extends Component<any, any> {
+    class Child3 extends Component {
      static template = xml`
          <span>Child 3</span>`;
      constructor(parent, props) {
@@ -824,13 +849,13 @@ describe("t-slot directive", () => {
        child3 = this;
      }
    }
-    class Dialog extends Component<any, any> {
+    class Dialog extends Component {
      static template = xml`
          <span id="c2">
            <t t-slot="default"/>
          </span>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Child3, Dialog };
      static template = xml`
          <span id="c1">
@@ -852,10 +877,10 @@ describe("t-slot directive", () => {
  });

  test("slots in slots, with vars", async () => {
-    class B extends Component<any, any> {
+    class B extends Component {
      static template = xml`<span><t t-slot="default"/></span>`;
    }
-    class A extends Component<any, any> {
+    class A extends Component {
      static template = xml`
          <div>
            <B>
@@ -864,7 +889,7 @@ describe("t-slot directive", () => {
          </div>`;
      static components = { B };
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`
          <div>
            <t t-set="test" t-value="state.name"/>
@@ -880,4 +905,28 @@ describe("t-slot directive", () => {
    await parent.mount(fixture);
    expect(fixture.innerHTML).toBe("<div><div><span><p>heyaaron</p></span></div></div>");
  });
+
+  test("t-set t-value in a slot", async () => {
+    class Dialog extends Component {
+      static template = xml`
+          <span>
+            <t t-slot="default"/>
+          </span>`;
+    }
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <Dialog>
+            <t t-set="rainbow" t-value="'dash'"/>
+            <t t-esc="rainbow"/>
+          </Dialog>
+        </div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>dash</span></div>");
+    expect(env.qweb.templates[Dialog.template].fn.toString()).toMatchSnapshot();
+  });
 });
@@ -0,0 +1,170 @@
+import { Component, Env } from "../../src/component/component";
+import { processSheet } from "../../src/component/styles";
+import { xml, css } from "../../src/tags";
+import { makeTestFixture, makeTestEnv } from "../helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - env: an Env, necessary to create new components
+
+let fixture: HTMLElement;
+let env: Env;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+  document.head.innerHTML = "";
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("styles and component", () => {
+  test("can define an inline stylesheet", async () => {
+    class App extends Component {
+      static template = xml`<div class="app">text</div>`;
+      static style = css`
+        .app {
+          color: red;
+        }
+      `;
+    }
+    expect(document.head.innerHTML).toBe("");
+    const app = new App();
+
+    expect(document.head.innerHTML).toBe(`<style component=\"App\">.app {
+  color: red;
+}</style>`);
+
+    await app.mount(fixture);
+    const style = getComputedStyle(app.el!);
+    expect(style.color).toBe("red");
+    expect(fixture.innerHTML).toBe('<div class="app">text</div>');
+  });
+
+  test("inherited components properly apply css", async () => {
+    class App extends Component {
+      static template = xml`<div class="app">text</div>`;
+      static style = css`
+        .app {
+          color: red;
+        }
+      `;
+    }
+    class SubApp extends App {
+      static style = css`
+        .app {
+          font-weight: bold;
+        }
+      `;
+    }
+    expect(document.head.innerHTML).toBe("");
+    const app = new SubApp();
+
+    expect(document.head.innerHTML).toBe(`<style component=\"SubApp\">.app {
+  font-weight: bold;
+}</style><style component=\"App\">.app {
+  color: red;
+}</style>`);
+
+    await app.mount(fixture);
+    const style = getComputedStyle(app.el!);
+    expect(style.color).toBe("red");
+    expect(style.fontWeight).toBe("bold");
+    expect(fixture.innerHTML).toBe('<div class="app">text</div>');
+  });
+
+  test("get a meaningful error message if css helper is missing", async () => {
+    class App extends Component {
+      static template = xml`<div class="app">text</div>`;
+      static style = `.app {color: red;}`;
+    }
+    let error;
+    try {
+      new App();
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe(
+      "Invalid css stylesheet for component 'App'. Did you forget to use the 'css' tag helper?"
+    );
+  });
+
+  test("inline stylesheets are processed", async () => {
+    class App extends Component {
+      static template = xml`<div class="app">text</div>`;
+      static style = css`
+        .app {
+          color: red;
+          .some-class {
+            font-weight: bold;
+            width: 40px;
+          }
+
+          display: block;
+        }
+      `;
+    }
+    new App();
+
+    expect(document.head.querySelector("style")!.innerHTML).toBe(`.app {
+  color: red;
+}
+.app .some-class {
+  font-weight: bold;
+  width: 40px;
+}
+.app {
+  display: block;
+}`);
+  });
+
+  test("properly handle rules with commas", async () => {
+    const sheet = processSheet(`.parent-a, .parent-b {
+      .child-a, .child-b {
+        color: red;
+      }
+    }`);
+
+    expect(sheet)
+      .toBe(`.parent-a .child-a, .parent-a .child-b, .parent-b .child-a, .parent-b .child-b {
+  color: red;
+}`);
+  });
+
+  test("handle & selector", async () => {
+    let sheet = processSheet(`.btn {
+      &.danger {
+        color: red;
+      }
+    }`);
+
+    expect(sheet).toBe(`.btn.danger {
+  color: red;
+}`);
+
+    sheet = processSheet(`.some-class {
+      &.btn {
+        .other-class ~ & {
+          color: red;
+        }
+      }
+    }`);
+
+    expect(sheet).toBe(`.other-class ~ .some-class.btn {
+  color: red;
+}`);
+  });
+});
@@ -0,0 +1,512 @@
+import { Component, Env } from "../../src/component/component";
+import { useState } from "../../src/hooks";
+import { xml } from "../../src/tags";
+import { makeDeferred, makeTestEnv, makeTestFixture, nextTick, nextMicroTick } from "../helpers";
+import { scheduler } from "../../src/component/scheduler";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - env: a WEnv, necessary to create new components
+
+let fixture: HTMLElement;
+let env: Env;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+describe("mount targets", () => {
+  test("can attach a component to an existing node (if same tagname)", async () => {
+    class App extends Component {
+      static template = xml`<div t-att-class="state.customClass">app<p>another tag</p></div>`;
+      state = useState({ customClass: "custom" });
+    }
+    const div = document.createElement("div");
+    div.classList.add("arbitrary");
+    div.innerHTML = `<p>pre-existing</p>`;
+    fixture.appendChild(div);
+
+    const app = new App();
+    await app.mount(div, { position: "self" });
+
+    expect(fixture.innerHTML).toBe(
+      `<div class="arbitrary custom"><p>pre-existing</p>app<p>another tag</p></div>`
+    );
+    expect(div).toBe(app.el);
+
+    app.state.customClass = "custom2";
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      `<div class="arbitrary custom2"><p>pre-existing</p>app<p>another tag</p></div>`
+    );
+    expect(div).toBe(app.el);
+
+    app.unmount();
+    // This assert is a best guess
+    // The use case it covers was not really thought through
+    // and may change in the future
+    expect(fixture.innerHTML).toBe("");
+  });
+
+  test("cannot attach a component to an existing node (if not same tagname)", async () => {
+    class App extends Component {
+      static template = xml`<span>app</span>`;
+    }
+    const div = document.createElement("div");
+    fixture.appendChild(div);
+
+    const app = new App();
+    let error;
+    try {
+      await app.mount(div, { position: "self" });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Cannot attach 'App' to target node (not same tag name)");
+  });
+
+  test("can mount a component (with position='first-child')", async () => {
+    class App extends Component {
+      static template = xml`<div>app</div>`;
+    }
+    const span = document.createElement("span");
+    fixture.appendChild(span);
+
+    const app = new App();
+    await app.mount(fixture, { position: "first-child" });
+    expect(fixture.innerHTML).toBe("<div>app</div><span></span>");
+  });
+
+  test("can mount a component (with position='last-child')", async () => {
+    class App extends Component {
+      static template = xml`<div>app</div>`;
+    }
+    const span = document.createElement("span");
+    fixture.appendChild(span);
+
+    const app = new App();
+    await app.mount(fixture, { position: "last-child" });
+    expect(fixture.innerHTML).toBe("<span></span><div>app</div>");
+  });
+
+  test("default mount option is 'last-child'", async () => {
+    class App extends Component {
+      static template = xml`<div>app</div>`;
+    }
+    const span = document.createElement("span");
+    fixture.appendChild(span);
+
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<span></span><div>app</div>");
+  });
+});
+
+describe("unmounting and remounting", () => {
+  test("widget can be unmounted and remounted", async () => {
+    const steps: string[] = [];
+    class MyWidget extends Component {
+      static template = xml`<div>Hey</div>`;
+      async willStart() {
+        steps.push("willstart");
+      }
+      mounted() {
+        steps.push("mounted");
+      }
+      willUnmount() {
+        steps.push("willunmount");
+      }
+      patched() {
+        throw new Error("patched should not be called");
+      }
+    }
+
+    const w = new MyWidget();
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>Hey</div>");
+    expect(steps).toEqual(["willstart", "mounted"]);
+
+    w.unmount();
+    expect(fixture.innerHTML).toBe("");
+    expect(steps).toEqual(["willstart", "mounted", "willunmount"]);
+
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>Hey</div>");
+    expect(steps).toEqual(["willstart", "mounted", "willunmount", "mounted"]);
+  });
+
+  test("widget can be mounted twice without ill effect", async () => {
+    const steps: string[] = [];
+    class MyWidget extends Component {
+      static template = xml`<div>Hey</div>`;
+      async willStart() {
+        steps.push("willstart");
+      }
+      mounted() {
+        steps.push("mounted");
+      }
+      willUnmount() {
+        steps.push("willunmount");
+      }
+    }
+
+    const w = new MyWidget();
+    await w.mount(fixture);
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>Hey</div>");
+    expect(steps).toEqual(["willstart", "mounted"]);
+  });
+
+  test("state changes in willUnmount do not trigger rerender", async () => {
+    const steps: string[] = [];
+
+    class Child extends Component {
+      static template = xml`
+          <span><t t-esc="props.val"/><t t-esc="state.n"/></span>
+        `;
+      state = useState({ n: 2 });
+      __render(f) {
+        steps.push("render");
+        return super.__render(f);
+      }
+      willPatch() {
+        steps.push("willPatch");
+      }
+      patched() {
+        steps.push("patched");
+      }
+
+      willUnmount() {
+        steps.push("willUnmount");
+        this.state.n = 3;
+      }
+    }
+    class Parent extends Component {
+      static template = xml`
+          <div>
+            <Child t-if="state.flag" val="state.val"/>
+          </div>
+        `;
+      static components = { Child };
+      state = useState({ val: 1, flag: true });
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+    expect(steps).toEqual(["render"]);
+    expect(fixture.innerHTML).toBe("<div><span>12</span></div>");
+    widget.state.flag = false;
+    await nextTick();
+    // we make sure here that no call to __render is done
+    expect(steps).toEqual(["render", "willUnmount"]);
+  });
+
+  test("state changes in willUnmount will be applied on remount", async () => {
+    class TestWidget extends Component {
+      static template = xml`
+          <div><t t-esc="state.val"/></div>
+        `;
+      state = useState({ val: 1 });
+      willUnmount() {
+        this.state.val = 3;
+      }
+    }
+
+    const widget = new TestWidget();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>1</div>");
+    widget.unmount();
+    expect(fixture.innerHTML).toBe("");
+    await nextTick(); // wait for changes to be detected before remounting
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>3</div>");
+    // we want to make sure that there are no remaining tasks left at this point.
+    expect(Component.scheduler.tasks.length).toBe(0);
+  });
+
+  test("sub component is still active after being unmounted and remounted", async () => {
+    class Child extends Component {
+      static template = xml`
+          <p t-on-click="state.value++">
+            <t t-esc="state.value"/>
+          </p>`;
+
+      state = useState({ value: 1 });
+    }
+
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`<div><Child/></div>`;
+    }
+
+    const w = new Parent();
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><p>1</p></div>");
+
+    fixture.querySelector("p")!.click();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><p>2</p></div>");
+    w.unmount();
+    await nextTick();
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><p>2</p></div>");
+    fixture.querySelector("p")!.click();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><p>3</p></div>");
+  });
+
+  test("change state just before mounting component", async () => {
+    const steps: number[] = [];
+    class TestWidget extends Component {
+      static template = xml`
+          <div><t t-esc="state.val"/></div>
+        `;
+      state = useState({ val: 1 });
+      __render(f) {
+        steps.push(this.state.val);
+        return super.__render(f);
+      }
+    }
+    TestWidget.prototype.__render = jest.fn(TestWidget.prototype.__render);
+
+    const widget = new TestWidget();
+    widget.state.val = 2;
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>2</div>");
+    expect(TestWidget.prototype.__render).toHaveBeenCalledTimes(1);
+
+    // unmount and re-mount, as in this case, willStart won't be called, so it's
+    // slightly different
+    widget.unmount();
+    widget.state.val = 3;
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>3</div>");
+    expect(TestWidget.prototype.__render).toHaveBeenCalledTimes(2);
+    expect(steps).toEqual([2, 3]);
+  });
+
+  test("change state while mounting component", async () => {
+    const steps: number[] = [];
+    class TestWidget extends Component {
+      static template = xml`
+          <div><t t-esc="state.val"/></div>
+        `;
+      state = useState({ val: 1 });
+      __render(f) {
+        steps.push(this.state.val);
+        return super.__render(f);
+      }
+    }
+    TestWidget.prototype.__render = jest.fn(TestWidget.prototype.__render);
+    TestWidget.prototype.__patch = jest.fn(TestWidget.prototype.__patch);
+
+    const widget = new TestWidget();
+    let prom = widget.mount(fixture);
+    widget.state.val = 2;
+    await prom;
+    expect(fixture.innerHTML).toBe("<div>2</div>");
+    expect(TestWidget.prototype.__render).toHaveBeenCalledTimes(1);
+
+    // unmount and re-mount, as in this case, willStart won't be called, so it's
+    // slightly different
+    widget.unmount();
+    prom = widget.mount(fixture);
+    widget.state.val = 3;
+    await prom;
+    expect(fixture.innerHTML).toBe("<div>3</div>");
+    expect(TestWidget.prototype.__render).toHaveBeenCalledTimes(3);
+    expect(TestWidget.prototype.__patch).toHaveBeenCalledTimes(2);
+    expect(steps).toEqual([2, 2, 3]);
+  });
+
+  test("change state while component is unmounted", async () => {
+    let child;
+    class Child extends Component {
+      static template = xml`<span t-esc="state.val"/>`;
+      state = useState({
+        val: "C1",
+      });
+      constructor(parent, props) {
+        super(parent, props);
+        child = this;
+      }
+    }
+
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`<div><t t-esc="state.val"/><Child/></div>`;
+      state = useState({ val: "P1" });
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>P1<span>C1</span></div>");
+
+    parent.unmount();
+    expect(fixture.innerHTML).toBe("");
+
+    parent.state.val = "P2";
+    child.state.val = "C2";
+
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>P2<span>C2</span></div>");
+  });
+
+  test("unmount component during a re-rendering", async () => {
+    const def = makeDeferred();
+    class Child extends Component {
+      static template = xml`<span><t t-esc="props.val"/></span>`;
+      willUpdateProps() {
+        return def;
+      }
+    }
+    Child.prototype.__render = jest.fn(Child.prototype.__render);
+
+    class Parent extends Component {
+      static template = xml`<div><Child val="state.val"/></div>`;
+      static components = { Child };
+      state = useState({ val: 1 });
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>1</span></div>");
+    expect(Child.prototype.__render).toBeCalledTimes(1);
+
+    parent.state.val = 2;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>1</span></div>");
+
+    parent.unmount();
+    expect(fixture.innerHTML).toBe("");
+
+    def.resolve();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("");
+    expect(Child.prototype.__render).toBeCalledTimes(1);
+  });
+
+  test("widget can be mounted on different target", async () => {
+    class MyWidget extends Component {
+      static template = xml`<div>Hey</div>`;
+      patched() {
+        throw new Error("patched should not be called");
+      }
+    }
+    const div = document.createElement("div");
+    const span = document.createElement("span");
+    fixture.appendChild(div);
+    fixture.appendChild(span);
+    const w = new MyWidget();
+    await w.mount(div);
+
+    expect(fixture.innerHTML).toBe("<div><div>Hey</div></div><span></span>");
+
+    await w.mount(span);
+    expect(fixture.innerHTML).toBe("<div></div><span><div>Hey</div></span>");
+  });
+
+  test("widget can be mounted on different target, another situation", async () => {
+    const def = makeDeferred();
+    const steps: string[] = [];
+
+    class MyWidget extends Component {
+      static template = xml`<div>Hey</div>`;
+      async willStart() {
+        return def;
+      }
+      patched() {
+        throw new Error("patched should not be called");
+      }
+    }
+    const div = document.createElement("div");
+    const span = document.createElement("span");
+    fixture.appendChild(div);
+    fixture.appendChild(span);
+    const w = new MyWidget();
+
+    w.mount(div).catch(() => steps.push("1 catch"));
+
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div></div><span></span>");
+
+    w.mount(span).then(() => steps.push("2 resolved"));
+
+    // we wait two microticks because this is the number of internal promises
+    // that need to be resolved/rejected, and because we want to prove here
+    // that the first mount operation is cancelled immediately, and not after
+    // one full tick.
+    await nextMicroTick();
+    await nextMicroTick();
+    expect(steps).toEqual(["1 catch"]);
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div></div><span></span>");
+
+    def.resolve();
+    await nextTick();
+    expect(steps).toEqual(["1 catch", "2 resolved"]);
+    expect(fixture.innerHTML).toBe("<div></div><span><div>Hey</div></span>");
+  });
+
+  test("widget can be mounted on same target, another situation", async () => {
+    const def = makeDeferred();
+    const steps: string[] = [];
+
+    class MyWidget extends Component {
+      static template = xml`<div>Hey</div>`;
+      async willStart() {
+        return def;
+      }
+      patched() {
+        throw new Error("patched should not be called");
+      }
+    }
+    const w = new MyWidget();
+
+    w.mount(fixture).then(() => steps.push("1 resolved"));
+
+    await nextTick();
+    expect(fixture.innerHTML).toBe("");
+
+    w.mount(fixture).then(() => steps.push("2 resolved"));
+
+    await nextTick();
+    expect(steps).toEqual([]);
+    expect(fixture.innerHTML).toBe("");
+
+    def.resolve();
+    await nextTick();
+    expect(steps).toEqual(["1 resolved", "2 resolved"]);
+    expect(fixture.innerHTML).toBe("<div>Hey</div>");
+  });
+
+  test("mounting a destroyed widget", async () => {
+    class MyWidget extends Component {
+      static template = xml`<div>Hey</div>`;
+    }
+    const w = new MyWidget();
+    w.destroy(); // because, why not
+
+    let error;
+    try {
+      await w.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(scheduler.tasks.length).toBe(0);
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Cannot mount a destroyed component");
+  });
+});
@@ -32,7 +32,7 @@ describe("Context", () => {
  test("very simple use, with initial value", async () => {
    const testContext = new Context({ value: 123 });

-    class Test extends Component<any, any> {
+    class Test extends Component {
      static template = xml`<div><t t-esc="contextObj.value"/></div>`;
      contextObj = useContext(testContext);
    }
@@ -44,7 +44,7 @@ describe("Context", () => {
  test("useContext hook is reactive, for one component", async () => {
    const testContext = new Context({ value: 123 });

-    class Test extends Component<any, any> {
+    class Test extends Component {
      static template = xml`<div><t t-esc="contextObj.value"/></div>`;
      contextObj = useContext(testContext);
    }
@@ -59,11 +59,11 @@ describe("Context", () => {
  test("two components can subscribe to same context", async () => {
    const testContext = new Context({ value: 123 });

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="contextObj.value"/></span>`;
      contextObj = useContext(testContext);
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child /><Child /></div>`;
      static components = { Child };
    }
@@ -80,7 +80,7 @@ describe("Context", () => {
    const def = makeDeferred();
    const steps: string[] = [];

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="contextObj.value"/></span>`;
      contextObj = useContext(testContext);
      async render() {
@@ -90,7 +90,7 @@ describe("Context", () => {
      }
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child /><Child /></div>`;
      static components = { Child };
    }
@@ -111,13 +111,13 @@ describe("Context", () => {
    const def = makeDeferred();
    const steps: string[] = [];

-    class SlowComp extends Component<any, any> {
+    class SlowComp extends Component {
      static template = xml`<p><t t-esc="props.value"/></p>`;
      willUpdateProps() {
        return def;
      }
    }
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><SlowComp value="contextObj.value"/></span>`;
      static components = { SlowComp };
      contextObj = useContext(testContext);
@@ -128,12 +128,12 @@ describe("Context", () => {
      }
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child /><Child /></div>`;
      static components = { Child };
    }

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><Child /><Parent /></div>`;
      static components = { Child, Parent };
    }
@@ -166,7 +166,7 @@ describe("Context", () => {
    const testContext = new Context({ a: 1, b: 2 });
    const steps: string[] = [];

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="contextObj1.a"/><t t-esc="contextObj2.b"/></span>`;
      contextObj1 = useContext(testContext);
      contextObj2 = useContext(testContext);
@@ -175,7 +175,7 @@ describe("Context", () => {
        return super.__render(fiber);
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child /></div>`;
      static components = { Child };
    }
@@ -193,7 +193,7 @@ describe("Context", () => {
    const testContext = new Context({ a: 123, b: 321 });
    const steps: string[] = [];

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="contextObj.a"/></span>`;
      contextObj = useContext(testContext);
      __render(fiber) {
@@ -201,7 +201,7 @@ describe("Context", () => {
        return super.__render(fiber);
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child /><t t-esc="contextObj.b"/></div>`;
      static components = { Child };
      contextObj = useContext(testContext);
@@ -227,7 +227,7 @@ describe("Context", () => {
    const testContext = new Context({ a: 123 });
    const steps: string[] = [];

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="contextObj.a"/></span>`;
      contextObj = useContext(testContext);
      __render(fiber) {
@@ -235,7 +235,7 @@ describe("Context", () => {
        return super.__render(fiber);
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child t-if="state.flag"/></div>`;
      static components = { Child };
      state = useState({ flag: true });
@@ -263,14 +263,14 @@ describe("Context", () => {
  test("destroyed component before being mounted is inactive", async () => {
    const testContext = new Context({ a: 123 });

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="contextObj.a"/></span>`;
      contextObj = useContext(testContext);
      willStart() {
        return makeDeferred();
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child t-if="state.flag"/></div>`;
      static components = { Child };
      state = useState({ flag: true });
@@ -293,7 +293,7 @@ describe("Context", () => {
    const testContext = new Context({ x: { n: 1 }, key: "x" });
    const def = makeDeferred();
    let stateC;
-    class ComponentC extends Component<any, any> {
+    class ComponentC extends Component {
      static template = xml`<span><t t-esc="context[props.key].n"/><t t-esc="state.x"/></span>`;
      context = useContext(testContext);
      state = useState({ x: "a" });
@@ -303,7 +303,7 @@ describe("Context", () => {
        stateC = this.state;
      }
    }
-    class ComponentB extends Component<any, any> {
+    class ComponentB extends Component {
      static components = { ComponentC };
      static template = xml`<p><ComponentC key="props.key"/></p>`;

@@ -311,7 +311,7 @@ describe("Context", () => {
        return def;
      }
    }
-    class ComponentA extends Component<any, any> {
+    class ComponentA extends Component {
      static components = { ComponentB };
      static template = xml`<div><ComponentB key="context.key"/></div>`;
      context = useContext(testContext);
@@ -14,7 +14,7 @@ describe("event bus behaviour", () => {
    expect.assertions(1);
    const bus = new EventBus();
    const owner = {};
-    bus.on("event", owner, function(this: any) {
+    bus.on("event", owner, function (this: any) {
      expect(this).toBe(owner);
    });
    bus.trigger("event");
@@ -22,7 +22,7 @@ describe("observer", () => {
    expect(observer.rev).toBe(2);

    expect(obj2).toEqual({
-      a: 2
+      a: 2,
    });
  });

@@ -47,7 +47,7 @@ describe("observer", () => {
    expect(observer.rev).toBe(5);
    expect(obj).toEqual({
      a: null,
-      b: undefined
+      b: undefined,
    });
  });

@@ -6,9 +6,10 @@ import { patch } from "../src/vdom";
 import "../src/qweb/base_directives";
 import "../src/qweb/extensions";
 import "../src/component/directive";
+import { browser } from "../src/browser";

 // modifies scheduler to make it faster to test components
-scheduler.requestAnimationFrame = function(callback: FrameRequestCallback) {
+scheduler.requestAnimationFrame = function (callback: FrameRequestCallback) {
  setTimeout(callback, 1);
  return 1;
 };
@@ -42,7 +43,7 @@ export function nextMicroTick(): Promise<void> {
 }

 export async function nextTick(): Promise<void> {
-  return new Promise(function(resolve) {
+  return new Promise(function (resolve) {
    setTimeout(() => scheduler.requestAnimationFrame(() => resolve()));
  });
 }
@@ -75,7 +76,8 @@ export function makeDeferred(): Deferred {

 export function makeTestEnv(): Env {
  return {
-    qweb: new QWeb()
+    qweb: new QWeb(),
+    browser: browser,
  };
 }

@@ -9,7 +9,8 @@ import {
  onWillPatch,
  onWillStart,
  onWillUpdateProps,
-  useSubEnv
+  useSubEnv,
+  useExternalListener,
 } from "../src/hooks";
 import { xml } from "../src/tags";

@@ -41,7 +42,7 @@ afterEach(() => {

 describe("hooks", () => {
  test("can use a state hook", async () => {
-    class Counter extends Component<any, any> {
+    class Counter extends Component {
      static template = xml`<div><t t-esc="counter.value"/></div>`;
      counter = useState({ value: 42 });
    }
@@ -63,7 +64,7 @@ describe("hooks", () => {
        steps.push("willunmount");
      });
    }
-    class MyComponent extends Component<any, any> {
+    class MyComponent extends Component {
      static template = xml`<div>hey</div>`;
      constructor() {
        super();
@@ -91,7 +92,7 @@ describe("hooks", () => {
        steps.push("willunmount");
      });
    }
-    class MyComponent extends Component<any, any> {
+    class MyComponent extends Component {
      static template = xml`<div>hey</div>`;
      constructor(parent, props) {
        super(parent, props);
@@ -99,7 +100,7 @@ describe("hooks", () => {
      }
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><MyComponent t-if="state.flag"/></div>`;
      static components = { MyComponent };
      state = useState({ flag: true });
@@ -125,7 +126,7 @@ describe("hooks", () => {
        steps.push("hook:willunmount");
      });
    }
-    class MyComponent extends Component<any, any> {
+    class MyComponent extends Component {
      static template = xml`<div>hey</div>`;
      constructor() {
        super();
@@ -156,7 +157,7 @@ describe("hooks", () => {
        steps.push("hook:willunmount");
      });
    }
-    class MyComponent extends Component<any, any> {
+    class MyComponent extends Component {
      static template = xml`<div>hey</div>`;
      constructor(parent, props) {
        super(parent, props);
@@ -170,7 +171,7 @@ describe("hooks", () => {
      }
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><MyComponent t-if="state.flag"/></div>`;
      static components = { MyComponent };
      state = useState({ flag: true });
@@ -196,7 +197,7 @@ describe("hooks", () => {
        steps.push("hook:willunmount" + i);
      });
    }
-    class MyComponent extends Component<any, any> {
+    class MyComponent extends Component {
      static template = xml`<div>hey</div>`;
      constructor() {
        super();
@@ -213,12 +214,12 @@ describe("hooks", () => {
      "hook:mounted1",
      "hook:mounted2",
      "hook:willunmount2",
-      "hook:willunmount1"
+      "hook:willunmount1",
    ]);
  });

  test("useRef hook", async () => {
-    class Counter extends Component<any, any> {
+    class Counter extends Component {
      static template = xml`<div><button t-ref="button"><t t-esc="value"/></button></div>`;
      button = useRef("button");
      value = 0;
@@ -240,7 +241,7 @@ describe("hooks", () => {

  test("useRef hook is null if ref is removed ", async () => {
    expect.assertions(4);
-    class TestRef extends Component<any, any> {
+    class TestRef extends Component {
      static template = xml`<div><span t-if="state.flag" t-ref="span">owl</span></div>`;
      spanRef = useRef("span");
      state = useState({ flag: true });
@@ -260,13 +261,13 @@ describe("hooks", () => {
  });

  test("t-refs on widget are components", async () => {
-    class WidgetB extends Component<any, any> {
+    class WidgetB extends Component {
      static template = xml`<div>b</div>`;
    }
-    class WidgetC extends Component<any, any> {
+    class WidgetC extends Component {
      static template = xml`<div class="outer-div">Hello<WidgetB t-ref="mywidgetb" /></div>`;
      static components = { WidgetB };
-      ref = useRef("mywidgetb");
+      ref = useRef<WidgetB>("mywidgetb");
    }

    const widget = new WidgetC();
@@ -279,11 +280,11 @@ describe("hooks", () => {

  test("t-refs are bound at proper timing", async () => {
    expect.assertions(2);
-    class Widget extends Component<any, any> {
+    class Widget extends Component {
      static template = xml`<div>widget</div>`;
    }

-    class ParentWidget extends Component<any, any> {
+    class ParentWidget extends Component {
      static template = xml`
        <div>
          <t t-foreach="state.list" t-as="elem" t-ref="child" t-key="elem" t-component="Widget"/>
@@ -308,10 +309,10 @@ describe("hooks", () => {

  test("t-refs are bound at proper timing (2)", async () => {
    expect.assertions(10);
-    class Widget extends Component<any, any> {
+    class Widget extends Component {
      static template = xml`<div>widget</div>`;
    }
-    class ParentWidget extends Component<any, any> {
+    class ParentWidget extends Component {
      static template = xml`
        <div>
          <t t-if="state.child1" t-ref="child1" t-component="Widget"/>
@@ -368,7 +369,7 @@ describe("hooks", () => {
      });
    }

-    class MyComponent extends Component<any, any> {
+    class MyComponent extends Component {
      static template = xml`<div><t t-if="state.flag">hey</t></div>`;
      state = useState({ flag: true });

@@ -402,7 +403,7 @@ describe("hooks", () => {
        steps.push("hook:willPatch");
      });
    }
-    class MyComponent extends Component<any, any> {
+    class MyComponent extends Component {
      static template = xml`<div><t t-if="state.flag">hey</t></div>`;
      state = useState({ flag: true });

@@ -436,7 +437,7 @@ describe("hooks", () => {
        steps.push("hook:willPatch" + i);
      });
    }
-    class MyComponent extends Component<any, any> {
+    class MyComponent extends Component {
      static template = xml`<div>hey<t t-esc="state.value"/></div>`;
      state = useState({ value: 1 });
      constructor() {
@@ -472,7 +473,7 @@ describe("hooks", () => {
    }

    test("simple input", async () => {
-      class SomeComponent extends Component<any, any> {
+      class SomeComponent extends Component {
        static template = xml`
            <div>
                <input t-ref="input1"/>
@@ -493,7 +494,7 @@ describe("hooks", () => {
    });

    test("input in a t-if", async () => {
-      class SomeComponent extends Component<any, any> {
+      class SomeComponent extends Component {
        static template = xml`
            <div>
                <input t-ref="input1"/>
@@ -520,7 +521,7 @@ describe("hooks", () => {
  });

  test("can use sub env", async () => {
-    class TestComponent extends Component<any, any> {
+    class TestComponent extends Component {
      static template = xml`<div><t t-esc="env.val"/></div>`;
      constructor() {
        super();
@@ -535,7 +536,7 @@ describe("hooks", () => {
  });

  test("parent and child env", async () => {
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<div><t t-esc="env.val"/></div>`;
      constructor(parent, props) {
        super(parent, props);
@@ -543,7 +544,7 @@ describe("hooks", () => {
      }
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><t t-esc="env.val"/><Child/></div>`;
      static components = { Child };
      constructor() {
@@ -558,23 +559,42 @@ describe("hooks", () => {

  test("can use onWillStart, onWillUpdateProps", async () => {
    const steps: string[] = [];
+    async function slow(): Promise<string> {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve("slow");
+        }, 0);
+      });
+    }
    function useMyHook() {
-      onWillStart(() => {
+      onWillStart(async () => {
+        steps.push(await slow());
        steps.push("onWillStart");
      });
-      onWillUpdateProps(nextProps => {
+      onWillUpdateProps(async (nextProps) => {
        expect(nextProps).toEqual({ value: 2 });
+        steps.push(await slow());
        steps.push("onWillUpdateProps");
      });
    }
-    class MyComponent extends Component<any, any> {
+    function use2ndHook() {
+      onWillStart(() => {
+        steps.push("on2ndStart");
+      });
+      onWillUpdateProps((nextProps) => {
+        expect(nextProps).toEqual({ value: 2 });
+        steps.push("on2ndUpdate");
+      });
+    }
+    class MyComponent extends Component {
      static template = xml`<span><t t-esc="props.value"/></span>`;
      constructor(parent, props) {
        super(parent, props);
        useMyHook();
+        use2ndHook();
      }
    }
-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><MyComponent value="state.value"/></div>`;
      static components = { MyComponent };
      state = useState({ value: 1 });
@@ -585,11 +605,60 @@ describe("hooks", () => {
    expect(app).not.toHaveProperty("willStart");
    expect(app).not.toHaveProperty("willUpdateProps");
    expect(fixture.innerHTML).toBe("<div><span>1</span></div>");
-    expect(steps).toEqual(["onWillStart"]);
+
+    // NOTE: 'on2ndStart' appears first in the list even though
+    // the 'use2ndHook' is declared after 'useMyHook'. This is
+    // because Promise.all is used to call the callbacks specified
+    // in the hooks, which runs them simultaneously.
+    // Additionally, 'slow' should be listed before 'onWillStart'
+    // because call to `slow` is awaited.
+    expect(steps).toEqual(["on2ndStart", "slow", "onWillStart"]);

    app.state.value = 2;
    await nextTick();
    expect(fixture.innerHTML).toBe("<div><span>2</span></div>");
-    expect(steps).toEqual(["onWillStart", "onWillUpdateProps"]);
+    expect(steps).toEqual([
+      "on2ndStart",
+      "slow",
+      "onWillStart",
+      "on2ndUpdate",
+      "slow",
+      "onWillUpdateProps",
+    ]);
+  });
+
+  test("useExternalListener", async () => {
+    let n = 0;
+
+    class MyComponent extends Component {
+      static template = xml`<span><t t-esc="props.value"/></span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        useExternalListener(window as any, "click", this.increment);
+      }
+      increment() {
+        n++;
+      }
+    }
+    class App extends Component {
+      static template = xml`<div><MyComponent t-if="state.flag"/></div>`;
+      static components = { MyComponent };
+      state = useState({ flag: false });
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+
+    expect(n).toBe(0);
+    window.dispatchEvent(new Event("click"));
+    expect(n).toBe(0);
+    app.state.flag = true;
+    await nextTick();
+    window.dispatchEvent(new Event("click"));
+    expect(n).toBe(1);
+    app.state.flag = false;
+    await nextTick();
+    window.dispatchEvent(new Event("click"));
+    expect(n).toBe(1);
  });
 });
@@ -27,7 +27,7 @@ afterEach(() => {
 describe("Asyncroot", () => {
  test("delayed component with AsyncRoot component", async () => {
    let def;
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="props.val"/></span>`;
    }
    class AsyncChild extends Child {
@@ -35,7 +35,7 @@ describe("Asyncroot", () => {
        return def;
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`
          <div>
            <button t-on-click="updateApp">Update App State</button>
@@ -74,7 +74,7 @@ describe("Asyncroot", () => {

  test("fast component with AsyncRoot", async () => {
    let def;
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="props.val"/></span>`;
    }
    class AsyncChild extends Child {
@@ -83,7 +83,7 @@ describe("Asyncroot", () => {
      }
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`
          <div>
            <button t-on-click="updateApp">Update App State</button>
@@ -122,7 +122,7 @@ describe("Asyncroot", () => {

  test("asyncroot component: mixed re-renderings", async () => {
    let def;
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`
        <span t-on-click="increment">
          <t t-esc="state.val"/>/<t t-esc="props.val"/>
@@ -138,7 +138,7 @@ describe("Asyncroot", () => {
        return def;
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`
        <div>
          <button t-on-click="updateApp">Update App State</button>
@@ -36,7 +36,7 @@ describe("Portal: Props validation", () => {
  test("target is mandatory", async () => {
    const dev = QWeb.dev;
    QWeb.dev = true;
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -61,7 +61,7 @@ describe("Portal: Props validation", () => {
  test("target is not list", async () => {
    const dev = QWeb.dev;
    QWeb.dev = true;
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -88,7 +88,7 @@ describe("Portal: Basic use and DOM placement", () => {
  test("basic use of portal", async () => {
    const dev = QWeb.dev;
    QWeb.dev = true;
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -113,7 +113,7 @@ describe("Portal: Basic use and DOM placement", () => {
  });

  test("conditional use of Portal", async () => {
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -148,10 +148,10 @@ describe("Portal: Basic use and DOM placement", () => {
  });

  test("conditional use of Portal (with sub Component)", async () => {
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<div><t t-esc="props.val"/></div>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div>
@@ -190,7 +190,7 @@ describe("Portal: Basic use and DOM placement", () => {
  });

  test("with target in template (before portal)", async () => {
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -210,7 +210,7 @@ describe("Portal: Basic use and DOM placement", () => {
  });

  test("with target in template (after portal)", async () => {
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -233,7 +233,7 @@ describe("Portal: Basic use and DOM placement", () => {
    const consoleError = console.error;
    console.error = jest.fn(() => {});

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -260,7 +260,7 @@ describe("Portal: Basic use and DOM placement", () => {

  test("portal with child and props", async () => {
    const steps: string[] = [];
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="props.val"/></span>`;
      mounted() {
        steps.push("mounted");
@@ -271,7 +271,7 @@ describe("Portal: Basic use and DOM placement", () => {
        expect(outside.innerHTML).toBe("<span>2</span>");
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div>
@@ -298,7 +298,7 @@ describe("Portal: Basic use and DOM placement", () => {
    const consoleError = console.error;
    console.error = jest.fn(() => {});

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -326,7 +326,7 @@ describe("Portal: Basic use and DOM placement", () => {
    const consoleError = console.error;
    console.error = jest.fn(() => {});

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -354,7 +354,7 @@ describe("Portal: Basic use and DOM placement", () => {
    const consoleError = console.error;
    console.error = jest.fn(() => {});

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -379,7 +379,7 @@ describe("Portal: Basic use and DOM placement", () => {
  });

  test("portal with dynamic body", async () => {
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -405,7 +405,7 @@ describe("Portal: Basic use and DOM placement", () => {
    const consoleError = console.error;
    console.error = jest.fn(() => {});

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -439,7 +439,7 @@ describe("Portal: Basic use and DOM placement", () => {
  test("lifecycle hooks of portal sub component are properly called", async () => {
    const steps: any[] = [];

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span t-esc="props.val"/>`;
      mounted() {
        steps.push("child:mounted");
@@ -454,7 +454,7 @@ describe("Portal: Basic use and DOM placement", () => {
        steps.push("child:willUnmount");
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div>
@@ -486,7 +486,7 @@ describe("Portal: Basic use and DOM placement", () => {
      "parent:mounted",
      "parent:willPatch",
      "child:mounted",
-      "parent:patched"
+      "parent:patched",
    ]);

    parent.state.val = 2;
@@ -499,7 +499,7 @@ describe("Portal: Basic use and DOM placement", () => {
      "parent:willPatch",
      "child:willPatch",
      "child:patched",
-      "parent:patched"
+      "parent:patched",
    ]);

    parent.state.hasChild = false;
@@ -515,16 +515,16 @@ describe("Portal: Basic use and DOM placement", () => {
      "parent:patched",
      "parent:willPatch",
      "child:willUnmount",
-      "parent:patched"
+      "parent:patched",
    ]);
  });

  test("portal destroys on crash", async () => {
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span t-esc="props.error and this.will.crash" />`;
      state = {};
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div>
@@ -550,7 +550,7 @@ describe("Portal: Basic use and DOM placement", () => {
  });

  test("portal manual unmount", async () => {
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -577,7 +577,7 @@ describe("Portal: Basic use and DOM placement", () => {

  test("portal manual unmount with subcomponent", async () => {
    expect.assertions(9);
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span>gloria</span>`;
      mounted() {
        expect(outside.contains(this.el)).toBeTruthy();
@@ -586,7 +586,7 @@ describe("Portal: Basic use and DOM placement", () => {
        expect(outside.contains(this.el)).toBeTruthy();
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div>
@@ -614,7 +614,7 @@ describe("Portal: Basic use and DOM placement", () => {

 describe("Portal: Events handling", () => {
  test("events triggered on movable pure node are handled", async () => {
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal };
      static template = xml`
        <div>
@@ -638,8 +638,8 @@ describe("Portal: Events handling", () => {
  });

  test("events triggered on movable owl components are redirected", async () => {
-    let childInst: Component<any, any> | null = null;
-    class Child extends Component<any, any> {
+    let childInst: Component | null = null;
+    class Child extends Component {
      static template = xml`
         <span t-on-custom="_onCustom" t-esc="props.val"/>`;

@@ -652,7 +652,7 @@ describe("Portal: Events handling", () => {
        this.trigger("custom-portal");
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div t-on-custom-portal="_onCustomPortal">
@@ -677,8 +677,8 @@ describe("Portal: Events handling", () => {

  test("events triggered on contained movable owl components are redirected", async () => {
    const steps: string[] = [];
-    let childInst: Component<any, any> | null = null;
-    class Child extends Component<any, any> {
+    let childInst: Component | null = null;
+    class Child extends Component {
      static template = xml`
         <span t-on-custom="_onCustom"/>`;

@@ -691,7 +691,7 @@ describe("Portal: Events handling", () => {
        this.trigger("custom-portal");
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div t-on-custom="_handled" t-on-custom-portal="_handled">
@@ -717,9 +717,9 @@ describe("Portal: Events handling", () => {
  });

  test("Dom events are not mapped", async () => {
-    let childInst: Component<any, any> | null = null;
+    let childInst: Component | null = null;
    const steps: string[] = [];
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`
        <button>child</button>`;

@@ -728,7 +728,7 @@ describe("Portal: Events handling", () => {
        childInst = this;
      }
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div t-on-click="_handled">
@@ -741,7 +741,7 @@ describe("Portal: Events handling", () => {
        steps.push(ev.type as string);
      }
    }
-    const bodyListener = ev => {
+    const bodyListener = (ev) => {
      steps.push(`body: ${ev.type}`);
    };
    document.body.addEventListener("click", bodyListener);
@@ -760,22 +760,22 @@ describe("Portal: Events handling", () => {
    fixture.appendChild(outside2);

    const steps: Array<string> = [];
-    let childInst: Component<any, any> | null = null;
-    class Child2 extends Component<any, any> {
+    let childInst: Component | null = null;
+    class Child2 extends Component {
      static template = xml`<div>child2</div>`;
      constructor(parent, props) {
        super(parent, props);
        childInst = this;
      }
    }
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static components = { Portal, Child2 };
      static template = xml`
        <Portal target="'#outside2'">
          <Child2 />
        </Portal>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div t-on-custom='_handled'>
@@ -797,11 +797,11 @@ describe("Portal: Events handling", () => {
  });

  test("portal's parent's env is not polluted", async () => {
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`
        <button>child</button>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div>
@@ -818,22 +818,22 @@ describe("Portal: Events handling", () => {

  test("Portal composed with t-slot", async () => {
    const steps: Array<string> = [];
-    let childInst: Component<any, any> | null = null;
-    class Child2 extends Component<any, any> {
+    let childInst: Component | null = null;
+    class Child2 extends Component {
      static template = xml`<div>child2</div>`;
      constructor(parent, props) {
        super(parent, props);
        childInst = this;
      }
    }
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static components = { Portal, Child2 };
      static template = xml`
        <Portal target="'#outside'">
          <t t-slot="default"/>
        </Portal>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Child, Child2 };
      static template = xml`
        <div t-on-custom='_handled'>
@@ -857,11 +857,11 @@ describe("Portal: Events handling", () => {

 describe("Portal: UI/UX", () => {
  test("focus is kept across re-renders", async () => {
-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`
        <input id="target-me" t-att-placeholder="props.val"/>`;
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static components = { Portal, Child };
      static template = xml`
        <div>
@@ -51,6 +51,16 @@ describe("static templates", () => {
    expect(renderToString(qweb, "test")).toBe(`<div class="abc">word</div>`);
  });

+  test("div with a class attribute with a quote", () => {
+    qweb.addTemplate("test", `<div class="a'bc">word</div>`);
+    expect(renderToString(qweb, "test")).toBe(`<div class="a'bc">word</div>`);
+  });
+
+  test("div with an arbitrary attribute with a quote", () => {
+    qweb.addTemplate("test", `<div abc="a'bc">word</div>`);
+    expect(renderToString(qweb, "test")).toBe(`<div abc="a'bc">word</div>`);
+  });
+
  test("div with a empty class attribute", () => {
    qweb.addTemplate("test", `<div class="">word</div>`);
    expect(renderToString(qweb, "test")).toBe(`<div>word</div>`);
@@ -65,6 +75,19 @@ describe("static templates", () => {
    qweb.addTemplate("test", "<div>hello <!-- comment-->owl</div>");
    expect(renderToString(qweb, "test")).toBe("<div>hello <!-- comment-->owl</div>");
  });
+
+  test("properly handle comments between t-if/t-else", () => {
+    qweb.addTemplate(
+      "test",
+      `
+      <div>
+        <span t-if="true">true</span>
+        <!-- comment-->
+        <span t-else="">owl</span>
+      </div>`
+    );
+    expect(renderToString(qweb, "test")).toBe("<div><span>true</span></div>");
+  });
 });

 describe("error handling", () => {
@@ -141,17 +164,56 @@ describe("t-esc", () => {
    qweb.addTemplate("test", `<span t-esc="var">nope</span>`);
    expect(renderToString(qweb, "test")).toBe("<span>nope</span>");
  });
+
  test("t-esc is escaped", () => {
    qweb.addTemplate("test", `<div><t t-set="var"><p>escaped</p></t><t t-esc="var"/></div>`);
    const domRendered = renderToDOM(qweb, "test");
    expect(domRendered.textContent).toBe("<p>escaped</p>");
  });
+
  test("t-esc=0 is escaped", () => {
    qweb.addTemplate("test", `<span><t t-esc="0"/></span>`);
    qweb.addTemplate("testCaller", `<div><t t-call="test"><p>escaped</p></t></div>`);
    const domRendered = renderToDOM(qweb, "testCaller") as HTMLElement;
    expect(domRendered.querySelector("span")!.textContent).toBe("<p>escaped</p>");
  });
+
+  test("div with falsy values", () => {
+    qweb.addTemplate(
+      "test",
+      `
+      <div>
+        <p t-esc="v1"/>
+        <p t-esc="v2"/>
+        <p t-esc="v3"/>
+        <p t-esc="v4"/>
+        <p t-esc="v5"/>
+      </div>`
+    );
+    const vals = {
+      v1: false,
+      v2: undefined,
+      v3: null,
+      v4: 0,
+      v5: "",
+    };
+    expect(renderToString(qweb, "test", vals)).toBe(
+      "<div><p>false</p><p></p><p></p><p>0</p><p></p></div>"
+    );
+  });
+
+  test("t-esc work with spread operator", () => {
+    qweb.addTemplate("test", `<span><t t-esc="[...state.list]"/></span>`);
+    const result = renderToString(qweb, "test", { state: { list: [1, 2] } });
+    expect(result).toBe("<span>1,2</span>");
+  });
+
+  test("t-esc inside t-call, with t-set outside", () => {
+    qweb.addTemplate("main", `<div><t t-set="v">Hi</t><t t-call="sub"/></div>`);
+    qweb.addTemplate("sub", `<span t-esc="v"/>`);
+    const result = renderToString(qweb, "main");
+    expect(result).toBe("<div><span>Hi</span></div>");
+  });
 });

 describe("t-raw", () => {
@@ -258,6 +320,18 @@ describe("t-set", () => {
    );
  });

+  test("t-set with content and sub t-esc", () => {
+    qweb.addTemplate(
+      "test",
+      `<div>
+        <t t-set="setvar"><t t-esc="beep"/> boop</t>
+        <t t-esc="setvar"/>
+      </div>`
+    );
+
+    expect(renderToString(qweb, "test", { beep: "beep" })).toBe("<div>beep boop</div>");
+  });
+
  test("evaluate value expression, part 2", () => {
    qweb.addTemplate(
      "test",
@@ -419,7 +493,7 @@ describe("t-if", () => {
      cond3: false,
      cond4: false,
      m: 5,
-      n: 2
+      n: 2,
    };
    expect(normalize(renderToString(qweb, "test", context))).toBe("<div>andormgtnlt</div>");
  });
@@ -558,7 +632,7 @@ describe("attributes", () => {
  test("object", () => {
    qweb.addTemplate("test", `<div t-att="value"/>`);
    const result = renderToString(qweb, "test", {
-      value: { a: 1, b: 2, c: 3 }
+      value: { a: 1, b: 2, c: 3 },
    });
    expect(result).toBe(`<div a="1" b="2" c="3"></div>`);
  });
@@ -617,7 +691,7 @@ describe("attributes", () => {
    const result = renderToString(qweb, "test", {
      value1: 0,
      value2: 1,
-      value3: 2
+      value3: 2,
    });
    expect(result).toBe(`<div foo="a 0 is 1 of 2 ]"></div>`);
  });
@@ -636,7 +710,7 @@ describe("attributes", () => {
    const result = renderToString(qweb, "test", {
      bar: 0,
      baz: 1,
-      qux: { qux: "<>" }
+      qux: { qux: "<>" },
    });
    const expected = '<div foo="<foo" bar="0" baz="<1>" qux="<>"></div>';
    expect(result).toBe(expected);
@@ -648,6 +722,12 @@ describe("attributes", () => {
    expect(result).toBe(`<div class="hello world"></div>`);
  });

+  test("class and t-att-class should combine together", () => {
+    qweb.addTemplate("test", `<div t-att-class="value" class="hello" />`);
+    const result = renderToString(qweb, "test", { value: "world" });
+    expect(result).toBe(`<div class="world hello"></div>`);
+  });
+
  test("class and t-attf-class with ternary operation", () => {
    qweb.addTemplate("test", `<div class="hello" t-attf-class="{{value ? 'world' : ''}}"/>`);
    const result = renderToString(qweb, "test", { value: true });
@@ -877,6 +957,38 @@ describe("t-call (template calling", () => {
    expect(recursiveFn.toString()).toMatchSnapshot();
  });

+  test("recursive template, part 4: with t-set recursive index", () => {
+    qweb.addTemplates(`
+        <templates>
+            <div t-name="Parent">
+                <t t-call="nodeTemplate">
+                    <t t-set="recursive_idx" t-value="1"/>
+                    <t t-set="node" t-value="root"/>
+                </t>
+            </div>
+            <div t-name="nodeTemplate">
+                <t t-set="recursive_idx" t-value="recursive_idx + 1"/>
+                <p><t t-esc="node.val"/> <t t-esc="recursive_idx"/></p>
+                <t t-foreach="node.children or []" t-as="subtree">
+                    <t t-call="nodeTemplate">
+                        <t t-set="node" t-value="subtree"/>
+                    </t>
+                </t>
+            </div>
+
+        </templates>
+    `);
+    const root = {
+      val: "a",
+      children: [{ val: "b", children: [{ val: "c", children: [{ val: "d" }] }] }],
+    };
+    const expected =
+      "<div><div><p>a 2</p><div><p>b 3</p><div><p>c 4</p><div><p>d 5</p></div></div></div></div></div>";
+    expect(renderToString(qweb, "Parent", { root })).toBe(expected);
+    const recursiveFn = Object.values(qweb.subTemplates)[0] as any;
+    expect(recursiveFn.toString()).toMatchSnapshot();
+  });
+
  test("t-call, global templates", () => {
    QWeb.registerTemplate("abcd", '<div><t t-call="john"/></div>');
    qweb.addTemplate("john", `<span>desk</span>`);
@@ -1130,7 +1242,7 @@ describe("t-on", () => {
      {
        add() {
          a = 3;
-        }
+        },
      },
      { handlers: [] }
    );
@@ -1153,7 +1265,7 @@ describe("t-on", () => {
        },
        handleDblClick() {
          steps.push("dblclick");
-        }
+        },
      },
      { handlers: [] }
    );
@@ -1173,7 +1285,7 @@ describe("t-on", () => {
      {
        add(n) {
          a = a + n;
-        }
+        },
      },
      { handlers: [] }
    );
@@ -1190,7 +1302,7 @@ describe("t-on", () => {
      {
        add({ val }) {
          a = a + val;
-        }
+        },
      },
      { handlers: [] }
    );
@@ -1207,7 +1319,7 @@ describe("t-on", () => {
      {
        doSomething(arg) {
          expect(arg).toEqual({});
-        }
+        },
      },
      { handlers: [] }
    );
@@ -1223,7 +1335,7 @@ describe("t-on", () => {
      {
        doSomething(arg) {
          expect(arg).toEqual({});
-        }
+        },
      },
      { handlers: [] }
    );
@@ -1245,7 +1357,7 @@ describe("t-on", () => {
      {
        activate(action) {
          expect(action).toBe("someval");
-        }
+        },
      },
      { handlers: [] }
    );
@@ -1258,7 +1370,7 @@ describe("t-on", () => {
    let owner = {
      add() {
        expect(this).toBe(owner);
-      }
+      },
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });
    (<HTMLElement>node).click();
@@ -1268,8 +1380,8 @@ describe("t-on", () => {
    qweb.addTemplate("test", `<button t-on-click="state.counter++">Click</button>`);
    let owner = {
      state: {
-        counter: 0
-      }
+        counter: 0,
+      },
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });
    expect(owner.state.counter).toBe(0);
@@ -1282,10 +1394,10 @@ describe("t-on", () => {
    let owner = {
      state: {
        counter: 0,
-        incrementCounter: inc => {
+        incrementCounter: (inc) => {
          owner.state.counter += inc;
-        }
-      }
+        },
+      },
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });
    expect(owner.state.counter).toBe(0);
@@ -1297,8 +1409,8 @@ describe("t-on", () => {
    qweb.addTemplate("test", `<button t-on-click="state.flag = !state.flag">Toggle</button>`);
    let owner = {
      state: {
-        flag: true
-      }
+        flag: true,
+      },
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });
    expect(owner.state.flag).toBe(true);
@@ -1315,8 +1427,8 @@ describe("t-on", () => {
        return n + 1;
      },
      state: {
-        n: 11
-      }
+        n: 11,
+      },
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });
    expect(owner.state.n).toBe(11);
@@ -1332,7 +1444,7 @@ describe("t-on", () => {
    let owner = {
      update() {
        expect(this).toBe(owner);
-      }
+      },
    };

    const node = renderToDOM(qweb, "main", owner, { handlers: [] });
@@ -1349,7 +1461,7 @@ describe("t-on", () => {
        expect(this).toBe(owner);
        expect(val).toBe(444);
      },
-      value: 444
+      value: 444,
    };

    const node = renderToDOM(qweb, "main", owner, { handlers: [] });
@@ -1378,7 +1490,7 @@ describe("t-on", () => {
      onClickPreventedAndStopped(e) {
        expect(e.defaultPrevented).toBe(true);
        expect(e.cancelBubble).toBe(true);
-      }
+      },
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });

@@ -1404,7 +1516,7 @@ describe("t-on", () => {
      },
      onClickSelf(e) {
        steps.push("onClickSelf");
-      }
+      },
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });

@@ -1428,10 +1540,10 @@ describe("t-on", () => {
    );
    let steps: boolean[] = [];
    let owner = {
-      onClick() {}
+      onClick() {},
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });
-    (<HTMLElement>node).addEventListener("click", function(e) {
+    (<HTMLElement>node).addEventListener("click", function (e) {
      steps.push(e.defaultPrevented);
    });

@@ -1453,10 +1565,10 @@ describe("t-on", () => {
    );
    let steps: boolean[] = [];
    let owner = {
-      onClick() {}
+      onClick() {},
    };
    const node = renderToDOM(qweb, "test", owner, { handlers: [] });
-    (<HTMLElement>node).addEventListener("click", function(e) {
+    (<HTMLElement>node).addEventListener("click", function (e) {
      steps.push(e.defaultPrevented);
    });

@@ -1484,13 +1596,13 @@ describe("t-on", () => {
    const owner = {
      projects: [
        { id: 1, name: "Project 1" },
-        { id: 2, name: "Project 2" }
+        { id: 2, name: "Project 2" },
      ],

      onEdit(projectId, ev) {
        expect(ev.defaultPrevented).toBe(true);
        steps.push(projectId);
-      }
+      },
    };

    const node = <HTMLElement>renderToDOM(qweb, "test", owner, { handlers: [] });
@@ -1515,7 +1627,7 @@ describe("t-on", () => {
    );
    const node = renderToDOM(qweb, "test", {}, { handlers: [] });

-    node.addEventListener("click", e => {
+    node.addEventListener("click", (e) => {
      expect(e.defaultPrevented).toBe(true);
    });

@@ -1531,7 +1643,7 @@ describe("t-on", () => {
      text: "Click here",
      onClick() {
        steps.push("onClick");
-      }
+      },
    };

    const node = <HTMLElement>renderToDOM(qweb, "test", owner, { handlers: [] });
@@ -1550,7 +1662,7 @@ describe("t-on", () => {
      html: "Click <b>here</b>",
      onClick() {
        steps.push("onClick");
-      }
+      },
    };

    const node = <HTMLElement>renderToDOM(qweb, "test", owner, { handlers: [] });
@@ -1560,6 +1672,31 @@ describe("t-on", () => {

    expect(steps).toEqual(["onClick"]);
  });
+
+  test("t-on with .capture modifier", () => {
+    expect.assertions(2);
+    qweb.addTemplate(
+      "test",
+      `<div t-on-click.capture="onCapture">
+        <button t-on-click="doSomething">Button</button>
+      </div>`
+    );
+
+    const steps: string[] = [];
+    const owner = {
+      onCapture() {
+        steps.push("captured");
+      },
+      doSomething() {
+        steps.push("normal");
+      },
+    };
+    const node = renderToDOM(qweb, "test", owner, { handlers: [] });
+
+    const button = (<HTMLElement>node).getElementsByTagName("button")[0];
+    button.click();
+    expect(steps).toEqual(["captured", "normal"]);
+  });
 });

 describe("t-ref", () => {
@@ -1716,7 +1853,7 @@ describe("t-key", () => {
    );
    expect(
      renderToString(qweb, "test", {
-        beers: [{ id: 12, name: "Chimay Rouge" }]
+        beers: [{ id: 12, name: "Chimay Rouge" }],
      })
    ).toMatchSnapshot();
  });
@@ -1829,9 +1966,9 @@ describe("properly support svg", () => {
 describe("translation support", () => {
  test("can translate node content", () => {
    const translations = {
-      word: "mot"
+      word: "mot",
    };
-    const translateFn = expr => translations[expr] || expr;
+    const translateFn = (expr) => translations[expr] || expr;
    const qweb = new QWeb({ translateFn });
    qweb.addTemplate("test", "<div>word</div>");
    expect(renderToString(qweb, "test")).toBe("<div>mot</div>");
@@ -1839,9 +1976,9 @@ describe("translation support", () => {

  test("does not translate node content if disabled", () => {
    const translations = {
-      word: "mot"
+      word: "mot",
    };
-    const translateFn = expr => translations[expr] || expr;
+    const translateFn = (expr) => translations[expr] || expr;
    const qweb = new QWeb({ translateFn });
    qweb.addTemplate(
      "test",
@@ -1856,9 +1993,9 @@ describe("translation support", () => {

  test("some attributes are translated", () => {
    const translations = {
-      word: "mot"
+      word: "mot",
    };
-    const translateFn = expr => translations[expr] || expr;
+    const translateFn = (expr) => translations[expr] || expr;
    const qweb = new QWeb({ translateFn });
    qweb.addTemplate(
      "test",
@@ -6,12 +6,12 @@ describe("tokenizer", () => {

    expect(tokenize("{}")).toEqual([
      { type: "LEFT_BRACE", value: "{" },
-      { type: "RIGHT_BRACE", value: "}" }
+      { type: "RIGHT_BRACE", value: "}" },
    ]);
    expect(tokenize("{ }}")).toEqual([
      { type: "LEFT_BRACE", value: "{" },
      { type: "RIGHT_BRACE", value: "}" },
-      { type: "RIGHT_BRACE", value: "}" }
+      { type: "RIGHT_BRACE", value: "}" },
    ]);
    expect(tokenize("a")).toEqual([{ type: "SYMBOL", value: "a" }]);
    expect(tokenize("true")).toEqual([{ type: "SYMBOL", value: "true" }]);
@@ -25,15 +25,15 @@ describe("tokenizer", () => {
      { type: "SYMBOL", value: "a" },
      { type: "COLON", value: ":" },
      { type: "VALUE", value: "2" },
-      { type: "RIGHT_BRACE", value: "}" }
+      { type: "RIGHT_BRACE", value: "}" },
    ]);
    expect(tokenize("a,")).toEqual([
      { type: "SYMBOL", value: "a" },
-      { type: "COMMA", value: "," }
+      { type: "COMMA", value: "," },
    ]);
    expect(tokenize("][")).toEqual([
      { type: "RIGHT_BRACKET", value: "]" },
-      { type: "LEFT_BRACKET", value: "[" }
+      { type: "LEFT_BRACKET", value: "[" },
    ]);
  });

@@ -44,11 +44,23 @@ describe("tokenizer", () => {
      { type: "OPERATOR", value: "<" },
      { type: "OPERATOR", value: ">" },
      { type: "OPERATOR", value: "!==" },
-      { type: "OPERATOR", value: "!=" }
+      { type: "OPERATOR", value: "!=" },
    ]);
    expect(tokenize("typeof a")).toEqual([
      { type: "OPERATOR", value: "typeof " },
-      { type: "SYMBOL", value: "a" }
+      { type: "SYMBOL", value: "a" },
+    ]);
+
+    expect(tokenize("a...1")).toEqual([
+      { type: "SYMBOL", value: "a" },
+      { type: "OPERATOR", value: "..." },
+      { type: "VALUE", value: "1" },
+    ]);
+
+    expect(tokenize("a in b")).toEqual([
+      { type: "SYMBOL", value: "a" },
+      { type: "OPERATOR", value: "in " },
+      { type: "SYMBOL", value: "b" },
    ]);
  });

@@ -64,7 +76,7 @@ describe("tokenizer", () => {
    expect(tokenize('"hello ged"')).toEqual([{ type: "VALUE", value: '"hello ged"' }]);
    expect(tokenize('"hello ged"}')).toEqual([
      { type: "VALUE", value: '"hello ged"' },
-      { type: "RIGHT_BRACE", value: "}" }
+      { type: "RIGHT_BRACE", value: "}" },
    ]);
    expect(tokenize('"hello \\"ged\\""')).toEqual([{ type: "VALUE", value: '"hello \\"ged\\""' }]);
  });
@@ -128,6 +140,7 @@ describe("expression evaluation", () => {
    expect(compileExpr("color === 'black'", {})).toBe("scope['color']==='black'");
    expect(compileExpr("'li_'+item", {})).toBe("'li_'+scope['item']");
    expect(compileExpr("state.val > 1", {})).toBe("scope['state'].val>1");
+    expect(compileExpr("a in b", {})).toBe("scope['a']in scope['b']");
  });

  test("boolean operations", () => {
@@ -177,4 +190,10 @@ describe("expression evaluation", () => {
    expect(compileExpr("a -= b", {})).toBe("scope['a']-=scope['b']");
    expect(compileExpr("a.b = !a.b", {})).toBe("scope['a'].b=!scope['a'].b");
  });
+
+  test("spread operator", () => {
+    expect(compileExpr("[...state.list]", {})).toBe("[...scope['state'].list]");
+    expect(compileExpr("f(...state.list)", {})).toBe("scope['f'](...scope['state'].list)");
+    expect(compileExpr("f([...list])", {})).toBe("scope['f']([...scope['list']])");
+  });
 });
@@ -6,11 +6,11 @@ exports[`Link component can render simple cases 1`] = `
    // Template name: \\"__template__1\\"
    let utils = this.constructor.utils;
    let scope = Object.create(context);
-    var h = this.h;
+    let h = this.h;
    let _4 = utils.toObj({'router-link-active':scope['isActive']});
-    var _5 = scope['href'];
+    let _5 = scope['href'];
    let c6 = [], p6 = {key:6,attrs:{href: _5},class:_4,on:{}};
-    var vn6 = h('a', p6, c6);
+    let vn6 = h('a', p6, c6);
    extra.handlers['click__7__'] = extra.handlers['click__7__'] || function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['navigate'](e);};
    p6.on['click'] = extra.handlers['click__7__'];
    const slot8 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
@@ -9,35 +9,37 @@ exports[`RouteComponent can render simple cases 1`] = `
    let parent = context;
    let scope = Object.create(context);
    let result;
-    var h = this.h;
+    let h = this.h;
    if (scope['routeComponent']) {
-        const nodeKey4 = scope['env'].router.currentRouteName;
-        // Component 'routeComponent'
-        let k6 = \`__6__\` + nodeKey4;
-        let w5 = k6 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k6]] : false;
-        let vn7 = {};
-        result = vn7;
-        let props5 = Object.assign({}, scope['env'].router.currentParams);
-        if (w5 && w5.__owl__.currentFiber && !w5.__owl__.vnode) {
-            w5.destroy();
-            w5 = false;
+        {
+            let key0 = scope['env'].router.currentRouteName;
+            // Component 'routeComponent'
+            let k5 = \`__5__\${key0}__\`;
+            let w4 = k5 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k5]] : false;
+            let vn6 = {};
+            result = vn6;
+            let props4 = Object.assign({}, scope['env'].router.currentParams);
+            if (w4 && w4.__owl__.currentFiber && !w4.__owl__.vnode) {
+                w4.destroy();
+                w4 = false;
+            }
+            if (w4) {
+                w4.__updateProps(props4, extra.fiber, undefined);
+                let pvnode = w4.__owl__.pvnode;
+                utils.defineProxy(vn6, pvnode);
+            } else {
+                let componentKey4 = \`routeComponent\`;
+                let W4 = context.constructor.components[componentKey4] || QWeb.components[componentKey4]|| scope['routeComponent'];
+                if (!W4) {throw new Error('Cannot find the definition of component \\"' + componentKey4 + '\\"')}
+                w4 = new W4(parent, props4);
+                parent.__owl__.cmap[k5] = w4.__owl__.id;
+                let fiber = w4.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+                let pvnode = h('dummy', {key: k5, hook: {remove() {},destroy(vn) {w4.destroy();}}});
+                utils.defineProxy(vn6, pvnode);
+                w4.__owl__.pvnode = pvnode;
+            }
+            w4.__owl__.parentLastFiberId = extra.fiber.id;
        }
-        if (w5) {
-            w5.__updateProps(props5, extra.fiber, undefined);
-            let pvnode = w5.__owl__.pvnode;
-            utils.defineProxy(vn7, pvnode);
-        } else {
-            let componentKey5 = \`routeComponent\`;
-            let W5 = context.constructor.components[componentKey5] || QWeb.components[componentKey5]|| scope['routeComponent'];
-            if (!W5) {throw new Error('Cannot find the definition of component \\"' + componentKey5 + '\\"')}
-            w5 = new W5(parent, props5);
-            parent.__owl__.cmap[k6] = w5.__owl__.id;
-            let fiber = w5.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
-            let pvnode = h('dummy', {key: k6, hook: {remove() {},destroy(vn) {w5.destroy();}}});
-            utils.defineProxy(vn7, pvnode);
-            w5.__owl__.pvnode = pvnode;
-        }
-        w5.__owl__.parentLastFiberId = extra.fiber.id;
    }
    return result;
 }"
@@ -31,13 +31,13 @@ describe("Link component", () => {
            </div>
        </templates>
    `);
-    class App extends Component<any, any> {
+    class App extends Component {
      static components = { Link: Link };
    }

    const routes = [
      { name: "about", path: "/about" },
-      { name: "users", path: "/users" }
+      { name: "users", path: "/users" },
    ];

    router = new TestRouter(env, routes, { mode: "history" });
@@ -65,13 +65,13 @@ describe("Link component", () => {
            </div>
        </templates>
    `);
-    class App extends Component<any, any> {
+    class App extends Component {
      static components = { Link: Link };
    }

    const routes = [
      { name: "about", path: "/about" },
-      { name: "users", path: "/users" }
+      { name: "users", path: "/users" },
    ];

    router = new TestRouter(env, routes, { mode: "history" });
@@ -81,7 +81,7 @@ describe("Link component", () => {

    expect(window.location.pathname).toBe("/users");
    var evt = new MouseEvent("click", {
-      button: 1
+      button: 1,
    });

    fixture.querySelector("a")!.dispatchEvent(evt);
@@ -33,15 +33,15 @@ describe("RouteComponent", () => {
            <span t-name="Users">Users</span>
        </templates>
    `);
-    class About extends Component<any, any> {}
-    class Users extends Component<any, any> {}
-    class App extends Component<any, any> {
+    class About extends Component {}
+    class Users extends Component {}
+    class App extends Component {
      static components = { RouteComponent };
    }

    const routes = [
      { name: "about", path: "/about", component: About },
-      { name: "users", path: "/users", component: Users }
+      { name: "users", path: "/users", component: Users },
    ];

    router = new TestRouter(env, routes, { mode: "history" });
@@ -65,8 +65,8 @@ describe("RouteComponent", () => {
            <span t-name="Book">Book <t t-esc="props.title"/></span>
        </templates>
    `);
-    class Book extends Component<any, any> {}
-    class App extends Component<any, any> {
+    class Book extends Component {}
+    class App extends Component {
      static components = { RouteComponent };
    }

@@ -87,12 +87,12 @@ describe("RouteComponent", () => {
            <span t-name="Book">Book <t t-esc="props.title"/>|<t t-esc="incVal"/></span>
        </templates>
    `);
-    class Book extends Component<any, any> {
+    class Book extends Component {
      get incVal() {
        return this.props.val + 1;
      }
    }
-    class App extends Component<any, any> {
+    class App extends Component {
      static components = { RouteComponent };
    }

@@ -21,7 +21,7 @@ describe("router miscellaneous", () => {
  test("validate routes shape", () => {
    expect(() => {
      router = new TestRouter(env, [
-        { name: "someroute", path: "/some/path", redirect: { abc: "hey" } as Destination }
+        { name: "someroute", path: "/some/path", redirect: { abc: "hey" } as Destination },
      ]);
    }).toThrow(`Invalid destination: {"abc":"hey"}`);
  });
@@ -133,7 +133,7 @@ describe("getRouteParams", () => {
  test("match some parameterized routes", () => {
    router = new TestRouter(env, []);
    expect(router["getRouteParams"]({ path: "/invoices/{{id}}" } as Route, "/invoices/3")).toEqual({
-      id: "3"
+      id: "3",
    });
  });

@@ -141,7 +141,7 @@ describe("getRouteParams", () => {
    router = new TestRouter(env, [], { mode: "hash" });
    expect(router["getRouteParams"]({ path: "/invoices/{{id}}" } as Route, "#/invoices/3")).toEqual(
      {
-        id: "3"
+        id: "3",
      }
    );
  });
@@ -151,7 +151,7 @@ describe("getRouteParams", () => {
    expect(
      router["getRouteParams"]({ path: "/invoices/{{id.number}}" } as Route, "/invoices/3")
    ).toEqual({
-      id: 3
+      id: 3,
    });
  });

@@ -160,7 +160,7 @@ describe("getRouteParams", () => {
    expect(
      router["getRouteParams"]({ path: "/invoices/{{id.number}}" } as Route, "#/invoices/3")
    ).toEqual({
-      id: 3
+      id: 3,
    });
  });
 });
@@ -169,7 +169,7 @@ describe("redirect", () => {
  test("can redirect to other route", async () => {
    router = new TestRouter(env, [
      { name: "routea", path: "/some/path" },
-      { name: "routeb", path: "/some/other/path", redirect: { to: "routea" } }
+      { name: "routeb", path: "/some/other/path", redirect: { to: "routea" } },
    ]);

    await router.start();
@@ -182,7 +182,7 @@ describe("redirect", () => {
  test("can redirect to other path", async () => {
    router = new TestRouter(env, [
      { name: "routea", path: "/some/path" },
-      { name: "routeb", path: "/some/other/path", redirect: { path: "/some/path" } }
+      { name: "routeb", path: "/some/other/path", redirect: { path: "/some/path" } },
    ]);
    router.navigate = jest.fn(router.navigate);

@@ -214,7 +214,7 @@ describe("beforeRouteEnter", () => {
    const guard = jest.fn(() => false);
    router = new TestRouter(env, [
      { name: "routea", path: "/some/patha" },
-      { name: "routeb", path: "/some/pathb", beforeRouteEnter: guard }
+      { name: "routeb", path: "/some/pathb", beforeRouteEnter: guard },
    ]);

    await router.start();
@@ -235,7 +235,7 @@ describe("beforeRouteEnter", () => {
    router = new TestRouter(env, [
      { name: "routea", path: "/some/patha" },
      { name: "routeb", path: "/some/pathb", beforeRouteEnter: guard },
-      { name: "routec", path: "/some/pathc" }
+      { name: "routec", path: "/some/pathc" },
    ]);

    await router.start();
@@ -255,7 +255,7 @@ describe("beforeRouteEnter", () => {
    });
    router = new TestRouter(env, [
      { name: "landing", path: "/", beforeRouteEnter: guard },
-      { name: "otherroute", path: "/some/other/route" }
+      { name: "otherroute", path: "/some/other/route" },
    ]);

    expect(window.location.pathname).toBe("/");
@@ -8,7 +8,7 @@ describe("basic use", () => {
    const actions = {
      inc({ state }, delta) {
        state.n += delta;
-      }
+      },
    };
    const store = new Store({ state, actions });

@@ -25,7 +25,7 @@ describe("basic use", () => {
        state.n1 += delta1;
        state.n2 += delta2;
        state.n3 += delta3;
-      }
+      },
    };
    const store = new Store({ state, actions });

@@ -47,7 +47,7 @@ describe("basic use", () => {
      },
      inc100({ dispatch }) {
        dispatch("inc", 100);
-      }
+      },
    };
    const store = new Store({ state, actions });

@@ -61,7 +61,7 @@ describe("basic use", () => {
    const actions = {
      inc({ state }) {
        return ++state.n;
-      }
+      },
    };
    const store = new Store({ state, actions });

@@ -87,7 +87,7 @@ describe("basic use", () => {
      async setTo10({ dispatch }) {
        await Promise.resolve();
        dispatch("setN", 10);
-      }
+      },
    };
    const store = new Store({ state, actions });

@@ -115,7 +115,7 @@ describe("basic use", () => {
        await Promise.resolve();
        dispatch("setN", 10);
        return 5;
-      }
+      },
    };
    const store = new Store({ state, actions });

@@ -132,7 +132,7 @@ describe("basic use", () => {
    const actions = {
      someaction({ env }) {
        expect(env).toBe(someEnv);
-      }
+      },
    };
    const store = new Store({ state: {}, actions, env: someEnv });

@@ -145,15 +145,15 @@ describe("basic use", () => {
        1: {
          id: 1,
          name: "bertinchamps",
-          tasterID: 1
-        }
+          tasterID: 1,
+        },
      },
      tasters: {
        1: {
          id: 1,
-          name: "aaron"
-        }
-      }
+          name: "aaron",
+        },
+      },
    };
    const getters: { [key: string]: Getter } = {
      beerTasterName({ state }, beerID) {
@@ -161,7 +161,7 @@ describe("basic use", () => {
      },
      bestBeerName({ state }) {
        return state.beers[1].name;
-      }
+      },
    };
    const store = new Store({ state, actions: {}, getters });
    expect(store.getters).toBeDefined();
@@ -176,15 +176,15 @@ describe("basic use", () => {
        1: {
          id: 1,
          name: "bertinchamps",
-          tasterID: 1
-        }
+          tasterID: 1,
+        },
      },
      tasters: {
        1: {
          id: 1,
-          name: "aaron"
-        }
-      }
+          name: "aaron",
+        },
+      },
    };
    const getters = {
      beerTasterName({ state }, beerID) {
@@ -192,14 +192,14 @@ describe("basic use", () => {
      },
      bestBeerName({ state }) {
        return state.beers[1].name;
-      }
+      },
    };
    const actions = {
      action({ getters }) {
        expect(getters).toBeDefined();
        expect(getters.bestBeerName()).toBe("bertinchamps");
        expect(getters.beerTasterName(1)).toBe("aaron");
-      }
+      },
    };
    const store = new Store({ state, actions, getters });
    store.dispatch("action");
@@ -215,7 +215,7 @@ describe("basic use", () => {
      },
      c({}, i) {
        return `c${i}`;
-      }
+      },
    };
    const store = new Store({ getters, state: {}, actions: {} });

@@ -226,7 +226,7 @@ describe("basic use", () => {
 describe("advanced state properties", () => {
  test("state in the store is reference equal after mutation", async () => {
    const actions = {
-      donothing() {}
+      donothing() {},
    };
    const store = new Store({ state: {}, actions });
    const state = store.state;
@@ -242,7 +242,7 @@ describe("advanced state properties", () => {
        expect(state.a.length).toBe(3);
        const l = state.a.push(53);
        expect(l).toBe(4);
-      }
+      },
    };
    const store = new Store({ state, actions });
    store.dispatch("m");
@@ -253,11 +253,11 @@ describe("advanced state properties", () => {
    const actions = {
      dosomething({ state }) {
        Object.assign(state.westmalle, { a: 3, b: 4 });
-      }
+      },
    };
    const store = new Store({
      state: { westmalle: { a: 1, b: 2 } },
-      actions
+      actions,
    });
    store.dispatch("dosomething");
    expect(store.state.westmalle).toEqual({ a: 3, b: 4 });
@@ -267,7 +267,7 @@ describe("advanced state properties", () => {
    const actions = {
      inc({ state }) {
        state.counter++;
-      }
+      },
    };
    const state = { counter: 0 };
    const store = new Store({ state, actions });
@@ -284,7 +284,7 @@ describe("updates triggered by the store", () => {
    const actions = {
      inc({ state }, delta) {
        state.n += delta;
-      }
+      },
    };
    const store = new Store({ state, actions });
    store.on("update", null, () => updateCounter++);
@@ -308,7 +308,7 @@ describe("updates triggered by the store", () => {
      noop2({ state }) {
        const val = state.n;
        state.n = val;
-      }
+      },
    };
    const store = new Store({ state, actions });
    store.on("update", null, () => updateCounter++);
@@ -1,5 +1,5 @@
 import { Component, Env } from "../src/component/component";
-import { Store, useStore, useDispatch, useGetters } from "../src/store";
+import { Store, useStore, useDispatch, useGetters, EnvWithStore } from "../src/store";
 import { useState } from "../src/hooks";
 import { xml } from "../src/tags";
 import { shallowEqual } from "../src/utils";
@@ -25,16 +25,16 @@ describe("connecting a component to store", () => {
    const actions = {
      addTodo({ state }, msg) {
        state.todos.push({ msg, id: nextId++ });
-      }
+      },
    };
    const store = new Store({ state, actions });

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`
            <div>
                <span t-foreach="todos" t-key="todo.id" t-as="todo"><t t-esc="todo.msg"/></span>
            </div>`;
-      todos = useStore(state => state.todos);
+      todos = useStore((state) => state.todos);
    }

    (<any>env).store = store;
@@ -49,26 +49,36 @@ describe("connecting a component to store", () => {
  });

  test("useStore can observe primitive types and call onUpdate", async () => {
-    const state = { isBoolean: false };
+    const state = { isBoolean: false, nullValue: null };
    const actions = {
      setTrue({ state }) {
        state.isBoolean = true;
-      }
+      },
+      setNotNull({ state }) {
+        state.nullValue = "ok";
+      },
    };
    const store = new Store({ state, actions });

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`
            <div>
                <span t-if="isBoolean">ok</span>
+                <span t-if="nullValue !== null">not null</span>
            </div>`;
      isBoolean: boolean;
+      nullValue: string;
      constructor() {
        super();
-        this.isBoolean = useStore(state => state.isBoolean, {
-          onUpdate: isBoolean => {
+        this.isBoolean = useStore((state) => state.isBoolean, {
+          onUpdate: (isBoolean) => {
            this.isBoolean = isBoolean;
-          }
+          },
+        });
+        this.nullValue = useStore((state) => state.nullValue, {
+          onUpdate: (nullValue) => {
+            this.nullValue = nullValue;
+          },
        });
      }
    }
@@ -82,12 +92,48 @@ describe("connecting a component to store", () => {
    store.dispatch("setTrue");
    await nextTick();
    expect(fixture.innerHTML).toBe("<div><span>ok</span></div>");
+
+    store.dispatch("setNotNull");
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>ok</span><span>not null</span></div>");
+  });
+
+  test("map works on the result of useStore when the resulting array changes for a bigger one", async () => {
+    const state = { smallerArray: [1], biggerArray: [2, 3], useSmallArray: true };
+    const store = new Store({ state });
+
+    class App extends Component {
+      static template = xml`<div t-esc="mapAdd"/>`;
+      storeProps = {
+        array: useStore((state) => {
+          if (state.useSmallArray) {
+            return state.smallerArray;
+          }
+          return state.biggerArray;
+        }),
+      };
+      get mapAdd() {
+        return this.storeProps.array.map((a) => {
+          return a + 1;
+        });
+      }
+    }
+
+    (<any>env).store = store;
+    const app = new App();
+
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>2</div>");
+
+    store.state.useSmallArray = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div>3,4</div>");
  });

  test("throw error if no store is found", async () => {
-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div></div>`;
-      todos = useStore(state => state.todos);
+      todos = useStore((state) => state.todos);
    }

    let error;
@@ -105,9 +151,9 @@ describe("connecting a component to store", () => {
    const actions = {};
    const store = new Store({ state, actions });

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div/>`;
-      storeState = useStore(state => state.a);
+      storeState = useStore((state) => state.a);
    }

    (<any>env).store = store;
@@ -124,18 +170,18 @@ describe("connecting a component to store", () => {
      doSomething({ state }) {
        state.a = 2;
        state.b = 3;
-      }
+      },
    };
    const store = new Store({ state, actions });

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`
            <div>
                <span t-esc="a.value"/>
                <span t-esc="b.value"/>
            </div>`;
-      a = useStore(state => ({ value: state.a }));
-      b = useStore(state => ({ value: state.b }));
+      a = useStore((state) => ({ value: state.a }));
+      b = useStore((state) => ({ value: state.b }));
    }
    App.prototype.__render = jest.fn(App.prototype.__render);

@@ -158,16 +204,16 @@ describe("connecting a component to store", () => {
    const actions = {
      addTodo({ state }, msg) {
        state.todos.push({ msg, id: nextId++ });
-      }
+      },
    };
    const store = new Store({ state, actions });

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`
            <div>
                <span t-foreach="todos" t-key="todo.id" t-as="todo"><t t-esc="todo.msg"/></span>
            </div>`;
-      todos = useStore(state => state.todos);
+      todos = useStore((state) => state.todos);
    }
    App.prototype.__render = jest.fn(App.prototype.__render);

@@ -195,13 +241,13 @@ describe("connecting a component to store", () => {
    const actions = {
      addTodo({ state }, msg) {
        state.todos.push({ msg, id: nextId++ });
-      }
+      },
    };
    const store = new Store({ state, actions });

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><t t-esc="nbrTodos.value"/></div>`;
-      nbrTodos = useStore(state => ({ value: state.todos.length }));
+      nbrTodos = useStore((state) => ({ value: state.todos.length }));
    }

    (<any>env).store = store;
@@ -224,12 +270,12 @@ describe("connecting a component to store", () => {
      },
      incrementA({ state }) {
        state.a++;
-      }
+      },
    };
    const store = new Store({ state, actions });
-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><t t-esc="nbrTodos.value"/></div>`;
-      nbrTodos = useStore(state => ({ value: state.todos.length }), { isEqual: shallowEqual });
+      nbrTodos = useStore((state) => ({ value: state.todos.length }), { isEqual: shallowEqual });
    }
    App.prototype.__render = jest.fn(App.prototype.__render);

@@ -257,16 +303,16 @@ describe("connecting a component to store", () => {
    const actions = {
      addTodo({ state }, msg) {
        state.todos.push({ msg, id: nextId++ });
-      }
+      },
    };
    const store = new Store({ state, actions });

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`
            <div>
                <span t-foreach="todos" t-key="todo.id" t-as="todo"><t t-esc="todo.msg"/></span>
            </div>`;
-      todos = useStore(state => state.todos, { store });
+      todos = useStore((state) => state.todos, { store });
    }

    const app = new App();
@@ -285,18 +331,18 @@ describe("connecting a component to store", () => {
      actions: {
        inc({ state }) {
          state.value++;
-        }
-      }
+        },
+      },
    });
    (<any>env).store = store;

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`
          <div>
              <button t-on-click="dispatch('inc')">Inc</button>
              <span><t t-esc="storeState.value"/></span>
          </div>`;
-      storeState = useStore(state => state);
+      storeState = useStore((state) => state);
      dispatch = useDispatch();
    }
    const app = new App();
@@ -314,19 +360,19 @@ describe("connecting a component to store", () => {
    const state = {
      todos: [
        { id: 1, text: "jupiler" },
-        { id: 2, text: "chimay" }
-      ]
+        { id: 2, text: "chimay" },
+      ],
    };
    const store = new Store({ state, actions: {} });

-    class TodoItem extends Component<any, any> {
+    class TodoItem extends Component {
      static template = xml`<span><t t-esc="todo.text"/></span>`;
      todo = useStore((state, props) => {
-        return state.todos.find(t => t.id === props.todoId);
+        return state.todos.find((t) => t.id === props.todoId);
      });
    }

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><TodoItem todoId="state.currentId"/></div>`;
      static components = { TodoItem };
      state = useState({ currentId: 1 });
@@ -349,24 +395,24 @@ describe("connecting a component to store", () => {
    const actions = {
      addTodo({ state }, text) {
        state.todos.push({ text, id: nextId++ });
-      }
+      },
    };
    const store = new Store({ state, actions });

-    class TodoItem extends Component<any, any> {
+    class TodoItem extends Component {
      static template = xml`<span><t t-esc="todo.text"/></span>`;
      todo = useStore((state, props) => {
-        return state.todos.find(t => t.id === props.id);
+        return state.todos.find((t) => t.id === props.id);
      });
    }

-    class TodoList extends Component<any, any> {
+    class TodoList extends Component {
      static template = xml`
        <div>
          <TodoItem t-foreach="todos" t-as="todo" id="todo.id" t-key="todo.id"/>
        </div>`;
      static components = { TodoItem };
-      todos = useStore(state => state.todos);
+      todos = useStore((state) => state.todos);
    }

    (<any>env).store = store;
@@ -385,20 +431,20 @@ describe("connecting a component to store", () => {
      importantID: 1,
      todos: [
        { id: 1, text: "jupiler" },
-        { id: 2, text: "bertinchamps" }
-      ]
+        { id: 2, text: "bertinchamps" },
+      ],
    };
    const getters = {
      importantTodoText({ state }) {
-        return state.todos.find(todo => todo.id === state.importantID).text;
+        return state.todos.find((todo) => todo.id === state.importantID).text;
      },
      text({ state }, id) {
-        return state.todos.find(todo => todo.id === id).text;
-      }
+        return state.todos.find((todo) => todo.id === id).text;
+      },
    };
    const store = new Store({ state, getters });

-    class TodoItem extends Component<any, any> {
+    class TodoItem extends Component {
      static template = xml`
        <div>
          <span><t t-esc="storeProps.activeTodoText"/></span>
@@ -406,15 +452,15 @@ describe("connecting a component to store", () => {
        </div>`;
      getters = useGetters();
      storeProps = useStore((state, props) => {
-        const todo = state.todos.find(t => t.id === props.id);
+        const todo = state.todos.find((t) => t.id === props.id);
        return {
          activeTodoText: this.getters.text(todo.id),
-          importantTodoText: this.getters.importantTodoText()
+          importantTodoText: this.getters.importantTodoText(),
        };
      });
    }

-    class TodoList extends Component<any, any> {
+    class TodoList extends Component {
      static components = { TodoItem };
      static template = xml`
        <div>
@@ -422,7 +468,7 @@ describe("connecting a component to store", () => {
            <TodoItem id="todo.id" t-key="todo.id"/>
          </t>
        </div>`;
-      todos = useStore(state => state.todos);
+      todos = useStore((state) => state.todos);
    }

    (<any>env).store = store;
@@ -435,12 +481,12 @@ describe("connecting a component to store", () => {
  });

  test("connected component is updated when props are updated", async () => {
-    class Beer extends Component<any, any> {
+    class Beer extends Component {
      static template = xml`<span><t t-esc="beer.name"/></span>`;
      beer = useStore((state, props) => state.beers[props.id]);
    }

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><Beer id="state.beerId"/></div>`;
      static components = { Beer };
      state = useState({ beerId: 1 });
@@ -460,20 +506,20 @@ describe("connecting a component to store", () => {
  });

  test("connected component is updated when store is changed", async () => {
-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`
        <div>
            <span t-foreach="data.beers" t-as="beer" t-key="beer.name"><t t-esc="beer.name"/></span>
        </div>`;

      // we have here a new object
-      data = useStore(state => ({ beers: state.beers, otherKey: 1 }));
+      data = useStore((state) => ({ beers: state.beers, otherKey: 1 }));
    }

    const actions = {
      addBeer({ state }, name) {
        state.beers.push({ name });
-      }
+      },
    };

    const state = { beers: [{ name: "jupiler" }] };
@@ -493,16 +539,16 @@ describe("connecting a component to store", () => {
  test("connected component is updated when mixing store and props changes", async () => {
    let counter = 0;

-    class Beer extends Component<any, any> {
+    class Beer extends Component {
      static template = xml`<span><t t-esc="beer.name"/></span>`;
      beer = useStore((state, props) => state.beers[props.id], {
-        onUpdate: result => {
+        onUpdate: (result) => {
          ++counter;
-        }
+        },
      });
    }

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><Beer id="state.beerId"/></div>`;
      static components = { Beer };
      state = useState({ beerId: 1 });
@@ -512,7 +558,7 @@ describe("connecting a component to store", () => {
    const actions = {
      renameBeer({ state }, { id, name }) {
        state.beers[id].name = name;
-      }
+      },
    };
    const store = new Store({ state, actions });
    (<any>env).store = store;
@@ -534,7 +580,7 @@ describe("connecting a component to store", () => {
  });

  test("connected component is properly cleaned up on destroy", async () => {
-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div></div>`;
      state = useStore((state, props) => state);
    }
@@ -553,7 +599,7 @@ describe("connecting a component to store", () => {
  });

  test("connected component with undefined, null and string props", async () => {
-    class Beer extends Component<any, any> {
+    class Beer extends Component {
      static template = xml`
            <div t-name="Beer">
                <span>taster:<t t-esc="data.taster"/></span>
@@ -563,11 +609,11 @@ describe("connecting a component to store", () => {
      data = useStore((state, props) => ({
        selected: state.beers[props.id],
        consumed: state.beers[state.consumedID] || null,
-        taster: state.taster
+        taster: state.taster,
      }));
    }

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><Beer id="state.beerId"/></div>`;
      static components = { Beer };
      state = useState({ beerId: 0 });
@@ -576,14 +622,14 @@ describe("connecting a component to store", () => {
    const actions = {
      consume({ state }, beerId) {
        state.consumedID = beerId;
-      }
+      },
    };
    const state = {
      beers: {
-        1: { name: "jupiler" }
+        1: { name: "jupiler" },
      },
      consumedID: null,
-      taster: "aaron"
+      taster: "aaron",
    };
    const store = new Store({ state, actions });
    (<any>env).store = store;
@@ -612,23 +658,23 @@ describe("connecting a component to store", () => {
  });

  test("connected component deeply reactive with undefined, null and string props", async () => {
-    class Beer extends Component<any, any> {
+    class Beer extends Component {
      static template = xml`
            <div>
                <span>taster:<t t-esc="info.taster"/></span>
                <span t-if="info.selected">selected:<t t-esc="info.selected.name"/></span>
                <span t-if="info.consumed">consumed:<t t-esc="info.consumed.name"/></span>
            </div>`;
-      info = useStore(function(state, props) {
+      info = useStore(function (state, props) {
        return {
          selected: state.beers[props.id],
          consumed: state.beers[state.consumedID] || null,
-          taster: state.taster
+          taster: state.taster,
        };
      });
    }

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><Beer id="state.beerId"/></div>`;
      static components = { Beer };
      state = useState({ beerId: 0 });
@@ -643,14 +689,14 @@ describe("connecting a component to store", () => {
      },
      renameBeer({ state }, { beerId, name }) {
        state.beers[beerId].name = name;
-      }
+      },
    };
    const state = {
      beers: {
-        1: { name: "jupiler" }
+        1: { name: "jupiler" },
      },
      consumedID: null,
-      taster: "aaron"
+      taster: "aaron",
    };
    const store = new Store({ state, actions });
    (<any>env).store = store;
@@ -701,11 +747,11 @@ describe("connecting a component to store", () => {
    const actions = {
      setValue({ state }, val) {
        state.x.val = val;
-      }
+      },
    };
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><t t-esc="x.val"/></div>`;
-      x = useStore(state => {
+      x = useStore((state) => {
        return Object.assign({}, state.x);
      });
      dispatch = useDispatch();
@@ -724,7 +770,7 @@ describe("connecting a component to store", () => {
  test("correct update order when parent/children are connected", async () => {
    const steps: string[] = [];

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="state.msg"/></span>`;

      state = useStore((state, props) => {
@@ -732,15 +778,15 @@ describe("connecting a component to store", () => {
        return { msg: state.msg[props.key] };
      });
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child key="state.current"/></div>`;
      static components = { Child };

-      state = useStore(state => {
+      state = useStore((state) => {
        steps.push("parent");
        return {
          current: state.current,
-          isvisible: state.isvisible
+          isvisible: state.isvisible,
        };
      });
    }
@@ -749,7 +795,7 @@ describe("connecting a component to store", () => {
    const actions = {
      setCurrent({ state }, c) {
        state.current = c;
-      }
+      },
    };

    const store = new Store({ state, actions });
@@ -771,7 +817,7 @@ describe("connecting a component to store", () => {
    let def = makeDeferred();
    def.resolve();

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<span><t t-esc="state.msg"/></span>`;
      state = useStore((s, props) => {
        steps.push("child");
@@ -779,13 +825,13 @@ describe("connecting a component to store", () => {
      });
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`
            <div>
                <Child t-if="state.flag" someId="state.someId"/>
            </div>`;
      static components = { Child };
-      state = useStore(s => {
+      state = useStore((s) => {
        steps.push("parent");
        return { flag: s.flag, someId: s.someId };
      });
@@ -800,7 +846,7 @@ describe("connecting a component to store", () => {
    const actions = {
      setFlagToFalse({ state }) {
        state.flag = false;
-      }
+      },
    };

    const store = new Store({ state, actions });
@@ -828,18 +874,18 @@ describe("connecting a component to store", () => {
    const actions = {
      editTodo({ state }) {
        state.todos[1].title = "abc";
-      }
+      },
    };
    const todos = { 1: { id: 1, title: "kikoou" } };
    const state = {
-      todos
+      todos,
    };
    const store = new Store({
      state,
-      actions
+      actions,
    });

-    class TodoItem extends Component<any, any> {
+    class TodoItem extends Component<{}, EnvWithStore> {
      static template = xml`
            <div class="todo">
                <t t-esc="state.todo.title"/>
@@ -848,7 +894,7 @@ describe("connecting a component to store", () => {
      state = useStore((state, props) => {
        steps.push("item:usestore");
        return {
-          todo: state.todos[props.id]
+          todo: state.todos[props.id],
        };
      });

@@ -860,7 +906,7 @@ describe("connecting a component to store", () => {
        return super.__render(f);
      }
    }
-    class TodoApp extends Component<any, any> {
+    class TodoApp extends Component {
      static template = xml`
            <div class="todoapp">
                <t t-foreach="Object.values(state.todos)" t-as="todo">
@@ -868,7 +914,7 @@ describe("connecting a component to store", () => {
                </t>
            </div>`;
      static components = { TodoItem };
-      state = useStore(state => {
+      state = useStore((state) => {
        steps.push("app:usestore");
        return { todos: state.todos };
      });
@@ -901,18 +947,18 @@ describe("connecting a component to store", () => {
    const actions = {
      removeTodo({ state }) {
        delete state.todos[1];
-      }
+      },
    };
    const todos = { 1: { id: 1, title: "kikoou" } };
    const state = {
-      todos
+      todos,
    };
    const store = new Store({
      state,
-      actions
+      actions,
    });

-    class TodoItem extends Component<any, any> {
+    class TodoItem extends Component<{}, EnvWithStore> {
      static template = xml`
            <div class="todo">
                <t t-esc="state.todo.title"/>
@@ -921,7 +967,7 @@ describe("connecting a component to store", () => {
      state = useStore((state, props) => {
        steps.push("item:usestore");
        return {
-          todo: state.todos[props.id]
+          todo: state.todos[props.id],
        };
      });

@@ -934,7 +980,7 @@ describe("connecting a component to store", () => {
      }
    }

-    class TodoApp extends Component<any, any> {
+    class TodoApp extends Component {
      static template = xml`
            <div class="todoapp">
                <t t-foreach="Object.values(state.todos)" t-as="todo">
@@ -942,7 +988,7 @@ describe("connecting a component to store", () => {
                </t>
            </div>`;
      static components = { TodoItem };
-      state = useStore(state => {
+      state = useStore((state) => {
        steps.push("app:usestore");
        return { todos: state.todos };
      });
@@ -970,7 +1016,7 @@ describe("connecting a component to store", () => {
      "item:usestore",
      "item:render",
      "app:usestore",
-      "app:render"
+      "app:render",
    ]);
    expect(fixture.innerHTML).toBe('<div class="todoapp"></div>');
  });
@@ -978,9 +1024,9 @@ describe("connecting a component to store", () => {
  test("connected component willpatch/patch hooks are called on store updates", async () => {
    const steps: string[] = [];

-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><t t-esc="store.msg"/></div>`;
-      store = useStore(s => ({ msg: s.msg }));
+      store = useStore((s) => ({ msg: s.msg }));

      willPatch() {
        steps.push("willpatch");
@@ -994,7 +1040,7 @@ describe("connecting a component to store", () => {
    const actions = {
      setMsg({ state }, c) {
        state.msg = c;
-      }
+      },
    };

    const store = new Store({ state, actions });
@@ -1013,12 +1059,12 @@ describe("connecting a component to store", () => {
  test("connected child components stop listening to store when destroyed", async () => {
    let steps: any = [];

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<div><t t-esc="store.val"/></div>`;
-      store = useStore(s => s);
+      store = useStore((s) => s);
    }

-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child t-if="state.child" /></div>`;
      static components = { Child };
      state = useState({ child: true });
@@ -1051,17 +1097,17 @@ describe("connecting a component to store", () => {
  test("connected child component destroyed by dispatched action", async () => {
    let steps: any = [];

-    class Child extends Component<any, any> {
+    class Child extends Component {
      static template = xml`<div><t t-esc="store.val"/></div>`;
-      store = useStore(s => {
+      store = useStore((s) => {
        steps.push("child selector");
        return s;
      });
    }
-    class Parent extends Component<any, any> {
+    class Parent extends Component {
      static template = xml`<div><Child t-if="store.child" /></div>`;
      static components = { Child };
-      store = useStore(s => {
+      store = useStore((s) => {
        steps.push("parent selector");
        return s;
      });
@@ -1072,7 +1118,7 @@ describe("connecting a component to store", () => {
    const actions = {
      toggleChild({ state }) {
        state.child = !state.child;
-      }
+      },
    };
    const store = new Store({ state, actions });
    (<any>env).store = store;
@@ -1089,20 +1135,20 @@ describe("connecting a component to store", () => {
  });

  test("dispatch an action", async () => {
-    class App extends Component<any, any> {
+    class App extends Component {
      static template = xml`<div><t t-esc="store.counter"/></div>`;
-      store = useStore(state => state);
+      store = useStore((state) => state);
      dispatch = useDispatch();
    }

    const state = {
-      counter: 0
+      counter: 0,
    };

    const actions = {
      inc({ state }) {
        return ++state.counter;
-      }
+      },
    };

    const store = new Store({ state, actions });
@@ -1139,25 +1185,25 @@ describe("various scenarios", () => {
        await Promise.resolve();
        delete state.attachments[100];
        state.messages[10].attachmentIds = [];
-      }
+      },
    };
    const state = {
      attachments: {
        100: {
          id: 100,
-          name: "text.txt"
-        }
+          name: "text.txt",
+        },
      },
      messages: {
        10: {
          attachmentIds: [100],
-          id: 10
-        }
-      }
+          id: 10,
+        },
+      },
    };
    const store = new Store({ actions, state });

-    class Attachment extends Component<any, any> {
+    class Attachment extends Component {
      static template = xml`
            <div>
                <span>Attachment <t t-esc="props.id"/></span>
@@ -1167,14 +1213,14 @@ describe("various scenarios", () => {
      attachment = useStore((state, props) => ({ name: state.attachments[props.id].name }));
    }

-    class Message extends Component<any, any> {
+    class Message extends Component {
      static template = xml`
            <div>
                <button t-on-click="doStuff">Do stuff</button>
                <Attachment t-foreach="store.attachmentIds" t-key="attachmentId" t-as="attachmentId" id="attachmentId"/>
            </div>`;

-      store = useStore(state => ({ attachmentIds: state.messages[10].attachmentIds }));
+      store = useStore((state) => ({ attachmentIds: state.messages[10].attachmentIds }));
      static components = { Attachment };
      state = { isAttachmentDeleted: false };
      dispatch = useDispatch();
@@ -20,13 +20,13 @@ debugOwl(owl, {});
 test("can log full lifecycle", async () => {
  const steps: string[] = [];
  const log = console.log;
-  console.log = arg => steps.push(arg);
+  console.log = (arg) => steps.push(arg);

-  class Child extends Component<any, any> {
+  class Child extends Component {
    static template = xml`<div>child</div>`;
  }

-  class Parent extends Component<any, any> {
+  class Parent extends Component {
    static template = xml`<div><Child t-if="state.flag"/></div>`;
    static components = { Child };
    state = useState({ flag: false });
@@ -51,7 +51,7 @@ test("can log full lifecycle", async () => {
    "[OWL_DEBUG] Child<id=2> rendering template",
    "[OWL_DEBUG] Parent<id=1> willPatch",
    "[OWL_DEBUG] Child<id=2> mounted",
-    "[OWL_DEBUG] Parent<id=1> patched"
+    "[OWL_DEBUG] Parent<id=1> patched",
  ]);
  console.log = log;
 });
@@ -19,13 +19,13 @@ debugOwl(owl, { logScheduler: true });
 test("can log scheduler start and stop", async () => {
  const steps: string[] = [];
  const log = console.log;
-  console.log = arg => steps.push(arg);
+  console.log = (arg) => steps.push(arg);

-  class Child extends Component<any, any> {
+  class Child extends Component {
    static template = xml`<div>child</div>`;
  }

-  class Parent extends Component<any, any> {
+  class Parent extends Component {
    static template = xml`<div><Child /></div>`;
    static components = { Child };
  }
@@ -44,7 +44,7 @@ test("can log scheduler start and stop", async () => {
    "[OWL_DEBUG] Child<id=2> rendering template",
    "[OWL_DEBUG] Child<id=2> mounted",
    "[OWL_DEBUG] Parent<id=1> mounted",
-    "[OWL_DEBUG] scheduler: stop running tasks queue"
+    "[OWL_DEBUG] scheduler: stop running tasks queue",
  ]);
  console.log = log;
 });
@@ -19,9 +19,9 @@ debugOwl(owl, { logScheduler: true });
 test("log a specific message for render method calls if component is not mounted", async () => {
  const steps: string[] = [];
  const log = console.log;
-  console.log = arg => steps.push(arg);
+  console.log = (arg) => steps.push(arg);

-  class Parent extends Component<any, any> {
+  class Parent extends Component {
    static template = xml`<div><t t-esc="state.value"/></div>`;
    state = owl.hooks.useState({ value: 1 });
  }
@@ -40,7 +40,7 @@ test("log a specific message for render method calls if component is not mounted
    "[OWL_DEBUG] Parent<id=1> mounted",
    "[OWL_DEBUG] scheduler: stop running tasks queue",
    "[OWL_DEBUG] Parent<id=1> willUnmount",
-    "[OWL_DEBUG] Parent<id=1> render (warning: component is not mounted, this render has no effect)"
+    "[OWL_DEBUG] Parent<id=1> render (warning: component is not mounted, this render has no effect)",
  ]);
  console.log = log;
 });
@@ -0,0 +1,57 @@
+/**
+ * We can only make one test per file, since the debug tool modify in place
+ * the owl object in a way that is difficult to undo.
+ */
+
+import { debugOwl } from "../../tools/debug";
+import * as owl from "../../src/index";
+
+import { Component, Env } from "../../src/component/component";
+import { xml } from "../../src/tags";
+import { makeTestFixture, makeTestEnv } from "../helpers";
+
+let fixture: HTMLElement = makeTestFixture();
+let env: Env = makeTestEnv();
+Component.env = env;
+
+debugOwl(owl, { logScheduler: true });
+
+test("log a sub component with non stringifiable props", async () => {
+  const steps: string[] = [];
+  const log = console.log;
+  console.log = (arg) => steps.push(arg);
+
+  class Child extends Component {
+    static template = xml`<span><t t-esc="props.obj.val"/></span>`;
+  }
+
+  const circularObject: any = { val: 1 };
+  circularObject.circularObject = circularObject;
+
+  class Parent extends Component {
+    static template = xml`<div><Child obj="obj"/></div>`;
+    static components = { Child };
+    obj = circularObject;
+  }
+
+  const parent = new Parent(null, {});
+  await parent.mount(fixture);
+  parent.unmount();
+
+  expect(steps).toEqual([
+    "[OWL_DEBUG] Parent<id=1> constructor, props={}",
+    "[OWL_DEBUG] Parent<id=1> mount",
+    "[OWL_DEBUG] Parent<id=1> willStart",
+    "[OWL_DEBUG] scheduler: start running tasks queue",
+    "[OWL_DEBUG] Parent<id=1> rendering template",
+    "[OWL_DEBUG] Child<id=2> constructor, props=<JSON error>",
+    "[OWL_DEBUG] Child<id=2> willStart",
+    "[OWL_DEBUG] Child<id=2> rendering template",
+    "[OWL_DEBUG] Child<id=2> mounted",
+    "[OWL_DEBUG] Parent<id=1> mounted",
+    "[OWL_DEBUG] scheduler: stop running tasks queue",
+    "[OWL_DEBUG] Parent<id=1> willUnmount",
+    "[OWL_DEBUG] Child<id=2> willUnmount",
+  ]);
+  console.log = log;
+});
@@ -60,14 +60,14 @@ function getFiles(path: string[] = []): FileData[] {
  if (path.length === 0) {
    const baseFiles: FileData[] = [
      { name: "README.md", path: [], links: [], sections: [], fullName: "README.md" },
-      { name: "roadmap.md", path: [], links: [], sections: [], fullName: "roadmap.md" }
+      { name: "roadmap.md", path: [], links: [], sections: [], fullName: "roadmap.md" },
    ];
    const rest = getFiles(["doc"]);
    const result = baseFiles.concat(rest);
    result.forEach(addMardownData);
    return result;
  }
-  const files = fs.readdirSync(path.join("/"), { withFileTypes: true }).map(f => {
+  const files = fs.readdirSync(path.join("/"), { withFileTypes: true }).map((f) => {
    if (f.isDirectory()) {
      return getFiles(path.concat(f.name));
    }
@@ -78,8 +78,8 @@ function getFiles(path: string[] = []): FileData[] {
        path,
        links: [],
        sections: [],
-        fullName
-      }
+        fullName,
+      },
    ];
  });
  return Array.prototype.concat(...files);
@@ -127,7 +127,7 @@ export function isLinkValid(link: MarkDownLink, current: FileData, files: FileDa
  }

  // Step 4: check if there is a matching file
-  let target: FileData | undefined = files.find(f => f.fullName === linkFullName);
+  let target: FileData | undefined = files.find((f) => f.fullName === linkFullName);
  if (!target) {
    return false;
  }
@@ -135,7 +135,7 @@ export function isLinkValid(link: MarkDownLink, current: FileData, files: FileDa
  // Step 5: if necessary, check if there is a corresponding link inside the target
  // link name
  if (hash) {
-    if (!target.sections.find(s => s.slug === hash)) {
+    if (!target.sections.find((s) => s.slug === hash)) {
      return false;
    }
  }
@@ -153,7 +153,7 @@ function slugify(str) {
    .toLowerCase()
    .replace(/\//g, "") // remove /
    .replace(/\s+/g, "-") // Replace spaces with -
-    .replace(p, c => b.charAt(a.indexOf(c))) // Replace special characters
+    .replace(p, (c) => b.charAt(a.indexOf(c))) // Replace special characters
    .replace(/&/g, "-and-") // Replace & with ‘and’
    .replace(/[^\w\-]+/g, "") // Remove all non-word characters
    .replace(/\-\-+/g, "-") // Replace multiple - with single -
@@ -1,4 +1,5 @@
 import { escape, debounce } from "../src/utils";
+import { browser } from "../src/browser";

 describe("escape", () => {
  test("normal strings", () => {
@@ -15,6 +16,10 @@ describe("escape", () => {
 describe("debounce", () => {
  test("works as expected", () => {
    jest.useFakeTimers();
+    // need to reset them on browser because they were mocked in window, but not
+    // on browser object
+    browser.setTimeout = window.setTimeout.bind(window);
+    browser.clearTimeout = window.clearTimeout.bind(window);
    let n = 0;
    let f = debounce(() => n++, 100);
    expect(n).toBe(0);
@@ -0,0 +1,154 @@
+import { buildData, startMeasure, stopMeasure, formatNumber } from "../shared/utils.js";
+
+const { useState, useRef } = owl.hooks;
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = useState({ counter: 0 });
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  shouldUpdate(nextProps) {
+    return nextProps.message !== this.props.message;
+  }
+  removeMessage() {
+    this.trigger("remove-message", {
+      id: this.props.message.id
+    });
+  }
+}
+Message.components = { Counter };
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  state = useState({ messages: [], multipleFlag: false, clearAfterFlag: false });
+  logRef = useRef("log");
+
+  mounted() {
+    this.log(`Benchmarking Owl v${owl.__info__.version} (build date: ${owl.__info__.date})`);
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this._benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        messages[i] = msg;
+      }
+    });
+  }
+
+  removeMessage(event) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === event.detail.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.logRef.el.appendChild(div);
+    this.logRef.el.scrollTop = this.logRef.el.scrollHeight;
+  }
+
+  clearLog() {
+    this.logRef.el.innerHTML = "";
+  }
+}
+App.components = { Message };
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadFile("templates.xml");
+  App.env = {
+    qweb: new owl.QWeb({ templates })
+  };
+  const app = new App();
+  app.mount(document.body);
+}
+
+start();
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OWL v1.0.0 Benchmark</title>
+  <link href="../shared/main.css" rel="stylesheet"/>
+  <script src='owl.js'></script>
+</head>
+<body>
+  <script src='app.js' type="module"></script>
+</body>
+</html>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Géry Debongnie	4b961cbffe	[REL] v1.0.8 # v1.0.8 - qweb fix: do not override t-att-class with class attribute in some cases - component fix: refuse to mount a destroyed component - hooks type improvement: useRef is now generic, and can capture the type of a component - qweb fix: t-esc inside t-call using outside t-set	2020-05-18 09:07:31 +02:00
Aaron Bohy	2af8cccd65	[FIX] qweb: t-esc inside t-call using outside t-set Before this commit, the generated code was incorrect, and crashed, when there was a t-esc="abc" in a subtemplate, with t-set="abc" done outside the subtemplate, with syntax <t t-set="abc">value</t>.	2020-05-15 13:47:57 +02:00
Géry Debongnie	b8d3618afa	[IMP] hooks: improve useRef typings With this commit, we can get the type for the target component for a ref. By default, if the generic type is not given, the ref will simply use the base Component type.	2020-04-30 16:23:36 +02:00
Géry Debongnie	559fadb62a	[FIX] component: properly handle mounting a destroyed component part of #685	2020-04-22 09:29:39 +02:00
Géry Debongnie	c36333dbbc	[CLEANUP] update prettier to v2.0.4	2020-04-21 16:23:31 +02:00
Géry Debongnie	b5c3422b4d	[FIX] qweb: do not override t-att-class with class There was some code in qweb to make sure that we support setting class and t-att-class on the same html element: <div class="some class" t-att-class="{b: true}">...</div> But the code did not work in the other direction: <div t-att-class="{b: true}" class="some class">...</div> With this commit, we just add the missing if statement closes #664	2020-04-21 16:23:31 +02:00
Géry Debongnie	23ce19e57a	[REL] v1.0.7	2020-04-17 15:52:52 +02:00
Géry Debongnie	aaf40e9bec	[IMP] tooling: add iife build to npm package This is useful to link to the iife version in some other projects.	2020-04-17 15:47:20 +02:00
Géry Debongnie	211f6ebdd6	[REL] v1.0.6	2020-04-17 15:16:24 +02:00
Géry Debongnie	1707bd240d	[IMP] add browser bindings to standard environment This could be done by each application, but it does cost only a few lines of code, and it helps standardizing the Owl ecosystem. For example, some library (such as o_spreadsheet) needs to mock side effects, and Odoo also needs to do that, so this prevents duplicated effort. closes #686	2020-04-17 13:39:46 +02:00
Géry Debongnie	142b69823f	[IMP] types: do not make Env an indexed type Before this commit, Env was an indexed type, this means that one could write env.anything, and it would accept it as a valid type. This is actually quite dangerous, because we lose the typing advantages for all keys that are properly defined. For example, if a component is defined as: class MyComponent extends Component<Props> { ... } Then Typescript will let it use anything from the environment, even if it is wrong. So, most properly typed Typescript applications should use instead a sub environment: interface MyAppEnv extends Env { someKey: someValue } Then, the component should be defined this way: class MyComponent extends Component<Props, MyAppEnv> { ... } Before this commit, any typos in the environment accesses would not be noticed by typescript.	2020-04-17 13:39:46 +02:00
Joseph Caburnay	94c8bce810	[IMP] allow anonymous Component extensions It is possible that a Component is extended dynamically and if this is the case, the class that extends it can be anonymous, with property name=''. If this is the case, current implementation interprets the empty string to be false so the while loop is terminated without further scanning the super classes. In this proposal, we allow anonymous class to be scanned until its Component ancestor. Basically, the anonymous class assumes the name of it super.	2020-04-15 08:54:02 +02:00
Géry Debongnie	ae172d42e7	[IMP] slots: add new t-set-slot directive This new t-set-slot directive is meant to replace t-set when we need to define the content of a sub slot. All new code should use that directive. The old t-set directive is still supported for now, but this should be removed when we publish Owl 2.0.	2020-04-06 15:42:32 +02:00
Géry Debongnie	ddf30a8a97	[CLEANUP] run prettier on the codebase	2020-04-06 15:42:32 +02:00
Géry Debongnie	8d0d8538ad	[FIX] slots: better heuristic to determine named slot content Unfortunately, we chose to use the directive `t-set` to define sub slot contents in a template. The goal was to reuse a directive for a similar use case: defining sub template is almost the same as defining a slot content. Obviously, this introduces a name conflict: the inner content of a component cannot use t-set t-value anymore (nor t-set with a body value), since they are interpreted as slot names. We mitigate the issue here by only interpreting as slot content the `t-set` statement located immediately below the parent component tag name and with a body content. However, a real fix need to introduce an additional directive to resolve the ambiguity.	2020-04-06 15:42:32 +02:00
Joseph Caburnay	2b0315c03f	[FIX] hooks: order of brackets for multiple async hooks	2020-03-30 08:46:16 +02:00
lucas	c469cac315	[FIX] qweb: protect scope in t-call writing recursively Have something like ```xml <div t-name="Parent"> <t t-call="nodeTemplate"> <t t-set="recursive_idx" t-value="1"/> <t t-set="node" t-value="root"/> </t> </div> <div t-name="nodeTemplate"> <t t-set="recursive_idx" t-value="recursive_idx + 1"/> <p><t t-esc="node.val"/> <t t-esc="recursive_idx"/></p> <t t-foreach="node.children or []" t-as="subtree"> <t t-call="nodeTemplate"> <t t-set="node" t-value="subtree"/> </t> </t> </div> ``` Where we want to propagate a recursion index through recursive t-calls Before this commit, it did not work as we protected the scope in order to not leak, in the wronf manner. Namely the protected scope only took firt level prototype properties of the original scope. After this commit, this case works as we mark the scope as read only solves #672	2020-03-12 13:15:28 +01:00
Lucas Perais (lpe)	b4ad14edc0	[FIX] component: self mounting position keeps the reference Have ```xml <body t-name="webclient" /> ``` and ```js const comp = new WebClient(); comp.mount(document.body, {position: 'self'}); ``` Before this commit, the body that was there before anything had happened was replaced by the new body node created by the WebClient OWL component After this commit, we ensure that the element body is the same at reference level	2020-03-05 16:35:33 +01:00
Aaron Bohy	718e5264ae	[FIX] test: missing await	2020-03-03 10:42:22 +01:00
Aaron Bohy	f5d019bb69	[FIX] component: concurrency issue with cancelled fiber Since `ee956a197`, the rendering is skipped if the currentFiber is completed. Unfortunately, cancelled fibers remain set in __owl__, so when a fiber is cancelled, subsequent calls to render are skipped. It would be nice to reset __owl__.currentFiber to null when the fiber is cancelled, but when trying to do so, a lot of tests fail. Part of issue #622 Closes #665	2020-03-02 11:35:47 +01:00
Géry Debongnie	afa36f52a0	[DOC] doc: fix t-debug example also, remove a useless console.log closes #661	2020-02-24 11:05:12 +01:00
Géry Debongnie	fd6327b068	[REL] v1.0.5	2020-02-21 09:47:01 +01:00
Géry Debongnie	d5098dd138	[MISC] set package.json license field to a valid SPDX expression closes #646	2020-02-21 09:32:35 +01:00
Géry Debongnie	ce052e0992	[FIX] transition: no crash if added/removed quickly This commit should fix crashes coming from transition code on nodes. This does not impact transitions on components. closes #637 closes #641	2020-02-21 09:30:47 +01:00
Géry Debongnie	b00188c1ce	[IMP] qweb: add support for event capture In this commit, we uses the "!" as suffix to designate an event that should be captured. This is inspired by the Vue source code. This solves the issue of communicating additional information to the underlying virtual dom. However, this will most likely disappear when we rewrite the vdom as a virtual block system. closes #650	2020-02-21 09:22:43 +01:00
Géry Debongnie	2c01802b8e	[FIX] qweb: support attributes with quotes closes #651	2020-02-21 08:08:55 +01:00
Géry Debongnie	20eb848262	[FIX] component: merge hooks properly Before this commit, creating a sub component with t-att-style/t-att-class attributes or with t-on- event handlers would override the hook object rendered by the sub component. This is an issue for some directives, such as t-ref, which defines hook functions. This commit fixes the issue by checking for an override, and wrapping the hooks in a function that calls each defined hook. closes #638	2020-02-17 15:50:53 +01:00
Géry Debongnie	8b479749b7	[IMP] add yarn.lock to .gitignore	2020-02-17 13:06:23 +01:00
Géry Debongnie	f7728b93bd	[FIX] component: cancel previous mounting operations if necessary closes #626	2020-02-17 12:49:32 +01:00
Géry Debongnie	03585d8fea	[DOC] add dedicated page on error handling closes #632	2020-02-17 09:11:04 +01:00
Géry Debongnie	047a9c8993	[DOC] add dedicated page on event handling part of #632	2020-02-17 09:11:04 +01:00
Géry Debongnie	69d35abe4f	[DOC] add a dedicated page on slots closes #640	2020-02-17 09:11:04 +01:00
Géry Debongnie	1d7503913e	[FIX] qweb: ignore comment nodes between t-if/t-elif/t-else closes #636	2020-02-17 08:10:20 +01:00
Géry Debongnie	ee956a1977	[FIX] component: resolve a subtle concurrency issue Asynchronous rendering is subtle. Before this commit, it was possible (though not easy) to get into a situation where the Owl rendering pipeline decremented twice the counter of a fiber that indicates that its work is complete. The situation occurs in the `render` method, where we create a fiber, wait for a micro tick before starting the actual rendering (the goal was to batch all changes coming from a single call stack). However, in this microtask tick, it was possible that the fiber was cancelled, and we did not have a check for that.	2020-02-07 14:19:43 +01:00
Géry Debongnie	3fdc7a48f3	[IMP] types: make component generic types optional In most cases, we just want Component<any, Env>. But since it was so annoying to have always the type Env, we actually used Component<any,any> everywhere. With this commit, the generic types have a default (and their order is swapped), so we can simply use Component in most cases, and Component<Props> when we want to type the props.	2020-02-06 09:37:44 +01:00
Fabrice Henrion	d212309f1b	[FIX] typo Courtesy of the en_US police	2020-02-04 09:03:02 +01:00
Géry Debongnie	8866905f33	[DOC] large refactoring, add section on starting project	2020-02-03 22:06:44 +01:00
Géry Debongnie	50b116c56d	[DOC] add information on why odoo made owl	2020-02-03 22:06:44 +01:00
Géry Debongnie	a823373220	[FIX] tool: properly wait in release script	2020-01-24 15:25:08 +01:00
Géry Debongnie	e402ee62de	[REL] v1.0.4	2020-01-21 10:28:50 +01:00
Géry Debongnie	5711eb065d	[ADD] tooling: add release script More work is needed to complete this, but the basics is here, and it is difficult to test. closes #612	2020-01-21 10:10:45 +01:00
Géry Debongnie	6739e79aac	[ADD] tools: add single file component example to playground	2020-01-21 09:27:30 +01:00
Géry Debongnie	1c8dc97fca	[FIX] component: can mount on different target without unmounting closes #616	2020-01-21 09:26:38 +01:00
Géry Debongnie	f9cac94dc7	[REF] tests: split component.test into multiple files	2020-01-21 09:26:38 +01:00
Géry Debongnie	c62c3fea19	[FIX] types: improve type of useExternalListener so it can work on window closes #613	2020-01-21 08:11:40 +01:00
Géry Debongnie	3845607feb	[DOC] store: clarify how a component can find a store closes #617	2020-01-21 08:08:14 +01:00
Géry Debongnie	3fcbb9ad16	[REL] v1.0.3	2020-01-09 16:27:18 +01:00
Géry Debongnie	e04b160bff	[REL] v1.0.2 v1.0.2 because I am fighting with npm...	2020-01-09 15:12:32 +01:00
Géry Debongnie	bc234d2053	[ADD] tools: add benchmarks for 1.0.0	2020-01-09 14:52:27 +01:00
Géry Debongnie	3d0f046d9a	[REL] v1.0.0 Finally!!	2020-01-09 14:37:36 +01:00
Géry Debongnie	4c75bae0e8	[IMP] owl: improve npm packaging closes #611	2020-01-09 14:35:13 +01:00
Géry Debongnie	54f5819ef9	[ADD] hooks: add useExternalListener hook It is very useful. Also, this commit prettifies the code. closes #608	2020-01-09 14:06:30 +01:00
Joseph Caburnay	0c9c5b877b	[FIX] playground: not all completed is deleted Before this fix, not all completed tasks are deleted when clicking clear completed button because we are looping to a mutated array. Looping thru a copy of the mutated array fixes this problem.	2020-01-09 09:40:13 +01:00
Joseph Caburnay	b7b0e38fca	[FIX] docs: some spelling corrections	2020-01-09 09:40:13 +01:00
mcm-odoo	74bd119bf5	[IMP] styles: handle & selector This commit adds the support of the & selector. This selector is useful to join a subrule with a parent selector. example: button { &:hover { background-color: red; } } will give button:hover { background-color: red; }	2020-01-09 09:37:27 +01:00
Géry Debongnie	4a0d04e4ae	[FIX] debug tools: do not crash on non json-stringifiable props closes #595	2020-01-09 09:24:50 +01:00
Géry Debongnie	49931104a1	[CLEANUP] update snapshots	2020-01-08 16:05:22 +01:00
Lucas Perais (lpe)	21d1306ec2	[FIX] qweb: t-foreach needs to hold on scope Have a t-on within a t-foreach the t-on has an expression Before this commit, when triggering the t-on, the expression was falsely evaluated In details, the expression took scope from outside the foreach loop as we protect it to have similar results than an actual for loop But, at triggering time, the scope protection had already been terminated meaning the info of the iteration of the loop the handler has been built in had already disappeared This commit fixes that closes #594	2020-01-08 15:45:44 +01:00
Lucas Perais (lpe)	21737d33fa	[FIX] qweb: variables set outside foreach must be altered by inloop t-tset In a template, have t-set t-value outside a t-foreach in the t-foreach, alter that variable by resetting it (as for a incrementation variable) Before this commit, when printing the variable when the loop had finished its value was the one set in the first place After this commit, the value becomes the one altered by the loop iterations closes #598	2020-01-08 15:45:44 +01:00
Géry Debongnie	23012f3e7c	[FIX] component: multiple t-calls Before this commit, owl could crash in some specific situations: multiple t-calls with sub components, outside a loop. The reason is that the t-call did not generate a key, so from the point of view of the children component, it had the same key, even though it was at a different place in a template. Also, with this fix, we can fix the playground responsive example. closes #602	2020-01-08 15:24:43 +01:00
Géry Debongnie	55889febd5	[FIX] qweb: add support for "in " operator in expressions closes #603	2020-01-08 15:20:01 +01:00
mcm-odoo	0af46bc123	[FIX] styles: fix selector generation This commit fixes the css selector generation for nested rules Before this fix, a selector like: .parent { .child-a, .child-b { color: red; } } was generated as: .parent .child-a, .child-b { color: red; } Now it generates: .parent .child-a, .parent .child-b { color: red; }	2019-12-27 12:31:17 +01:00
Géry Debongnie	b63cd4c9d9	[REL] v1.0.0-beta5	2019-12-20 11:26:53 +01:00
Géry Debongnie	953778dc50	[IMP] component/tags: add inline css tag This add an important feature: defining completely standalone owl components, with the template/style and javascript code together. closes #284	2019-12-20 11:20:10 +01:00
Géry Debongnie	4f61d9f1e0	[FIX] component: no crash if empty props The expression parser properly format an empty string into an empty string. But then, this empty string was injected in the props object of a component, and the compiled code looked like this: let props5 = { val: }; So, in this case, we simply put undefined, since there are no props value. closes #587	2019-12-19 14:32:10 +01:00
Sébastien Theys	bc2c7edff4	[FIX] store: prevent crash when selector returns `null` Because `typeof null === 'object'`.	2019-12-19 14:24:36 +01:00
Géry Debongnie	c8d9c0b50e	[DOC] add npm install instruction	2019-12-19 14:12:00 +01:00
Géry Debongnie	15b25fd838	[IMP] owl: prepare owl to be released on npm closes #196	2019-12-19 14:09:41 +01:00
Géry Debongnie	1db0f5ac9b	[REL] v1.0.0-beta4	2019-12-17 15:26:49 +01:00
Géry Debongnie	6465665550	[FIX] qweb/component: handle nested t-foreach and components The way keys were handled in QWeb was mostly ok, but a little naive. It is fine when we deal with a list of dom nodes, since the reconciliation algorithm need only to be able to differentiate/reconcile nodes in that list, but it is an issue with components, which needs to globally be able to find themselves in their parent's children map. Because of the way this was handled, there were situations were Owl internal virtual dom would crash, since components wrongly assumed that they were already rendered in a different place. To fix this, we generalize the way keys are generated, by concatenating all sub keys coming from each iteration loops. closes #584	2019-12-17 15:23:24 +01:00
Géry Debongnie	9216c5c24b	[FIX] qweb: t-call properly transfer key to sub components Since t-call is now a function call, we need to properly handle the internal key used to find previous components. If a t-call is inside a t-foreach, then we need to transfer the key to the sub template. Otherwise, each component in the subtemplate will be associated to the same key, which means that it will lead to big issues: components are destroyed and reused... closes #581	2019-12-16 20:30:34 +01:00
Géry Debongnie	d9bf4284c6	[REL] v1.0.0-beta3	2019-12-16 09:56:35 +01:00
Géry Debongnie	ef6fd457f8	[FIX] qweb: add support for spread operator closes #575	2019-12-13 22:35:26 +01:00
Sébastien Theys	455e45c148	[FIX] store: make Array.map work correctly on the result of selector closes #577	2019-12-13 20:32:02 +01:00
Lucas Perais (lpe)	5e7f1d5e6d	[FIX] qweb: t-call must pass extra parent Before this commit, when template was t-call'ed and defined t-component directive within it, there was a crash because extra.parent was never defined After this commit, this use case works	2019-12-13 20:28:49 +01:00
Géry Debongnie	0b05ad619f	[FIX] qweb: t-set with a body should not be joined with comma closes #574	2019-12-13 20:15:37 +01:00
Géry Debongnie	29a80d0b28	[FIX] qweb: properly display falsy values While it is not tested, nor documented, the reference QWeb implementation display the `false` value as "false". So, we have to adapt the Owl implementation to match that behaviour. At the same time, this commit uses 'let' instead of 'var' in various places, to make the compiled code more consistant.	2019-12-13 14:48:19 +01:00