[REL] v1.4.3

# v1.4.3

- fix: another scoping issue with t-slots

.github/workflows/deploy.yml

@@ -0,0 +1,27 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm install
+    - run: npm run test
+    - run: npm run prettier

.gitignore

@@ -26,4 +26,9 @@ node_modules
 # Extras temp file
 /tools/owl.js
 
-release-notes.md
+release-notes.md
+
+.rpt2_cache
+
+# useful in some cases
+/temp

README.md

@@ -41,7 +41,7 @@ find some more additional information [here](doc/miscellaneous/comparison.md).
 Here is a short example to illustrate interactive components:
 
 ```javascript
-const { Component, useState } = owl;
+const { Component, useState, mount } = owl;
 const { xml } = owl.tags;
 
 class Counter extends Component {
@@ -63,8 +63,7 @@ class App extends Component {
   static components = { Counter };
 }
 
-const app = new App();
-app.mount(document.body);
+mount(App, { target: document.body });
 ```
 
 Note that the counter component is made reactive with the [`useState` hook](doc/reference/hooks.md#usestate).
@@ -121,8 +120,7 @@ npm install @odoo/owl
 
 If you want to use a simple `<script>` tag, the last release can be downloaded here:
 
-- [owl-1.0.6.js](https://github.com/odoo/owl/releases/download/v1.0.6/owl.js)
-- [owl-1.0.6.min.js](https://github.com/odoo/owl/releases/download/v1.0.6/owl.min.js)
+- [owl-1.4.3](https://github.com/odoo/owl/releases/tag/v1.4.3)
 
 ## License
 

doc/learning/how_to_test.md

@@ -85,8 +85,7 @@ afterEach(() => {
 describe("SomeComponent", () => {
   test("component behaves as expected", async () => {
     const props = {...}; // depends on the component
-    const comp = new SomeComponent(null, props);
-    await comp.mount(fixture);
+    const comp = await mount(SomeComponent, { target: fixture, props });
 
     // do some assertions
     expect(...).toBe(...);

doc/learning/overview.md

@@ -96,7 +96,7 @@ class OrderLine extends Component {
     </div>`;
 
   add() {
-    this.trigger("add-to-order", { line: props.line });
+    this.trigger("add-to-order", { line: this.props.line });
   }
 }
 
@@ -111,7 +111,7 @@ class Parent extends Component {
   static components = { OrderLine };
   orders = useState([
     { id: 1, name: "Coffee", quantity: 0 },
-    { id: 2, name: "Tea", quantity: 0 }
+    { id: 2, name: "Tea", quantity: 0 },
   ]);
 
   addToOrder(event) {

doc/learning/quick_start.md

@@ -54,7 +54,7 @@ Now, `index.html` should contain the following:
 And `app.js` should look like this:
 
 ```js
-const { Component } = owl;
+const { Component, mount } = owl;
 const { xml } = owl.tags;
 const { whenReady } = owl.utils;
 
@@ -65,8 +65,7 @@ class App extends Component {
 
 // Setup code
 function setup() {
-  const app = new App();
-  app.mount(document.body);
+  mount(App, target: { document.body })
 }
 
 whenReady(setup);
@@ -124,7 +123,7 @@ Here is the content of `app.js` and `main.js`:
 
 ```js
 // app.js ----------------------------------------------------------------------
-const { Component } = owl;
+const { Component, mount } = owl;
 const { xml } = owl.tags;
 
 export class App extends Component {
@@ -135,8 +134,7 @@ export class App extends Component {
 import { App } from "./app.js";
 
 function setup() {
-  const app = new App();
-  app.mount(document.body);
+  mount(App, { target: document.body });
 }
 
 owl.utils.whenReady(setup);
@@ -240,12 +238,11 @@ export class App extends Component {
 }
 
 // src/main.js -----------------------------------------------------------------
-import { utils } from "@odoo/owl";
+import { utils, mount } from "@odoo/owl";
 import { App } from "./components/App";
 
 function setup() {
-  const app = new App();
-  app.mount(document.body);
+  mount(App, { target: document.body });
 }
 
 utils.whenReady(setup);
@@ -253,6 +250,7 @@ utils.whenReady(setup);
 // tests/components/App.test.js ------------------------------------------------
 import { App } from "../../src/components/App";
 import { makeTestFixture, nextTick, click } from "../helpers";
+import { mount } from "@odoo/owl";
 
 let fixture;
 
@@ -266,8 +264,7 @@ afterEach(() => {
 
 describe("App", () => {
   test("Works as expected...", async () => {
-    const app = new App();
-    await app.mount(fixture);
+    await mount(App, { target: fixture });
     expect(fixture.innerHTML).toBe("<div>Hello Owl</div>");
 
     click(fixture, "div");
@@ -281,7 +278,7 @@ import { Component } from "@odoo/owl";
 import "regenerator-runtime/runtime";
 
 export async function nextTick() {
-  return new Promise(function(resolve) {
+  return new Promise(function (resolve) {
     setTimeout(() => Component.scheduler.requestAnimationFrame(() => resolve()));
   });
 }
@@ -361,26 +358,26 @@ const HtmlWebpackPlugin = require("html-webpack-plugin");
 
 const host = process.env.HOST || "localhost";
 
-module.exports = function(env, argv) {
+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")
+      path: path.resolve(__dirname, "dist"),
     },
     module: {
       rules: [
         {
           test: /\.jsx?$/,
           loader: "babel-loader",
-          exclude: /node_modules/
-        }
-      ]
+          exclude: /node_modules/,
+        },
+      ],
     },
     resolve: {
-      extensions: [".js", ".jsx"]
+      extensions: [".js", ".jsx"],
     },
     devServer: {
       contentBase: path.resolve(__dirname, "public/index.html"),
@@ -388,14 +385,14 @@ module.exports = function(env, argv) {
       hot: true,
       host,
       port: 3000,
-      publicPath: "/"
+      publicPath: "/",
     },
     plugins: [
       new HtmlWebpackPlugin({
         inject: true,
-        template: path.resolve(__dirname, "public/index.html")
-      })
-    ]
+        template: path.resolve(__dirname, "public/index.html"),
+      }),
+    ],
   };
 };
 ```

doc/learning/tutorial_todoapp.md

@@ -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);
 })();
 ```
@@ -83,7 +83,7 @@ a single root component. Let us start by defining an `App` component. Replace th
 content of the function in `app.js` by the following code:
 
 ```js
-const { Component } = owl;
+const { Component, mount } = owl;
 const { xml } = owl.tags;
 const { whenReady } = owl.utils;
 
@@ -94,8 +94,7 @@ class App extends Component {
 
 // Setup code
 function setup() {
-  const app = new App();
-  app.mount(document.body);
+  mount(App, { target: document.body });
 }
 
 whenReady(setup);
@@ -170,13 +169,13 @@ class App extends Component {
     {
       id: 1,
       title: "buy milk",
-      isCompleted: true
+      isCompleted: true,
     },
     {
       id: 2,
       title: "clean house",
-      isCompleted: false
-    }
+      isCompleted: false,
+    },
   ];
 }
 ```
@@ -279,8 +278,7 @@ class App extends Component {
 // -------------------------------------------------------------------------
 function setup() {
     owl.config.mode = "dev";
-    const app = new App();
-    app.mount(document.body);
+    mount(App, { target: document.body });
 }
 
 whenReady(setup);
@@ -547,7 +545,7 @@ application), since it involves extracting all task related code out of the
 components. Here is the new content of the `app.js` file:
 
 ```js
-const { Component, Store } = owl;
+const { Component, Store, mount } = owl;
 const { xml } = owl.tags;
 const { whenReady } = owl.utils;
 const { useRef, useDispatch, useStore } = owl.hooks;
@@ -562,23 +560,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 +614,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() {
@@ -639,8 +637,7 @@ function setup() {
   owl.config.mode = "dev";
   const store = new Store({ actions, state: initialState });
   App.env.store = store;
-  const app = new App();
-  app.mount(document.body);
+  mount(App, { target: document.body });
 }
 
 whenReady(setup);
@@ -666,9 +663,8 @@ function makeStore() {
 
 function setup() {
   owl.config.mode = "dev";
-  App.env.store = makeStore();
-  const app = new App();
-  app.mount(document.body);
+  const env = { store: makeStore() };
+  mount(App, { target: document.body, env });
 }
 ```
 
@@ -811,8 +807,8 @@ For reference, here is the final code:
 ```
 
 ```js
-(function() {
-  const { Component, Store } = owl;
+(function () {
+  const { Component, Store, mount } = owl;
   const { xml } = owl.tags;
   const { whenReady } = owl.utils;
   const { useRef, useDispatch, useState, useStore } = owl.hooks;
@@ -827,24 +823,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 +893,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 +912,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;
       }
@@ -943,9 +939,8 @@ For reference, here is the final code:
 
   function setup() {
     owl.config.mode = "dev";
-    App.env.store = makeStore();
-    const app = new App();
-    app.mount(document.body);
+    const env = { store: makeStore() };
+    mount(App, { target: document.body, env });
   }
 
   whenReady(setup);

doc/miscellaneous/comparison.md

@@ -4,7 +4,7 @@ OWL, React and Vue have the same main feature: they allow developers to build
 declarative user interfaces. To do that, all these frameworks uses a virtual dom. However, there are still obviously many differences.
 
 In this page, we try to highlight some of these differences. Obviously, a lot of
-effort was done to be fair. However, if you disagree with some of the points
+effort was put to be fair. However, if you disagree with some of the points
 discussed, feel free to open an issue/submit a PR to correct this text.
 
 ## Content
@@ -47,7 +47,7 @@ components are fast enough for all our usecases, and making it as simple as
 possible for developers is more valuable (for us).
 
 Also, functions or class based components are more than just syntax. Functions
-comes with a mindset of composition and class are about inheritance. Clearly,
+come with a mindset of composition and class are about inheritance. Clearly,
 both of these are important mechanisms for reusing code. Also, one does not
 exclude the other.
 
@@ -257,11 +257,11 @@ to the store like in redux, with the `useStore` hook (see the [store documentati
 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();
 }
 

doc/miscellaneous/why_owl.md

@@ -61,14 +61,14 @@ because a lot of the state is hidden in their internals.
 
 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
+since the assets are totally dynamic (and could change whenever the user installs
+or removes 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
+its own module system, which are resolved 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!)
 
@@ -78,12 +78,12 @@ 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
+can use template strings to write single file components, 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
+Odoo stores templates as XML documents 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.
 
@@ -104,12 +104,12 @@ 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
+as an investment for the future, and we want to make onboarding developers 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
+overwhelmed with the frontend world: functional components, 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
@@ -135,7 +135,7 @@ 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
+Currently, Odoo form views interpret an 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.
@@ -147,16 +147,16 @@ 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 there certainly are situations where we need a state, which is not read-only,
 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
+(basically, whenever the user performs 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
+action is performed, but Odoo wants 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).
@@ -175,6 +175,6 @@ 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.
+that is different. For a framework that makes choices compatible with Odoo.
 
 And that is why we built Owl 🦉.

doc/readme.md

@@ -17,6 +17,7 @@ You will find here a complete reference of every feature, class or object
 provided by Owl.
 
 - [Animations](reference/animations.md)
+- [Browser](reference/browser.md)
 - [Component](reference/component.md)
 - [Content](reference/content.md)
 - [Concurrency Model](reference/concurrency_model.md)
@@ -27,6 +28,7 @@ provided by Owl.
 - [Event Handling](reference/event_handling.md)
 - [Error Handling](reference/error_handling.md)
 - [Hooks](reference/hooks.md)
+- [Mounting a component](reference/mounting.md)
 - [Miscellaneous Components](reference/misc.md)
 - [Observer](reference/observer.md)
 - [Props](reference/props.md)

doc/reference/animations.md

@@ -52,21 +52,20 @@ sequence of events will happen:
 At node insertion:
 
 - the css classes `name-enter` and `name-enter-active` will be added directly
-  when the node is inserted into the DOM,
+  when the node is inserted into the DOM.
 - on the next animation frame: the css class `name-enter` will be removed and the
   class `name-enter-to` will be added (so they can be used to trigger css
-  transition effects),
-- the css class `name-enter-active` will be removed whenever a css transition
-  ends.
+  transition effects).
+- at the end of the transition, `name-enter-to` and `name-enter-active` will be removed.
 
 At node destruction:
 
 - the css classes `name-leave` and `name-leave-active` will be added before the
-  node is removed to the DOM,
-- the css class `name-leave` will be removed on the next animation frame (so it
-  can be used to trigger css transition effects),
-- the css class `name-leave-active` will be removed whenever a css transition
-  ends. Only then will the element be removed from the DOM.
+  node is removed to the DOM.
+- on the next animation frame: the css class `name-leave` will be removed and the
+  class `name-leave-to` will be added (so they can be used to trigger css
+  transition effects).
+- at the end of the transition, `name-leave-to` and `name-leave-active` will be removed.
 
 For example, a simple fade in/out effect can be done with this:
 
@@ -93,3 +92,36 @@ Notes:
 
 Owl does not support more than one transition on a single node, so the
 `t-transition` expression must be a single value (i.e. no space allowed).
+
+## SCSS Mixins
+
+If you use SCSS, you can use mixins to make generic animations. Here is an exemple with a fade in / fade out animation:
+
+```scss
+@mixin animation-fade($time, $name) {
+  .#{$name}_fade-enter-active,
+  .#{$name}_fade-active {
+    transition: all $time;
+  }
+
+  .#{$name}_fade-enter {
+    opacity: 0;
+  }
+
+  .#{$name}_fade-leave-to {
+    opacity: 0;
+  }
+}
+```
+
+Usage:
+
+```scss
+@include animation-fade(0.5s, "o_notification");
+```
+
+You can now have in your template:
+
+```xml
+<SomeTag  t-transition="o_notification_fade"/>
+```

doc/reference/browser.md

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

doc/reference/component.md

@@ -10,13 +10,22 @@
   - [Static Properties](#static-properties)
   - [Methods](#methods)
   - [Lifecycle](#lifecycle)
+    - [`constructor(parent, props)`](#constructorparent-props)
+    - [`setup()`](#setup)
+    - [`willStart()`](#willstart)
+    - [`mounted()`](#mounted)
+    - [`willUpdateProps(nextProps)`](#willupdatepropsnextprops)
+    - [`willPatch()`](#willpatch)
+    - [`patched(snapshot)`](#patchedsnapshot)
+    - [`willUnmount()`](#willunmount)
+    - [`catchError(error)`](#catcherrorerror)
   - [Root Component](#root-component)
   - [Composition](#composition)
   - [Form Input Bindings](#form-input-bindings)
   - [References](#references)
   - [Dynamic sub components](#dynamic-sub-components)
   - [Functional Components](#functional-components)
-  - [SVG components](#svg-components)
+  - [SVG Components](#svg-components)
 
 ## Overview
 
@@ -204,7 +213,7 @@ to be called in the constructor.
   class Counter extends owl.Component {
     static props = {
       initialValue: Number,
-      optional: true
+      optional: true,
     };
   }
   ```
@@ -217,7 +226,7 @@ to be called in the constructor.
   ```js
   class Counter extends owl.Component {
     static defaultProps = {
-      initialValue: 0
+      initialValue: 0,
     };
   }
   ```
@@ -270,6 +279,10 @@ We explain here all the public methods of the `Component` class.
   // app is now visible
   ```
 
+  Note that the normal way of mounting an application is by using the `mount`
+  method on a component class, not by creating the instance by hand. See the
+  documentation on [mounting applications](mounting.md).
+
 * **`unmount()`**: in case a component needs to be detached/removed from the DOM, this
   method can be used. Most applications should not call `unmount`, this is more
   useful to the underlying component system.
@@ -285,8 +298,13 @@ We explain here all the public methods of the `Component` class.
   are updated. It returns a boolean, which indicates if the component should
   ignore a props update. If it returns false, then `willUpdateProps` will not
   be called, and no rendering will occur. Its default implementation is to
-  always return true. This is an optimization, similar to React's `shouldComponentUpdate`. Most of the time, this should not be used, but it
-  can be useful if we are handling large number of components.
+  always return true. Note that this is an optimization, similar to React's `shouldComponentUpdate`. Most of the time, this should not be used, but it
+  can be useful if we are handling large number of components. Since this is an
+  optimization, Owl has the freedom to ignore the result of `shouldUpdate` in
+  some cases (for example, if a component is remounted, or if we want to force
+  a full rerender of the UI). However, if `shouldUpdate` returns true, then Owl
+  provides the guarantee that the component will be rendered at some point in
+  the future (except if the component is destroyed or if some part of the UI crashes).
 
 * **`destroy()`**. As its name suggests, this method will remove the component,
   and perform all necessary cleanup, such as unmounting the component, its children,
@@ -307,7 +325,7 @@ a owl component:
 
 | Method                                           | Description                                                 |
 | ------------------------------------------------ | ----------------------------------------------------------- |
-| **[constructor](#constructorparent-props)**      | constructor                                                 |
+| **[setup](#setup)**                              | setup                                                       |
 | **[willStart](#willstart)**                      | async, before first rendering                               |
 | **[mounted](#mounted)**                          | just after component is rendered and added to the DOM       |
 | **[willUpdateProps](#willupdatepropsnextprops)** | async, before props update                                  |
@@ -352,6 +370,23 @@ class ClickCounter extends owl.Component {
 }
 ```
 
+Hook functions can be called in the constructor.
+
+#### `setup()`
+
+_setup_ is run just after the component is constructed. It is a lifecycle method,
+very similar to the _constructor_, except that it does not receive any argument.
+
+It is a valid method to call hook functions. Note that one of the main reason to
+have the `setup` hook in the component lifecycle is to make it possible to
+monkey patch it. It is a common need in the Odoo ecosystem.
+
+```javascript
+setup() {
+  useSetupAutofocus();
+}
+```
+
 #### `willStart()`
 
 willStart is an asynchronous hook that can be implemented to
@@ -754,7 +789,7 @@ template rendered with `props`. In Owl, this can be done by
 simply defining a template, that will access the `props` object:
 
 ```js
-const Welcome = xml`<h1>Hello, {props.name}</h1>`;
+const Welcome = xml`<h1>Hello, <t t-esc="props.name"/></h1>`;
 
 class MyComponent extends Component {
   static template = xml`
@@ -804,8 +839,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" }] },
+    ],
   };
 }
 ```

doc/reference/config.md

@@ -2,9 +2,10 @@
 
 The Owl framework is designed to work in many situations. However, it is
 sometimes necessary to customize some behaviour. This is done by using the
-global `config` object. It currently has one key:
+global `config` object. It provides two settings:
 
-- [`mode`](#mode).
+- [`mode`](#mode) (default value: `prod`),
+- [`enableTransitions`](#enabletransitions) (default value: `true`).
 
 ## Mode
 
@@ -25,3 +26,19 @@ So, changing this setting is best done at startup.
 
 An important job done by the `dev` mode is to validate props for each component
 creation and update. Also, extra props will cause an error.
+
+## `enableTransitions`
+
+Transitions are usually nice, but they can cause issues in some specific cases,
+such as automated tests. It is uncomfortable having to wait for a transition
+to end before moving to the next step.
+
+To solve this issue, Owl can be configured to ignore the `t-transition` directive.
+To do that, one only needs to set the `enableTransitions` flag to false:
+
+```js
+owl.config.enableTransitions = false;
+```
+
+Note that it suffers from the same drawback as the "dev" mode: all compiled
+templates, if any, will keep their current behaviours.

doc/reference/content.md

@@ -7,13 +7,15 @@ For example, `Component` is available at `owl.Component` and `EventBus` is
 exported as `owl.core.EventBus`.
 
 ```
+browser
 Component                               misc
 Context                                     AsyncRoot
 QWeb                                        Portal
-Store                                   router
-useState                                    Link
-config                                      RouteComponent
-    mode                                    Router
+mount                                   router
+Store                                       Link
+useState                                    RouteComponent
+config                                      Router
+    mode
 core                                    tags
     EventBus                                css
     Observer                                xml
@@ -27,6 +29,8 @@ hooks                                   utils
     useContext
     useState
     useRef
+    useComponent
+    useEnv
     useSubEnv
     useStore
     useDispatch

doc/reference/environment.md

@@ -49,15 +49,14 @@ The correct way to customize an environment is to simply set it up on the root
 component class, before the first component is created:
 
 ```js
-App.env = {
+const env = {
     _t: myTranslateFunction,
     user: {...},
     services: {
         ...
     },
 };
-const app = new App();
-app.mount(document.body);
+mount(App, { target: document.body, env });
 ```
 
 It is also possible to simply share an environment between all root components,
@@ -113,17 +112,16 @@ async function myEnv() {
     qweb: qweb,
     services: {
       localStorage: localStorage,
-      rpc: rpc
+      rpc: rpc,
     },
     debug: false,
-    inMobileMode: true
+    inMobileMode: true,
   };
 }
 
 async function start() {
-  App.env = await myEnv();
-  const app = new App();
-  await app.mount(document.body);
+  const env = await myEnv();
+  mount(App, { target: document.body, env });
 }
 ```
 
@@ -135,17 +133,4 @@ 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`
+  browser methods with a side effect. See [browser](browser.md) for more information. Note that the browser object will be removed from the environment in Owl 2.0.

doc/reference/error_handling.md

@@ -74,7 +74,7 @@ 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) {
+env.qweb.on("error", null, function (error) {
   // do something
   // react to the error
 });

doc/reference/event_bus.md

@@ -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);
 });
 

doc/reference/event_handling.md

@@ -78,6 +78,20 @@ The `t-on` directive allows to prebind its arguments. For example,
 Here, `expr` is a valid Owl expression, so it could be `true` or some variable
 from the rendering context.
 
+### Type Hinting
+
+Note that if you work with Typescript, the `trigger` method is generic on the type of the payload.
+
+You can then describe the type of the event, so you will see typing errors...
+
+```typescript
+this.trigger<MyCustomPayload>("my-custom-event", payload);
+```
+
+```typescript
+myCustomEventHandler(ev: OwlEvent<MyCustomPayload>) { ... }
+```
+
 ## Inline Event Handlers
 
 One can also directly specify inline statements. For example,

doc/reference/hooks.md

@@ -21,6 +21,8 @@
   - [`useStore`](#usestore)
   - [`useDispatch`](#usedispatch)
   - [`useGetters`](#usegetters)
+  - [`useComponent`](#usecomponent)
+  - [`useEnv`](#useenv)
   - [Making customized hooks](#making-customized-hooks)
 
 ## Overview
@@ -129,7 +131,7 @@ class SomeComponent extends Component {
 ### One rule
 
 There is only one rule: every hook for a component has to be called in the
-constructor (or in class fields):
+constructor, in the _setup_ method, or in class fields:
 
 ```js
 // ok
@@ -145,6 +147,13 @@ class SomeComponent extends Component {
   }
 }
 
+// also ok
+class SomeComponent extends Component {
+  setup() {
+    this.state = useState({ value: 0 });
+  }
+}
+
 // not ok: this is executed after the constructor is called
 class SomeComponent extends Component {
   async willStart() {
@@ -259,7 +268,7 @@ function useLoader() {
   }
 
   onWillStart(() => updateRecord(component.props.id));
-  onWillUpdateProps(nextProps => updateRecord(nextProps.id));
+  onWillUpdateProps((nextProps) => updateRecord(nextProps.id));
 
   return record;
 }
@@ -381,6 +390,16 @@ The `useDispatch` hook is the way for components to get a reference to the store
 The `useGetters` hook is the way for components to get a reference to the store
 getters. See the [store documentation](store.md) for more information.
 
+### `useComponent`
+
+The `useComponent` hook is useful as a building block for some customized hooks,
+that may need a reference to the component calling them.
+
+### `useEnv`
+
+The `useEnv` hook is useful as a building block for some customized hooks,
+that may need a reference to the env of the component calling them.
+
 ### Making customized hooks
 
 Hooks are a wonderful way to organize the code of a complex component by feature
@@ -435,13 +454,11 @@ not the solution to every problem.
 
   ```js
   function useRouter() {
-    return Component.current.env.router;
+    const env = useEnv();
+    return env.router;
   }
   ```
 
   This means that we give control to the application developer to create the
   router, which is good, so they can set it up, subclass it, ... And then, to
   test our components, we can just add a mock router in the environment.
-
-Note: the code above makes use of the `Component.current` property. This is the
-way hooks are able to get a reference to the component currently being created.

doc/reference/misc.md

@@ -43,7 +43,7 @@ workflow to help the user put in some data, which it could use later on.
 JavaScript:
 
 ```js
-const { Component } = owl;
+const { Component, mount } = owl;
 const { Portal } = owl.misc;
 
 class TeleportedComponent extends Component {}
@@ -51,8 +51,7 @@ class App extends Component {
   static components = { Portal, TeleportedComponent };
 }
 
-const app = new App();
-app.mount(document.body);
+mount(App, { target: document.body });
 ```
 
 XML:

doc/reference/mounting.md

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

doc/reference/observer.md

@@ -15,7 +15,7 @@ use cases, there is no need to directly instantiate an observer.
 For example, this code will display `update` in the console:
 
 ```javascript
-const observer = new owl.Observer();
+const observer = new owl.core.Observer();
 observer.notifyCB = () => console.log("update");
 const obj = observer.observe({ a: { b: 1 } });
 
@@ -39,14 +39,14 @@ is incremented every time the value is observed. Sometimes, it can be useful
 to obtain that number:
 
 ```js
-const observer = new owl.Observer();
+const observer = new owl.core.Observer();
 const obj = observer.observe({ a: { b: 1 } });
 
-observer.deepRevNumber(obj.a); // 1
+observer.revNumber(obj.a); // 1
 obj.a.b = 2;
 
-observer.deepRevNumber(obj.a); // 2
+observer.revNumber(obj.a); // 2
 ```
 
-The `deepRevNumber` can also return 0, which indicates that the value is not
+The `revNumber` can also return 0, which indicates that the value is not
 observed.

doc/reference/props.md

@@ -18,7 +18,7 @@ class Child extends Component {
 }
 
 class Parent extends Component {
-  static template = xml`<div><ComponentA a="state.a" b="'string'"/></div>`;
+  static template = xml`<div><Child a="state.a" b="'string'"/></div>`;
   static components = { Child };
   state = useState({ a: "fromparent" });
 }

doc/reference/props_validation.md

@@ -30,7 +30,7 @@ class ComponentB extends owl.Component {
     count: {type: Number},
     messages: {
       type: Array,
-      element: {type: Object, shape: {id: Boolean, text: 'string' }
+      element: {type: Object, shape: {id: Boolean, text: String }
     },
    date: Date,
    combinedVal: [Number, Boolean]

doc/reference/qweb_engine.md

@@ -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 });
 ```

doc/reference/qweb_templating_language.md

@@ -13,8 +13,11 @@
   - [Setting Variables](#setting-variables)
   - [Conditionals](#conditionals)
   - [Dynamic Attributes](#dynamic-attributes)
+  - [Dynamic Class Attribute](#dynamic-class-attribute)
+  - [Dynamic Tag Names](#dynamic-tag-names)
   - [Loops](#loops)
   - [Rendering Sub Templates](#rendering-sub-templates)
+  - [Dynamic Sub Templates](#dynamic-sub-templates)
   - [Translations](#translations)
   - [Debugging](#debugging)
 
@@ -75,6 +78,7 @@ needs. Here is a list of all Owl specific directives:
 | `t-transition`           | [Defining an animation](animations.md#css-transitions)                          |
 | `t-slot`                 | [Rendering a slot](slots.md)                                                    |
 | `t-model`                | [Form input bindings](component.md#form-input-bindings)                         |
+| `t-tag`                  | [Rendering nodes with dynamic tag name](#dynamic-tag-names)                     |
 
 ## Reference
 
@@ -323,6 +327,40 @@ values) or a pair `[key, value]`. For example:
 <div t-att="['a', 'b']"/> <!-- <div a="b"></div> -->
 ```
 
+### Dynamic class attribute
+
+For convenience, Owl supports a special case for the `t-att-class` case: one can
+use an object with keys describing the classes, and values boolean value denoting
+if the class is or is not present:
+
+```xml
+<div t-att-class="{'a': true, 'b': true}"/> <!-- result: <div class="a b"></div> -->
+
+<div t-att-class="{'a b': true, 'c': true}"/> <!-- result: <div class="a b c"></div> -->
+```
+
+Note that it can be combined with normal class attribute:
+
+```xml
+<div class="a" t-att-class="{'b': true}"/> <!-- result: <div class="a b"></div> -->
+```
+
+### Dynamic tag names
+
+When writing generic components or templates, the specific concrete tag for an
+HTML element is not known yet. In those situations, the `t-tag` directive is
+useful. It simply evaluates dynamically an expression to use as a tag name. The
+template:
+
+```xml
+<t t-tag="tag">
+    <span>content</span>
+</t>
+```
+
+will be rendered as `<div><span>content</span></div>` if the `tag` context key
+is set to `div`.
+
 ### Loops
 
 QWeb has an iteration directive `t-foreach` which take an expression returning the
@@ -452,6 +490,17 @@ are all equivalent:
 
 If there is no `t-key` directive, Owl will use the index as a default key.
 
+Note: the `t-foreach` directive only accepts arrays (lists) or objects. It does
+not work with other iterables, such as `Set`. However, it is only a matter of
+using the `...` javascript operator. For example:
+
+```xml
+<t t-foreach="...items" t-as="item">...</t>
+```
+
+The `...` operator will convert the `Set` (or any other iterables) into a list,
+which will work with Owl QWeb.
+
 ### Rendering Sub Templates
 
 QWeb templates can be used for top level rendering, but they can also be used
@@ -509,6 +558,22 @@ This can be used to define variables scoped to a sub template:
 <!-- "var" does not exist here -->
 ```
 
+### Dynamic sub templates
+
+The `t-call` directive can also be used to dynamically call a sub template,
+using string interpolation. For example:
+
+```xml
+<div t-name="main-template">
+    <t t-call="{{template}}">
+        <em>content</em>
+    </t>
+</div>
+```
+
+Here, the name of the template is obtained from the `template` value in the
+template rendering context.
+
 ### Translations
 
 By default, QWeb specify that templates should be translated. If this behaviour

doc/reference/slots.md

@@ -25,6 +25,8 @@ some sub template, but still be the owner. For example, a generic dialog compone
 will need to render some content, some footer, but with the parent as the
 rendering context.
 
+Slots are inserted with the `t-slot` directive:
+
 ```xml
 <div t-name="Dialog" class="modal">
   <div class="modal-title"><t t-esc="props.title"/></div>
@@ -42,7 +44,7 @@ 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">
+  <Dialog title="'Some Dialog'">
     <t t-set-slot="content">
       <div>hey</div>
     </t>
@@ -62,7 +64,9 @@ 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
+### Default Slot
+
+The first element inside the component which is not a named slot will
 be considered the `default` slot. For example:
 
 ```xml
@@ -77,7 +81,9 @@ be considered the `default` slot. For example:
 </div>
 ```
 
-Default content: slots can define a default content, in case the parent did not define them:
+### Default content
+
+Slots can define a default content, in case the parent did not define them:
 
 ```xml
 <div t-name="Parent">
@@ -94,3 +100,12 @@ Rendering context: the content of the slots is actually rendered with the
 rendering context corresponding to where it was defined, not where it is
 positioned. This allows the user to define event handlers that will be bound
 to the correct component (usually, the grandparent of the slot content).
+
+### Dynamic Slots
+
+The `t-slot` directive is actually able to use any expressions, using string
+interplolation:
+
+```xml
+ <t t-slot="{{current}}" />
+```

doc/reference/store.md

@@ -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
@@ -224,11 +224,11 @@ 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 });
 ```
@@ -245,7 +245,7 @@ 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();
 }
 

doc/reference/tags.md

@@ -62,14 +62,14 @@ The CSS tag is useful to define a css stylesheet in the javascript file:
 
 ```js
 class MyComponent extends Component {
-    static template = xml`
+  static template = xml`
         <div class="my-component">some template</div>
     `;
-    static css`
-      .my-component {
-          color: red;
-      }
-    `;
+  static style = css`
+    .my-component {
+      color: red;
+    }
+  `;
 }
 ```
 

doc/reference/utils.md

@@ -19,20 +19,20 @@ not ready yet, resolved directly otherwise). If called with a callback as
 argument, it executes it as soon as the DOM ready (or directly).
 
 ```js
-Promise.all([loadFile("templates.xml"), owl.utils.whenReady()]).then(function([templates]) {
+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);
+  const env = { qweb };
+  await mount(App, { env, target: document.body });
 });
 ```
 
 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);
+  const env = { qweb };
+  await mount(App, { env, target: document.body });
 });
 ```
 

package.json

@@ -1,22 +1,20 @@
 {
   "name": "@odoo/owl",
-  "version": "1.0.6",
+  "version": "1.4.3",
   "description": "Odoo Web Library (OWL)",
-  "main": "dist/owl.js",
+  "main": "dist/owl.cjs.js",
+  "browser": "dist/owl.iife.js",
+  "module": "dist/owl.es.js",
   "types": "dist/types/index.d.ts",
   "files": [
-    "dist/types/",
-    "dist/owl.js"
+    "dist"
   ],
   "engines": {
-    "node": ">=10.15.3"
+    "node": ">=12.18.3"
   },
   "scripts": {
-    "build:js": "tsc --target esnext --module es6 --outDir dist/owl",
     "build:bundle": "rollup -c",
-    "build": "npm run build:js && npm run build:bundle",
-    "buildcommonjs": "npm run build:js && npm run build:bundle -- -f cjs",
-    "minify": "uglifyjs dist/owl.js -o dist/owl.min.js --compress --mangle",
+    "build": "npm run build:bundle",
     "test": "jest",
     "test:watch": "jest --watch",
     "tools:serve": "python3 tools/server.py || python tools/server.py",
@@ -24,7 +22,8 @@
     "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",
-    "publish": "npm run buildcommonjs && npm publish",
+    "check-formatting": "prettier {src/*.ts,src/**/*.ts,tests/*.ts,tests/**/*.ts,doc/*.md,doc/**/*.md} --check",
+    "publish": "npm run build && npm publish",
     "release": "node tools/release.js"
   },
   "repository": {
@@ -37,20 +36,22 @@
     "url": "https://github.com/odoo/owl/issues"
   },
   "homepage": "https://github.com/odoo/owl#readme",
-  "dependencies": {},
   "devDependencies": {
-    "@types/jest": "^23.3.12",
+    "@types/jest": "^23.3.14",
+    "@types/node": "^14.11.8",
     "chalk": "^3.0.0",
     "cpx": "^1.5.0",
+    "current-git-branch": "^1.1.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",
+    "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-typescript2": "^0.27.3",
     "sass": "^1.16.1",
     "source-map-support": "^0.5.10",
     "ts-jest": "^23.10.5",
@@ -77,6 +78,7 @@
     ]
   },
   "prettier": {
-    "printWidth": 100
+    "printWidth": 100,
+    "endOfLine": "auto"
   }
 }

roadmap.md

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

rollup.config.js

@@ -1,14 +1,70 @@
-import { version } from "./package.json";
+import pkg from "./package.json";
 import git from "git-rev-sync";
+import typescript from 'rollup-plugin-typescript2';
+import { terser } from "rollup-plugin-terser";
+
+const name = "owl";
+const extend = true;
+
+/**
+ * Meta data to be added on the __info__ object.
+ * Used to let external tools know the current owl version.
+ */
+const outro = `
+__info__.version = '${pkg.version}';
+__info__.date = '${new Date().toISOString()}';
+__info__.hash = '${git.short()}';
+__info__.url = 'https://github.com/odoo/owl';
+`;
+
+/**
+ * Generate from a string depicting a path a new path for the minified version.
+ * @param {string} pkgFileName file name
+ */
+function generateMinifiedNameFromPkgName(pkgFileName) {
+  const parts = pkgFileName.split('.');
+  parts.splice(parts.length - 1, 0, "min");
+  return parts.join('.');
+}
+
+/**
+ * Get the rollup config based on the arguments
+ * @param {string} format format of the bundle
+ * @param {string} generatedFileName generated file name
+ * @param {boolean} minified should it be minified
+ */
+function getConfigForFormat(format, generatedFileName, minified = false) {
+  return {
+    file: minified ? generateMinifiedNameFromPkgName(generatedFileName) : generatedFileName,
+    format: format,
+    name: name,
+    extend: extend,
+    outro: outro,
+    plugins: minified ? [terser()] : [],
+    indent: '    ', // indent with 4 spaces
+  };
+}
 
-// rollup.config.js
 export default {
-  input: "dist/owl/index.js",
-  output: {
-    file: "dist/owl.js",
-    format: "iife",
-    name: "owl",
-    extend: true,
-    outro: `exports.__info__.version = '${version}';\nexports.__info__.date = '${new Date().toISOString()}';\nexports.__info__.hash = '${git.short()}';\nexports.__info__.url = 'https://github.com/odoo/owl';`
-  }
+  input: "src/index.ts",
+  output: [
+
+    /**
+     * Read about module formats:
+     *  https://auth0.com/blog/javascript-module-systems-showdown/
+     *  https://medium.com/@kelin2025/so-you-wanna-use-es6-modules-714f48b3a953
+     */
+
+    getConfigForFormat('esm', pkg.module),
+    getConfigForFormat('esm', pkg.module, true),
+    getConfigForFormat('cjs', pkg.main),
+    getConfigForFormat('cjs', pkg.main, true),
+    getConfigForFormat('iife', pkg.browser),
+    getConfigForFormat('iife', pkg.browser, true),
+  ],
+  plugins: [
+    typescript({
+      useTsconfigDeclarationDir: true
+    }),
+  ]
 };

src/browser.ts

@@ -10,6 +10,8 @@ export interface Browser {
   localStorage: Window["localStorage"];
 }
 
+let localStorage: Window["localStorage"] | null = null;
+
 export const browser: Browser = {
   setTimeout: window.setTimeout.bind(window),
   clearTimeout: window.clearTimeout.bind(window),
@@ -19,5 +21,10 @@ export const browser: Browser = {
   random: Math.random,
   Date: window.Date,
   fetch: (window.fetch || (() => {})).bind(window),
-  localStorage: window.localStorage
+  get localStorage() {
+    return localStorage || window.localStorage;
+  },
+  set localStorage(newLocalStorage: Window["localStorage"]) {
+    localStorage = newLocalStorage;
+  },
 };

src/component/component.ts

@@ -44,6 +44,15 @@ interface MountOptions {
   position?: MountPosition;
 }
 
+export const enum STATUS {
+  CREATED,
+  WILLSTARTED, // willstart has been called
+  RENDERED, // first render is completed (so, vnode is now defined)
+  MOUNTED, // is ready, and in DOM. It has a valid el
+  UNMOUNTED, // has a valid el, but is not in DOM
+  DESTROYED,
+}
+
 /**
  * This is mostly an internal detail of implementation. The Meta interface is
  * useful to typecheck and describe the internal keys used by Owl to manage the
@@ -56,8 +65,7 @@ interface Internal<T extends Env> {
   depth: number;
   vnode: VNode | null;
   pvnode: VNode | null;
-  isMounted: boolean;
-  isDestroyed: boolean;
+  status: STATUS;
 
   // parent and children keys are obviously useful to setup the parent-children
   // relationship.
@@ -159,20 +167,23 @@ export class Component<Props extends {} = any, T extends Env = Env> {
       if (!this.env.qweb) {
         this.env.qweb = new QWeb();
       }
+      // TODO: remove this in owl 2.0
       if (!this.env.browser) {
         this.env.browser = browser;
       }
       this.env.qweb.on("update", this, () => {
-        if (this.__owl__.isMounted) {
-          this.render(true);
-        }
-        if (this.__owl__.isDestroyed) {
-          // this is unlikely to happen, but if a root widget is destroyed,
-          // we want to remove our subscription.  The usual way to do that
-          // would be to perform some check in the destroy method, but since
-          // it is very performance sensitive, and since this is a rare event,
-          // we simply do it lazily
-          this.env.qweb.off("update", this);
+        switch (this.__owl__.status) {
+          case STATUS.MOUNTED:
+            this.render(true);
+            break;
+          case STATUS.DESTROYED:
+            // this is unlikely to happen, but if a root widget is destroyed,
+            // we want to remove our subscription.  The usual way to do that
+            // would be to perform some check in the destroy method, but since
+            // it is very performance sensitive, and since this is a rare event,
+            // we simply do it lazily
+            this.env.qweb.off("update", this);
+            break;
         }
       });
       depth = 0;
@@ -185,8 +196,7 @@ export class Component<Props extends {} = any, T extends Env = Env> {
       depth: depth,
       vnode: null,
       pvnode: null,
-      isMounted: false,
-      isDestroyed: false,
+      status: STATUS.CREATED,
       parent: parent || null,
       children: {},
       cmap: {},
@@ -203,13 +213,25 @@ export class Component<Props extends {} = any, T extends Env = Env> {
       renderFn: qweb.render.bind(qweb, template),
       classObj: null,
       refs: null,
-      scope: null
+      scope: null,
     };
     if (constr.style) {
       this.__applyStyles(constr);
     }
+    this.setup();
   }
 
+  /**
+   * setup is run just after the component is constructed. This is the standard
+   * location where the component can setup its hooks. It has some advantages
+   * over the constructor:
+   *  - it can be patched (useful in odoo ecosystem)
+   *  - it does not need to propagate the arguments to the super call
+   *
+   * Note: this method should not be called manually.
+   */
+  setup() {}
+
   /**
    * willStart is an asynchronous hook that can be implemented to perform some
    * action before the initial rendering of a component.
@@ -304,39 +326,49 @@ export class Component<Props extends {} = any, T extends Env = Env> {
    * Note that a component can be mounted an unmounted several times
    */
   async mount(target: HTMLElement | DocumentFragment, options: MountOptions = {}): Promise<void> {
-    const position = options.position || "last-child";
-    const __owl__ = this.__owl__;
-    if (__owl__.isMounted) {
-      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__.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);
     }
-    const fiber = new Fiber(null, this, false, target, position);
-    fiber.shouldPatch = false;
-    if (!__owl__.vnode) {
-      this.__prepareAndRender(fiber, () => {});
-    } else {
-      this.__render(fiber);
+    const position = options.position || "last-child";
+    const __owl__ = this.__owl__;
+    const currentFiber = __owl__.currentFiber;
+
+    switch (__owl__.status) {
+      case STATUS.CREATED: {
+        const fiber = new Fiber(null, this, true, target, position);
+        fiber.shouldPatch = false;
+        this.__prepareAndRender(fiber, () => {});
+        return scheduler.addFiber(fiber);
+      }
+      case STATUS.WILLSTARTED:
+      case STATUS.RENDERED:
+        currentFiber.target = target;
+        currentFiber.position = position;
+        return scheduler.addFiber(currentFiber);
+
+      case STATUS.UNMOUNTED: {
+        const fiber = new Fiber(null, this, true, target, position);
+        fiber.shouldPatch = false;
+        this.__render(fiber);
+        return scheduler.addFiber(fiber);
+      }
+
+      case STATUS.MOUNTED: {
+        if (position !== "self" && this.el!.parentNode !== target) {
+          const fiber = new Fiber(null, this, true, target, position);
+          fiber.shouldPatch = false;
+          this.__render(fiber);
+          return scheduler.addFiber(fiber);
+        } else {
+          return Promise.resolve();
+        }
+      }
+
+      case STATUS.DESTROYED:
+        throw new Error("Cannot mount a destroyed component");
     }
-    return scheduler.addFiber(fiber);
   }
 
   /**
@@ -344,7 +376,7 @@ export class Component<Props extends {} = any, T extends Env = Env> {
    * to call willUnmount calls and remove the component from the DOM.
    */
   unmount() {
-    if (this.__owl__.isMounted) {
+    if (this.__owl__.status === STATUS.MOUNTED) {
       this.__callWillUnmount();
       this.el!.remove();
     }
@@ -362,10 +394,7 @@ export class Component<Props extends {} = any, T extends Env = Env> {
   async render(force: boolean = false): Promise<void> {
     const __owl__ = this.__owl__;
     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.
+    if (!__owl__.vnode && !currentFiber) {
       return;
     }
     if (currentFiber && !currentFiber.isRendered && !currentFiber.isCompleted) {
@@ -374,15 +403,13 @@ export class Component<Props extends {} = any, T extends Env = Env> {
     // 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 status = __owl__.status;
     const fiber = new Fiber(null, this, force, null, null);
     Promise.resolve().then(() => {
-      if (__owl__.isMounted || !isMounted) {
-        if (fiber.isCompleted) {
+      if (__owl__.status === STATUS.MOUNTED || status !== STATUS.MOUNTED) {
+        if (fiber.isCompleted || fiber.isRendered) {
           return;
         }
-        // we are mounted (__owl__.isMounted), or if we are currently being
-        // mounted (!isMounted), so we call __render
         this.__render(fiber);
       } else {
         // we were mounted when render was called, but we aren't anymore, so we
@@ -406,7 +433,7 @@ export class Component<Props extends {} = any, T extends Env = Env> {
    */
   destroy() {
     const __owl__ = this.__owl__;
-    if (!__owl__.isDestroyed) {
+    if (__owl__.status !== STATUS.DESTROYED) {
       const el = this.el;
       this.__destroy(__owl__.parent);
       if (el) {
@@ -430,8 +457,8 @@ export class Component<Props extends {} = any, T extends Env = Env> {
    * up to the parent DOM nodes. Thus, it must be called between mounted() and
    * willUnmount().
    */
-  trigger(eventType: string, payload?: any) {
-    this.__trigger(this, eventType, payload);
+  trigger<T = any>(eventType: string, payload?: T) {
+    this.__trigger<T>(this, eventType, payload);
   }
 
   //--------------------------------------------------------------------------
@@ -451,13 +478,12 @@ export class Component<Props extends {} = any, T extends Env = Env> {
    */
   __destroy(parent: Component | null) {
     const __owl__ = this.__owl__;
-    const isMounted = __owl__.isMounted;
-    if (isMounted) {
+    if (__owl__.status === STATUS.MOUNTED) {
       if (__owl__.willUnmountCB) {
         __owl__.willUnmountCB();
       }
       this.willUnmount();
-      __owl__.isMounted = false;
+      __owl__.status = STATUS.UNMOUNTED;
     }
     const children = __owl__.children;
     for (let key in children) {
@@ -468,7 +494,7 @@ export class Component<Props extends {} = any, T extends Env = Env> {
       delete parent.__owl__.children[id];
       __owl__.parent = null;
     }
-    __owl__.isDestroyed = true;
+    __owl__.status = STATUS.DESTROYED;
     delete __owl__.vnode;
     if (__owl__.currentFiber) {
       __owl__.currentFiber.isCompleted = true;
@@ -478,7 +504,7 @@ export class Component<Props extends {} = any, T extends Env = Env> {
   __callMounted() {
     const __owl__ = this.__owl__;
 
-    __owl__.isMounted = true;
+    __owl__.status = STATUS.MOUNTED;
     __owl__.currentFiber = null;
     this.mounted();
     if (__owl__.mountedCB) {
@@ -492,15 +518,15 @@ export class Component<Props extends {} = any, T extends Env = Env> {
       __owl__.willUnmountCB();
     }
     this.willUnmount();
-    __owl__.isMounted = false;
-    if (this.__owl__.currentFiber) {
-      this.__owl__.currentFiber.isCompleted = true;
-      this.__owl__.currentFiber.root.counter = 0;
+    __owl__.status = STATUS.UNMOUNTED;
+    if (__owl__.currentFiber) {
+      __owl__.currentFiber.isCompleted = true;
+      __owl__.currentFiber.root.counter = 0;
     }
     const children = __owl__.children;
     for (let id in children) {
       const comp = children[id];
-      if (comp.__owl__.isMounted) {
+      if (comp.__owl__.status === STATUS.MOUNTED) {
         comp.__callWillUnmount();
       }
     }
@@ -509,12 +535,12 @@ export class Component<Props extends {} = any, T extends Env = Env> {
    * Private trigger method, allows to choose the component which triggered
    * the event in the first place
    */
-  __trigger(component: Component, eventType: string, payload?: any) {
+  __trigger<T>(component: Component, eventType: string, payload?: T) {
     if (this.el) {
-      const ev = new OwlEvent(component, eventType, {
+      const ev = new OwlEvent<T>(component, eventType, {
         bubbles: true,
         cancelable: true,
-        detail: payload
+        detail: payload,
       });
       const triggerHook = this.env[portalSymbol as any];
       if (triggerHook) {
@@ -549,7 +575,7 @@ export class Component<Props extends {} = any, T extends Env = Env> {
       }
       await Promise.all([
         this.willUpdateProps(nextProps),
-        __owl__.willUpdatePropsCB && __owl__.willUpdatePropsCB(nextProps)
+        __owl__.willUpdatePropsCB && __owl__.willUpdatePropsCB(nextProps),
       ]);
       if (fiber.isCompleted) {
         return;
@@ -621,18 +647,25 @@ export class Component<Props extends {} = any, T extends Env = Env> {
     }
     return p._template;
   }
+
   async __prepareAndRender(fiber: Fiber, cb: CallableFunction) {
     try {
-      await Promise.all([this.willStart(), this.__owl__.willStartCB && this.__owl__.willStartCB()]);
+      const proms = Promise.all([
+        this.willStart(),
+        this.__owl__.willStartCB && this.__owl__.willStartCB(),
+      ]);
+      this.__owl__.status = STATUS.WILLSTARTED;
+      await proms;
+      if (this.__owl__.status === <any>STATUS.DESTROYED) {
+        return Promise.resolve();
+      }
     } catch (e) {
       fiber.handleError(e);
       return Promise.resolve();
     }
-    if (this.__owl__.isDestroyed) {
-      return Promise.resolve();
-    }
     if (!fiber.isCompleted) {
       this.__render(fiber);
+      this.__owl__.status = STATUS.RENDERED;
       cb();
     }
   }
@@ -646,16 +679,35 @@ export class Component<Props extends {} = any, T extends Env = Env> {
     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
       // destroyed right now, because they are not in the DOM, and thus we won't
       // be notified later on (when patching), that they are removed from the DOM
       for (let childKey in __owl__.children) {
-        let child = __owl__.children[childKey];
-        if (!child.__owl__.isMounted && child.__owl__.parentLastFiberId < fiber.id) {
-          child.destroy();
+        const child = __owl__.children[childKey];
+        const childOwl = child.__owl__;
+        if (childOwl.status !== STATUS.MOUNTED && childOwl.parentLastFiberId < fiber.id) {
+          // we only do here a "soft" destroy, meaning that we leave the child
+          // dom node alone, without removing it.  Most of the time, it does not
+          // matter, because the child component is already unmounted.  However,
+          // if some of its parent have been unmounted, the child could actually
+          // still be attached to its parent, and this may be important if we
+          // want to remount the parent, because the vdom need to match the
+          // actual DOM
+          child.__destroy(childOwl.parent);
+          if (childOwl.pvnode) {
+            // we remove the key here to make sure that the patching algorithm
+            // is able to make the difference between this pvnode and an eventual
+            // other instance of the same component
+            delete childOwl.pvnode.key;
+            // Since the component has been unmounted, we do not want to actually
+            // call a remove hook.  This is pretty important, since the t-component
+            // directive actually disabled it, so the vdom algorithm will just
+            // not remove the child elm if we don't remove the hook.
+            delete childOwl.pvnode.data!.hook!.remove;
+          }
         }
       }
       if (!vnode) {
@@ -683,17 +735,6 @@ export class Component<Props extends {} = any, T extends Env = Env> {
     }
   }
 
-  /**
-   * Only called by qweb t-component directive (when t-keepalive is set)
-   */
-  __remount() {
-    const __owl__ = this.__owl__;
-    if (!__owl__.isMounted) {
-      __owl__.isMounted = true;
-      this.mounted();
-    }
-  }
-
   /**
    * Apply default props (only top level).
    *
@@ -707,3 +748,34 @@ export class Component<Props extends {} = any, T extends Env = Env> {
     }
   }
 }
+
+interface MountParameters {
+  env?: Env;
+  target: HTMLElement | DocumentFragment;
+  props?: any;
+  position?: MountOptions["position"];
+}
+
+interface Type<T> extends Function {
+  new (...args: any[]): T;
+}
+
+export async function mount<T extends Type<Component>>(
+  C: T,
+  params: MountParameters
+): Promise<InstanceType<T>> {
+  const { env, props, target } = params;
+  let origEnv = C.hasOwnProperty("env") ? (C as any).env : null;
+  if (env) {
+    ((C as any) as typeof Component).env = env;
+  }
+  const component: Component = new C(null, props);
+  if (origEnv) {
+    (C as any).env = origEnv;
+  } else {
+    delete (C as any).env;
+  }
+  const position = params.position || "last-child";
+  await component.mount(target, { position });
+  return component as any;
+}

src/component/directive.ts

@@ -1,13 +1,14 @@
 import { QWeb } from "../qweb/index";
 import { INTERP_REGEXP } from "../qweb/compilation_context";
 import { makeHandlerCode, MODS_CODE } from "../qweb/extensions";
+import { STATUS } from "./component";
 
 //------------------------------------------------------------------------------
 // t-component
 //------------------------------------------------------------------------------
 
 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,7 +19,7 @@ QWeb.utils.defineProxy = function defineProxy(target, source) {
       },
       set(val) {
         source[k] = val;
-      }
+      },
     });
   }
 };
@@ -227,7 +228,9 @@ QWeb.addDirective({
       if (name.startsWith("t-on-")) {
         events.push([name, value]);
       } else if (name === "t-transition") {
-        transition = value;
+        if (QWeb.enableTransitions) {
+          transition = value;
+        }
       } else if (!name.startsWith("t-")) {
         if (name !== "class" && name !== "style") {
           // this is a prop!
@@ -238,11 +241,22 @@ QWeb.addDirective({
 
     // 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();
 
-    const templateKey = ctx.generateTemplateKey();
+    let hasDefinedKey = false;
+    let templateKey;
+    if (node.tagName === "t" && !node.hasAttribute("t-key") && value.match(INTERP_REGEXP)) {
+      defineComponentKey();
+      const id = ctx.generateID();
+      // the ___ is to make sure we have no possible conflict with normal
+      // template keys
+      ctx.addLine(`let k${id} = '___' + componentKey${componentID}`);
+      templateKey = `k${id}`;
+    } else {
+      templateKey = ctx.generateTemplateKey();
+    }
     let ref = node.getAttribute("t-ref");
     let refExpr = "";
     let refKey: string = "";
@@ -280,7 +294,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}};`);
@@ -288,7 +302,7 @@ QWeb.addDirective({
       if (tattClass) {
         let tattExpr = ctx.formatExpression(tattClass);
         if (tattExpr[0] !== "{" || tattExpr[tattExpr.length - 1] !== "}") {
-          tattExpr = `utils.toObj(${tattExpr})`;
+          tattExpr = `utils.toClassObj(${tattExpr})`;
         }
         if (classAttr) {
           ctx.addLine(`Object.assign(${classObj}, ${tattExpr})`);
@@ -298,7 +312,7 @@ 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(
@@ -333,7 +347,7 @@ QWeb.addDirective({
     }
     if (hasDynamicProps) {
       const dynamicProp = ctx.formatExpression(node.getAttribute("t-props")!);
-      ctx.addLine(`let props${componentID} = Object.assign({${propStr}}, ${dynamicProp});`);
+      ctx.addLine(`let props${componentID} = Object.assign({}, ${dynamicProp}, {${propStr}});`);
     } else {
       ctx.addLine(`let props${componentID} = {${propStr}};`);
     }
@@ -352,14 +366,14 @@ QWeb.addDirective({
     // SLOTS
     const hasSlots = node.childNodes.length;
 
-    let scope = hasSlots ? `Object.assign(Object.create(context), scope)` : "undefined";
+    let scope = hasSlots ? `utils.combine(context, scope)` : "undefined";
 
     ctx.addIf(`w${componentID}`);
 
     // need to update component
     let styleCode = "";
     if (tattStyle) {
-      styleCode = `.then(()=>{if (w${componentID}.__owl__.isDestroyed) {return};w${componentID}.el.style=${tattStyle};});`;
+      styleCode = `.then(()=>{if (w${componentID}.__owl__.status === ${STATUS.DESTROYED}) {return};w${componentID}.el.style=${tattStyle};});`;
     }
     ctx.addLine(
       `w${componentID}.__updateProps(props${componentID}, extra.fiber, ${scope})${styleCode};`
@@ -375,14 +389,17 @@ QWeb.addDirective({
     ctx.addElse();
 
     // new component
-    let dynamicFallback = "";
-    if (!value.match(INTERP_REGEXP)) {
-      dynamicFallback = `|| ${ctx.formatExpression(value)}`;
+    function defineComponentKey() {
+      if (!hasDefinedKey) {
+        const interpValue = ctx.interpolate(value);
+        ctx.addLine(`let componentKey${componentID} = ${interpValue};`);
+        hasDefinedKey = true;
+      }
     }
-    const interpValue = ctx.interpolate(value);
-    ctx.addLine(`let componentKey${componentID} = ${interpValue};`);
+    defineComponentKey();
+    const contextualValue = value.match(INTERP_REGEXP) ? "false" : ctx.formatExpression(value);
     ctx.addLine(
-      `let W${componentID} = context.constructor.components[componentKey${componentID}] || QWeb.components[componentKey${componentID}]${dynamicFallback};`
+      `let W${componentID} = ${contextualValue} || context.constructor.components[componentKey${componentID}] || QWeb.components[componentKey${componentID}];`
     );
 
     // maybe only do this in dev mode...
@@ -400,7 +417,6 @@ QWeb.addDirective({
 
     if (hasSlots) {
       const clone = <Element>node.cloneNode(true);
-      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
@@ -410,37 +426,60 @@ QWeb.addDirective({
       // 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);
+      for (let node of clone.children) {
+        if (node.hasAttribute("t-set") && node.hasChildNodes()) {
+          node.setAttribute("t-set-slot", node.getAttribute("t-set")!);
+          node.removeAttribute("t-set");
         }
       }
+      const slotNodes = Array.from(clone.querySelectorAll("[t-set-slot]"));
+      const slotNames = new Set<string>();
       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);
-          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");
+          // check if this is defined in a sub component (in which case it should
+          // be ignored)
+          let el = slotNode.parentElement;
+          let isInSubComponent = false;
+          while (el !== clone) {
+            if (
+              el!.hasAttribute("t-component") ||
+              el!.tagName[0] === el!.tagName[0].toUpperCase()
+            ) {
+              isInSubComponent = true;
+              break;
+            }
+            el = el.parentElement;
           }
-          const slotFn = qweb._compile(`slot_${key}_template`, slotNode, ctx);
+          if (isInSubComponent) {
+            continue;
+          }
+          let key = slotNode.getAttribute("t-set-slot")!;
+          if (slotNames.has(key)) {
+            continue;
+          }
+          slotNames.add(key);
+          slotNode.removeAttribute("t-set-slot");
+          slotNode.parentElement!.removeChild(slotNode);
+
+          const slotFn = qweb._compile(`slot_${key}_template`, { elem: slotNode, hasParent: true });
           QWeb.slots[`${slotId}_${key}`] = slotFn;
         }
       }
       if (clone.childNodes.length) {
+        let hasContent = false;
         const t = clone.ownerDocument!.createElement("t");
         for (let child of Object.values(clone.childNodes)) {
+          hasContent =
+            hasContent || (child instanceof Text ? Boolean(child.textContent.trim().length) : true);
           t.appendChild(child);
         }
-        const slotFn = qweb._compile(`slot_default_template`, t, ctx);
-        QWeb.slots[`${slotId}_default`] = slotFn;
+        if (hasContent) {
+          const slotFn = qweb._compile(`slot_default_template`, { elem: t, hasParent: true });
+          QWeb.slots[`${slotId}_default`] = slotFn;
+        }
       }
     }
 
@@ -469,5 +508,5 @@ QWeb.addDirective({
     ctx.addLine(`w${componentID}.__owl__.parentLastFiberId = extra.fiber.id;`);
 
     return true;
-  }
+  },
 });

src/component/fiber.ts

@@ -1,5 +1,5 @@
 import { h, VNode } from "../vdom/index";
-import { Component, MountPosition } from "./component";
+import { Component, MountPosition, STATUS } from "./component";
 import { scheduler } from "./scheduler";
 
 /**
@@ -82,6 +82,7 @@ export class Fiber {
 
     let oldFiber = __owl__.currentFiber;
     if (oldFiber && !oldFiber.isCompleted) {
+      this.force = true;
       if (oldFiber.root === oldFiber && !parent) {
         // both oldFiber and this fiber are root fibers
         this._reuseFiber(oldFiber);
@@ -106,6 +107,8 @@ export class Fiber {
    */
   _reuseFiber(oldFiber: Fiber) {
     oldFiber.cancel(); // cancel children fibers
+    oldFiber.target = this.target || oldFiber.target;
+    oldFiber.position = this.position || oldFiber.position;
     oldFiber.isCompleted = false; // keep the root fiber alive
     oldFiber.isRendered = false; // the fiber has to be re-rendered
     if (oldFiber.child) {
@@ -187,13 +190,14 @@ export class Fiber {
   complete() {
     let component = this.component;
     this.isCompleted = true;
-    if (!this.target && !component.__owl__.isMounted) {
+    const status = component.__owl__.status;
+    if (status === STATUS.DESTROYED) {
       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;
     };
@@ -201,14 +205,16 @@ export class Fiber {
     const patchLen = patchQueue.length;
 
     // call willPatch hook on each fiber of patchQueue
-    for (let i = 0; i < patchLen; i++) {
-      const fiber = patchQueue[i];
-      if (fiber.shouldPatch) {
-        component = fiber.component;
-        if (component.__owl__.willPatchCB) {
-          component.__owl__.willPatchCB();
+    if (status === STATUS.MOUNTED) {
+      for (let i = 0; i < patchLen; i++) {
+        const fiber = patchQueue[i];
+        if (fiber.shouldPatch) {
+          component = fiber.component;
+          if (component.__owl__.willPatchCB) {
+            component.__owl__.willPatchCB();
+          }
+          component.willPatch();
         }
-        component.willPatch();
       }
     }
 
@@ -238,12 +244,21 @@ export class Fiber {
       } else {
         if (fiber.shouldPatch) {
           component.__patch(component.__owl__.vnode!, fiber.vnode!);
+          // When updating a Component's props (in directive),
+          // the component has a pvnode AND should be patched.
+          // However, its pvnode.elm may have changed if it is a High Order Component
+          if (component.__owl__.pvnode) {
+            component.__owl__.pvnode.elm = component.__owl__.vnode!.elm;
+          }
         } else {
           component.__patch(document.createElement(fiber.vnode!.sel!), fiber.vnode!);
           component.__owl__.pvnode!.elm = component.__owl__.vnode!.elm;
         }
       }
-      component.__owl__.currentFiber = null;
+      const compOwl = component.__owl__;
+      if (fiber === compOwl.currentFiber) {
+        compOwl.currentFiber = null;
+      }
     }
 
     // insert into the DOM (mount case)
@@ -262,16 +277,24 @@ export class Fiber {
     }
 
     // call patched/mounted hook on each fiber of (reversed) patchQueue
-    for (let i = patchLen - 1; i >= 0; i--) {
-      const fiber = patchQueue[i];
-      component = fiber.component;
-      if (fiber.shouldPatch && !this.target) {
-        component.patched();
-        if (component.__owl__.patchedCB) {
-          component.__owl__.patchedCB();
+    if (status === STATUS.MOUNTED || inDOM) {
+      for (let i = patchLen - 1; i >= 0; i--) {
+        const fiber = patchQueue[i];
+        component = fiber.component;
+        if (fiber.shouldPatch && !this.target) {
+          component.patched();
+          if (component.__owl__.patchedCB) {
+            component.__owl__.patchedCB();
+          }
+        } else {
+          component.__callMounted();
         }
-      } else if (this.target ? inDOM : true) {
-        component.__callMounted();
+      }
+    } else {
+      for (let i = patchLen - 1; i >= 0; i--) {
+        const fiber = patchQueue[i];
+        component = fiber.component;
+        component.__owl__.status = STATUS.UNMOUNTED;
       }
     }
   }
@@ -280,7 +303,7 @@ export class Fiber {
    * Cancel a fiber and all its children.
    */
   cancel() {
-    this._walk(f => {
+    this._walk((f) => {
       if (!f.isRendered) {
         f.root.counter--;
       }
@@ -303,22 +326,43 @@ export class Fiber {
 
     const qweb = component.env.qweb;
     let root = component;
-    let canCatch = false;
-    while (component && !(canCatch = !!component.catchError)) {
-      root = component;
-      component = component.__owl__.parent!;
-    }
-    qweb.trigger("error", error);
 
-    if (canCatch) {
-      component.catchError!(error);
-    } else {
+    function handle(error) {
+      let canCatch = false;
+      qweb.trigger("error", error);
+      while (component && !(canCatch = !!component.catchError)) {
+        root = component;
+        component = component.__owl__.parent!;
+      }
+      if (canCatch) {
+        try {
+          component.catchError!(error);
+        } catch (e) {
+          root = component;
+          component = component.__owl__.parent!;
+          return handle(e);
+        }
+        return true;
+      }
+      return false;
+    }
+
+    let isHandled = handle(error);
+
+    if (!isHandled) {
       // the 3 next lines aim to mark the root fiber as being in error, and
       // to force it to end, without waiting for its children
       this.root.counter = 0;
       this.root.error = error;
       scheduler.flush();
-      root.destroy();
+      // at this point, the state of the application is corrupted and we could
+      // have a lot of issues or crashes. So we destroy the application in a try
+      // catch and swallow these errors because the fiber is already in error,
+      // and this is the actual issue that needs to be solved, not those followup
+      // errors.
+      try {
+        root.destroy();
+      } catch (e) {}
     }
   }
 }

src/component/props_validation.ts

@@ -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)
@@ -37,7 +37,7 @@ QWeb.utils.validateProps = function(Widget, props: Object) {
         if (propsDef[propName] && !propsDef[propName].optional) {
           throw new Error(`Missing props '${propName}' (component '${Widget.name}')`);
         } else {
-          break;
+          continue;
         }
       }
       let isValid;

src/component/scheduler.ts

@@ -50,7 +50,7 @@ export class Scheduler {
             return reject(fiber.error);
           }
           resolve();
-        }
+        },
       });
       if (!this.isRunning) {
         this.start();
@@ -60,7 +60,7 @@ export class Scheduler {
 
   rejectFiber(fiber: Fiber, reason: string) {
     fiber = fiber.root;
-    const index = this.tasks.findIndex(t => t.fiber === fiber);
+    const index = this.tasks.findIndex((t) => t.fiber === fiber);
     if (index >= 0) {
       const [task] = this.tasks.splice(index, 1);
       fiber.cancel();
@@ -76,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;

src/component/styles.ts

@@ -8,7 +8,7 @@
 export const STYLESHEETS: { [id: string]: HTMLStyleElement } = {};
 
 export function processSheet(str: string): string {
-  const tokens = str.split(/(\{|\}|;)/).map(s => s.trim());
+  const tokens = str.split(/(\{|\}|;)/).map((s) => s.trim());
   const selectorStack: string[][] = [];
   const parts: string[] = [];
   let rules: string[] = [];

src/config.ts

@@ -8,6 +8,7 @@ import { QWeb } from "./qweb/index";
 
 interface Config {
   mode: string;
+  enableTransitions: boolean;
 }
 
 export const config = {} as Config;
@@ -19,12 +20,21 @@ Object.defineProperty(config, "mode", {
   set(mode: string) {
     QWeb.dev = mode === "dev";
     if (QWeb.dev) {
-      const url = `https://github.com/odoo/owl/blob/master/doc/reference/config.md#mode`;
-      console.warn(
-        `Owl is running in 'dev' mode.  This is not suitable for production use. See ${url} for more information.`
-      );
+      console.info(`Owl is running in 'dev' mode.
+
+This is not suitable for production use.
+See https://github.com/odoo/owl/blob/master/doc/reference/config.md#mode for more information.`);
     } else {
       console.log(`Owl is now running in 'prod' mode.`);
     }
-  }
+  },
+});
+
+Object.defineProperty(config, "enableTransitions", {
+  get() {
+    return QWeb.enableTransitions;
+  },
+  set(value: boolean) {
+    QWeb.enableTransitions = value;
+  },
 });

src/context.ts

@@ -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
@@ -115,31 +115,21 @@ export function useContextWithCB(ctx: Context, component: Component, method): an
     __owl__.observer = new Observer();
     __owl__.observer.notifyCB = component.render.bind(component);
   }
-  const currentCB = __owl__.observer.notifyCB;
-  __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
-      // rendering is coming anyway, with the correct props.
-      return;
-    }
-    currentCB();
-  };
 
   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);

src/core/event_bus.ts

@@ -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);
     }
   }
 

src/core/observer.ts

@@ -25,7 +25,12 @@ export class Observer {
   notifyCB() {}
 
   observe<T>(value: T, parent?: any): T {
-    if (value === null || typeof value !== "object" || value instanceof Date) {
+    if (
+      value === null ||
+      typeof value !== "object" ||
+      value instanceof Date ||
+      value instanceof Promise
+    ) {
       // fun fact: typeof null === 'object'
       return value;
     }
@@ -67,14 +72,14 @@ export class Observer {
           self.notifyCB();
         }
         return true;
-      }
+      },
     });
 
     const metadata = {
       value,
       proxy,
       rev: this.rev,
-      parent
+      parent,
     };
 
     this.weakMap.set(value, metadata);

src/hooks.ts

@@ -1,4 +1,4 @@
-import { Component } from "./component/component";
+import { Component, Env } from "./component/component";
 import { Observer } from "./core/observer";
 
 /**
@@ -36,11 +36,11 @@ export function useState<T>(state: T): T {
 // -----------------------------------------------------------------------------
 function makeLifecycleHook(method: string, reverse: boolean = false) {
   if (reverse) {
-    return function(cb) {
+    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) {
+    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,11 +65,11 @@ function makeLifecycleHook(method: string, reverse: boolean = false) {
 }
 
 function makeAsyncHook(method: string) {
-  return function(cb) {
+  return function (cb) {
     const component: Component = Component.current!;
     if (component.__owl__[method]) {
       const current = component.__owl__[method];
-      component.__owl__[method] = function(...args) {
+      component.__owl__[method] = function (...args) {
         return Promise.all([current.call(component, ...args), cb.call(component, ...args)]);
       };
     } else {
@@ -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 | 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,13 +111,33 @@ export function useRef(name: string): Ref {
       }
       return null;
     },
-    get comp(): Component | 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;
+    },
   };
 }
 
+// -----------------------------------------------------------------------------
+// "Builder" hooks
+// -----------------------------------------------------------------------------
+
+/**
+ * This hook is useful as a building block for some customized hooks, that may
+ * need a reference to the component calling them.
+ */
+export function useComponent<P, E extends Env>(): Component<P, E> {
+  return Component.current as any;
+}
+
+/**
+ * This hook is useful as a building block for some customized hooks, that may
+ * need a reference to the env of the component calling them.
+ */
+export function useEnv<E extends Env>(): E {
+  return Component.current.env as any;
+}
+
 // -----------------------------------------------------------------------------
 // useSubEnv
 // -----------------------------------------------------------------------------

src/index.ts

@@ -19,9 +19,10 @@ import { Link } from "./router/link";
 import { RouteComponent } from "./router/route_component";
 import { Router } from "./router/router";
 
-export { Component } from "./component/component";
+export { Component, mount } from "./component/component";
 export { QWeb };
 export { config };
+export { browser } from "./browser";
 
 export const Context = _context.Context;
 export const useState = _hooks.useState;
@@ -35,6 +36,7 @@ export const hooks = Object.assign({}, _hooks, {
   useContext: _context.useContext,
   useDispatch: _store.useDispatch,
   useGetters: _store.useGetters,
-  useStore: _store.useStore
+  useStore: _store.useStore,
 });
+
 export const __info__ = {};

src/misc/portal.ts

@@ -26,8 +26,8 @@ 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
@@ -55,12 +55,12 @@ export class Portal extends Component<Props> {
     // 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);
         }
-      }
+      },
     });
   }
   /**

src/qweb/base_directives.ts

@@ -1,4 +1,4 @@
-import { CompilationContext } from "./compilation_context";
+import { CompilationContext, INTERP_REGEXP } from "./compilation_context";
 import { QWeb } from "./qweb";
 import { htmlToVDOM } from "../vdom/html_to_vdom";
 import { QWebVar } from "./expression_parser";
@@ -49,6 +49,7 @@ function compileValueNode(value: any, node: Element, qweb: QWeb, ctx: Compilatio
   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};`
@@ -96,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({
@@ -106,7 +107,7 @@ QWeb.addDirective({
     let value = ctx.getValue(node.getAttribute("t-raw")!);
     compileValueNode(value, node, qweb, ctx);
     return true;
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -163,7 +164,7 @@ QWeb.addDirective({
       }
     }
     return true;
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -179,7 +180,7 @@ QWeb.addDirective({
   },
   finalize({ ctx }) {
     ctx.closeIf();
-  }
+  },
 });
 
 QWeb.addDirective({
@@ -195,7 +196,7 @@ QWeb.addDirective({
   },
   finalize({ ctx }) {
     ctx.closeIf();
-  }
+  },
 });
 
 QWeb.addDirective({
@@ -208,7 +209,7 @@ QWeb.addDirective({
   },
   finalize({ ctx }) {
     ctx.closeIf();
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -222,77 +223,90 @@ QWeb.addDirective({
     // ------------------------------------------------
     ctx.rootContext.shouldDefineScope = true;
     ctx.rootContext.shouldDefineUtils = true;
-    if (node.nodeName !== "t") {
-      throw new Error("Invalid tag for t-call directive (should be 't')");
-    }
     const subTemplate = node.getAttribute("t-call")!;
+    const isDynamic = INTERP_REGEXP.test(subTemplate);
     const nodeTemplate = qweb.templates[subTemplate];
-    if (!nodeTemplate) {
+    if (!isDynamic && !nodeTemplate) {
       throw new Error(`Cannot find template "${subTemplate}" (t-call)`);
     }
 
     // Step 2: compile target template in sub templates
     // ------------------------------------------------
-    if (!qweb.subTemplates[subTemplate]) {
-      qweb.subTemplates[subTemplate] = true;
-      const subTemplateFn = qweb._compile(subTemplate, nodeTemplate.elem, ctx, true);
-      qweb.subTemplates[subTemplate] = subTemplateFn;
+    let subIdstr: string;
+    if (isDynamic) {
+      const _id = ctx.generateID();
+      ctx.addLine(`let tname${_id} = ${ctx.interpolate(subTemplate)};`);
+      ctx.addLine(`let tid${_id} = this.subTemplates[tname${_id}];`);
+      ctx.addIf(`!tid${_id}`);
+      ctx.addLine(`tid${_id} = this.constructor.nextId++;`);
+      ctx.addLine(`this.subTemplates[tname${_id}] = tid${_id};`);
+      ctx.addLine(
+        `this.constructor.subTemplates[tid${_id}] = this._compile(tname${_id}, {hasParent: true, defineKey: true});`
+      );
+      ctx.closeIf();
+      subIdstr = `tid${_id}`;
+    } else {
+      let subId = qweb.subTemplates[subTemplate];
+      if (!subId) {
+        subId = QWeb.nextId++;
+        qweb.subTemplates[subTemplate] = subId;
+        const subTemplateFn = qweb._compile(subTemplate, { hasParent: true, defineKey: true });
+        QWeb.subTemplates[subId] = subTemplateFn;
+      }
+      subIdstr = `'${subId}'`;
     }
 
     // Step 3: compile t-call body if necessary
     // ------------------------------------------------
     let hasBody = node.hasChildNodes();
-    let protectID;
+    const protectID = ctx.startProtectScope();
     if (hasBody) {
       // we add a sub scope to protect the ambient scope
       ctx.addLine(`{`);
       ctx.indent();
-      protectID = ctx.startProtectScope();
       const nodeCopy = node.cloneNode(true) as Element;
       for (let attr of ["t-if", "t-else", "t-elif", "t-call"]) {
         nodeCopy.removeAttribute(attr);
       }
-      const parentNode = ctx.parentNode;
-      ctx.parentNode = "__0";
       // this local scope is intended to trap c__0
       ctx.addLine(`{`);
       ctx.indent();
       ctx.addLine("let c__0 = [];");
-      qweb._compileNode(nodeCopy, ctx);
+      qweb._compileNode(nodeCopy, ctx.subContext("parentNode", "__0"));
       ctx.rootContext.shouldDefineUtils = true;
       ctx.addLine("scope[utils.zero] = c__0;");
-      ctx.parentNode = parentNode;
       ctx.dedent();
       ctx.addLine(`}`);
     }
 
     // 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 parentComponent = ctx.rootContext.shouldDefineParent
+      ? `parent`
+      : `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}, ${extra});`);
+      ctx.addLine(`this.constructor.subTemplates[${subIdstr}].call(this, scope, ${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}, ${extra});`);
+      ctx.addLine(`this.constructor.subTemplates[${subIdstr}].call(this, scope, ${extra});`);
       ctx.addLine(`result = result[0]`);
     }
 
     // Step 5: restore previous scope
     // ------------------------------------------------
     if (hasBody) {
-      ctx.stopProtectScope(protectID);
       ctx.dedent();
       ctx.addLine(`}`);
     }
+    ctx.stopProtectScope(protectID);
 
     return true;
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -353,7 +367,7 @@ QWeb.addDirective({
     ctx.addLine("}");
     ctx.stopProtectScope(varsID);
     return true;
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -364,7 +378,7 @@ QWeb.addDirective({
   priority: 1,
   atNodeEncounter({ ctx }) {
     ctx.addLine("debugger;");
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -376,5 +390,5 @@ QWeb.addDirective({
   atNodeEncounter({ ctx, value }) {
     const expr = ctx.formatExpression(value);
     ctx.addLine(`console.log(${expr})`);
-  }
+  },
 });

src/qweb/compilation_context.ts

@@ -162,7 +162,7 @@ export class CompilationContext {
     const tokens = compileExprToArray(expr, this.variables);
     const done = new Set();
     return tokens
-      .map(tok => {
+      .map((tok) => {
         if (tok.varName) {
           if (!done.has(tok.varName)) {
             done.add(tok.varName);
@@ -189,7 +189,7 @@ 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(codeBlock?: boolean): number {

src/qweb/expression_parser.ts

@@ -29,14 +29,14 @@ const RESERVED_WORDS = "true,false,NaN,null,undefined,debugger,console,window,in
   ","
 );
 
-const WORD_REPLACEMENT = {
+const WORD_REPLACEMENT = Object.assign(Object.create(null), {
   and: "&&",
   or: "||",
   gt: ">",
   gte: ">=",
   lt: "<",
-  lte: "<="
-};
+  lte: "<=",
+});
 
 export interface QWebVar {
   id: string; // foo
@@ -57,6 +57,7 @@ type TKind =
   | "RIGHT_PAREN"
   | "COMMA"
   | "VALUE"
+  | "TEMPLATE_STRING"
   | "SYMBOL"
   | "OPERATOR"
   | "COLON";
@@ -67,9 +68,10 @@ interface Token {
   originalValue?: string;
   size?: number;
   varName?: string;
+  replace?: Function;
 }
 
-const STATIC_TOKEN_MAP: { [key: string]: TKind } = {
+const STATIC_TOKEN_MAP: { [key: string]: TKind } = Object.assign(Object.create(null), {
   "{": "LEFT_BRACE",
   "}": "RIGHT_BRACE",
   "[": "LEFT_BRACKET",
@@ -77,8 +79,8 @@ 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
@@ -86,10 +88,10 @@ const OPERATORS = "...,.,===,==,+,!==,!=,!,||,&&,>=,>,<=,<,?,-,*,/,%,typeof ,=>,
 
 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 !== '"') {
+  if (s !== "'" && s !== '"' && s !== "`") {
     return false;
   }
   let i = 1;
@@ -111,10 +113,21 @@ let tokenizeString: Tokenizer = function(expr) {
     throw new Error("Invalid expression");
   }
   s += start;
+  if (start === "`") {
+    return {
+      type: "TEMPLATE_STRING",
+      value: s,
+      replace(replacer) {
+        return s.replace(/\$\{(.*?)\}/g, (match, group) => {
+          return "${" + replacer(group) + "}";
+        });
+      },
+    };
+  }
   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;
@@ -128,7 +141,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;
@@ -145,7 +158,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 };
@@ -153,7 +166,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 };
@@ -167,7 +180,7 @@ const TOKENIZERS = [
   tokenizeNumber,
   tokenizeOperator,
   tokenizeSymbol,
-  tokenizeStatic
+  tokenizeStatic,
 ];
 
 /**
@@ -210,6 +223,10 @@ export function tokenize(expr: string): Token[] {
 // Expression "evaluator"
 //------------------------------------------------------------------------------
 
+const isLeftSeparator = (token) => token && (token.type === "LEFT_BRACE" || token.type === "COMMA");
+const isRightSeparator = (token) =>
+  token && (token.type === "RIGHT_BRACE" || token.type === "COMMA");
+
 /**
  * This is the main function exported by this file. This is the code that will
  * process an expression (given as a string) and returns another expression with
@@ -238,13 +255,39 @@ export function tokenize(expr: string): Token[] {
 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++) {
+
+  let i = 0;
+  let stack = []; // to track last opening [ or {
+
+  while (i < tokens.length) {
     let token = tokens[i];
     let prevToken = tokens[i - 1];
     let nextToken = tokens[i + 1];
+    let groupType = stack[stack.length - 1];
+
+    switch (token.type) {
+      case "LEFT_BRACE":
+      case "LEFT_BRACKET":
+        stack.push(token.type);
+        break;
+      case "RIGHT_BRACE":
+      case "RIGHT_BRACKET":
+        stack.pop();
+    }
+
     let isVar = token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value);
     if (token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value)) {
       if (prevToken) {
+        // normalize missing tokens: {a} should be equivalent to {a:a}
+        if (
+          groupType === "LEFT_BRACE" &&
+          isLeftSeparator(prevToken) &&
+          isRightSeparator(nextToken)
+        ) {
+          tokens.splice(i + 1, 0, { type: "COLON", value: ":" }, { ...token });
+          nextToken = tokens[i + 1];
+        }
+
         if (prevToken.type === "OPERATOR" && prevToken.value === ".") {
           isVar = false;
         } else if (prevToken.type === "LEFT_BRACE" || prevToken.type === "COMMA") {
@@ -254,6 +297,9 @@ export function compileExprToArray(expr: string, scope: { [key: string]: QWebVar
         }
       }
     }
+    if (token.type === "TEMPLATE_STRING") {
+      token.value = token.replace((expr) => compileExpr(expr, scope));
+    }
     if (nextToken && nextToken.type === "OPERATOR" && nextToken.value === "=>") {
       if (token.type === "RIGHT_PAREN") {
         let j = i - 1;
@@ -278,12 +324,13 @@ export function compileExprToArray(expr: string, scope: { [key: string]: QWebVar
         token.value = `scope['${token.value}']`;
       }
     }
+    i++;
   }
   return tokens;
 }
 
 export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): string {
   return compileExprToArray(expr, scope)
-    .map(t => t.value)
+    .map((t) => t.value)
     .join("");
 }

src/qweb/extensions.ts

@@ -1,5 +1,8 @@
+import { STATUS } from "../component/component";
 import { VNode } from "../vdom/index";
+import { INTERP_REGEXP } from "./compilation_context";
 import { QWeb } from "./qweb";
+import { browser } from "../browser";
 
 /**
  * Owl QWeb Extensions
@@ -23,7 +26,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 {
@@ -50,7 +53,7 @@ export function makeHandlerCode(
   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 "";
   });
@@ -73,9 +76,10 @@ export function makeHandlerCode(
     // we need to capture every variable in it
     putInCache = false;
     code = ctx.captureExpression(value);
+    code = `const res = (() => { return ${code} })(); if (typeof res === 'function') { res(e) }`;
   }
-  const modCode = mods.map(mod => modcodes[mod]).join("");
-  let handler = `function (e) {if (!context.__owl__.isMounted){return}${modCode}${code}}`;
+  const modCode = mods.map((mod) => modcodes[mod]).join("");
+  let handler = `function (e) {if (context.__owl__.status === ${STATUS.DESTROYED}){return}${modCode}${code}}`;
   if (putInCache) {
     const key = ctx.generateTemplateKey(event);
     ctx.addLine(`extra.handlers[${key}] = extra.handlers[${key}] || ${handler};`);
@@ -90,7 +94,7 @@ QWeb.addDirective({
   atNodeCreation({ ctx, fullName, value, nodeID }) {
     const { event, handler } = makeHandlerCode(ctx, fullName, value, true);
     ctx.addLine(`p${nodeID}.on['${event}'] = ${handler};`);
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -105,17 +109,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
@@ -139,7 +143,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!);
 
@@ -195,7 +199,14 @@ function whenTransitionEnd(elm: HTMLElement, cb) {
   const durations: Array<string> = (styles.transitionDuration || "").split(", ");
   const timeout: number = getTimeout(delays, durations);
   if (timeout > 0) {
-    elm.addEventListener("transitionend", cb, { once: true });
+    const transitionEndCB = () => {
+      if (!elm.parentNode) return;
+      cb();
+      browser.clearTimeout(fallbackTimeout);
+      elm.removeEventListener("transitionend", transitionEndCB);
+    };
+    elm.addEventListener("transitionend", transitionEndCB, { once: true });
+    const fallbackTimeout = browser.setTimeout(transitionEndCB, timeout + 1);
   } else {
     cb();
   }
@@ -205,16 +216,19 @@ QWeb.addDirective({
   name: "transition",
   priority: 96,
   atNodeCreation({ ctx, value, addNodeHook }) {
+    if (!QWeb.enableTransitions) {
+      return;
+    }
     ctx.rootContext.shouldDefineUtils = true;
     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]);
     }
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -225,8 +239,9 @@ QWeb.addDirective({
   priority: 80,
   atNodeEncounter({ ctx, value, node, qweb }): boolean {
     const slotKey = ctx.generateID();
+    const valueExpr = value.match(INTERP_REGEXP) ? ctx.interpolate(value) : `'${value}'`;
     ctx.addLine(
-      `const slot${slotKey} = this.constructor.slots[context.__owl__.slotId + '_' + '${value}'];`
+      `const slot${slotKey} = this.constructor.slots[context.__owl__.slotId + '_' + ${valueExpr}];`
     );
     ctx.addIf(`slot${slotKey}`);
     let parentNode = `c${ctx.parentNode}`;
@@ -251,17 +266,20 @@ 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;
 };
 
+const hasDotAtTheEnd = /\.[\w_]+\s*$/;
+const hasBracketsAtTheEnd = /\[[^\[]+\]\s*$/;
+
 QWeb.addDirective({
   name: "model",
   priority: 42,
@@ -270,15 +288,41 @@ QWeb.addDirective({
     let handler;
     let event = fullName.includes(".lazy") ? "change" : "input";
 
-    // we keep here a reference to the "base expression" (if the expression
-    // is `t-model="some.expr.value", then the base expression is "some.expr").
-    // This is necessary so we can capture it in the handler closure.
-    let expr = ctx.formatExpression(value);
-    const index = expr.lastIndexOf(".");
-    const baseExpr = expr.slice(0, index);
-    ctx.addLine(`let expr${nodeID} = ${baseExpr};`);
+    // First step: we need to understand the structure of the expression, and
+    // from it, extract a base expression (that we can capture, which is
+    // important because it will be used in a handler later) and a formatted
+    // expression (which uses the captured base expression)
+    //
+    // Also, we support 2 kinds of values: some.expr.value or some.expr[value]
+    // For the first one, we have:
+    // - base expression = scope[some].expr
+    // - expression = exprX.value (where exprX is the var that captures the base expr)
+    // and for the expression with brackets:
+    // - base expression = scope[some].expr
+    // - expression = exprX[keyX] (where exprX is the var that captures the base expr
+    //        and keyX captures scope[value])
+    let expr: string;
+    let baseExpr: string;
+
+    if (hasDotAtTheEnd.test(value)) {
+      // we manage the case where the expr has a dot: some.expr.value
+      const index = value.lastIndexOf(".");
+      baseExpr = value.slice(0, index);
+      ctx.addLine(`let expr${nodeID} = ${ctx.formatExpression(baseExpr)};`);
+      expr = `expr${nodeID}${value.slice(index)}`;
+    } else if (hasBracketsAtTheEnd.test(value)) {
+      // we manage here the case where the expr ends in a bracket expression:
+      //    some.expr[value]
+      const index = value.lastIndexOf("[");
+      baseExpr = value.slice(0, index);
+      ctx.addLine(`let expr${nodeID} = ${ctx.formatExpression(baseExpr)};`);
+      let exprKey = value.trimRight().slice(index + 1, -1);
+      ctx.addLine(`let exprKey${nodeID} = ${ctx.formatExpression(exprKey)};`);
+      expr = `expr${nodeID}[exprKey${nodeID}]`;
+    } else {
+      throw new Error(`Invalid t-model expression: "${value}" (it should be assignable)`);
+    }
 
-    expr = `expr${nodeID}.${expr.slice(index + 1)}`;
     const key = ctx.generateTemplateKey();
     if (node.tagName === "select") {
       ctx.addLine(`p${nodeID}.props = {value: ${expr}};`);
@@ -305,7 +349,7 @@ QWeb.addDirective({
     }
     ctx.addLine(`extra.handlers[${key}] = extra.handlers[${key}] || (${handler});`);
     ctx.addLine(`p${nodeID}.on['${event}'] = extra.handlers[${key}];`);
-  }
+  },
 });
 
 //------------------------------------------------------------------------------
@@ -329,5 +373,5 @@ QWeb.addDirective({
     if (ctx.loopNumber === 0) {
       ctx.rootContext.hasKey0 = ctx.keyStack.pop() as boolean;
     }
-  }
+  },
 });

src/qweb/qweb.ts

@@ -66,65 +66,105 @@ interface QWebConfig {
 // Const/global stuff/helpers
 //------------------------------------------------------------------------------
 
-const DISABLED_TAGS = ["input", "textarea", "button", "select", "option", "optgroup"];
-
 const TRANSLATABLE_ATTRS = ["label", "title", "placeholder", "alt"];
 
 const lineBreakRE = /[\r\n]/;
 const whitespaceRE = /\s+/g;
+const translationRE = /^(\s*)([\s\S]+?)(\s*)$/;
 
 const NODE_HOOKS_PARAMS = {
   create: "(_, n)",
   insert: "vn",
   remove: "(vn, rm)",
-  destroy: "()"
+  destroy: "()",
 };
 
 interface Utils {
-  toObj(expr: any): Object;
+  toClassObj(expr: any): Object;
   shallowEqual(p1: Object, p2: Object): boolean;
   [key: string]: any;
 }
 
-function isComponent(obj) {
+function isComponent(obj): boolean {
   return obj && obj.hasOwnProperty("__owl__");
 }
 
+class VDomArray extends Array {
+  toString() {
+    return vDomToString(this);
+  }
+}
+
+function vDomToString(vdom: VNode[]): string {
+  return vdom
+    .map((vnode) => {
+      if (vnode.sel) {
+        const node = document.createElement(vnode.sel);
+        const result = patch(node, vnode);
+        return (<HTMLElement>result.elm).outerHTML;
+      } else {
+        return vnode.text;
+      }
+    })
+    .join("");
+}
+
 const UTILS: Utils = {
   zero: Symbol("zero"),
-  toObj(expr) {
+  toClassObj(expr) {
+    const result = {};
     if (typeof expr === "string") {
+      // we transform here a list of classes into an object:
+      //  'hey you' becomes {hey: true, you: true}
       expr = expr.trim();
       if (!expr) {
         return {};
       }
       let words = expr.split(/\s+/);
-      let result = {};
       for (let i = 0; i < words.length; i++) {
         result[words[i]] = true;
       }
       return result;
     }
-    return expr;
+    // this is already an object, but we may need to split keys:
+    // {'a': true, 'b c': true} should become {a: true, b: true, c: true}
+    for (let key in expr) {
+      const value = expr[key];
+      const words = key.split(/\s+/);
+      for (let word of words) {
+        result[word] = value;
+      }
+    }
+    return result;
+  },
+  /**
+   * This method combines the current context with the variables defined in a
+   * scope for use in a slot.
+   *
+   * The implementation is kind of tricky because we want to preserve the
+   * prototype chain structure of the cloned result. So we need to traverse the
+   * prototype chain, cloning each level respectively.
+   */
+  combine(context, scope) {
+    let clone = context;
+    const scopeStack = [];
+    while (!isComponent(scope)) {
+      scopeStack.push(scope);
+      scope = scope.__proto__;
+    }
+    while (scopeStack.length) {
+      let scope = scopeStack.pop();
+      clone = Object.create(clone);
+      Object.assign(clone, scope);
+    }
+    return clone;
   },
   shallowEqual,
   addNameSpace(vnode) {
     addNS(vnode.data, vnode.children, vnode.sel);
   },
-  VDomArray: class VDomArray extends Array {},
-  vDomToString: function(vdom: VNode[]): string {
-    return vdom
-      .map(vnode => {
-        if (vnode.sel) {
-          const node = document.createElement(vnode.sel);
-          const result = patch(node, vnode);
-          return (<HTMLElement>result.elm).outerHTML;
-        } else {
-          return vnode.text;
-        }
-      })
-      .join("");
-  },
+  VDomArray,
+  vDomToString,
   getComponent(obj) {
     while (obj && !isComponent(obj)) {
       obj = obj.__proto__;
@@ -145,7 +185,7 @@ const UTILS: Utils = {
       obj = newObj;
     }
     return obj;
-  }
+  },
 };
 
 function parseXML(xml: string): Document {
@@ -195,7 +235,8 @@ export class QWeb extends EventBus {
     name: 1,
     att: 1,
     attf: 1,
-    translation: 1
+    translation: 1,
+    tag: 1,
   };
   static DIRECTIVES: Directive[] = [];
 
@@ -206,16 +247,19 @@ export class QWeb extends EventBus {
   h = h;
   // dev mode enables better error messages or more costly validations
   static dev: boolean = false;
+  static enableTransitions: boolean = true;
 
   // slots contains sub templates defined with t-set inside t-component nodes, and
   // are meant to be used by the t-slot directive.
   static slots = {};
   static nextSlotId = 1;
 
-  // recursiveTemplates contains sub templates called with t-call, but which
-  // ends up in recursive situations.  This is very similar to the slot situation,
-  // as in we need to propagate the scope.
-  subTemplates = {};
+  // subTemplates are stored in two objects: a (local) mapping from a name to an
+  // id, and a (global) mapping from an id to the compiled function.  This is
+  // necessary to ensure that global templates can be called with more than one
+  // QWeb instance.
+  subTemplates: { [key: string]: number } = {};
+  static subTemplates: { [id: number]: Function } = {};
 
   isUpdating: boolean = false;
   translateFn?: QWebConfig["translateFn"];
@@ -239,7 +283,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));
     }
   }
 
@@ -303,11 +347,11 @@ export class QWeb extends EventBus {
     this._processTemplate(elem);
     const template = {
       elem,
-      fn: function(this: QWeb, context, extra) {
-        const compiledFunction = this._compile(name, elem);
+      fn: function (this: QWeb, context, extra) {
+        const compiledFunction = this._compile(name);
         template.fn = compiledFunction;
         return compiledFunction.call(this, context, extra);
-      }
+      },
     };
     this.templates[name] = template;
   }
@@ -317,10 +361,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"))) {
@@ -330,7 +374,7 @@ 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
         ) {
@@ -409,30 +453,34 @@ export class QWeb extends EventBus {
 
   _compile(
     name: string,
-    elem: Element,
-    parentContext?: CompilationContext,
-    defineKey?: boolean
+    options: {
+      elem?: Element;
+      hasParent?: boolean;
+      defineKey?: boolean;
+    } = {}
   ): CompiledTemplate {
+    const elem = options.elem || this.templates[name].elem;
     const isDebug = elem.attributes.hasOwnProperty("t-debug");
     const ctx = new CompilationContext(name);
     if (elem.tagName !== "t") {
       ctx.shouldDefineResult = false;
     }
-    if (parentContext) {
-      ctx.variables = Object.create(parentContext.variables);
-      ctx.parentNode = parentContext.parentNode || ctx.generateID();
+    if (options.hasParent) {
+      ctx.variables = Object.create(null);
+      ctx.parentNode = ctx.generateID();
       ctx.allowMultipleRoots = true;
+      ctx.shouldDefineParent = true;
       ctx.hasParentWidget = true;
       ctx.shouldDefineResult = false;
       ctx.addLine(`let c${ctx.parentNode} = extra.parentNode;`);
-      if (defineKey) {
+      if (options.defineKey) {
         ctx.addLine(`let key0 = extra.key || "";`);
         ctx.hasKey0 = true;
       }
     }
     this._compileNode(elem, ctx);
 
-    if (!parentContext) {
+    if (!options.hasParent) {
       if (ctx.shouldDefineResult) {
         ctx.addLine(`return result;`);
       } else {
@@ -484,7 +532,8 @@ export class QWeb extends EventBus {
       }
       if (this.translateFn) {
         if ((node.parentNode as any).getAttribute("t-translation") !== "off") {
-          text = this.translateFn(text);
+          const match = translationRE.exec(text);
+          text = match[1] + this.translateFn(match[2]) + match[3];
         }
       }
       if (ctx.parentNode) {
@@ -507,10 +556,17 @@ export class QWeb extends EventBus {
       return;
     }
 
+    if (node.tagName !== "t" && node.hasAttribute("t-call")) {
+      const tCallNode = document.createElement("t");
+      tCallNode.setAttribute("t-call", node.getAttribute("t-call")!);
+      node.removeAttribute("t-call");
+      node.prepend(tCallNode);
+    }
+
     const firstLetter = node.tagName[0];
     if (firstLetter === firstLetter.toUpperCase()) {
       // this is a component, we modify in place the xml document to change
-      // <SomeComponent ... /> to <t t-component="SomeComponent" ... />
+      // <SomeComponent ... /> to <SomeComponent t-component="SomeComponent" ... />
       node.setAttribute("t-component", node.tagName);
     } else if (node.tagName !== "t" && node.hasAttribute("t-component")) {
       throw new Error(
@@ -582,7 +638,7 @@ export class QWeb extends EventBus {
           qweb: this,
           ctx,
           fullName,
-          value
+          value,
         });
         if (isDone) {
           for (let { directive, value, fullName } of finalizers) {
@@ -593,14 +649,22 @@ export class QWeb extends EventBus {
       }
     }
 
-    if (node.nodeName !== "t") {
-      let nodeID = this._compileGenericNode(node, ctx, withHandlers);
-      ctx = ctx.withParent(nodeID);
+    if (node.nodeName !== "t" || node.hasAttribute("t-tag")) {
       let nodeHooks = {};
-      let addNodeHook = function(hook, handler) {
+      let addNodeHook = function (hook, handler) {
         nodeHooks[hook] = nodeHooks[hook] || [];
         nodeHooks[hook].push(handler);
       };
+      if (node.tagName === "select" && node.hasAttribute("t-att-value")) {
+        const value = node.getAttribute("t-att-value");
+        let exprId = ctx.generateID();
+        ctx.addLine(`let expr${exprId} = ${ctx.formatExpression(value)};`);
+        let expr = `expr${exprId}`;
+        node.setAttribute("t-att-value", expr);
+        addNodeHook("create", `n.elm.value=${expr};`);
+      }
+      let nodeID = this._compileGenericNode(node, ctx, withHandlers);
+      ctx = ctx.withParent(nodeID);
 
       for (let { directive, value, fullName } of validDirectives) {
         if (directive.atNodeCreation) {
@@ -611,7 +675,7 @@ export class QWeb extends EventBus {
             fullName,
             value,
             nodeID,
-            addNodeHook
+            addNodeHook,
           });
         }
       }
@@ -664,25 +728,36 @@ export class QWeb extends EventBus {
     const props: string[] = [];
     const tattrs: number[] = [];
 
-    function handleBooleanProps(key, val) {
+    function handleProperties(key, val) {
       let isProp = false;
-      if (node.nodeName === "input" && key === "checked") {
-        let type = (<Element>node).getAttribute("type");
-        if (type === "checkbox" || type === "radio") {
-          isProp = true;
-        }
-      }
-      if (node.nodeName === "option" && key === "selected") {
-        isProp = true;
-      }
-      if (key === "disabled" && DISABLED_TAGS.indexOf(node.nodeName) > -1) {
-        isProp = true;
-      }
-      if ((key === "readonly" && node.nodeName === "input") || node.nodeName === "textarea") {
-        isProp = true;
+      switch (node.nodeName) {
+        case "input":
+          let type = (<Element>node).getAttribute("type");
+          if (type === "checkbox" || type === "radio") {
+            if (key === "checked" || key === "indeterminate") {
+              isProp = true;
+            }
+          }
+          if (key === "value" || key === "readonly" || key === "disabled") {
+            isProp = true;
+          }
+          break;
+        case "option":
+          isProp = key === "selected" || key === "disabled";
+          break;
+        case "textarea":
+          isProp = key === "readonly" || key === "disabled" || key === "value";
+          break;
+        case "select":
+          isProp = key === "disabled" || key === "value";
+          break;
+        case "button":
+        case "optgroup":
+          isProp = key === "disabled";
+          break;
       }
       if (isProp) {
-        props.push(`${key}: _${val}`);
+        props.push(`${key}: ${val}`);
       }
     }
     let classObj = "";
@@ -702,10 +777,14 @@ export class QWeb extends EventBus {
           if ((value = value.trim())) {
             let classDef = value
               .split(/\s+/)
-              .map(a => `'${escapeQuotes(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(`let _${attID} = '${escapeQuotes(value)}';`);
@@ -714,7 +793,7 @@ export class QWeb extends EventBus {
             name = '"' + name + '"';
           }
           attrs.push(`${name}: _${attID}`);
-          handleBooleanProps(name, attID);
+          handleProperties(name, `_${attID}`);
         }
       }
 
@@ -726,7 +805,7 @@ export class QWeb extends EventBus {
 
         if (attName === "class") {
           ctx.rootContext.shouldDefineUtils = true;
-          formattedValue = `utils.toObj(${formattedValue})`;
+          formattedValue = `utils.toClassObj(${formattedValue})`;
           if (classObj) {
             ctx.addLine(`Object.assign(${classObj}, ${formattedValue})`);
           } else {
@@ -746,12 +825,17 @@ export class QWeb extends EventBus {
             const attValueID = ctx.generateID();
             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(`let _${attID} = ${formattedValue};`);
-          attrs.push(`${attName}: _${attID}`);
-          handleBooleanProps(attName, attID);
+          if (node.nodeName === "select" && attName === "value") {
+            attrs.push(`${attName}: ${v}`);
+            handleProperties(attName, v);
+          } else {
+            ctx.addLine(`let _${attID} = ${formattedValue};`);
+            attrs.push(`${attName}: _${attID}`);
+            handleProperties(attName, "_" + attID);
+          }
         }
       }
 
@@ -807,7 +891,14 @@ export class QWeb extends EventBus {
       ctx.addLine(`}`);
       ctx.closeIf();
     }
-    ctx.addLine(`let vn${nodeID} = h('${node.nodeName}', p${nodeID}, c${nodeID});`);
+    let nodeName = `'${node.nodeName}'`;
+    if ((<Element>node).hasAttribute("t-tag")) {
+      const tagExpr = (<Element>node).getAttribute("t-tag");
+      (<Element>node).removeAttribute("t-tag");
+      nodeName = `tag${ctx.generateID()}`;
+      ctx.addLine(`let ${nodeName} = ${ctx.formatExpression(tagExpr)};`);
+    }
+    ctx.addLine(`let vn${nodeID} = h(${nodeName}, p${nodeID}, c${nodeID});`);
     if (ctx.parentNode) {
       ctx.addLine(`c${ctx.parentNode}.push(vn${nodeID});`);
     } else if (ctx.loopNumber || ctx.hasKey0) {

src/router/router.ts

@@ -11,6 +11,7 @@ type NavigationGuard = (info: {
 export interface Route {
   name: string;
   path: string;
+  extractionRegExp: RegExp;
   component?: any;
   redirect?: Destination;
   params: string[];
@@ -54,6 +55,7 @@ export interface EnvWithRouter extends Env {
 }
 
 const paramRegexp = /\{\{(.*?)\}\}/;
+const globalParamRegexp = new RegExp(paramRegexp.source, "g");
 
 export class Router {
   currentRoute: Route | null = null;
@@ -87,6 +89,7 @@ export class Router {
         this.validateDestination(partialRoute.redirect);
       }
       partialRoute.params = partialRoute.path ? findParams(partialRoute.path) : [];
+      partialRoute.extractionRegExp = makeExtractionRegExp(partialRoute.path);
       this.routes[partialRoute.name] = partialRoute as Route;
       this.routeIds.push(partialRoute.name);
     }
@@ -97,7 +100,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);
@@ -122,7 +125,10 @@ export class Router {
     const initialParams = this.currentParams;
     const result = await this.matchAndApplyRules(path);
     if (result.type === "match") {
-      const finalPath = this.routeToPath(result.route, result.params);
+      let finalPath = this.routeToPath(result.route, result.params);
+      if (path.indexOf("?") > -1) {
+        finalPath += "?" + path.split("?")[1];
+      }
       const isPopStateEvent = ev && ev instanceof PopStateEvent;
       if (!isPopStateEvent) {
         this.setUrlFromPath(finalPath);
@@ -170,19 +176,14 @@ export class Router {
   }
 
   private routeToPath(route: Route, params: RouteParams): string {
-    const path = route.path;
-    const parts = path.split("/");
-    const l = parts.length;
-    for (let i = 0; i < l; i++) {
-      const part = parts[i];
-      const match = part.match(paramRegexp);
-      if (match) {
-        const key = match[1].split(".")[0];
-        parts[i] = <string>params[key];
-      }
-    }
     const prefix = this.mode === "hash" ? "#" : "";
-    return prefix + parts.join("/");
+    return (
+      prefix +
+      route.path.replace(globalParamRegexp, (match, param) => {
+        const [key] = param.split(".");
+        return <string>params[key];
+      })
+    );
   }
 
   private currentPath(): string {
@@ -198,7 +199,7 @@ export class Router {
         return {
           type: "match",
           route: route,
-          params: params
+          params: params,
         };
       }
     }
@@ -223,7 +224,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" };
@@ -241,43 +242,53 @@ export class Router {
     if (route.path === "*") {
       return {};
     }
+    if (path.indexOf("?") > -1) {
+      path = path.split("?")[0];
+    }
     if (path.startsWith("#")) {
       path = path.slice(1);
     }
-    const descrParts = route.path.split("/");
-    const targetParts = path.split("/");
-    const l = descrParts.length;
-    if (l !== targetParts.length) {
+    const paramsMatch = path.match(route.extractionRegExp);
+    if (!paramsMatch) {
       return false;
     }
     const result = {};
-    for (let i = 0; i < l; i++) {
-      const descr = descrParts[i];
-      let target: string | number = targetParts[i];
-      const match = descr.match(paramRegexp);
-      if (match) {
-        const [key, suffix] = match[1].split(".");
-        if (suffix === "number") {
-          target = parseInt(target, 10);
-        }
-        result[key] = target;
-      } else if (descr !== target) {
-        return false;
+    route.params.forEach((param, index) => {
+      const [key, suffix] = param.split(".");
+      const paramValue = paramsMatch[index + 1];
+      if (suffix === "number") {
+        return (result[key] = parseInt(paramValue, 10));
       }
-    }
+      return (result[key] = paramValue);
+    });
     return result;
   }
 }
 
 function findParams(str: string): string[] {
-  const globalParamRegexp = /\{\{(.*?)\}\}/g;
   const result: string[] = [];
   let m;
   do {
     m = globalParamRegexp.exec(str);
     if (m) {
-      result.push(m[1].split(".")[0]);
+      result.push(m[1]);
     }
   } while (m);
   return result;
 }
+
+function escapeRegExp(str: string) {
+  return str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+
+function makeExtractionRegExp(path: string) {
+  // replace param strings with capture groups so that we can build a regex to match over the path
+  const extractionString = path
+    .split(paramRegexp)
+    .map((part, index) => {
+      return index % 2 ? "(.*)" : escapeRegExp(part);
+    })
+    .join("");
+  // Example: /home/{{param1}}/{{param2}} => ^\/home\/(.*)\/(.*)$
+  return new RegExp(`^${extractionString}$`);
+}

src/store.ts

@@ -1,5 +1,4 @@
-import { Component } from "./component/component";
-import { Env } from "./component/component";
+import { Component, Env } from "./component/component";
 import { Context, useContextWithCB } from "./context";
 import { onWillUpdateProps } from "./hooks";
 
@@ -53,7 +52,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);
@@ -70,12 +69,17 @@ export class Store extends Context {
         dispatch: this.dispatch.bind(this),
         env: this.env,
         state: this.state,
-        getters: this.getters
+        getters: this.getters,
       },
       ...payload
     );
     return result;
   }
+
+  __notifyComponents(): Promise<void> {
+    this.trigger("before-update");
+    return super.__notifyComponents();
+  }
 }
 
 interface SelectorOptions {
@@ -106,18 +110,21 @@ export function useStore(selector, options: SelectorOptions = {}): any {
     const newRevNumber = hashFn(result);
     if ((newRevNumber > 0 && revNumber !== newRevNumber) || !isEqual(oldResult, result)) {
       revNumber = newRevNumber;
-      if (options.onUpdate) {
-        options.onUpdate(result);
-      }
       return true;
     }
     return false;
   }
-  store.updateFunctions[componentId].push(function(): boolean {
+  if (options.onUpdate) {
+    store.on("before-update", component, () => {
+      const newValue = selector(store!.state, component.props!);
+      options.onUpdate(newValue);
+    });
+  }
+  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;
@@ -126,13 +133,16 @@ 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];
+    if (options.onUpdate) {
+      store.off("before-update", component);
+    }
     __destroy.call(component, parent);
   };
 
@@ -148,7 +158,7 @@ export function useStore(selector, options: SelectorOptions = {}): any {
     },
     has(target, k) {
       return k in result;
-    }
+    },
   });
 }
 

src/utils.ts

@@ -13,13 +13,13 @@
 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> } = {};
@@ -28,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];
@@ -75,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() {

src/vdom/html_to_vdom.ts

@@ -1,4 +1,4 @@
-import { VNode, h } from "./vdom";
+import { VNode, h, addNS } from "./vdom";
 
 const parser = new DOMParser();
 
@@ -13,6 +13,9 @@ export function htmlToVDOM(html: string): VNode[] {
 
 function htmlToVNode(node: ChildNode): VNode {
   if (!(node instanceof Element)) {
+    if (node instanceof Comment) {
+      return h("!", node.textContent);
+    }
     return { text: node.textContent! } as VNode;
   }
   const attrs = {};
@@ -23,5 +26,9 @@ function htmlToVNode(node: ChildNode): VNode {
   for (let c of node.childNodes) {
     children.push(htmlToVNode(c));
   }
-  return h((node as Element).tagName, { attrs }, children);
+  const vnode = h((node as Element).tagName, { attrs }, children);
+  if (vnode.sel === "svg") {
+    addNS(vnode.data, (vnode as any).children, vnode.sel);
+  }
+  return vnode;
 }

src/vdom/modules.ts

@@ -33,7 +33,7 @@ function updateProps(oldVnode: VNode, vnode: VNode): void {
 
 export const propsModule = {
   create: updateProps,
-  update: updateProps
+  update: updateProps,
 } as Module;
 
 //------------------------------------------------------------------------------
@@ -151,7 +151,7 @@ function updateEventListeners(oldVnode: VNode, vnode?: VNode): void {
 export const eventListenersModule = {
   create: updateEventListeners,
   update: updateEventListeners,
-  destroy: updateEventListeners
+  destroy: updateEventListeners,
 } as Module;
 
 //------------------------------------------------------------------------------
@@ -210,7 +210,7 @@ function updateAttrs(oldVnode: VNode, vnode: VNode): void {
 
 export const attrsModule = {
   create: updateAttrs,
-  update: updateAttrs
+  update: updateAttrs,
 } as Module;
 
 //------------------------------------------------------------------------------
@@ -231,7 +231,8 @@ function updateClass(oldVnode: VNode, vnode: VNode): void {
   elm = vnode.elm as Element;
 
   for (name in oldClass) {
-    if (name && !klass[name]) {
+    if (name && !klass[name] && !Object.prototype.hasOwnProperty.call(klass, name)) {
+      // was `true` and now not provided
       elm.classList.remove(name);
     }
   }

src/vdom/vdom.ts

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

tests/__snapshots__/animations.test.ts.snap

@@ -24,7 +24,7 @@ exports[`animations t-transition combined with component 1`] = `
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
         const __patch2 = w2.__patch;
@@ -69,7 +69,7 @@ exports[`animations t-transition combined with t-component and t-if 1`] = `
             c1.push(pvnode);
         } else {
             let componentKey2 = \`Child\`;
-            let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+            let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
             if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
             w2 = new W2(parent, props2);
             const __patch2 = w2.__patch;
@@ -115,7 +115,7 @@ exports[`animations t-transition combined with t-component, remove and re-add be
             c1.push(pvnode);
         } else {
             let componentKey2 = \`Child\`;
-            let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+            let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
             if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
             w2 = new W2(parent, props2);
             const __patch2 = w2.__patch;

tests/animations.test.ts

@@ -1,15 +1,15 @@
 import { Component, Env } from "../src/component/component";
+import { useRef, useState } from "../src/hooks";
 import { QWeb } from "../src/qweb/index";
-import { useState, useRef } from "../src/hooks";
 import { xml } from "../src/tags";
 import {
   makeDeferred,
-  makeTestFixture,
   makeTestEnv,
+  makeTestFixture,
+  nextFrame,
   patchNextFrame,
   renderToDOM,
   unpatchNextFrame,
-  nextTick
 } from "./helpers";
 
 //------------------------------------------------------------------------------
@@ -71,7 +71,7 @@ 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");
@@ -91,7 +91,7 @@ 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");
@@ -112,7 +112,7 @@ 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("");
@@ -139,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");
@@ -155,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");
@@ -182,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");
@@ -210,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>'
       );
@@ -250,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>'
       );
@@ -275,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>'
       );
@@ -315,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`);
@@ -366,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`);
@@ -413,36 +413,36 @@ describe("animations", () => {
       state = useState({ flag: false });
     }
 
-    patchNextFrame(cb => cb());
+    patchNextFrame((cb) => cb());
 
     const widget = new Parent();
     await widget.mount(fixture);
 
     widget.state.flag = true;
 
-    await nextTick();
+    await nextFrame();
     widget.el!.querySelector("span")!.dispatchEvent(new Event("transitionend"));
     expect(fixture.innerHTML).toBe('<div><span class="">blue</span></div>');
     expect(QWeb.utils.transitionInsert).toBeCalledTimes(1);
 
     widget.state.flag = false;
-    await nextTick();
+    await nextFrame();
     expect(fixture.innerHTML).toBe(
       '<div><span class="chimay-leave-active chimay-leave-to" data-owl-key="__3__">blue</span></div>'
     );
     expect(QWeb.utils.transitionInsert).toBeCalledTimes(1);
 
     widget.state.flag = true;
-    await nextTick();
+    await nextFrame();
     expect(fixture.innerHTML).toBe(
       '<div><span class="chimay-enter-active chimay-enter-to" data-owl-key="__3__">blue</span></div>'
     );
     expect(QWeb.utils.transitionInsert).toBeCalledTimes(2);
 
     widget.state.flag = false;
-    await nextTick();
+    await nextFrame();
     widget.state.flag = true;
-    await nextTick();
+    await nextFrame();
 
     expect(QWeb.utils.transitionInsert).toBeCalledTimes(3);
     widget.el!.querySelector("span")!.dispatchEvent(new Event("transitionend"));

tests/component/__snapshots__/class_style.test.ts.snap

@@ -20,12 +20,12 @@ exports[`class and style attributes with t-component dynamic t-att-style is prop
         w2 = false;
     }
     if (w2) {
-        w2.__updateProps(props2, extra.fiber, undefined).then(()=>{if (w2.__owl__.isDestroyed) {return};w2.el.style=_4;});;
+        w2.__updateProps(props2, extra.fiber, undefined).then(()=>{if (w2.__owl__.status === 5) {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'];
+        let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
         parent.__owl__.cmap['__3__'] = w2.__owl__.id;
@@ -67,7 +67,7 @@ exports[`class and style attributes with t-component t-att-class is properly add
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
         parent.__owl__.cmap['__3__'] = w2.__owl__.id;
@@ -90,7 +90,7 @@ exports[`class and style attributes with t-component t-att-class is properly add
     let scope = Object.create(context);
     let h = this.h;
     let _7 = {'c':true};
-    Object.assign(_7, utils.toObj({d:scope['state'].d}))
+    Object.assign(_7, utils.toClassObj({d:scope['state'].d}))
     let c8 = [], p8 = {key:8,class:_7};
     let vn8 = h('span', p8, c8);
     return vn8;
@@ -112,7 +112,7 @@ exports[`class and style attributes with t-component t-att-class is properly add
     // Component 'Child'
     const ref4 = \`child\`;
     let _5 = {'a':true};
-    Object.assign(_5, utils.toObj(scope['state'].b?'b':''))
+    Object.assign(_5, utils.toClassObj(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) {
@@ -125,7 +125,7 @@ exports[`class and style attributes with t-component t-att-class is properly add
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
         parent.__owl__.cmap['__3__'] = w2.__owl__.id;
@@ -148,7 +148,7 @@ exports[`class and style attributes with t-component t-att-class is properly add
     let scope = Object.create(context);
     let h = this.h;
     let _7 = {'c':true};
-    Object.assign(_7, utils.toObj(scope['state'].d?'d':''))
+    Object.assign(_7, utils.toClassObj(scope['state'].d?'d':''))
     let c8 = [], p8 = {key:8,class:_7};
     let vn8 = h('span', p8, c8);
     return vn8;

tests/component/__snapshots__/component.test.ts.snap

@@ -24,7 +24,7 @@ exports[`basic widget properties can handle empty props 1`] = `
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
         parent.__owl__.cmap['__3__'] = w2.__owl__.id;
@@ -97,7 +97,7 @@ exports[`basic widget properties reconciliation alg works for t-foreach in t-for
                 c1.push(pvnode);
             } else {
                 let componentKey10 = \`Child\`;
-                let W10 = context.constructor.components[componentKey10] || QWeb.components[componentKey10]|| scope['Child'];
+                let W10 = scope['Child'] || context.constructor.components[componentKey10] || QWeb.components[componentKey10];
                 if (!W10) {throw new Error('Cannot find the definition of component \\"' + componentKey10 + '\\"')}
                 w10 = new W10(parent, props10);
                 parent.__owl__.cmap[k11] = w10.__owl__.id;
@@ -145,7 +145,7 @@ exports[`basic widget properties same t-keys in two different places 1`] = `
             c2.push(pvnode);
         } else {
             let componentKey3 = \`Child\`;
-            let W3 = context.constructor.components[componentKey3] || QWeb.components[componentKey3]|| scope['Child'];
+            let W3 = scope['Child'] || context.constructor.components[componentKey3] || QWeb.components[componentKey3];
             if (!W3) {throw new Error('Cannot find the definition of component \\"' + componentKey3 + '\\"')}
             w3 = new W3(parent, props3);
             parent.__owl__.cmap[k4] = w3.__owl__.id;
@@ -175,7 +175,7 @@ exports[`basic widget properties same t-keys in two different places 1`] = `
             c5.push(pvnode);
         } else {
             let componentKey6 = \`Child\`;
-            let W6 = context.constructor.components[componentKey6] || QWeb.components[componentKey6]|| scope['Child'];
+            let W6 = scope['Child'] || context.constructor.components[componentKey6] || QWeb.components[componentKey6];
             if (!W6) {throw new Error('Cannot find the definition of component \\"' + componentKey6 + '\\"')}
             w6 = new W6(parent, props6);
             parent.__owl__.cmap[k7] = w6.__owl__.id;
@@ -218,7 +218,7 @@ exports[`basic widget properties t-key on a component with t-if, and a sibling c
                 c1.push(pvnode);
             } else {
                 let componentKey2 = \`Child\`;
-                let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+                let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
                 if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
                 w2 = new W2(parent, props2);
                 parent.__owl__.cmap[k3] = w2.__owl__.id;
@@ -243,7 +243,7 @@ exports[`basic widget properties t-key on a component with t-if, and a sibling c
         c1.push(pvnode);
     } else {
         let componentKey4 = \`Child\`;
-        let W4 = context.constructor.components[componentKey4] || QWeb.components[componentKey4]|| scope['Child'];
+        let W4 = scope['Child'] || context.constructor.components[componentKey4] || QWeb.components[componentKey4];
         if (!W4) {throw new Error('Cannot find the definition of component \\"' + componentKey4 + '\\"')}
         w4 = new W4(parent, props4);
         parent.__owl__.cmap['__5__'] = w4.__owl__.id;
@@ -257,6 +257,45 @@ exports[`basic widget properties t-key on a component with t-if, and a sibling c
 }"
 `;
 
+exports[`composition can switch between dynamic components without the need for a t-key 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__3\\"
+    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 '{{state.child}}'
+    let componentKey2 = (scope['state'].child);
+    let k3 = '___' + componentKey2
+    let w2 = k3 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k3]] : 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 W2 = false || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        parent.__owl__.cmap[k3] = w2.__owl__.id;
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        let pvnode = h('dummy', {key: k3, hook: {remove() {},destroy(vn) {w2.destroy();}}});
+        c1.push(pvnode);
+        w2.__owl__.pvnode = pvnode;
+    }
+    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
 exports[`composition sub components with some state rendered in a loop 1`] = `
 "function anonymous(context, extra
 ) {
@@ -301,7 +340,7 @@ exports[`composition sub components with some state rendered in a loop 1`] = `
                 c1.push(pvnode);
             } else {
                 let componentKey6 = \`ChildWidget\`;
-                let W6 = context.constructor.components[componentKey6] || QWeb.components[componentKey6]|| scope['ChildWidget'];
+                let W6 = scope['ChildWidget'] || context.constructor.components[componentKey6] || QWeb.components[componentKey6];
                 if (!W6) {throw new Error('Cannot find the definition of component \\"' + componentKey6 + '\\"')}
                 w6 = new W6(parent, props6);
                 parent.__owl__.cmap[k7] = w6.__owl__.id;
@@ -330,7 +369,9 @@ exports[`composition t-component with dynamic value 1`] = `
     let c1 = [], p1 = {key:1};
     let vn1 = h('div', p1, c1);
     // Component '{{state.widget}}'
-    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let componentKey2 = (scope['state'].widget);
+    let k3 = '___' + componentKey2
+    let w2 = k3 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k3]] : false;
     let props2 = {};
     if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
         w2.destroy();
@@ -341,13 +382,12 @@ exports[`composition t-component with dynamic value 1`] = `
         let pvnode = w2.__owl__.pvnode;
         c1.push(pvnode);
     } else {
-        let componentKey2 = (scope['state'].widget);
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2];
+        let W2 = false || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
-        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        parent.__owl__.cmap[k3] = 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) {w2.destroy();}}});
+        let pvnode = h('dummy', {key: k3, hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
     }
@@ -368,7 +408,9 @@ exports[`composition t-component with dynamic value 2 1`] = `
     let c1 = [], p1 = {key:1};
     let vn1 = h('div', p1, c1);
     // Component 'Widget{{state.widget}}'
-    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let componentKey2 = \`Widget\${scope['state'].widget}\`;
+    let k3 = '___' + componentKey2
+    let w2 = k3 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k3]] : false;
     let props2 = {};
     if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
         w2.destroy();
@@ -379,13 +421,12 @@ exports[`composition t-component with dynamic value 2 1`] = `
         let pvnode = w2.__owl__.pvnode;
         c1.push(pvnode);
     } else {
-        let componentKey2 = \`Widget\${scope['state'].widget}\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2];
+        let W2 = false || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
-        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        parent.__owl__.cmap[k3] = 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) {w2.destroy();}}});
+        let pvnode = h('dummy', {key: k3, hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
     }
@@ -440,11 +481,11 @@ exports[`composition t-ref on a node, and t-on-click 2`] = `
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('click', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['doSomething'](e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('click', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['doSomething'](e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -467,7 +508,7 @@ exports[`dynamic t-props basic use 1`] = `
     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 = Object.assign({}, scope['some'].obj);
+    let props2 = Object.assign({}, scope['some'].obj, {});
     if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
         w2.destroy();
         w2 = false;
@@ -478,7 +519,7 @@ exports[`dynamic t-props basic use 1`] = `
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
         parent.__owl__.cmap['__3__'] = w2.__owl__.id;
@@ -518,27 +559,27 @@ exports[`other directives with t-component slot setted value (with t-set) not ac
         w3 = false;
     }
     if (w3) {
-        w3.__updateProps(props3, extra.fiber, Object.assign(Object.create(context), scope));
+        w3.__updateProps(props3, extra.fiber, utils.combine(context, scope));
         let pvnode = w3.__owl__.pvnode;
         c1.push(pvnode);
     } else {
         let componentKey3 = \`ChildWidget\`;
-        let W3 = context.constructor.components[componentKey3] || QWeb.components[componentKey3]|| scope['ChildWidget'];
+        let W3 = scope['ChildWidget'] || context.constructor.components[componentKey3] || QWeb.components[componentKey3];
         if (!W3) {throw new Error('Cannot find the definition of component \\"' + componentKey3 + '\\"')}
         w3 = new W3(parent, props3);
         parent.__owl__.cmap['__4__'] = w3.__owl__.id;
         w3.__owl__.slotId = 1;
-        let fiber = w3.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        let fiber = w3.__prepare(extra.fiber, utils.combine(context, scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
         let pvnode = h('dummy', {key: '__4__', hook: {remove() {},destroy(vn) {w3.destroy();}}});
         c1.push(pvnode);
         w3.__owl__.pvnode = pvnode;
     }
     w3.__owl__.parentLastFiberId = extra.fiber.id;
-    let c5 = [], p5 = {key:5};
-    let vn5 = h('p', p5, c5);
-    c1.push(vn5);
+    let c6 = [], p6 = {key:6};
+    let vn6 = h('p', p6, c6);
+    c1.push(vn6);
     if (scope.iter != null) {
-        c5.push({text: scope.iter});
+        c6.push({text: scope.iter});
     }
     return vn1;
 }"
@@ -579,7 +620,7 @@ exports[`other directives with t-component t-on expression captured in t-foreach
         c6.push(vn7);
         const otherState_8 = scope['otherState'];
         const iter_8 = scope.iter;
-        p7.on['click'] = function (e) {if (!context.__owl__.isMounted){return}otherState_8.vals.push(iter_8+'_'+iter_8)};
+        p7.on['click'] = function (e) {if (context.__owl__.status === 5){return}const res = (() => { return otherState_8.vals.push(iter_8+'_'+iter_8) })(); if (typeof res === 'function') { res(e) }};
         c7.push({text: \`expr\`});
         utils.getScope(scope, 'iter').iter = scope.iter+1;
     }
@@ -630,7 +671,7 @@ exports[`other directives with t-component t-on expression in t-foreach 1`] = `
         c6.push(vn9);
         const otherState_10 = scope['otherState'];
         const val_10 = scope['val'];
-        p9.on['click'] = function (e) {if (!context.__owl__.isMounted){return}otherState_10.vals.push(val_10)};
+        p9.on['click'] = function (e) {if (context.__owl__.status === 5){return}const res = (() => { return otherState_10.vals.push(val_10) })(); if (typeof res === 'function') { res(e) }};
         c9.push({text: \`Expr\`});
     }
     scope = _origScope5;
@@ -684,7 +725,7 @@ exports[`other directives with t-component t-on expression in t-foreach with t-s
         const otherState_10 = scope['otherState'];
         const val_10 = scope['val'];
         const bossa_10 = scope.bossa;
-        p9.on['click'] = function (e) {if (!context.__owl__.isMounted){return}otherState_10.vals.push(val_10+'_'+bossa_10)};
+        p9.on['click'] = function (e) {if (context.__owl__.status === 5){return}const res = (() => { return otherState_10.vals.push(val_10+'_'+bossa_10) })(); if (typeof res === 'function') { res(e) }};
         c9.push({text: \`Expr\`});
     }
     scope = _origScope5;
@@ -734,7 +775,7 @@ exports[`other directives with t-component t-on method call in t-foreach 1`] = `
         let vn9 = h('button', p9, c9);
         c6.push(vn9);
         let args10 = [scope['val']];
-        p9.on['click'] = function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['addVal'](...args10, e);};
+        p9.on['click'] = function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['addVal'](...args10, e);};
         c9.push({text: \`meth call\`});
     }
     scope = _origScope5;
@@ -766,11 +807,11 @@ exports[`other directives with t-component t-on with .capture modifier 1`] = `
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('click', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['capture'](e);}, true);}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('click', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['capture'](e);}, true);}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -808,11 +849,11 @@ exports[`other directives with t-component t-on with getter as handler 1`] = `
         c1.push(pvnode);
     } else {
         let componentKey3 = \`Child\`;
-        let W3 = context.constructor.components[componentKey3] || QWeb.components[componentKey3]|| scope['Child'];
+        let W3 = scope['Child'] || context.constructor.components[componentKey3] || QWeb.components[componentKey3];
         if (!W3) {throw new Error('Cannot find the definition of component \\"' + componentKey3 + '\\"')}
         w3 = new W3(parent, props3);
         parent.__owl__.cmap['__4__'] = w3.__owl__.id;
-        let fiber = w3.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['handler'](e);});}});});
+        let fiber = w3.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['handler'](e);});}});});
         let pvnode = h('dummy', {key: '__4__', hook: {remove() {},destroy(vn) {w3.destroy();}}});
         c1.push(pvnode);
         w3.__owl__.pvnode = pvnode;
@@ -847,11 +888,11 @@ exports[`other directives with t-component t-on with handler bound to argument 1
         c1.push(pvnode);
     } else {
         let componentKey2 = \`child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+        let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['onEv'](...args4, e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['onEv'](...args4, e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -886,11 +927,11 @@ exports[`other directives with t-component t-on with handler bound to empty obje
         c1.push(pvnode);
     } else {
         let componentKey2 = \`child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+        let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['onEv'](...args4, e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['onEv'](...args4, e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -925,11 +966,11 @@ exports[`other directives with t-component t-on with handler bound to empty obje
         c1.push(pvnode);
     } else {
         let componentKey2 = \`child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+        let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['onEv'](...args4, e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['onEv'](...args4, e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -964,11 +1005,11 @@ exports[`other directives with t-component t-on with handler bound to object 1`]
         c1.push(pvnode);
     } else {
         let componentKey2 = \`child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+        let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['onEv'](...args4, e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['onEv'](...args4, e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -1007,11 +1048,11 @@ exports[`other directives with t-component t-on with inline statement 1`] = `
         c1.push(pvnode);
     } else {
         let componentKey3 = \`Child\`;
-        let W3 = context.constructor.components[componentKey3] || QWeb.components[componentKey3]|| scope['Child'];
+        let W3 = scope['Child'] || context.constructor.components[componentKey3] || QWeb.components[componentKey3];
         if (!W3) {throw new Error('Cannot find the definition of component \\"' + componentKey3 + '\\"')}
         w3 = new W3(parent, props3);
         parent.__owl__.cmap['__4__'] = w3.__owl__.id;
-        let fiber = w3.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}state_5.counter++});}});});
+        let fiber = w3.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}const res = (() => { return state_5.counter++ })(); if (typeof res === 'function') { res(e) }});}});});
         let pvnode = h('dummy', {key: '__4__', hook: {remove() {},destroy(vn) {w3.destroy();}}});
         c1.push(pvnode);
         w3.__owl__.pvnode = pvnode;
@@ -1045,11 +1086,11 @@ exports[`other directives with t-component t-on with no handler (only modifiers)
         c1.push(pvnode);
     } else {
         let componentKey2 = \`ComponentA\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['ComponentA'];
+        let W2 = scope['ComponentA'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['onEv'](e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['onEv'](e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -1083,11 +1124,11 @@ exports[`other directives with t-component t-on with prevent and self modifiers
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}e.preventDefault();if (e.target !== vn.elm) {return}utils.getComponent(context)['onEv'](e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}e.preventDefault();if (e.target !== vn.elm) {return}utils.getComponent(context)['onEv'](e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -1121,11 +1162,11 @@ exports[`other directives with t-component t-on with self and prevent modifiers
         c1.push(pvnode);
     } else {
         let componentKey2 = \`child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+        let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}if (e.target !== vn.elm) {return}e.preventDefault();utils.getComponent(context)['onEv'](e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}if (e.target !== vn.elm) {return}e.preventDefault();utils.getComponent(context)['onEv'](e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -1159,11 +1200,11 @@ exports[`other directives with t-component t-on with self modifier 1`] = `
         c1.push(pvnode);
     } else {
         let componentKey2 = \`child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+        let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev-1', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['onEv1'](e);});vn.elm.addEventListener('ev-2', function (e) {if (!context.__owl__.isMounted){return}if (e.target !== vn.elm) {return}utils.getComponent(context)['onEv2'](e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev-1', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['onEv1'](e);});vn.elm.addEventListener('ev-2', function (e) {if (context.__owl__.status === 5){return}if (e.target !== vn.elm) {return}utils.getComponent(context)['onEv2'](e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -1197,11 +1238,11 @@ exports[`other directives with t-component t-on with stop and/or prevent modifie
         c1.push(pvnode);
     } else {
         let componentKey2 = \`child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+        let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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.addEventListener('ev-1', function (e) {if (!context.__owl__.isMounted){return}e.stopPropagation();utils.getComponent(context)['onEv1'](e);});vn.elm.addEventListener('ev-2', function (e) {if (!context.__owl__.isMounted){return}e.preventDefault();utils.getComponent(context)['onEv2'](e);});vn.elm.addEventListener('ev-3', function (e) {if (!context.__owl__.isMounted){return}e.stopPropagation();e.preventDefault();utils.getComponent(context)['onEv3'](e);});}});});
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev-1', function (e) {if (context.__owl__.status === 5){return}e.stopPropagation();utils.getComponent(context)['onEv1'](e);});vn.elm.addEventListener('ev-2', function (e) {if (context.__owl__.status === 5){return}e.preventDefault();utils.getComponent(context)['onEv2'](e);});vn.elm.addEventListener('ev-3', function (e) {if (context.__owl__.status === 5){return}e.stopPropagation();e.preventDefault();utils.getComponent(context)['onEv3'](e);});}});});
         let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
         c1.push(pvnode);
         w2.__owl__.pvnode = pvnode;
@@ -1253,12 +1294,16 @@ exports[`other directives with t-component t-set can't alter from within callee
     if (scope.iter != null) {
         c2.push({text: scope.iter});
     }
-    this.subTemplates['ChildWidget'].call(this, Object.assign(Object.create(context), scope), Object.assign({}, extra, {parentNode: c1, parent: utils.getComponent(context), key: '__4__'}));
-    let c5 = [], p5 = {key:5};
-    let vn5 = h('p', p5, c5);
-    c1.push(vn5);
+    let _origScope6 = scope;
+    scope = Object.create(scope);
+    scope.__access_mode__ = 'ro';
+    this.constructor.subTemplates['2'].call(this, scope, Object.assign({}, extra, {parentNode: c1, parent: utils.getComponent(context), key: '__7__'}));
+    scope = _origScope6;
+    let c8 = [], p8 = {key:8};
+    let vn8 = h('p', p8, c8);
+    c1.push(vn8);
     if (scope.iter != null) {
-        c5.push({text: scope.iter});
+        c8.push({text: scope.iter});
     }
     return vn1;
 }"
@@ -1280,23 +1325,23 @@ exports[`other directives with t-component t-set can't alter in t-call body 1`]
     if (scope.iter != null) {
         c2.push({text: scope.iter});
     }
+    let _origScope6 = scope;
+    scope = Object.create(scope);
+    scope.__access_mode__ = 'ro';
     {
-        let _origScope4 = scope;
-        scope = Object.create(scope);
-        scope.__access_mode__ = 'ro';
         {
             let c__0 = [];
             utils.getScope(scope, 'iter').iter = 'inCall';
             scope[utils.zero] = c__0;
         }
-        this.subTemplates['ChildWidget'].call(this, scope, Object.assign({}, extra, {parentNode: c1, parent: utils.getComponent(context), key: '__5__'}));
-        scope = _origScope4;
+        this.constructor.subTemplates['2'].call(this, scope, Object.assign({}, extra, {parentNode: c1, parent: utils.getComponent(context), key: '__7__'}));
     }
-    let c6 = [], p6 = {key:6};
-    let vn6 = h('p', p6, c6);
-    c1.push(vn6);
+    scope = _origScope6;
+    let c8 = [], p8 = {key:8};
+    let vn8 = h('p', p8, c8);
+    c1.push(vn8);
     if (scope.iter != null) {
-        c6.push({text: scope.iter});
+        c8.push({text: scope.iter});
     }
     return vn1;
 }"
@@ -1333,7 +1378,7 @@ exports[`other directives with t-component t-set not altered by child widget 1`]
         c1.push(pvnode);
     } else {
         let componentKey3 = \`ChildWidget\`;
-        let W3 = context.constructor.components[componentKey3] || QWeb.components[componentKey3]|| scope['ChildWidget'];
+        let W3 = scope['ChildWidget'] || context.constructor.components[componentKey3] || QWeb.components[componentKey3];
         if (!W3) {throw new Error('Cannot find the definition of component \\"' + componentKey3 + '\\"')}
         w3 = new W3(parent, props3);
         parent.__owl__.cmap['__4__'] = w3.__owl__.id;
@@ -1401,6 +1446,47 @@ exports[`other directives with t-component t-set outside modified in t-foreach 1
 }"
 `;
 
+exports[`props evaluation  t-set with a body expression can be used as textual prop 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);
+    let c2 = new utils.VDomArray();
+    c2.push({text: \`42\`});
+    scope.abc = c2
+    // Component 'Child'
+    let w3 = '__4__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__4__']] : false;
+    let props3 = {val:scope.abc};
+    if (w3 && w3.__owl__.currentFiber && !w3.__owl__.vnode) {
+        w3.destroy();
+        w3 = false;
+    }
+    if (w3) {
+        w3.__updateProps(props3, extra.fiber, undefined);
+        let pvnode = w3.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey3 = \`Child\`;
+        let W3 = scope['Child'] || context.constructor.components[componentKey3] || QWeb.components[componentKey3];
+        if (!W3) {throw new Error('Cannot find the definition of component \\"' + componentKey3 + '\\"')}
+        w3 = new W3(parent, props3);
+        parent.__owl__.cmap['__4__'] = w3.__owl__.id;
+        let fiber = w3.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        let pvnode = h('dummy', {key: '__4__', hook: {remove() {},destroy(vn) {w3.destroy();}}});
+        c1.push(pvnode);
+        w3.__owl__.pvnode = pvnode;
+    }
+    w3.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
 exports[`random stuff/miscellaneous can inject values in tagged templates 1`] = `
 "function anonymous(context, extra
 ) {
@@ -1410,7 +1496,11 @@ exports[`random stuff/miscellaneous can inject values in tagged templates 1`] =
     let h = this.h;
     let c1 = [], p1 = {key:1};
     let vn1 = h('div', p1, c1);
-    this.subTemplates['__template__1'].call(this, Object.assign(Object.create(context), scope), Object.assign({}, extra, {parentNode: c1, parent: utils.getComponent(context), key: '__4__'}));
+    let _origScope5 = scope;
+    scope = Object.create(scope);
+    scope.__access_mode__ = 'ro';
+    this.constructor.subTemplates['3'].call(this, scope, Object.assign({}, extra, {parentNode: c1, parent: utils.getComponent(context), key: '__6__'}));
+    scope = _origScope5;
     return vn1;
 }"
 `;
@@ -1442,7 +1532,7 @@ exports[`random stuff/miscellaneous snapshotting compiled code 1`] = `
             c1.push(pvnode);
         } else {
             let componentKey2 = \`child\`;
-            let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['child'];
+            let W2 = scope['child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
             if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
             w2 = new W2(parent, props2);
             parent.__owl__.cmap[k3] = w2.__owl__.id;
@@ -1502,11 +1592,11 @@ exports[`random stuff/miscellaneous t-on with handler bound to dynamic argument
                 c1.push(pvnode);
             } else {
                 let componentKey6 = \`Child\`;
-                let W6 = context.constructor.components[componentKey6] || QWeb.components[componentKey6]|| scope['Child'];
+                let W6 = scope['Child'] || context.constructor.components[componentKey6] || QWeb.components[componentKey6];
                 if (!W6) {throw new Error('Cannot find the definition of component \\"' + componentKey6 + '\\"')}
                 w6 = new W6(parent, props6);
                 parent.__owl__.cmap[k7] = w6.__owl__.id;
-                let fiber = w6.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['onEv'](...args8, e);});}});});
+                let fiber = w6.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; utils.assignHooks(vnode.data, {create(_, vn){vn.elm.addEventListener('ev', function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['onEv'](...args8, e);});}});});
                 let pvnode = h('dummy', {key: k7, hook: {remove() {},destroy(vn) {w6.destroy();}}});
                 c1.push(pvnode);
                 w6.__owl__.pvnode = pvnode;
@@ -1524,16 +1614,17 @@ exports[`t-call handlers are properly bound through a t-call 1`] = `
 ) {
     // Template name: \\"sub\\"
     let utils = this.constructor.utils;
+    let parent = extra.parent;
     let h = this.h;
-    let c1 = extra.parentNode;
+    let c2 = extra.parentNode;
     let key0 = extra.key || \\"\\";
-    let c2 = [], p2 = {key:\`\${key0}_2\`,on:{}};
-    let vn2 = h('p', p2, c2);
-    c1.push(vn2);
-    let k3 = \`click__3__\${key0}__\`;
-    extra.handlers[k3] = extra.handlers[k3] || function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['update'](e);};
-    p2.on['click'] = extra.handlers[k3];
-    c2.push({text: \`lucas\`});
+    let c3 = [], p3 = {key:\`\${key0}_3\`,on:{}};
+    let vn3 = h('p', p3, c3);
+    c2.push(vn3);
+    let k4 = \`click__4__\${key0}__\`;
+    extra.handlers[k4] = extra.handlers[k4] || function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['update'](e);};
+    p3.on['click'] = extra.handlers[k4];
+    c3.push({text: \`lucas\`});
 }"
 `;
 
@@ -1542,16 +1633,17 @@ exports[`t-call handlers with arguments are properly bound through a t-call 1`]
 ) {
     // Template name: \\"sub\\"
     let utils = this.constructor.utils;
+    let parent = extra.parent;
     let scope = Object.create(context);
     let h = this.h;
-    let c1 = extra.parentNode;
+    let c2 = extra.parentNode;
     let key0 = extra.key || \\"\\";
-    let c2 = [], p2 = {key:\`\${key0}_2\`,on:{}};
-    let vn2 = h('p', p2, c2);
-    c1.push(vn2);
-    let args3 = [scope['a']];
-    p2.on['click'] = function (e) {if (!context.__owl__.isMounted){return}utils.getComponent(context)['update'](...args3, e);};
-    c2.push({text: \`lucas\`});
+    let c3 = [], p3 = {key:\`\${key0}_3\`,on:{}};
+    let vn3 = h('p', p3, c3);
+    c2.push(vn3);
+    let args4 = [scope['a']];
+    p3.on['click'] = function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['update'](...args4, e);};
+    c3.push({text: \`lucas\`});
 }"
 `;
 
@@ -1564,32 +1656,32 @@ exports[`t-call parent is set within t-call 1`] = `
     let parent = extra.parent;
     let scope = Object.create(context);
     let h = this.h;
-    let c1 = extra.parentNode;
+    let c2 = extra.parentNode;
     let key0 = extra.key || \\"\\";
     // Component 'Child'
-    let k3 = \`__3__\${key0}__\`;
-    let w2 = k3 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k3]] : false;
-    let props2 = {};
-    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
-        w2.destroy();
-        w2 = false;
+    let k4 = \`__4__\${key0}__\`;
+    let w3 = k4 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k4]] : false;
+    let props3 = {};
+    if (w3 && w3.__owl__.currentFiber && !w3.__owl__.vnode) {
+        w3.destroy();
+        w3 = false;
     }
-    if (w2) {
-        w2.__updateProps(props2, extra.fiber, undefined);
-        let pvnode = w2.__owl__.pvnode;
-        c1.push(pvnode);
+    if (w3) {
+        w3.__updateProps(props3, extra.fiber, undefined);
+        let pvnode = w3.__owl__.pvnode;
+        c2.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[k3] = w2.__owl__.id;
-        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
-        let pvnode = h('dummy', {key: k3, hook: {remove() {},destroy(vn) {w2.destroy();}}});
-        c1.push(pvnode);
-        w2.__owl__.pvnode = pvnode;
+        let componentKey3 = \`Child\`;
+        let W3 = scope['Child'] || context.constructor.components[componentKey3] || QWeb.components[componentKey3];
+        if (!W3) {throw new Error('Cannot find the definition of component \\"' + componentKey3 + '\\"')}
+        w3 = new W3(parent, props3);
+        parent.__owl__.cmap[k4] = w3.__owl__.id;
+        let fiber = w3.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        let pvnode = h('dummy', {key: k4, hook: {remove() {},destroy(vn) {w3.destroy();}}});
+        c2.push(pvnode);
+        w3.__owl__.pvnode = pvnode;
     }
-    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    w3.__owl__.parentLastFiberId = extra.fiber.id;
 }"
 `;
 
@@ -1618,7 +1710,7 @@ exports[`t-call parent is set within t-call with no parentNode 1`] = `
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
         parent.__owl__.cmap[k3] = w2.__owl__.id;
@@ -1683,6 +1775,33 @@ exports[`t-model directive basic use, on an input 1`] = `
 }"
 `;
 
+exports[`t-model directive basic use, on an input with bracket expression 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__1\\"
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    let c2 = [], p2 = {key:2,on:{}};
+    let vn2 = h('input', p2, c2);
+    c1.push(vn2);
+    let expr2 = scope['state'];
+    let exprKey2 = 'text';
+    p2.props = {value: expr2[exprKey2]};
+    extra.handlers['__3__'] = extra.handlers['__3__'] || ((ev) => {expr2[exprKey2] = ev.target.value});
+    p2.on['input'] = extra.handlers['__3__'];
+    let c4 = [], p4 = {key:4};
+    let vn4 = h('span', p4, c4);
+    c1.push(vn4);
+    let _5 = scope['state'].text;
+    if (_5 != null) {
+        c4.push({text: _5});
+    }
+    return vn1;
+}"
+`;
+
 exports[`t-model directive basic use, on another key in component 1`] = `
 "function anonymous(context, extra
 ) {
@@ -1749,6 +1868,46 @@ exports[`t-model directive in a t-foreach 1`] = `
 }"
 `;
 
+exports[`t-model directive in a t-foreach, part 2 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__1\\"
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    let _2 = scope['state'];
+    if (!_2) { throw new Error('QWeb error: Invalid loop expression')}
+    let _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
+    let _length3 = _3.length;
+    let _origScope5 = scope;
+    scope = Object.create(scope);
+    for (let i1 = 0; i1 < _length3; i1++) {
+        scope.thing_first = i1 === 0
+        scope.thing_last = i1 === _length3 - 1
+        scope.thing_index = i1
+        scope.thing = _3[i1]
+        scope.thing_value = _4[i1]
+        let key1 = scope['thing_index'];
+        let c6 = [], p6 = {key:\`\${key1}_6\`,on:{}};
+        let vn6 = h('input', p6, c6);
+        c1.push(vn6);
+        let expr6 = scope['state'];
+        let exprKey6 = scope['thing_index'];
+        let k7 = \`__7__\${key1}__\`;
+        p6.props = {value: expr6[exprKey6]};
+        extra.handlers[k7] = extra.handlers[k7] || ((ev) => {expr6[exprKey6] = ev.target.value});
+        p6.on['input'] = extra.handlers[k7];
+    }
+    scope = _origScope5;
+    return vn1;
+}"
+`;
+
 exports[`t-model directive on a select 1`] = `
 "function anonymous(context, extra
 ) {
@@ -1833,7 +1992,7 @@ exports[`t-model directive on an input type=radio 1`] = `
     let _2 = 'radio';
     let _3 = 'one';
     let _4 = 'One';
-    let c5 = [], p5 = {key:5,attrs:{type: _2,id: _3,value: _4},on:{}};
+    let c5 = [], p5 = {key:5,attrs:{type: _2,id: _3,value: _4},props:{value: _4},on:{}};
     let vn5 = h('input', p5, c5);
     c1.push(vn5);
     let expr5 = scope['state'];
@@ -1843,7 +2002,7 @@ exports[`t-model directive on an input type=radio 1`] = `
     let _7 = 'radio';
     let _8 = 'two';
     let _9 = 'Two';
-    let c10 = [], p10 = {key:10,attrs:{type: _7,id: _8,value: _9},on:{}};
+    let c10 = [], p10 = {key:10,attrs:{type: _7,id: _8,value: _9},props:{value: _9},on:{}};
     let vn10 = h('input', p10, c10);
     c1.push(vn10);
     let expr10 = scope['state'];
@@ -1946,7 +2105,7 @@ exports[`top level sub widgets basic use 1`] = `
         utils.defineProxy(vn3, pvnode);
     } else {
         let componentKey1 = \`Child\`;
-        let W1 = context.constructor.components[componentKey1] || QWeb.components[componentKey1]|| scope['Child'];
+        let W1 = scope['Child'] || context.constructor.components[componentKey1] || QWeb.components[componentKey1];
         if (!W1) {throw new Error('Cannot find the definition of component \\"' + componentKey1 + '\\"')}
         w1 = new W1(parent, props1);
         parent.__owl__.cmap['__2__'] = w1.__owl__.id;
@@ -1986,7 +2145,7 @@ exports[`top level sub widgets can select a sub widget  1`] = `
             utils.defineProxy(vn3, pvnode);
         } else {
             let componentKey1 = \`Child\`;
-            let W1 = context.constructor.components[componentKey1] || QWeb.components[componentKey1]|| scope['Child'];
+            let W1 = scope['Child'] || context.constructor.components[componentKey1] || QWeb.components[componentKey1];
             if (!W1) {throw new Error('Cannot find the definition of component \\"' + componentKey1 + '\\"')}
             w1 = new W1(parent, props1);
             parent.__owl__.cmap['__2__'] = w1.__owl__.id;
@@ -2013,7 +2172,7 @@ exports[`top level sub widgets can select a sub widget  1`] = `
             utils.defineProxy(vn6, pvnode);
         } else {
             let componentKey4 = \`OtherChild\`;
-            let W4 = context.constructor.components[componentKey4] || QWeb.components[componentKey4]|| scope['OtherChild'];
+            let W4 = scope['OtherChild'] || context.constructor.components[componentKey4] || QWeb.components[componentKey4];
             if (!W4) {throw new Error('Cannot find the definition of component \\"' + componentKey4 + '\\"')}
             w4 = new W4(parent, props4);
             parent.__owl__.cmap['__5__'] = w4.__owl__.id;

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

@@ -24,7 +24,7 @@ exports[`props validation props are validated in dev mode (code snapshot) 1`] =
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Child\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        let W2 = scope['Child'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
         w2 = new W2(parent, props2);
         parent.__owl__.cmap['__3__'] = w2.__owl__.id;

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

@@ -19,17 +19,17 @@ exports[`t-slot directive can define and call slots 1`] = `
         w2 = false;
     }
     if (w2) {
-        w2.__updateProps(props2, extra.fiber, Object.assign(Object.create(context), scope));
+        w2.__updateProps(props2, extra.fiber, utils.combine(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'];
+        let W2 = scope['Dialog'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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 fiber = w2.__prepare(extra.fiber, utils.combine(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;
@@ -44,23 +44,23 @@ exports[`t-slot directive can define and call slots 2`] = `
 ) {
     // Template name: \\"Dialog\\"
     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 c8 = [], p8 = {key:8};
+    let vn8 = h('div', p8, c8);
     let c9 = [], p9 = {key:9};
     let vn9 = h('div', p9, c9);
-    c6.push(vn9);
-    const slot10 = this.constructor.slots[context.__owl__.slotId + '_' + 'footer'];
+    c8.push(vn9);
+    const slot10 = this.constructor.slots[context.__owl__.slotId + '_' + 'header'];
     if (slot10) {
         slot10.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c9, parent: extra.parent || context}));
     }
-    return vn6;
+    let c11 = [], p11 = {key:11};
+    let vn11 = h('div', p11, c11);
+    c8.push(vn11);
+    const slot12 = this.constructor.slots[context.__owl__.slotId + '_' + 'footer'];
+    if (slot12) {
+        slot12.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c11, parent: extra.parent || context}));
+    }
+    return vn8;
 }"
 `;
 
@@ -68,12 +68,13 @@ exports[`t-slot directive can define and call slots 3`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_header_template\\"
+    let parent = extra.parent;
     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\`});
+    let c4 = extra.parentNode;
+    let c5 = [], p5 = {key:5};
+    let vn5 = h('span', p5, c5);
+    c4.push(vn5);
+    c5.push({text: \`header\`});
 }"
 `;
 
@@ -81,12 +82,13 @@ exports[`t-slot directive can define and call slots 4`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_footer_template\\"
+    let parent = extra.parent;
     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\`});
+    let c6 = extra.parentNode;
+    let c7 = [], p7 = {key:7};
+    let vn7 = h('span', p7, c7);
+    c6.push(vn7);
+    c7.push({text: \`footer\`});
 }"
 `;
 
@@ -109,17 +111,17 @@ exports[`t-slot directive can define and call slots using old t-set keyword 1`]
         w2 = false;
     }
     if (w2) {
-        w2.__updateProps(props2, extra.fiber, Object.assign(Object.create(context), scope));
+        w2.__updateProps(props2, extra.fiber, utils.combine(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'];
+        let W2 = scope['Dialog'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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 fiber = w2.__prepare(extra.fiber, utils.combine(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;
@@ -134,23 +136,23 @@ exports[`t-slot directive can define and call slots using old t-set keyword 2`]
 ) {
     // 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 c8 = [], p8 = {key:8};
+    let vn8 = h('div', p8, c8);
     let c9 = [], p9 = {key:9};
     let vn9 = h('div', p9, c9);
-    c6.push(vn9);
-    const slot10 = this.constructor.slots[context.__owl__.slotId + '_' + 'footer'];
+    c8.push(vn9);
+    const slot10 = this.constructor.slots[context.__owl__.slotId + '_' + 'header'];
     if (slot10) {
         slot10.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c9, parent: extra.parent || context}));
     }
-    return vn6;
+    let c11 = [], p11 = {key:11};
+    let vn11 = h('div', p11, c11);
+    c8.push(vn11);
+    const slot12 = this.constructor.slots[context.__owl__.slotId + '_' + 'footer'];
+    if (slot12) {
+        slot12.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c11, parent: extra.parent || context}));
+    }
+    return vn8;
 }"
 `;
 
@@ -158,12 +160,13 @@ 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 parent = extra.parent;
     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\`});
+    let c4 = extra.parentNode;
+    let c5 = [], p5 = {key:5};
+    let vn5 = h('span', p5, c5);
+    c4.push(vn5);
+    c5.push({text: \`header\`});
 }"
 `;
 
@@ -171,12 +174,13 @@ 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 parent = extra.parent;
     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\`});
+    let c6 = extra.parentNode;
+    let c7 = [], p7 = {key:7};
+    let vn7 = h('span', p7, c7);
+    c6.push(vn7);
+    c7.push({text: \`footer\`});
 }"
 `;
 
@@ -184,12 +188,13 @@ exports[`t-slot directive content is the default slot 1`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_default_template\\"
+    let parent = extra.parent;
     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: \`sts rocks\`});
+    let c4 = extra.parentNode;
+    let c5 = [], p5 = {key:5};
+    let vn5 = h('span', p5, c5);
+    c4.push(vn5);
+    c5.push({text: \`sts rocks\`});
 }"
 `;
 
@@ -210,13 +215,72 @@ exports[`t-slot directive dafault slots can define a default content 1`] = `
 }"
 `;
 
+exports[`t-slot directive default slot next to named slot, with default content 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, utils.combine(context, scope));
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`Dialog\`;
+        let W2 = scope['Dialog'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
+        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, utils.combine(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 default slot work with text nodes 1`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_default_template\\"
+    let parent = extra.parent;
     let h = this.h;
-    let c1 = extra.parentNode;
-    c1.push({text: \`sts rocks\`});
+    let c4 = extra.parentNode;
+    c4.push({text: \`sts rocks\`});
+}"
+`;
+
+exports[`t-slot directive dynamic t-slot call 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__1\\"
+    let utils = this.constructor.utils;
+    let scope = Object.create(context);
+    let h = this.h;
+    let c9 = [], p9 = {key:9,on:{}};
+    let vn9 = h('button', p9, c9);
+    extra.handlers['click__10__'] = extra.handlers['click__10__'] || function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['toggle'](e);};
+    p9.on['click'] = extra.handlers['click__10__'];
+    const slot11 = this.constructor.slots[context.__owl__.slotId + '_' + (scope['current'].slot)];
+    if (slot11) {
+        slot11.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c9, parent: extra.parent || context}));
+    }
+    return vn9;
 }"
 `;
 
@@ -224,16 +288,17 @@ exports[`t-slot directive multiple roots are allowed in a default slot 1`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_default_template\\"
+    let parent = extra.parent;
     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: \`sts\`});
+    let c4 = extra.parentNode;
     let c5 = [], p5 = {key:5};
     let vn5 = h('span', p5, c5);
-    c1.push(vn5);
-    c5.push({text: \`rocks\`});
+    c4.push(vn5);
+    c5.push({text: \`sts\`});
+    let c6 = [], p6 = {key:6};
+    let vn6 = h('span', p6, c6);
+    c4.push(vn6);
+    c6.push({text: \`rocks\`});
 }"
 `;
 
@@ -241,16 +306,17 @@ exports[`t-slot directive multiple roots are allowed in a named slot 1`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_content_template\\"
+    let parent = extra.parent;
     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: \`sts\`});
+    let c4 = extra.parentNode;
     let c5 = [], p5 = {key:5};
     let vn5 = h('span', p5, c5);
-    c1.push(vn5);
-    c5.push({text: \`rocks\`});
+    c4.push(vn5);
+    c5.push({text: \`sts\`});
+    let c6 = [], p6 = {key:6};
+    let vn6 = h('span', p6, c6);
+    c4.push(vn6);
+    c6.push({text: \`rocks\`});
 }"
 `;
 
@@ -276,24 +342,25 @@ exports[`t-slot directive refs are properly bound in slots 1`] = `
 ) {
     // Template name: \\"slot_footer_template\\"
     let utils = this.constructor.utils;
+    let parent = extra.parent;
     context.__owl__.refs = context.__owl__.refs || {};
     let h = this.h;
-    let c1 = extra.parentNode;
-    let c8 = [], p8 = {key:8,on:{}};
-    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__'];
-    const ref10 = \`myButton\`;
-    p8.hook = {
+    let c8 = extra.parentNode;
+    let c9 = [], p9 = {key:9,on:{}};
+    let vn9 = h('button', p9, c9);
+    c8.push(vn9);
+    extra.handlers['click__10__'] = extra.handlers['click__10__'] || function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['doSomething'](e);};
+    p9.on['click'] = extra.handlers['click__10__'];
+    const ref11 = \`myButton\`;
+    p9.hook = {
       create: (_, n) => {
-        context.__owl__.refs[ref10] = n.elm;
+        context.__owl__.refs[ref11] = n.elm;
       },
       destroy: () => {
-        delete context.__owl__.refs[ref10];
+        delete context.__owl__.refs[ref11];
       },
     };
-    c8.push({text: \`do something\`});
+    c9.push({text: \`do something\`});
 }"
 `;
 
@@ -302,14 +369,15 @@ exports[`t-slot directive slots are rendered with proper context 1`] = `
 ) {
     // Template name: \\"slot_footer_template\\"
     let utils = this.constructor.utils;
+    let parent = extra.parent;
     let h = this.h;
-    let c1 = extra.parentNode;
-    let c8 = [], p8 = {key:8,on:{}};
-    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__'];
-    c8.push({text: \`do something\`});
+    let c8 = extra.parentNode;
+    let c9 = [], p9 = {key:9,on:{}};
+    let vn9 = h('button', p9, c9);
+    c8.push(vn9);
+    extra.handlers['click__10__'] = extra.handlers['click__10__'] || function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['doSomething'](e);};
+    p9.on['click'] = extra.handlers['click__10__'];
+    c9.push({text: \`do something\`});
 }"
 `;
 
@@ -319,14 +387,14 @@ exports[`t-slot directive slots are rendered with proper context, part 2 1`] = `
     // Template name: \\"Link\\"
     let scope = Object.create(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}));
+    let _12 = scope['props'].to;
+    let c13 = [], p13 = {key:13,attrs:{href: _12}};
+    let 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}));
     }
-    return vn12;
+    return vn13;
 }"
 `;
 
@@ -373,17 +441,17 @@ exports[`t-slot directive slots are rendered with proper context, part 2 2`] = `
             w8 = false;
         }
         if (w8) {
-            w8.__updateProps(props8, extra.fiber, Object.assign(Object.create(context), scope));
+            w8.__updateProps(props8, extra.fiber, utils.combine(context, scope));
             let pvnode = w8.__owl__.pvnode;
             c7.push(pvnode);
         } else {
             let componentKey8 = \`Link\`;
-            let W8 = context.constructor.components[componentKey8] || QWeb.components[componentKey8]|| scope['Link'];
+            let W8 = scope['Link'] || context.constructor.components[componentKey8] || QWeb.components[componentKey8];
             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 fiber = w8.__prepare(extra.fiber, utils.combine(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;
@@ -399,13 +467,14 @@ exports[`t-slot directive slots are rendered with proper context, part 2 3`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_default_template\\"
+    let parent = extra.parent;
     let scope = Object.create(context);
     let h = this.h;
-    let c7 = extra.parentNode;
-    c7.push({text: \`User \`});
-    let _10 = scope['user'].name;
-    if (_10 != null) {
-        c7.push({text: _10});
+    let c10 = extra.parentNode;
+    c10.push({text: \`User \`});
+    let _11 = scope['user'].name;
+    if (_11 != null) {
+        c10.push({text: _11});
     }
 }"
 `;
@@ -416,14 +485,14 @@ exports[`t-slot directive slots are rendered with proper context, part 3 1`] = `
     // Template name: \\"Link\\"
     let scope = Object.create(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}));
+    let _12 = scope['props'].to;
+    let c13 = [], p13 = {key:13,attrs:{href: _12}};
+    let 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}));
     }
-    return vn11;
+    return vn13;
 }"
 `;
 
@@ -471,17 +540,17 @@ exports[`t-slot directive slots are rendered with proper context, part 3 2`] = `
             w8 = false;
         }
         if (w8) {
-            w8.__updateProps(props8, extra.fiber, Object.assign(Object.create(context), scope));
+            w8.__updateProps(props8, extra.fiber, utils.combine(context, scope));
             let pvnode = w8.__owl__.pvnode;
             c7.push(pvnode);
         } else {
             let componentKey8 = \`Link\`;
-            let W8 = context.constructor.components[componentKey8] || QWeb.components[componentKey8]|| scope['Link'];
+            let W8 = scope['Link'] || context.constructor.components[componentKey8] || QWeb.components[componentKey8];
             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 fiber = w8.__prepare(extra.fiber, utils.combine(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;
@@ -497,11 +566,13 @@ exports[`t-slot directive slots are rendered with proper context, part 3 3`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_default_template\\"
+    let parent = extra.parent;
     let scope = Object.create(context);
     let h = this.h;
-    let c7 = extra.parentNode;
-    if (scope.userdescr != null) {
-        c7.push({text: scope.userdescr});
+    let c10 = extra.parentNode;
+    let _11 = scope['userdescr'];
+    if (_11 != null) {
+        c10.push({text: _11});
     }
 }"
 `;
@@ -526,17 +597,17 @@ exports[`t-slot directive slots are rendered with proper context, part 4 1`] = `
         w2 = false;
     }
     if (w2) {
-        w2.__updateProps(props2, extra.fiber, Object.assign(Object.create(context), scope));
+        w2.__updateProps(props2, extra.fiber, utils.combine(context, scope));
         let pvnode = w2.__owl__.pvnode;
         c1.push(pvnode);
     } else {
         let componentKey2 = \`Link\`;
-        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Link'];
+        let W2 = scope['Link'] || context.constructor.components[componentKey2] || QWeb.components[componentKey2];
         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 fiber = w2.__prepare(extra.fiber, utils.combine(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;
@@ -550,27 +621,117 @@ exports[`t-slot directive slots are rendered with proper context, part 4 2`] = `
 "function anonymous(context, extra
 ) {
     // Template name: \\"slot_default_template\\"
+    let parent = extra.parent;
     let scope = Object.create(context);
     let h = this.h;
-    let c1 = extra.parentNode;
-    if (scope.userdescr != null) {
-        c1.push({text: scope.userdescr});
+    let c4 = extra.parentNode;
+    let _5 = scope['userdescr'];
+    if (_5 != null) {
+        c4.push({text: _5});
     }
 }"
 `;
 
+exports[`t-slot directive slots in t-foreach in t-foreach 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);
+    let _2 = scope['tree'];
+    if (!_2) { throw new Error('QWeb error: Invalid loop expression')}
+    let _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
+    let _length3 = _3.length;
+    let _origScope5 = scope;
+    scope = Object.create(scope);
+    for (let i1 = 0; i1 < _length3; i1++) {
+        scope.node1_first = i1 === 0
+        scope.node1_last = i1 === _length3 - 1
+        scope.node1_index = i1
+        scope.node1 = _3[i1]
+        scope.node1_value = _4[i1]
+        let key1 = scope['node1'].key;
+        let c6 = [], p6 = {key:\`\${key1}_6\`};
+        let vn6 = h('div', p6, c6);
+        c1.push(vn6);
+        let _7 = scope['node1'].value;
+        if (_7 != null) {
+            c6.push({text: _7});
+        }
+        let c8 = [], p8 = {key:\`\${key1}_8\`};
+        let vn8 = h('ul', p8, c8);
+        c1.push(vn8);
+        let _9 = scope['node1'].nodes;
+        if (!_9) { throw new Error('QWeb error: Invalid loop expression')}
+        let _10 = _11 = _9;
+        if (!(_9 instanceof Array)) {
+            _10 = Object.keys(_9);
+            _11 = Object.values(_9);
+        }
+        let _length10 = _10.length;
+        let _origScope12 = scope;
+        scope = Object.create(scope);
+        for (let i2 = 0; i2 < _length10; i2++) {
+            scope.node2_first = i2 === 0
+            scope.node2_last = i2 === _length10 - 1
+            scope.node2_index = i2
+            scope.node2 = _10[i2]
+            scope.node2_value = _11[i2]
+            let key2 = scope['node2'].key;
+            // Component 'Child'
+            let k14 = \`__14__\${key1}__\${key2}__\`;
+            let w13 = k14 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k14]] : false;
+            let props13 = {};
+            if (w13 && w13.__owl__.currentFiber && !w13.__owl__.vnode) {
+                w13.destroy();
+                w13 = false;
+            }
+            if (w13) {
+                w13.__updateProps(props13, extra.fiber, utils.combine(context, scope));
+                let pvnode = w13.__owl__.pvnode;
+                c8.push(pvnode);
+            } else {
+                let componentKey13 = \`Child\`;
+                let W13 = scope['Child'] || context.constructor.components[componentKey13] || QWeb.components[componentKey13];
+                if (!W13) {throw new Error('Cannot find the definition of component \\"' + componentKey13 + '\\"')}
+                w13 = new W13(parent, props13);
+                parent.__owl__.cmap[k14] = w13.__owl__.id;
+                w13.__owl__.slotId = 1;
+                let fiber = w13.__prepare(extra.fiber, utils.combine(context, scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+                let pvnode = h('dummy', {key: k14, hook: {remove() {},destroy(vn) {w13.destroy();}}});
+                c8.push(pvnode);
+                w13.__owl__.pvnode = pvnode;
+            }
+            w13.__owl__.parentLastFiberId = extra.fiber.id;
+        }
+        scope = _origScope12;
+    }
+    scope = _origScope5;
+    return vn1;
+}"
+`;
+
 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}));
+    let c5 = [], p5 = {key:5};
+    let vn5 = h('span', p5, c5);
+    const slot6 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
+    if (slot6) {
+        slot6.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c5, parent: extra.parent || context}));
     }
-    return vn4;
+    return vn5;
 }"
 `;
 
@@ -581,12 +742,12 @@ exports[`t-slot directive template can just return a slot 1`] = `
     let utils = this.constructor.utils;
     let result;
     let h = this.h;
-    const slot6 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
-    if (slot6) {
-        let children7= []
+    const slot7 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
+    if (slot7) {
+        let children8= []
         result = {}
-        slot6.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: children7, parent: extra.parent || context}));
-        utils.defineProxy(result, children7[0]);
+        slot7.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: children8, parent: extra.parent || context}));
+        utils.defineProxy(result, children8[0]);
     }
     return result;
 }"

tests/component/async.test.ts

@@ -1,4 +1,4 @@
-import { Component, Env } from "../../src/component/component";
+import { Component, Env, STATUS } from "../../src/component/component";
 import { useState } from "../../src/hooks";
 import { xml } from "../../src/tags";
 import { makeDeferred, makeTestEnv, makeTestFixture, nextMicroTick, nextTick } from "../helpers";
@@ -27,7 +27,7 @@ afterEach(() => {
 
 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]);
 }
 
 describe("async rendering", () => {
@@ -40,14 +40,14 @@ describe("async rendering", () => {
       }
     }
     const w = new W();
+    expect(w.__owl__.status).toBe(STATUS.CREATED);
     w.mount(fixture);
-    expect(w.__owl__.isDestroyed).toBe(false);
-    expect(w.__owl__.isMounted).toBe(false);
+    expect(w.__owl__.status).toBe(STATUS.WILLSTARTED);
     w.destroy();
+    expect(w.__owl__.status).toBe(STATUS.DESTROYED);
     def.resolve();
     await nextTick();
-    expect(w.__owl__.isDestroyed).toBe(true);
-    expect(w.__owl__.isMounted).toBe(false);
+    expect(w.__owl__.status).toBe(STATUS.DESTROYED);
   });
 
   test("destroying/recreating a subwidget with different props (if start is not over)", async () => {
@@ -404,7 +404,7 @@ describe("async rendering", () => {
     }
     class ChildB extends Component {
       willStart(): any {
-        return new Promise(function() {});
+        return new Promise(function () {});
       }
     }
     class Parent extends Component {
@@ -1405,4 +1405,160 @@ describe("async rendering", () => {
     expect(fixture.innerHTML).toBe("<div>2</div>");
     expect(Widget.prototype.__render).toHaveBeenCalledTimes(2);
   });
+
+  test("components with shouldUpdate=false", async () => {
+    const state = { p: 1, cc: 10 };
+
+    class ChildChild extends Component {
+      static template = xml`
+        <div>
+          child child: <t t-esc="state.cc"/>
+        </div>`;
+      state = state;
+      shouldUpdate() {
+        return false;
+      }
+    }
+
+    class Child extends Component {
+      static components = { ChildChild };
+      static template = xml`
+        <div>
+          child
+          <ChildChild/>
+        </div>`;
+
+      shouldUpdate() {
+        return false;
+      }
+    }
+
+    let parent: any;
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`
+        <div>
+          parent: <t t-esc="state.p"/>
+          <Child/>
+        </div>`;
+
+      state = state;
+      constructor(a, b) {
+        super(a, b);
+        parent = this;
+      }
+      shouldUpdate() {
+        return false;
+      }
+    }
+
+    class App extends Component {
+      static components = { Parent };
+      static template = xml`
+        <div>
+          <Parent/>
+        </div>`;
+    }
+
+    var div = document.createElement("div");
+    fixture.appendChild(div);
+
+    const app = new App();
+
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe(
+      "<div></div><div><div> parent: 1<div> child <div> child child: 10</div></div></div></div>"
+    );
+    app.mount(div);
+
+    // wait for rendering from second mount to go through parent
+    await Promise.resolve();
+    await Promise.resolve();
+    state.cc++;
+    state.p++;
+    parent.render();
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      "<div><div><div> parent: 2<div> child <div> child child: 11</div></div></div></div></div>"
+    );
+  });
+
+  test("components with shouldUpdate=false, part 2", async () => {
+    const state = { p: 1, cc: 10 };
+    let shouldUpdate = true;
+
+    class ChildChild extends Component {
+      static template = xml`
+        <div>
+          child child: <t t-esc="state.cc"/>
+        </div>`;
+      state = state;
+      shouldUpdate() {
+        return shouldUpdate;
+      }
+    }
+
+    class Child extends Component {
+      static components = { ChildChild };
+      static template = xml`
+        <div>
+          child
+          <ChildChild/>
+        </div>`;
+
+      shouldUpdate() {
+        return shouldUpdate;
+      }
+    }
+
+    let parent: any;
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`
+        <div>
+          parent: <t t-esc="state.p"/>
+          <Child/>
+        </div>`;
+
+      state = state;
+      constructor(a, b) {
+        super(a, b);
+        parent = this;
+      }
+      shouldUpdate() {
+        return shouldUpdate;
+      }
+    }
+
+    class App extends Component {
+      static components = { Parent };
+      static template = xml`
+        <div>
+          <Parent/>
+        </div>`;
+    }
+
+    const app = new App();
+
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe(
+      "<div><div> parent: 1<div> child <div> child child: 10</div></div></div></div>"
+    );
+
+    state.cc++;
+    state.p++;
+    app.render();
+
+    // wait for rendering to go through child
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    shouldUpdate = false;
+    parent.render();
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      "<div><div> parent: 2<div> child <div> child child: 11</div></div></div></div>"
+    );
+  });
 });

tests/component/component.test.ts

@@ -1,16 +1,16 @@
-import { Component, Env } from "../../src/component/component";
+import { Component, Env, mount, STATUS } from "../../src/component/component";
+import { EventBus } from "../../src/core/event_bus";
+import { useRef, useState } from "../../src/hooks";
 import { QWeb } from "../../src/qweb/qweb";
 import { xml } from "../../src/tags";
-import { useState, useRef } from "../../src/hooks";
-import { EventBus } from "../../src/core/event_bus";
 import {
+  editInput,
   makeDeferred,
-  makeTestFixture,
   makeTestEnv,
+  makeTestFixture,
   nextMicroTick,
   nextTick,
   normalize,
-  editInput
 } from "../helpers";
 
 //------------------------------------------------------------------------------
@@ -39,7 +39,7 @@ afterEach(() => {
 
 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]);
 }
 
 // Test components
@@ -69,18 +69,23 @@ describe("basic widget properties", () => {
     class SomeWidget extends Component {
       static template = xml`<div>content</div>`;
     }
-    const widget = new SomeWidget();
-    widget.mount(fixture);
-    await nextTick();
+    await mount(SomeWidget, { target: fixture });
     expect(fixture.innerHTML).toBe("<div>content</div>");
   });
 
+  test("can be mounted with props", async () => {
+    class SomeWidget extends Component {
+      static template = xml`<div><t t-esc="props.content"/></div>`;
+    }
+    await mount(SomeWidget, { target: fixture, props: { content: "foo" } });
+    expect(fixture.innerHTML).toBe("<div>foo</div>");
+  });
+
   test("can be mounted on a documentFragment", async () => {
     class SomeWidget extends Component {
       static template = xml`<div>content</div>`;
     }
-    const widget = new SomeWidget();
-    await widget.mount(document.createDocumentFragment());
+    const widget = await mount(SomeWidget, { target: document.createDocumentFragment() });
     expect(fixture.innerHTML).toBe("");
     await widget.mount(fixture);
     expect(fixture.innerHTML).toBe("<div>content</div>");
@@ -90,10 +95,9 @@ describe("basic widget properties", () => {
     class SomeWidget extends Component {
       static template = xml`<div>content</div>`;
     }
-    const widget = new SomeWidget();
     let error;
     try {
-      await widget.mount(null as any);
+      await mount(SomeWidget, { target: null as any });
     } catch (e) {
       error = e;
     }
@@ -107,10 +111,9 @@ describe("basic widget properties", () => {
     class SomeWidget extends Component {
       static template = xml`<t/>`;
     }
-    const widget = new SomeWidget();
     let error;
     try {
-      await widget.mount(fixture);
+      await mount(SomeWidget, { target: fixture });
     } catch (e) {
       error = e;
     }
@@ -133,12 +136,11 @@ describe("basic widget properties", () => {
       static template = xml`
       <div><t t-esc="state.counter"/><button t-on-click="state.counter++">Inc</button></div>`;
       state = useState({
-        counter: 0
+        counter: 0,
       });
     }
 
-    const counter = new Counter();
-    counter.mount(fixture);
+    const counter = await mount(Counter, { target: fixture });
     await nextTick();
     expect(fixture.innerHTML).toBe("<div>0<button>Inc</button></div>");
     const button = (<HTMLElement>counter.el).getElementsByTagName("button")[0];
@@ -147,6 +149,24 @@ describe("basic widget properties", () => {
     expect(fixture.innerHTML).toBe("<div>1<button>Inc</button></div>");
   });
 
+  test("support for callable expression in event handler", async () => {
+    class Counter extends Component {
+      static template = xml`
+      <div><t t-esc="state.value"/><input type="text" t-on-input="obj.onInput"/></div>`;
+      state = useState({ value: "" });
+      obj = { onInput: (ev) => (this.state.value = ev.target.value) };
+    }
+
+    const counter = await mount(Counter, { target: fixture });
+    await nextTick();
+    expect(fixture.innerHTML).toBe(`<div><input type="text"></div>`);
+    const input = (<HTMLElement>counter.el).getElementsByTagName("input")[0];
+    input.value = "test";
+    input.dispatchEvent(new Event("input"));
+    await nextTick();
+    expect(fixture.innerHTML).toBe(`<div>test<input type="text"></div>`);
+  });
+
   test("can handle empty props", async () => {
     class Child extends Component {
       static template = xml`<span><t t-esc="props.val"/></span>`;
@@ -156,30 +176,28 @@ describe("basic widget properties", () => {
       static components = { Child };
     }
 
-    const parent = new Parent();
-    await parent.mount(fixture);
+    await mount(Parent, { target: fixture });
     expect(env.qweb.templates[Parent.template].fn.toString()).toMatchSnapshot();
     expect(fixture.innerHTML).toBe("<div><span></span></div>");
   });
 
-  test("cannot be clicked on and updated if not in DOM", async () => {
+  test("can be clicked on and updated if not in DOM", async () => {
     class Counter extends Component {
       static template = xml`
       <div><t t-esc="state.counter"/><button t-on-click="state.counter++">Inc</button></div>`;
       state = useState({
-        counter: 0
+        counter: 0,
       });
     }
 
-    const counter = new Counter();
     const target = document.createElement("div");
-    await counter.mount(target);
+    const counter = await mount(Counter, { target: target });
     expect(target.innerHTML).toBe("<div>0<button>Inc</button></div>");
     const button = (<HTMLElement>counter.el).getElementsByTagName("button")[0];
     button.click();
     await nextTick();
-    expect(target.innerHTML).toBe("<div>0<button>Inc</button></div>");
-    expect(counter.state.counter).toBe(0);
+    expect(target.innerHTML).toBe("<div>1<button>Inc</button></div>");
+    expect(counter.state.counter).toBe(1);
   });
 
   test("widget style and classname", async () => {
@@ -188,8 +206,7 @@ describe("basic widget properties", () => {
         <div style="font-weight:bold;" class="some-class">world</div>
       `;
     }
-    const widget = new StyledWidget();
-    await widget.mount(fixture);
+    await mount(StyledWidget, { target: fixture });
     expect(fixture.innerHTML).toBe(`<div style="font-weight:bold;" class="some-class">world</div>`);
   });
 
@@ -212,8 +229,8 @@ describe("basic widget properties", () => {
         steps.push("patched");
       }
     }
-    const widget = new TestW();
-    await widget.mount(fixture);
+    await mount(TestW, { target: fixture });
+
     expect(steps).toEqual(["__render", "mounted"]);
   });
 
@@ -537,7 +554,7 @@ describe("lifecycle hooks", () => {
       "child:mounted",
       "parent:willUnmount",
       "child:willUnmount",
-      "childchild:willUnmount"
+      "childchild:willUnmount",
     ]);
   });
 
@@ -589,7 +606,7 @@ describe("lifecycle hooks", () => {
       "childchild:willPatch",
       "childchild:patched",
       "child:patched",
-      "parent:patched"
+      "parent:patched",
     ]);
   });
 
@@ -662,9 +679,8 @@ describe("lifecycle hooks", () => {
 
     class ChildWidget extends Component {
       static template = xml`<div/>`;
-      constructor(parent) {
-        super(parent);
-        steps.push("init");
+      setup() {
+        steps.push("setup");
       }
       async willStart() {
         steps.push("willstart");
@@ -688,10 +704,10 @@ describe("lifecycle hooks", () => {
 
     const widget = new ParentWidget();
     await widget.mount(fixture);
-    expect(steps).toEqual(["init", "willstart", "mounted"]);
+    expect(steps).toEqual(["setup", "willstart", "mounted"]);
     widget.state.ok = false;
     await nextTick();
-    expect(steps).toEqual(["init", "willstart", "mounted", "willunmount"]);
+    expect(steps).toEqual(["setup", "willstart", "mounted", "willunmount"]);
   });
 
   test("components are unmounted and destroyed if no longer in DOM, even after updateprops", async () => {
@@ -739,8 +755,7 @@ describe("lifecycle hooks", () => {
 
     class ChildWidget extends Component {
       static template = xml`<div/>`;
-      constructor(parent) {
-        super(parent);
+      setup() {
         steps.push("c init");
       }
       async willStart() {
@@ -756,8 +771,7 @@ describe("lifecycle hooks", () => {
     class ParentWidget extends Component {
       static template = xml`<div><t t-component="child"/></div>`;
       static components = { child: ChildWidget };
-      constructor(parent?) {
-        super(parent);
+      setup() {
         steps.push("p init");
       }
       async willStart() {
@@ -782,7 +796,7 @@ describe("lifecycle hooks", () => {
       "c mounted",
       "p mounted",
       "p willunmount",
-      "c willunmount"
+      "c willunmount",
     ]);
   });
 
@@ -960,7 +974,70 @@ describe("lifecycle hooks", () => {
       "parent:willPatch",
       "child:willPatch",
       "child:patched",
-      "parent:patched"
+      "parent:patched",
+    ]);
+  });
+
+  test("willPatch/patched hook is not called if not mounted in DOM", async () => {
+    const steps: string[] = [];
+
+    class ChildWidget extends Component {
+      static template = xml`<div/>`;
+      constructor(parent, props) {
+        super(parent, props);
+        steps.push("child:constructor");
+      }
+      mounted() {
+        steps.push("child:mounted");
+      }
+      willPatch() {
+        steps.push("child:willPatch");
+      }
+      patched() {
+        steps.push("child:patched");
+      }
+    }
+    class ParentWidget extends Component {
+      static template = xml`
+        <div>
+          <t t-component="child" v="state.n"/>
+        </div>
+      `;
+      static components = { child: ChildWidget };
+      state = useState({ n: 1 });
+      constructor() {
+        super();
+        steps.push("parent:constructor");
+      }
+      mounted() {
+        steps.push("parent:mounted");
+      }
+      willPatch() {
+        steps.push("parent:willPatch");
+      }
+      patched() {
+        steps.push("parent:patched");
+      }
+    }
+
+    const div = document.createElement("div");
+    const widget = new ParentWidget();
+    await widget.mount(div);
+    expect(steps).toEqual(["parent:constructor", "child:constructor"]);
+
+    widget.state.n = 2;
+    await nextTick();
+
+    expect(steps).toEqual(["parent:constructor", "child:constructor"]);
+
+    // then we remount the component in the dom
+    await widget.mount(fixture);
+
+    expect(steps).toEqual([
+      "parent:constructor",
+      "child:constructor",
+      "child:mounted",
+      "parent:mounted",
     ]);
   });
 });
@@ -976,8 +1053,7 @@ describe("destroy method", () => {
     expect(document.contains(widget.el)).toBe(true);
     widget.destroy();
     expect(document.contains(widget.el)).toBe(false);
-    expect(widget.__owl__.isMounted).toBe(false);
-    expect(widget.__owl__.isDestroyed).toBe(true);
+    expect(widget.__owl__.status).toBe(STATUS.DESTROYED);
   });
 
   test("destroying a parent also destroys its children", async () => {
@@ -986,9 +1062,9 @@ describe("destroy method", () => {
 
     const child = children(parent)[0];
 
-    expect(child.__owl__.isDestroyed).toBe(false);
+    expect(child.__owl__.status).toBe(STATUS.MOUNTED);
     parent.destroy();
-    expect(child.__owl__.isDestroyed).toBe(true);
+    expect(child.__owl__.status).toBe(STATUS.DESTROYED);
   });
 
   test("destroy remove the parent/children link", async () => {
@@ -1014,17 +1090,15 @@ describe("destroy method", () => {
     }
     expect(fixture.innerHTML).toBe("");
     const widget = new DelayedWidget();
+    expect(widget.__owl__.status).toBe(STATUS.CREATED);
     widget.mount(fixture);
-    expect(widget.__owl__.isMounted).toBe(false);
-    expect(widget.__owl__.isDestroyed).toBe(false);
+    expect(widget.__owl__.status).toBe(STATUS.WILLSTARTED);
     widget.destroy();
-    expect(widget.__owl__.isMounted).toBe(false);
-    expect(widget.__owl__.isDestroyed).toBe(true);
+    expect(widget.__owl__.status).toBe(STATUS.DESTROYED);
     def.resolve();
     await nextTick();
 
-    expect(widget.__owl__.isMounted).toBe(false);
-    expect(widget.__owl__.isDestroyed).toBe(true);
+    expect(widget.__owl__.status).toBe(STATUS.DESTROYED);
     expect(widget.__owl__.vnode).toBe(undefined);
     expect(fixture.innerHTML).toBe("");
     expect(isRendered).toBe(false);
@@ -1134,7 +1208,7 @@ describe("composition", () => {
     class App extends Component {
       static template = xml`<t t-component="myComponent" t-key="state.child"/>`;
       state = useState({
-        child: "a"
+        child: "a",
       });
       get myComponent() {
         return this.state.child === "a" ? A : B;
@@ -1158,7 +1232,7 @@ describe("composition", () => {
     class App extends Component {
       static template = xml`<t t-component="myComponent" t-key="state.child"/>`;
       state = useState({
-        child: "a"
+        child: "a",
       });
       get myComponent() {
         return this.state.child === "a" ? A : B;
@@ -1172,6 +1246,30 @@ describe("composition", () => {
     expect(fixture.innerHTML).toBe("<div>child b</div>");
   });
 
+  test("can switch between dynamic components without the need for a t-key", async () => {
+    class A extends Component {
+      static template = xml`<span>child a</span>`;
+    }
+    class B extends Component {
+      static template = xml`<span>child b</span>`;
+    }
+    class App extends Component {
+      static template = xml`
+        <div>
+            <t t-component="{{state.child}}"/>
+        </div>`;
+      static components = { A, B };
+
+      state = useState({ child: "A" });
+    }
+    const app = await mount(App, { target: fixture });
+    expect(fixture.innerHTML).toBe("<div><span>child a</span></div>");
+    app.state.child = "B";
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>child b</span></div>");
+    expect(QWeb.TEMPLATES[App.template].fn.toString()).toMatchSnapshot();
+  });
+
   test("don't fallback to global registry if widget defined locally", async () => {
     QWeb.registerComponent("WidgetB", WidgetB); // should not use this widget
     env.qweb.addTemplate("ParentWidget", `<div><t t-component="WidgetB"/></div>`);
@@ -1186,6 +1284,23 @@ describe("composition", () => {
     delete QWeb.components["WidgetB"];
   });
 
+  test("don't fallback to global/component's registry if widget defined in the instance's context", async () => {
+    QWeb.registerComponent("WidgetB", WidgetB); // should not use this widget
+    env.qweb.addTemplate("ParentWidget", `<div><t t-component="WidgetB"/></div>`);
+    env.qweb.addTemplate("ComponentWidgetB", `<span>Belgium</span>`); // should not use this widget either
+    env.qweb.addTemplate("InstanceWidgetB", `<span>Chocolate</span>`); // should use this
+    class ComponentWidgetB extends Component {}
+    class InstanceWidgetB extends Component {}
+    class ParentWidget extends Component {
+      static components = { WidgetB: ComponentWidgetB };
+      WidgetB = InstanceWidgetB;
+    }
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>Chocolate</span></div>");
+    delete QWeb.components["WidgetB"];
+  });
+
   test("can define components in template without t-component", async () => {
     env.qweb.addTemplates(`
       <templates>
@@ -1228,7 +1343,7 @@ describe("composition", () => {
       static template = xml`
       <div><t t-esc="state.counter"/><button t-on-click="state.counter++">Inc</button></div>`;
       state = useState({
-        counter: 0
+        counter: 0,
       });
     }
 
@@ -1327,7 +1442,7 @@ describe("composition", () => {
       static template = xml`
       <div><t t-esc="state.counter"/><button t-on-click="state.counter++">Inc</button></div>`;
       state = useState({
-        counter: 0
+        counter: 0,
       });
     }
 
@@ -1350,7 +1465,7 @@ describe("composition", () => {
       static template = xml`
       <div><t t-esc="state.counter"/><button t-on-click="state.counter++">Inc</button></div>`;
       state = useState({
-        counter: 0
+        counter: 0,
       });
     }
 
@@ -1389,7 +1504,7 @@ describe("composition", () => {
     );
     class Parent extends Component {
       state = useState({
-        numbers: [1, 2, 3]
+        numbers: [1, 2, 3],
       });
       static components = { ChildWidget };
     }
@@ -1429,7 +1544,7 @@ describe("composition", () => {
     class Parent extends Component {
       static template = "parent";
       state = useState({
-        numbers: [1, 2, 3]
+        numbers: [1, 2, 3],
       });
       static components = { ChildWidget };
     }
@@ -1480,7 +1595,7 @@ describe("composition", () => {
     parent.state.flag = true;
     await nextTick();
     expect(children(parent)[0]).toBe(child);
-    expect(child.__owl__.isDestroyed).toBe(false);
+    expect(child.__owl__.status).toBe(STATUS.MOUNTED);
     expect(normalize(fixture.innerHTML)).toBe(
       normalize(`
       <div>
@@ -1513,8 +1628,8 @@ describe("composition", () => {
         blips: [
           { a: "a", id: 1 },
           { b: "b", id: 2 },
-          { c: "c", id: 4 }
-        ]
+          { c: "c", id: 4 },
+        ],
       });
     }
     const parent = new Parent();
@@ -1621,8 +1736,8 @@ describe("composition", () => {
         records: [
           { id: 1, val: 1 },
           { id: 2, val: 2 },
-          { id: 3, val: 3 }
-        ]
+          { id: 3, val: 3 },
+        ],
       });
       static components = { ChildWidget };
     }
@@ -1725,6 +1840,47 @@ describe("props evaluation ", () => {
     await widget.mount(fixture);
     expect(normalize(fixture.innerHTML)).toBe("<div><span>42</span></div>");
   });
+
+  test("t-set with a body expression can be used as textual prop", async () => {
+    class Child extends Component {
+      static template = xml`<span t-esc="props.val"/>`;
+    }
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`
+        <div>
+          <t t-set="abc">42</t>
+          <Child val="abc"/>
+        </div>`;
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>42</span></div>");
+    expect(env.qweb.templates[Parent.template].fn.toString()).toMatchSnapshot();
+  });
+
+  test("t-set with a body expression can be passed in props, and then t-raw", async () => {
+    class Child extends Component {
+      static template = xml`
+        <span>
+          <t t-esc="props.val"/>
+          <t t-raw="props.val"/>
+        </span>`;
+    }
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`
+        <div>
+          <t t-set="abc"><p>43</p></t>
+          <Child val="abc"/>
+        </div>`;
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>&lt;p&gt;4343&lt;/p&gt;<p>43</p></span></div>");
+  });
 });
 
 describe("other directives with t-component", () => {
@@ -2003,7 +2159,7 @@ describe("other directives with t-component", () => {
     }
     const widget = new ParentWidget();
     await widget.mount(fixture);
-    (<HTMLElement>fixture).addEventListener("ev", function(e) {
+    (<HTMLElement>fixture).addEventListener("ev", function (e) {
       steps.push(e.defaultPrevented);
     });
 
@@ -2038,7 +2194,7 @@ describe("other directives with t-component", () => {
     }
     const widget = new ParentWidget();
     await widget.mount(fixture);
-    (<HTMLElement>fixture).addEventListener("ev", function(e) {
+    (<HTMLElement>fixture).addEventListener("ev", function (e) {
       steps.push(e.defaultPrevented);
     });
 
@@ -2187,9 +2343,29 @@ describe("other directives with t-component", () => {
     el.click();
     expect(steps).toEqual(["click"]);
     parent.unmount();
-    expect(child.__owl__.isMounted).toBe(false);
+    expect(child.__owl__.status).toBe(STATUS.UNMOUNTED);
     el.click();
-    expect(steps).toEqual(["click"]);
+    expect(steps).toEqual(["click", "click"]);
+  });
+
+  test("triggering custom event on mounted components", async () => {
+    let value = false;
+    class Child extends Component {
+      static template = xml`<div/>`;
+      mounted() {
+        this.trigger("coucou");
+      }
+    }
+    class Parent extends Component {
+      static template = xml`<Child t-on-coucou="doSomething"/>`;
+      static components = { Child };
+      doSomething() {
+        value = true;
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(value).toBe(true);
   });
 
   test("t-on with .capture modifier", async () => {
@@ -2241,7 +2417,7 @@ describe("other directives with t-component", () => {
     expect(steps).toEqual(["click"]);
     parent.state.flag = false;
     await nextTick();
-    expect(child.__owl__.isDestroyed).toBe(true);
+    expect(child.__owl__.status).toBe(STATUS.DESTROYED);
     el.click();
     expect(steps).toEqual(["click"]);
   });
@@ -2276,7 +2452,7 @@ describe("other directives with t-component", () => {
     expect(steps).toEqual(["click"]);
     parent.state.flag = false;
     await nextTick();
-    expect(child.__owl__.isDestroyed).toBe(true);
+    expect(child.__owl__.status).toBe(STATUS.DESTROYED);
     el.click();
     expect(steps).toEqual(["click"]);
   });
@@ -2976,7 +3152,7 @@ describe("random stuff/miscellaneous", () => {
       "D:mounted",
       "C:mounted",
       "B:mounted",
-      "A:mounted"
+      "A:mounted",
     ]);
 
     // update
@@ -2999,7 +3175,7 @@ describe("random stuff/miscellaneous", () => {
       "E:destroy",
       "F:mounted",
       "D:patched",
-      "C:patched"
+      "C:patched",
     ]);
   });
 
@@ -3015,6 +3191,85 @@ describe("random stuff/miscellaneous", () => {
     expect(env.qweb.templates[Parent.template].fn.toString()).toMatchSnapshot();
     expect(fixture.innerHTML).toBe("<div><span>42</span></div>");
   });
+
+  test("update props of component without concrete own node", async () => {
+    class Custom extends Component {
+      static template = xml`
+        <div class="widget-subkey">
+          <t t-esc="props.key"/>__<t t-esc="props.subKey"/>
+        </div>`;
+    }
+    class Child extends Component {
+      static components = { Custom };
+      static template = xml`
+        <t t-component="Custom"
+          t-key="props.subKey"
+          key="props.key"
+          subKey="props.subKey"/>`;
+    }
+
+    class Parent extends Component {
+      static components = { Child };
+      static template = xml`
+        <div>
+          <Child t-key="childProps.key" t-props="childProps"/>
+        </div>`;
+      childProps = {
+        key: 1,
+        subKey: 1,
+      };
+    }
+    const parent = new Parent(null);
+    await parent.mount(fixture);
+    expect(fixture.textContent!.trim()).toBe("1__1");
+
+    // First step: change the Custom's instance
+    Object.assign(parent.childProps, {
+      subKey: 2,
+    });
+    parent.render();
+    await nextTick();
+    expect(fixture.textContent!.trim()).toBe("1__2");
+
+    // Second step, change both Child's and Custom's instance
+    Object.assign(parent.childProps, {
+      key: 2,
+      subKey: 3,
+    });
+    parent.render();
+    await nextTick();
+    expect(fixture.textContent!.trim()).toBe("2__3");
+  });
+
+  test("two renderings initiated between willPatch and patched", async () => {
+    let app;
+
+    class Panel extends Component {
+      static template = xml`<abc><t t-esc="props.val"/></abc>`;
+      mounted() {
+        app.render();
+      }
+      willUnmount() {
+        app.render();
+      }
+    }
+
+    // Main root component
+    class App extends Component {
+      static components = { Panel };
+      static template = xml`<div><Panel t-key="'panel_' + state.panel" val="state.panel"/></div>`;
+
+      state = useState({ panel: "Panel1" });
+    }
+
+    app = new App();
+    await app.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><abc>Panel1</abc></div>");
+    app.state.panel = "Panel2";
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><abc>Panel2</abc></div>");
+  });
 });
 
 describe("widget and observable state", () => {
@@ -3138,6 +3393,46 @@ describe("t-model directive", () => {
     expect(env.qweb.templates[SomeComponent.template].fn.toString()).toMatchSnapshot();
   });
 
+  test("basic use, on an input with bracket expression", async () => {
+    class SomeComponent extends Component {
+      static template = xml`
+        <div>
+          <input t-model="state['text']"/>
+          <span><t t-esc="state.text"/></span>
+        </div>`;
+      state = useState({ text: "" });
+    }
+    const comp = new SomeComponent();
+    await comp.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><input><span></span></div>");
+
+    const input = fixture.querySelector("input")!;
+    await editInput(input, "test");
+    expect(comp.state.text).toBe("test");
+    expect(fixture.innerHTML).toBe("<div><input><span>test</span></div>");
+    expect(env.qweb.templates[SomeComponent.template].fn.toString()).toMatchSnapshot();
+  });
+
+  test("throws if invalid expression", async () => {
+    class SomeComponent extends Component {
+      static template = xml`
+        <div>
+          <input t-model="state"/>
+        </div>`;
+      state = useState({ text: "" });
+    }
+    const comp = new SomeComponent();
+    let error;
+    try {
+      await comp.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe(`Invalid t-model expression: "state" (it should be assignable)`);
+  });
+
   test("basic use, on another key in component", async () => {
     env.qweb.addTemplates(`
     <templates>
@@ -3410,7 +3705,7 @@ describe("t-model directive", () => {
       state = useState([
         { f: false, id: 1 },
         { f: false, id: 2 },
-        { f: false, id: 3 }
+        { f: false, id: 3 },
       ]);
     }
     const comp = new SomeComponent();
@@ -3427,6 +3722,28 @@ describe("t-model directive", () => {
     expect(env.qweb.templates[SomeComponent.template].fn.toString()).toMatchSnapshot();
   });
 
+  test("in a t-foreach, part 2", async () => {
+    class SomeComponent extends Component {
+      static template = xml`
+        <div>
+          <t t-foreach="state" t-as="thing" t-key="thing_index" >
+            <input t-model="state[thing_index]"/>
+          </t>
+        </div>
+      `;
+      state = useState(["zuko", "iroh"]);
+    }
+    const comp = new SomeComponent();
+    await comp.mount(fixture);
+    expect(comp.state).toEqual(["zuko", "iroh"]);
+
+    const input = fixture.querySelectorAll("input")[1]!;
+    input.value = "uncle iroh";
+    input.dispatchEvent(new Event("input"));
+    expect(comp.state).toEqual(["zuko", "uncle iroh"]);
+    expect(env.qweb.templates[SomeComponent.template].fn.toString()).toMatchSnapshot();
+  });
+
   test("two inputs in a div with a t-key", async () => {
     class SomeComponent extends Component {
       static template = xml`
@@ -3455,7 +3772,7 @@ describe("environment and plugins", () => {
   let bus = new EventBus();
 
   // definition of a plugin
-  const somePlugin = env => {
+  const somePlugin = (env) => {
     env.someFlag = true;
     bus.on("some-event", null, () => {
       env.someFlag = !env.someFlag;
@@ -3747,6 +4064,30 @@ describe("dynamic t-props", () => {
     expect(fixture.innerHTML).toBe("<div><span>3</span></div>");
     expect(env.qweb.templates[Parent.template].fn.toString()).toMatchSnapshot();
   });
+
+  test("t-props with props", async () => {
+    expect.assertions(1);
+
+    class Child extends Component {
+      static template = xml`<div />`;
+      setup() {
+        expect(this.props).toEqual({ a: 1, b: 2, c: "c" });
+      }
+    }
+    class Parent extends Component {
+      static template = xml`
+        <div>
+            <Child t-props="props" a="1" b="2" />
+        </div>
+      `;
+      static components = { Child };
+
+      props = { a: "a", c: "c" };
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+  });
 });
 
 describe("support svg components", () => {
@@ -3825,7 +4166,9 @@ describe("t-call", () => {
 
     expect(fixture.innerHTML).toBe("<div><p>lucas</p></div>");
     fixture.querySelector("p")!.click();
-    expect(env.qweb.subTemplates["sub"].toString()).toMatchSnapshot();
+    const subId = env.qweb.subTemplates["sub"];
+    const subFn = QWeb.subTemplates[subId] as any;
+    expect(subFn.toString()).toMatchSnapshot();
   });
 
   test("parent is set within t-call", async () => {
@@ -3847,7 +4190,10 @@ describe("t-call", () => {
 
     expect(fixture.innerHTML).toBe("<div><span>lucas</span></div>");
     expect(child.__owl__.parent).toBe(parent);
-    expect(env.qweb.subTemplates["sub"].toString()).toMatchSnapshot();
+    const subId = env.qweb.subTemplates["sub"];
+    const subFn = QWeb.subTemplates[subId] as any;
+
+    expect(subFn.toString()).toMatchSnapshot();
   });
 
   test("t-call in t-foreach and children component", async () => {
@@ -3889,7 +4235,9 @@ describe("t-call", () => {
 
     expect(fixture.innerHTML).toBe("<span>lucas</span>");
     expect(child.__owl__.parent).toBe(parent);
-    expect(env.qweb.subTemplates["sub"].toString()).toMatchSnapshot();
+    const subId = env.qweb.subTemplates["sub"];
+    const subFn = QWeb.subTemplates[subId] as any;
+    expect(subFn.toString()).toMatchSnapshot();
   });
 
   test("handlers with arguments are properly bound through a t-call", async () => {
@@ -3905,7 +4253,9 @@ describe("t-call", () => {
     }
     const parent = new Parent();
     await parent.mount(fixture);
-    expect(env.qweb.subTemplates["sub"].toString()).toMatchSnapshot();
+    const subId = env.qweb.subTemplates["sub"];
+    const subFn = QWeb.subTemplates[subId] as any;
+    expect(subFn.toString()).toMatchSnapshot();
 
     fixture.querySelector("p")!.click();
   });

tests/component/error_handling.test.ts

@@ -1,4 +1,4 @@
-import { Component, Env } from "../../src/component/component";
+import { Component, Env, mount, STATUS } from "../../src/component/component";
 import { useState } from "../../src/hooks";
 import { xml } from "../../src/tags";
 import { makeTestEnv, makeTestFixture, nextTick } from "../helpers";
@@ -108,7 +108,7 @@ describe("component error handling (catchError)", () => {
 
     expect(console.error).toBeCalledTimes(0);
     console.error = consoleError;
-    expect(app.__owl__.isDestroyed).toBe(true);
+    expect(app.__owl__.status).toBe(STATUS.DESTROYED);
     expect(handler).toBeCalledTimes(1);
   });
 
@@ -520,4 +520,91 @@ describe("component error handling (catchError)", () => {
     expect(error).toBeDefined();
     expect(error.message).toBe("Cannot read property 'y' of undefined");
   });
+
+  test("simple catchError", async () => {
+    class Boom extends Component {
+      static template = xml`<div t-esc="a.b.c"/>`;
+    }
+
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <t t-if="error">Error</t>
+          <t t-else="">
+            <Boom />
+          </t>
+        </div>`;
+      static components = { Boom };
+
+      error = false;
+
+      catchError(error) {
+        this.error = error;
+        this.render();
+      }
+    }
+
+    await mount(Parent, { target: fixture });
+    expect(fixture.innerHTML).toBe("<div>Error</div>");
+  });
+
+  test("catchError in catchError", async () => {
+    class Boom extends Component {
+      static template = xml`<div t-esc="a.b.c"/>`;
+    }
+
+    class Child extends Component {
+      static template = xml`
+        <div>
+          <Boom />
+        </div>`;
+      static components = { Boom };
+
+      catchError(error) {
+        throw error;
+      }
+    }
+
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <t t-if="error">Error</t>
+          <t t-else="">
+            <Child />
+          </t>
+        </div>`;
+      static components = { Child };
+
+      error = false;
+
+      catchError(error) {
+        this.error = error;
+        this.render();
+      }
+    }
+
+    await mount(Parent, { target: fixture });
+    expect(fixture.innerHTML).toBe("<div>Error</div>");
+  });
+
+  test("errors in mounted and in willUnmount", async () => {
+    expect.assertions(1);
+    class Example extends Component {
+      static template = xml`<div/>`;
+      val;
+      mounted() {
+        throw new Error("Error in mounted");
+        this.val = { foo: "bar" };
+      }
+      willUnmount() {
+        console.log(this.val.foo);
+      }
+    }
+
+    try {
+      await mount(Example, { target: fixture });
+    } catch (e) {
+      expect(e.message).toBe("Error in mounted");
+    }
+  });
 });

tests/component/props_validation.test.ts

@@ -92,7 +92,7 @@ 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;
@@ -149,7 +149,7 @@ 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;
@@ -396,7 +396,7 @@ describe("props validation", () => {
     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 {
@@ -458,9 +458,9 @@ describe("props validation", () => {
           type: Object,
           shape: {
             id: Number,
-            url: [Boolean, { type: Array, element: Number }]
-          }
-        }
+            url: [Boolean, { type: Array, element: Number }],
+          },
+        },
       };
     }
     class Parent extends Component {
@@ -510,10 +510,10 @@ describe("props validation", () => {
           element: {
             type: Object,
             shape: {
-              num: { type: Number, optional: true }
-            }
-          }
-        }
+              num: { type: Number, optional: true },
+            },
+          },
+        },
       };
     }
     let error;
@@ -539,8 +539,8 @@ describe("props validation", () => {
     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);
+    const validator = jest.fn((n) => 0 <= n && n <= 10);
     class TestComponent extends Component {
       static props = {
         n: {
           type: Number,
-          validate: validator
-        }
+          validate: validator,
+        },
       };
     }
     let error;
@@ -786,6 +786,31 @@ describe("props validation", () => {
     await nextTick();
     expect(fixture.innerHTML).toBe("<div><div>4</div></div>");
   });
+
+  test("mix of optional and mandatory", async () => {
+    class Child extends Component {
+      static props = {
+        optional: { type: String, optional: true },
+        mandatory: Number,
+      };
+      static template = xml` <div><t t-esc="props.mandatory"/></div>`;
+    }
+
+    class App extends Component {
+      static components = { Child };
+      static template = xml`<div><Child/></div>`;
+    }
+
+    const w = new App(undefined, {});
+    let error;
+    try {
+      await w.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Missing props 'mandatory' (component 'Child')");
+  });
 });
 
 describe("default props", () => {

tests/component/slots.test.ts

@@ -1,4 +1,4 @@
-import { Component, Env } from "../../src/component/component";
+import { Component, Env, mount } from "../../src/component/component";
 import { QWeb } from "../../src/qweb/qweb";
 import { xml } from "../../src/tags";
 import { useState, useRef } from "../../src/hooks";
@@ -28,7 +28,7 @@ afterEach(() => {
 
 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]);
 }
 
 //------------------------------------------------------------------------------
@@ -224,8 +224,8 @@ describe("t-slot directive", () => {
       state = useState({
         users: [
           { id: 1, name: "Aaron" },
-          { id: 2, name: "David" }
-        ]
+          { id: 2, name: "David" },
+        ],
       });
       static components = { Link };
     }
@@ -268,8 +268,8 @@ describe("t-slot directive", () => {
       state = useState({
         users: [
           { id: 1, name: "Aaron" },
-          { id: 2, name: "David" }
-        ]
+          { id: 2, name: "David" },
+        ],
       });
       static components = { Link };
     }
@@ -325,6 +325,70 @@ describe("t-slot directive", () => {
     expect(QWeb.slots["1_default"].toString()).toMatchSnapshot();
   });
 
+  test("slots in t-foreach in t-foreach", async () => {
+    class Child extends Component {
+      static template = xml`
+        <div><t t-slot="default" /></div>
+      `;
+    }
+
+    class App extends Component {
+      static template = xml`
+        <div>
+          <t t-foreach="tree" t-as="node1" t-key="node1.key">
+            <div t-esc="node1.value" />
+            <ul>
+              <t t-foreach="node1.nodes" t-as="node2" t-key="node2.key">
+                <Child>
+                  <li t-esc="node1.value" />
+                </Child>
+              </t>
+            </ul>
+          </t>
+        </div>`;
+
+      static components = { Child };
+
+      tree = [
+        {
+          key: "a",
+          value: "A",
+          nodes: [
+            {
+              key: "1",
+              value: "A-1",
+            },
+            {
+              key: "2",
+              value: "A-2",
+            },
+          ],
+        },
+        {
+          key: "b",
+          value: "B",
+          nodes: [
+            {
+              key: "1",
+              value: "B-1",
+            },
+            {
+              key: "2",
+              value: "B-2",
+            },
+          ],
+        },
+      ];
+    }
+
+    await mount(App, { target: fixture });
+
+    expect(fixture.innerHTML).toBe(
+      "<div><div>A</div><ul><div><li>A</li></div><div><li>A</li></div></ul><div>B</div><ul><div><li>B</li></div><div><li>B</li></div></ul></div>"
+    );
+    expect(env.qweb.templates[App.template].fn.toString()).toMatchSnapshot();
+  });
+
   test("refs are properly bound in slots", async () => {
     class Dialog extends Component {
       static template = xml`<span><t t-slot="footer"/></span>`;
@@ -403,6 +467,48 @@ describe("t-slot directive", () => {
     expect(QWeb.slots["1_default"].toString()).toMatchSnapshot();
   });
 
+  test("default slot next to named slot, with default content", async () => {
+    class Dialog extends Component {
+      // We're using 2 slots here: a "default" one and a "footer",
+      // both having default children nodes.
+      static template = xml`
+        <div class="Dialog">
+          <div class="content">
+            <t t-slot="default">
+              Default content
+            </t>
+          </div>
+          <div class="footer">
+            <t t-slot="footer">
+              Default footer
+            </t>
+          </div>
+        </div>
+      `;
+    }
+
+    class App extends Component {
+      // Here we're trying to assign the "footer" slot with some content
+      static components = { Dialog };
+      static template = xml`
+        <div>
+          <Dialog>
+            <t t-set-slot="footer">
+              Overridden footer
+            </t>
+          </Dialog>
+        </div>
+      `;
+    }
+
+    await mount(App, { target: fixture });
+
+    expect(fixture.innerHTML).toBe(
+      '<div><div class="Dialog"><div class="content"> Default content </div><div class="footer"> Overridden footer </div></div></div>'
+    );
+    expect(QWeb.TEMPLATES[App.template].fn.toString()).toMatchSnapshot();
+  });
+
   test("multiple roots are allowed in a named slot", async () => {
     env.qweb.addTemplates(`
           <templates>
@@ -929,4 +1035,339 @@ describe("t-slot directive", () => {
     expect(fixture.innerHTML).toBe("<div><span>dash</span></div>");
     expect(env.qweb.templates[Dialog.template].fn.toString()).toMatchSnapshot();
   });
+
+  test("slot and t-esc", 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-esc="'toph'"/></Dialog></div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>toph</span></div>");
+  });
+
+  test("slot and (inline) t-esc", async () => {
+    class Dialog extends Component {
+      static template = xml`<span><t t-slot="default"/></span>`;
+    }
+    class Parent extends Component {
+      static template = xml`<div><Dialog t-esc="'toph'"/></div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>toph</span></div>");
+  });
+
+  test("slot and t-call", async () => {
+    env.qweb.addTemplate("sokka", "<p>sokka</p>");
+    class Dialog extends Component {
+      static template = xml`<span><t t-slot="default"/></span>`;
+    }
+    class Parent extends Component {
+      static template = xml`<div><Dialog><t t-call="sokka"/></Dialog></div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span><p>sokka</p></span></div>");
+  });
+
+  test("slot and (inline) t-call", async () => {
+    env.qweb.addTemplate("sokka", "<p>sokka</p>");
+    class Dialog extends Component {
+      static template = xml`<span><t t-slot="default"/></span>`;
+    }
+    class Parent extends Component {
+      static template = xml`<div><Dialog t-call="sokka"/></div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span><p>sokka</p></span></div>");
+  });
+
+  test("named slot inside slot", async () => {
+    class Child extends Component {
+      static template = xml`
+        <div>
+          <t t-slot="brol"/>
+          <t t-slot="default"/>
+        </div>`;
+    }
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <Child>
+            <t t-set-slot="brol">
+              <p>A<t t-esc="value"/></p>
+            </t>
+            <Child>
+              <t t-set-slot="brol">
+                <p>B<t t-esc="value"/></p>
+              </t>
+            </Child>
+          </Child>
+        </div>`;
+      static components = { Child };
+      value = "blip";
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><div><p>Ablip</p><div><p>Bblip</p></div></div></div>");
+  });
+
+  test("named slots inside slot, again", async () => {
+    class Child extends Component {
+      static template = xml`
+        <child>
+          <t t-slot="brol1">default1</t>
+          <t t-slot="brol2">default2</t>
+          <t t-slot="default"/>
+        </child>`;
+    }
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <Child>
+            <t t-set-slot="brol1">
+              <p>A<t t-esc="value"/></p>
+            </t>
+            <Child>
+              <t t-set-slot="brol2">
+                <p>B<t t-esc="value"/></p>
+              </t>
+            </Child>
+          </Child>
+        </div>`;
+      static components = { Child };
+      value = "blip";
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(
+      "<div><child><p>Ablip</p>default2<child>default1<p>Bblip</p></child></child></div>"
+    );
+  });
+
+  test("named slot inside slot, part 3", async () => {
+    class Child extends Component {
+      static template = xml`
+        <div>
+          <t t-slot="brol"/>
+          <t t-slot="default"/>
+        </div>`;
+    }
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <Child>
+            <t t-set-slot="brol">
+              <p>A<t t-esc="value"/></p>
+            </t>
+            <Child>
+              <t>
+                <t t-set-slot="brol">
+                  <p>B<t t-esc="value"/></p>
+                </t>
+              </t>
+            </Child>
+          </Child>
+        </div>`;
+      static components = { Child };
+      value = "blip";
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><div><p>Ablip</p><div><p>Bblip</p></div></div></div>");
+  });
+
+  test("dynamic t-slot call", async () => {
+    class Toggler extends Component {
+      static template = xml`<button t-on-click="toggle"><t t-slot="{{current.slot}}"/></button>`;
+      current = useState({ slot: "slot1" });
+      toggle() {
+        this.current.slot = this.current.slot === "slot1" ? "slot2" : "slot1";
+      }
+    }
+
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          <Toggler>
+            <t t-set-slot="slot1"><p>slot1</p><span>content</span></t>
+            <t t-set-slot="slot2"><h1>slot2</h1></t>
+          </Toggler>
+        </div>`;
+      static components = { Toggler };
+    }
+    await mount(Parent, { target: fixture });
+    expect(fixture.innerHTML).toBe("<div><button><p>slot1</p><span>content</span></button></div>");
+
+    fixture.querySelector<HTMLElement>("button")!.click();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><button><h1>slot2</h1></button></div>");
+
+    fixture.querySelector<HTMLElement>("button")!.click();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><button><p>slot1</p><span>content</span></button></div>");
+
+    expect(env.qweb.templates[Toggler.template].fn.toString()).toMatchSnapshot();
+  });
+
+  test("t-slot within dynamic t-call", async () => {
+    let child;
+    class Child extends Component {
+      static template = xml`<div class="child"/>`;
+      constructor(...args) {
+        super(...args);
+        child = this;
+      }
+    }
+
+    class Slotted extends Component {
+      static template = xml`<div class="slotted"><t t-slot="default" /></div>`;
+    }
+
+    class UsingTcallInSlotted extends Component {
+      tcallTemplate = xml`<div class="slot"><Child/></div>`;
+      static template = xml`
+      <div>
+        <Slotted>
+          <t t-call="{{ tcallTemplate }}"/>
+        </Slotted>
+      </div>`;
+      static components = { Slotted, Child };
+    }
+
+    await mount(UsingTcallInSlotted, { target: fixture });
+
+    expect(child.__owl__.parent).toBeInstanceOf(Slotted);
+    expect(fixture.innerHTML).toBe(
+      `<div><div class="slotted"><div class="slot"><div class="child"></div></div></div></div>`
+    );
+  });
+
+  test("t-slot scope context", async () => {
+    expect.assertions(1);
+
+    class Wrapper extends Component {
+      static template = xml`<t t-slot="default"/>`;
+    }
+
+    let dialog;
+
+    class Dialog extends Component {
+      static template = xml`
+        <Wrapper>
+          <div t-on-click="onClick">
+            <t t-slot="default" />
+          </div>
+        </Wrapper>
+      `;
+
+      static components = { Wrapper };
+
+      setup() {
+        dialog = this;
+      }
+
+      onClick(ev) {
+        // we do not use expect(this).toBe(dialog) here because if it fails, it
+        // may blow up jest because it then tries to compute a diff, which is
+        // infinite if there is a cycle
+        expect(this === dialog).toBe(true);
+      }
+    }
+
+    class Parent extends Component {
+      static template = xml`
+        <Dialog>
+            <button>The Button</button>
+        </Dialog>`;
+      static components = { Dialog };
+    }
+
+    await mount(Parent, { target: fixture });
+
+    document.querySelector("button").click();
+    await nextTick();
+  });
+
+  test("t-slot in recursive templates", async () => {
+    QWeb.registerTemplate(
+      "_test_recursive_template",
+      `
+      <Wrapper>
+          <t t-esc="name" />
+          <t t-foreach="items" t-as="item">
+
+            <t t-if="!item.children.length">
+              <t t-esc="item.name" />
+            </t>
+
+            <t t-else="" t-call="_test_recursive_template">
+              <t t-set="name" t-value="item.name" />
+              <t t-set="items" t-value="item.children" />
+            </t>
+
+          </t>
+      </Wrapper>`
+    );
+
+    class Wrapper extends Component {
+      static template = xml`
+        <wrapper>
+          <t t-slot="default"/>
+        </wrapper>`;
+    }
+
+    class Parent extends Component {
+      static template = "_test_recursive_template";
+      static components = { Wrapper };
+      name = "foo";
+      items = [
+        {
+          name: "foo-0",
+          children: [
+            { name: "foo-00", children: [] },
+            {
+              name: "foo-01",
+              children: [
+                { name: "foo-010", children: [] },
+                { name: "foo-011", children: [] },
+                {
+                  name: "foo-012",
+                  children: [
+                    { name: "foo-0120", children: [] },
+                    { name: "foo-0121", children: [] },
+                    { name: "foo-0122", children: [] },
+                  ],
+                },
+              ],
+            },
+            { name: "foo-02", children: [] },
+          ],
+        },
+        { name: "foo-1", children: [] },
+        { name: "foo-2", children: [] },
+      ];
+    }
+
+    await mount(Parent, { target: fixture });
+
+    expect(fixture.innerHTML).toBe(
+      "<wrapper>foo<wrapper>foo-0foo-00<wrapper>foo-01foo-010foo-011<wrapper>foo-012foo-0120foo-0121foo-0122</wrapper></wrapper>foo-02</wrapper>foo-1foo-2</wrapper>"
+    );
+  });
 });

tests/component/un_mounting.test.ts

@@ -1,7 +1,8 @@
-import { Component, Env } from "../../src/component/component";
+import { Component, Env, mount } 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
@@ -36,8 +37,7 @@ describe("mount targets", () => {
     div.innerHTML = `<p>pre-existing</p>`;
     fixture.appendChild(div);
 
-    const app = new App();
-    await app.mount(div, { position: "self" });
+    const app = await mount(App, { target: div, position: "self" });
 
     expect(fixture.innerHTML).toBe(
       `<div class="arbitrary custom"><p>pre-existing</p>app<p>another tag</p></div>`
@@ -65,10 +65,9 @@ describe("mount targets", () => {
     const div = document.createElement("div");
     fixture.appendChild(div);
 
-    const app = new App();
     let error;
     try {
-      await app.mount(div, { position: "self" });
+      await mount(App, { target: div, position: "self" });
     } catch (e) {
       error = e;
     }
@@ -83,8 +82,7 @@ describe("mount targets", () => {
     const span = document.createElement("span");
     fixture.appendChild(span);
 
-    const app = new App();
-    await app.mount(fixture, { position: "first-child" });
+    await mount(App, { target: fixture, position: "first-child" });
     expect(fixture.innerHTML).toBe("<div>app</div><span></span>");
   });
 
@@ -95,8 +93,7 @@ describe("mount targets", () => {
     const span = document.createElement("span");
     fixture.appendChild(span);
 
-    const app = new App();
-    await app.mount(fixture, { position: "last-child" });
+    await mount(App, { target: fixture, position: "last-child" });
     expect(fixture.innerHTML).toBe("<span></span><div>app</div>");
   });
 
@@ -107,8 +104,7 @@ describe("mount targets", () => {
     const span = document.createElement("span");
     fixture.appendChild(span);
 
-    const app = new App();
-    await app.mount(fixture);
+    await mount(App, { target: fixture });
     expect(fixture.innerHTML).toBe("<span></span><div>app</div>");
   });
 });
@@ -132,8 +128,7 @@ describe("unmounting and remounting", () => {
       }
     }
 
-    const w = new MyWidget();
-    await w.mount(fixture);
+    const w = await mount(MyWidget, { target: fixture });
     expect(fixture.innerHTML).toBe("<div>Hey</div>");
     expect(steps).toEqual(["willstart", "mounted"]);
 
@@ -161,8 +156,7 @@ describe("unmounting and remounting", () => {
       }
     }
 
-    const w = new MyWidget();
-    await w.mount(fixture);
+    const w = await mount(MyWidget, { target: fixture });
     await w.mount(fixture);
     expect(fixture.innerHTML).toBe("<div>Hey</div>");
     expect(steps).toEqual(["willstart", "mounted"]);
@@ -202,8 +196,7 @@ describe("unmounting and remounting", () => {
       state = useState({ val: 1, flag: true });
     }
 
-    const widget = new Parent();
-    await widget.mount(fixture);
+    const widget = await mount(Parent, { target: fixture });
     expect(steps).toEqual(["render"]);
     expect(fixture.innerHTML).toBe("<div><span>12</span></div>");
     widget.state.flag = false;
@@ -330,12 +323,60 @@ describe("unmounting and remounting", () => {
     expect(steps).toEqual([2, 2, 3]);
   });
 
+  test("change state and render while mounted in detached dom", async () => {
+    class App extends Component {
+      static template = xml`<div><t t-esc="state.val"/></div>`;
+      state = useState({ val: 1 });
+    }
+
+    const detachedDiv = document.createElement("div");
+    const app = await mount(App, { target: detachedDiv });
+
+    expect(detachedDiv.innerHTML).toBe("<div>1</div>");
+    app.state.val = 2;
+    await nextTick();
+    expect(detachedDiv.innerHTML).toBe("<div>2</div>");
+  });
+
+  test("change state and render while not mounted ", async () => {
+    class App extends Component {
+      static template = xml`<div><t t-esc="state.val"/></div>`;
+      state = useState({ val: 1 });
+    }
+
+    const app = new App(null);
+
+    app.state.val = 2; // will call the render method (before being mounted)
+    await nextTick();
+
+    await app.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div>2</div>");
+  });
+
+  test("destroy and change state after mounted in detached dom", async () => {
+    class App extends Component {
+      static template = xml`<div><t t-esc="state.val"/></div>`;
+      state = useState({ val: 1 });
+    }
+
+    const detachedDiv = document.createElement("div");
+    const app = await mount(App, { target: detachedDiv });
+
+    expect(detachedDiv.innerHTML).toBe("<div>1</div>");
+
+    app.destroy();
+    app.state.val = 2;
+    await nextTick();
+    expect(detachedDiv.innerHTML).toBe("");
+  });
+
   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"
+        val: "C1",
       });
       constructor(parent, props) {
         super(parent, props);
@@ -363,6 +404,40 @@ describe("unmounting and remounting", () => {
     expect(fixture.innerHTML).toBe("<div>P2<span>C2</span></div>");
   });
 
+  test("change state while component is mounted in a fragment", async () => {
+    class Child1 extends Component {
+      static template = xml`<span>C1</span>`;
+    }
+
+    class Child2 extends Component {
+      static template = xml`<span>C2</span>`;
+    }
+
+    class Parent extends Component {
+      static components = { Child1, Child2 };
+      static template = xml`
+        <div>
+          <Child1 t-if="child == 'c1'"/>
+          <Child2 t-if="child == 'c2'"/>
+        </div>`;
+      child: string | false = false;
+    }
+
+    const fragment = document.createDocumentFragment();
+    const parent = new Parent();
+    await parent.mount(fragment);
+    expect(parent.el.outerHTML).toBe("<div></div>");
+
+    parent.child = "c1";
+    parent.render();
+    await Promise.resolve();
+
+    parent.child = "c2";
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>C2</span></div>");
+  });
+
   test("unmount component during a re-rendering", async () => {
     const def = makeDeferred();
     class Child extends Component {
@@ -449,17 +524,17 @@ describe("unmounting and remounting", () => {
     // one full tick.
     await nextMicroTick();
     await nextMicroTick();
-    expect(steps).toEqual(["1 catch"]);
+    expect(steps).toEqual([]);
     await nextTick();
     expect(fixture.innerHTML).toBe("<div></div><span></span>");
 
     def.resolve();
     await nextTick();
-    expect(steps).toEqual(["1 catch", "2 resolved"]);
+    expect(steps).toEqual(["2 resolved"]);
     expect(fixture.innerHTML).toBe("<div></div><span><div>Hey</div></span>");
   });
 
-  test("widget can be mounted on same target, another situation", async () => {
+  test("component can be mounted on same target, another situation", async () => {
     const def = makeDeferred();
     const steps: string[] = [];
 
@@ -487,7 +562,171 @@ describe("unmounting and remounting", () => {
 
     def.resolve();
     await nextTick();
-    expect(steps).toEqual(["1 resolved", "2 resolved"]);
     expect(fixture.innerHTML).toBe("<div>Hey</div>");
+    expect(steps).toEqual(["1 resolved", "2 resolved"]);
+  });
+
+  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");
+  });
+
+  test("destroying a sub-component cleans itself from parent's vnode", async () => {
+    class C1 extends Component {
+      static template = xml`<div><div><t t-esc="props.a"/></div></div>`;
+    }
+    class P extends Component {
+      static components = { C1 };
+      static template = xml`<div><div><C1 t-props="state" t-if="state.a"/></div></div>`;
+      state = {
+        a: "first",
+      };
+    }
+    const parent = new P();
+    await parent.mount(fixture);
+    expect(fixture.textContent).toBe("first");
+    parent.unmount();
+    parent.state.a = "";
+    parent.mount(fixture);
+    parent.state.a = "fixed";
+    await parent.render();
+    expect(fixture.textContent).toBe("fixed");
+  });
+
+  test("destroying a sub-component cleans itself from parent's vnode, part 2", async () => {
+    class C1 extends Component {
+      static template = xml`<div><div><t t-esc="props.a"/></div></div>`;
+    }
+    class P extends Component {
+      static components = { C1 };
+      static template = xml`<div><div><C1 t-props="state" t-if="state.a"/>some text</div></div>`;
+      state = {
+        a: "first",
+      };
+    }
+    const parent = new P();
+    await parent.mount(fixture);
+    expect(fixture.textContent).toBe("firstsome text");
+    parent.unmount();
+    parent.state.a = "";
+    parent.mount(fixture);
+    parent.state.a = "fixed";
+    await parent.render();
+    expect(fixture.textContent).toBe("fixedsome text");
+  });
+
+  test("destroying a sub-component cleans itself from parent's vnode, part 3", async () => {
+    class C1 extends Component {
+      static template = xml`<div><div><t t-esc="props.a"/></div></div>`;
+    }
+
+    class C2 extends Component {
+      static template = xml`<C1 a="props.a"/>`;
+      static components = { C1 };
+    }
+
+    class P extends Component {
+      static components = { C2 };
+      static template = xml`<div><div><C2 t-props="state" t-if="state.a"/></div></div>`;
+      state = {
+        a: "first",
+      };
+    }
+    const parent = new P();
+    await parent.mount(fixture);
+    expect(fixture.textContent).toBe("first");
+    parent.unmount();
+    parent.state.a = "";
+    parent.mount(fixture);
+    parent.state.a = "fixed";
+    await parent.render();
+    expect(fixture.textContent).toBe("fixed");
+  });
+
+  test("destroying a sub-component cleans itself from parent's vnode, part 4", async () => {
+    class C1 extends Component {
+      static template = xml`<div><div><t t-esc="props.a"/></div></div>`;
+    }
+
+    class C2 extends Component {
+      static template = xml`<C1 a="props.a"/>`;
+      static components = { C1 };
+    }
+    class P extends Component {
+      static components = { C2 };
+      static template = xml`<div><div><C2 t-props="state" t-if="state.a"/>some text</div></div>`;
+      state = {
+        a: "first",
+      };
+    }
+    const parent = new P();
+    await parent.mount(fixture);
+    expect(fixture.textContent).toBe("firstsome text");
+    parent.unmount();
+    parent.state.a = "";
+    parent.mount(fixture);
+    parent.state.a = "fixed";
+    await parent.render();
+    expect(fixture.textContent).toBe("fixedsome text");
+  });
+
+  test("remounting component tree where a component implement shouldupdate", async () => {
+    let state: any;
+    const steps = [];
+    class Child extends Component {
+      static template = xml`<div><t t-esc="state.word"/><t t-esc="props.name"/></div>`;
+
+      state = useState({ word: "hello" });
+
+      constructor(parent, props) {
+        super(parent, props);
+        state = this.state;
+      }
+      patched() {
+        steps.push("patched");
+      }
+      mounted() {
+        steps.push("mounted");
+      }
+      willUnmount() {
+        steps.push("willUnmount");
+      }
+      shouldUpdate() {
+        return false;
+      }
+    }
+
+    class Parent extends Component {
+      static template = xml`<div><Child name="state.name"/></div>`;
+      static components = { Child };
+      state = useState({ name: "World" });
+    }
+
+    const parent = await mount(Parent, { target: fixture });
+    expect(fixture.innerHTML).toBe("<div><div>helloWorld</div></div>");
+
+    parent.unmount();
+    expect(fixture.innerHTML).toBe("");
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>helloWorld</div></div>");
+
+    state.word = "test";
+
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div>testWorld</div></div>");
+    expect(steps).toEqual(["mounted", "willUnmount", "mounted", "patched"]);
   });
 });

tests/context.test.ts

@@ -289,7 +289,26 @@ describe("Context", () => {
     expect(testContext.subscriptions.update.length).toBe(0);
   });
 
-  test("concurrent renderings", async () => {
+  test.skip("concurrent renderings", async () => {
+    /**
+     * Note: this test is interesting, but sadly just an incomplete attempt at
+     * protecting users against themselves.  With the context API, it is not
+     * possible for the framework to protect completely against crashes.  Maybe
+     * like in this case, when a component is in a simple hierarchy where all
+     * renderings come from the context changes, but in a real case, where some
+     * code can trigger a rendering independently, it is insufficient.
+     *
+     * The main problem is that the sub component depends on some external state,
+     * which may be modified, and then incompatible with the component actual
+     * state (for example, if the sub component has an id key related to some
+     * object that has been removed from the context).
+     *
+     * For now, sadly, the only solution is that components that depends on external
+     * state should guarantee their own integrity themselves. Then maybe this
+     * could be solved at the level of a state management solution that has a
+     * more advanced API, to let components determine if they should be updated
+     * or not (so, something slightly more advanced that the useStore hook).
+     */
     const testContext = new Context({ x: { n: 1 }, key: "x" });
     const def = makeDeferred();
     let stateC;

tests/core/event_bus.test.ts

@@ -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");

tests/core/observer.test.ts

@@ -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,
     });
   });
 
@@ -68,6 +68,23 @@ describe("observer", () => {
     expect(obj.date).not.toBe(date);
   });
 
+  test("properly handle promises (i.e.: treat them like primitive values", async () => {
+    const observer = new Observer();
+    let resolved = false;
+    const prom = new Promise((r) => r());
+    const obj: any = observer.observe({ prom });
+    expect(obj.prom).toBeInstanceOf(Promise);
+
+    obj.prom.then(() => (resolved = true));
+
+    expect(observer.revNumber(obj)).toBe(1);
+
+    expect(resolved).toBe(false);
+    await Promise.resolve();
+    expect(resolved).toBe(true);
+    expect(observer.revNumber(obj)).toBe(1);
+  });
+
   test("can change values in array", () => {
     const observer = new Observer();
     const obj: any = observer.observe({ arr: [1, 2] });

tests/helpers.ts

@@ -1,4 +1,4 @@
-import { Env, Component } from "../src/component/component";
+import { Env, Component, STATUS } from "../src/component/component";
 import { scheduler } from "../src/component/scheduler";
 import { EvalContext, QWeb } from "../src/qweb/qweb";
 import { CompilationContext } from "../src/qweb/compilation_context";
@@ -8,12 +8,6 @@ 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) {
-  setTimeout(callback, 1);
-  return 1;
-};
-
 // Some static cleanup
 let nextSlotId;
 let slots;
@@ -43,9 +37,13 @@ export function nextMicroTick(): Promise<void> {
 }
 
 export async function nextTick(): Promise<void> {
-  return new Promise(function(resolve) {
-    setTimeout(() => scheduler.requestAnimationFrame(() => resolve()));
-  });
+  await new Promise((resolve) => setTimeout(resolve));
+  await new Promise((resolve) => scheduler.requestAnimationFrame(resolve));
+}
+
+export async function nextFrame(): Promise<void> {
+  await new Promise((resolve) => scheduler.requestAnimationFrame(resolve));
+  await new Promise((resolve) => scheduler.requestAnimationFrame(resolve));
 }
 
 export function makeTestFixture() {
@@ -77,7 +75,7 @@ export function makeDeferred(): Deferred {
 export function makeTestEnv(): Env {
   return {
     qweb: new QWeb(),
-    browser: browser
+    browser: browser,
   };
 }
 
@@ -94,7 +92,7 @@ export function renderToDOM(
   if (!context.__owl__) {
     // we add `__owl__` to better simulate a component as context.  This is
     // particularly important for event handlers added with the `t-on` directive.
-    context.__owl__ = { isMounted: true };
+    context.__owl__ = { status: STATUS.MOUNTED };
   }
   const vnode = qweb.render(template, context, extra);
 
@@ -134,7 +132,7 @@ export function renderToString(
 // is useful for animations tests, as we hook before repaints to trigger
 // animations (thanks to requestAnimationFrame). Patching nextFrame allows to
 // simulate calls to this hook. One must not forget to unpatch afterwards.
-let nextFrame = QWeb.utils.nextFrame;
+let _nextFrame = QWeb.utils.nextFrame;
 export function patchNextFrame(f: Function) {
   QWeb.utils.nextFrame = (cb: () => void) => {
     setTimeout(() => f(cb));
@@ -142,7 +140,7 @@ export function patchNextFrame(f: Function) {
 }
 
 export function unpatchNextFrame() {
-  QWeb.utils.nextFrame = nextFrame;
+  QWeb.utils.nextFrame = _nextFrame;
 }
 
 export async function editInput(input: HTMLInputElement | HTMLTextAreaElement, value: string) {

tests/hooks.test.ts

@@ -9,8 +9,10 @@ import {
   onWillPatch,
   onWillStart,
   onWillUpdateProps,
+  useEnv,
   useSubEnv,
-  useExternalListener
+  useExternalListener,
+  useComponent,
 } from "../src/hooks";
 import { xml } from "../src/tags";
 
@@ -214,7 +216,7 @@ describe("hooks", () => {
       "hook:mounted1",
       "hook:mounted2",
       "hook:willunmount2",
-      "hook:willunmount1"
+      "hook:willunmount1",
     ]);
   });
 
@@ -267,7 +269,7 @@ describe("hooks", () => {
     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();
@@ -520,6 +522,19 @@ describe("hooks", () => {
     });
   });
 
+  test("can use useEnv", async () => {
+    expect.assertions(1);
+    class TestComponent extends Component {
+      static template = xml`<div><t t-esc="env.val"/></div>`;
+      constructor() {
+        super();
+        expect(useEnv()).toBe(env);
+      }
+    }
+    const component = new TestComponent();
+    await component.mount(fixture);
+  });
+
   test("can use sub env", async () => {
     class TestComponent extends Component {
       static template = xml`<div><t t-esc="env.val"/></div>`;
@@ -535,6 +550,19 @@ describe("hooks", () => {
     expect(component.env).toHaveProperty("val");
   });
 
+  test("can use useComponent", async () => {
+    expect.assertions(1);
+    class TestComponent extends Component {
+      static template = xml`<div></div>`;
+      constructor() {
+        super();
+        expect(useComponent()).toBe(this);
+      }
+    }
+    const component = new TestComponent();
+    await component.mount(fixture);
+  });
+
   test("parent and child env", async () => {
     class Child extends Component {
       static template = xml`<div><t t-esc="env.val"/></div>`;
@@ -560,7 +588,7 @@ describe("hooks", () => {
   test("can use onWillStart, onWillUpdateProps", async () => {
     const steps: string[] = [];
     async function slow(): Promise<string> {
-      return new Promise(resolve => {
+      return new Promise((resolve) => {
         setTimeout(() => {
           resolve("slow");
         }, 0);
@@ -571,7 +599,7 @@ describe("hooks", () => {
         steps.push(await slow());
         steps.push("onWillStart");
       });
-      onWillUpdateProps(async nextProps => {
+      onWillUpdateProps(async (nextProps) => {
         expect(nextProps).toEqual({ value: 2 });
         steps.push(await slow());
         steps.push("onWillUpdateProps");
@@ -581,7 +609,7 @@ describe("hooks", () => {
       onWillStart(() => {
         steps.push("on2ndStart");
       });
-      onWillUpdateProps(nextProps => {
+      onWillUpdateProps((nextProps) => {
         expect(nextProps).toEqual({ value: 2 });
         steps.push("on2ndUpdate");
       });
@@ -623,7 +651,7 @@ describe("hooks", () => {
       "onWillStart",
       "on2ndUpdate",
       "slow",
-      "onWillUpdateProps"
+      "onWillUpdateProps",
     ]);
   });
 

tests/misc/portal.test.ts

@@ -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,7 +515,7 @@ describe("Portal: Basic use and DOM placement", () => {
       "parent:patched",
       "parent:willPatch",
       "child:willUnmount",
-      "parent:patched"
+      "parent:patched",
     ]);
   });
 
@@ -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);

tests/qweb/__snapshots__/qweb_t_att.test.ts.snap

@@ -0,0 +1,29 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`qweb t-att t-att-class with multiple classes 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let utils = this.constructor.utils;
+    let scope = Object.create(context);
+    let h = this.h;
+    let _1 = utils.toClassObj({'a b c':scope['value']});
+    let c2 = [], p2 = {key:2,class:_1};
+    let vn2 = h('div', p2, c2);
+    return vn2;
+}"
+`;
+
+exports[`qweb t-att t-att-class with multiple classes 2`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let utils = this.constructor.utils;
+    let scope = Object.create(context);
+    let h = this.h;
+    let _3 = utils.toClassObj({['a b c']:scope['value']});
+    let c4 = [], p4 = {key:4,class:_3};
+    let vn4 = h('div', p4, c4);
+    return vn4;
+}"
+`;

tests/qweb/__snapshots__/qweb_t_tag.test.ts.snap

@@ -0,0 +1,71 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`qweb t-tag simple usecases 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let scope = Object.create(context);
+    let result;
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let tag2 = 'div';
+    let vn1 = h(tag2, p1, c1);
+    result = vn1;
+    return result;
+}"
+`;
+
+exports[`qweb t-tag simple usecases 2`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let scope = Object.create(context);
+    let result;
+    let h = this.h;
+    let c3 = [], p3 = {key:3};
+    let tag4 = scope['tag'];
+    let vn3 = h(tag4, p3, c3);
+    result = vn3;
+    c3.push({text: \`text\`});
+    return result;
+}"
+`;
+
+exports[`qweb t-tag with multiple attributes 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let scope = Object.create(context);
+    let result;
+    let h = this.h;
+    let _2 = {'blueberry':true};
+    let _3 = 'raspberry';
+    let c4 = [], p4 = {key:4,attrs:{taste: _3},class:_2};
+    let tag5 = scope['tag'];
+    let vn4 = h(tag5, p4, c4);
+    result = vn4;
+    c4.push({text: \`gooseberry\`});
+    return result;
+}"
+`;
+
+exports[`qweb t-tag with multiple child nodes 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let scope = Object.create(context);
+    let result;
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let tag2 = scope['tag'];
+    let vn1 = h(tag2, p1, c1);
+    result = vn1;
+    c1.push({text: \` pear \`});
+    let c3 = [], p3 = {key:3};
+    let vn3 = h('span', p3, c3);
+    c1.push(vn3);
+    c3.push({text: \`apple\`});
+    c1.push({text: \` strawberry \`});
+    return result;
+}"
+`;

tests/qweb/qweb.test.ts

@@ -31,6 +31,21 @@ describe("static templates", () => {
     expect(renderToString(qweb, "test", { text: "hello vdom" })).toBe("hello vdom");
   });
 
+  test("inline template string in t-esc", () => {
+    qweb.addTemplate("test", '<t><t t-esc="`text`"/></t>');
+    expect(renderToString(qweb, "test")).toBe("text");
+  });
+
+  test("inline template string with content in t-esc", () => {
+    qweb.addTemplate("test", '<t><t t-set="v" t-value="1"/><t t-esc="`text${v}`"/></t>');
+    expect(renderToString(qweb, "test")).toBe("text1");
+  });
+
+  test("inline template string with variable in context", () => {
+    qweb.addTemplate("test", '<t><t t-esc="`text ${v}`"/></t>');
+    expect(renderToString(qweb, "test", { v: "from context" })).toBe("text from context");
+  });
+
   test("simple string, with some dynamic value", () => {
     qweb.addTemplate("test", '<t>hello <t t-esc="text"/></t>');
     expect(renderToString(qweb, "test", { text: "vdom" })).toBe("hello vdom");
@@ -195,7 +210,7 @@ describe("t-esc", () => {
       v2: undefined,
       v3: null,
       v4: 0,
-      v5: ""
+      v5: "",
     };
     expect(renderToString(qweb, "test", vals)).toBe(
       "<div><p>false</p><p></p><p></p><p>0</p><p></p></div>"
@@ -207,6 +222,13 @@ describe("t-esc", () => {
     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", () => {
@@ -231,6 +253,13 @@ describe("t-raw", () => {
       "<span><span>hello</span><ok>world</ok></span>"
     );
   });
+
+  test("t-raw with comment", () => {
+    qweb.addTemplate("test", `<span><t t-raw="var"/></span>`);
+    expect(renderToString(qweb, "test", { var: "<p>text<!-- top secret --></p>" })).toBe(
+      "<span><p>text<!-- top secret --></p></span>"
+    );
+  });
 });
 
 describe("t-set", () => {
@@ -486,7 +515,7 @@ describe("t-if", () => {
       cond3: false,
       cond4: false,
       m: 5,
-      n: 2
+      n: 2,
     };
     expect(normalize(renderToString(qweb, "test", context))).toBe("<div>andormgtnlt</div>");
   });
@@ -625,7 +654,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>`);
   });
@@ -684,7 +713,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>`);
   });
@@ -703,7 +732,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);
@@ -715,6 +744,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 });
@@ -734,7 +769,7 @@ describe("t-call (template calling", () => {
     qweb.addTemplate("caller", '<div><t t-call="_basic-callee"/></div>');
     const expected = "<div><span>ok</span></div>";
     expect(renderToString(qweb, "caller")).toBe(expected);
-    expect(qweb.subTemplates["_basic-callee"].toString()).toMatchSnapshot();
+    expect(qweb.subTemplates["_basic-callee"]).toBeTruthy();
   });
 
   test("basic caller, no parent node", () => {
@@ -742,7 +777,7 @@ describe("t-call (template calling", () => {
     qweb.addTemplate("caller", '<t t-call="_basic-callee"/>');
     const expected = "<div>ok</div>";
     expect(renderToString(qweb, "caller")).toBe(expected);
-    expect(qweb.subTemplates["_basic-callee"].toString()).toMatchSnapshot();
+    expect(qweb.subTemplates["_basic-callee"]).toBeTruthy();
   });
 
   test("t-call with t-if", () => {
@@ -750,13 +785,14 @@ describe("t-call (template calling", () => {
     qweb.addTemplate("caller", '<div><t t-if="flag" t-call="sub"/></div>');
     const expected = "<div><span>ok</span></div>";
     expect(renderToString(qweb, "caller", { flag: true })).toBe(expected);
-    expect(qweb.subTemplates["sub"].toString()).toMatchSnapshot();
+    expect(qweb.subTemplates["sub"]).toBeTruthy();
   });
 
-  test("t-call not allowed on a non t node", () => {
-    qweb.addTemplate("_basic-callee", "<t>ok</t>");
+  test("t-call allowed on a non t node", () => {
+    qweb.addTemplate("_basic-callee", "<span>ok</span>");
     qweb.addTemplate("caller", '<div t-call="_basic-callee"/>');
-    expect(() => renderToString(qweb, "caller")).toThrow("Invalid tag");
+    const expected = "<div><span>ok</span></div>";
+    expect(renderToString(qweb, "caller")).toBe(expected);
   });
 
   test("with unused body", () => {
@@ -885,7 +921,8 @@ describe("t-call (template calling", () => {
     `);
     const expected = "<div><span>hey</span></div>";
     expect(renderToString(qweb, "recursive")).toBe(expected);
-    const recursiveFn = Object.values(qweb.subTemplates)[0] as any;
+    const subId = qweb.subTemplates["recursive"];
+    const recursiveFn = QWeb.subTemplates[subId] as any;
     expect(recursiveFn.toString()).toMatchSnapshot();
   });
 
@@ -913,7 +950,8 @@ describe("t-call (template calling", () => {
     expect(renderToString(qweb, "Parent", { root }, { fiber: { vars: {}, scope: {} } })).toBe(
       expected
     );
-    const recursiveFn = Object.values(qweb.subTemplates)[0] as any;
+    const subId = qweb.subTemplates["nodeTemplate"];
+    const recursiveFn = QWeb.subTemplates[subId] as any;
     expect(recursiveFn.toString()).toMatchSnapshot();
   });
 
@@ -940,7 +978,8 @@ describe("t-call (template calling", () => {
     const expected =
       "<div><div><p>a</p><div><p>b</p><div><p>d</p></div></div><div><p>c</p></div></div></div>";
     expect(renderToString(qweb, "Parent", { root }, { fiber: {} })).toBe(expected);
-    const recursiveFn = Object.values(qweb.subTemplates)[0] as any;
+    const subId = qweb.subTemplates["nodeTemplate"];
+    const recursiveFn = QWeb.subTemplates[subId] as any;
     expect(recursiveFn.toString()).toMatchSnapshot();
   });
 
@@ -967,12 +1006,13 @@ describe("t-call (template calling", () => {
     `);
     const root = {
       val: "a",
-      children: [{ val: "b", children: [{ val: "c", children: [{ val: "d" }] }] }]
+      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;
+    const subId = qweb.subTemplates["nodeTemplate"];
+    const recursiveFn = QWeb.subTemplates[subId] as any;
     expect(recursiveFn.toString()).toMatchSnapshot();
   });
 
@@ -1044,6 +1084,52 @@ describe("t-call (template calling", () => {
     const context = { list: [{ val: 1 }, { val: 2 }, { val: 3 }] };
     expect(trim(renderToString(qweb, "wrapper", context))).toBe(expected);
   });
+
+  test("two different QWeb instances, and shared templates", () => {
+    QWeb.registerTemplate("sub", `<span>ok</span>`);
+    QWeb.registerTemplate("main", `<div><t t-call="sub"/></div>`);
+
+    const qweb1 = new QWeb();
+    const qweb2 = new QWeb();
+
+    expect(renderToString(qweb1, "main")).toBe("<div><span>ok</span></div>");
+    expect(renderToString(qweb2, "main")).toBe("<div><span>ok</span></div>");
+  });
+
+  test("t-call with t-set inside and body text content", () => {
+    qweb.addTemplate("sub", `<p><t t-esc="val"/></p>`);
+    qweb.addTemplate(
+      "main",
+      `
+      <div>
+        <t t-call="sub">
+          <t t-set="val">yip yip</t>
+        </t>
+      </div>`
+    );
+    const expected = "<div><p>yip yip</p></div>";
+    expect(renderToString(qweb, "main")).toBe(expected);
+  });
+
+  test("t-call with body content as root of a template", () => {
+    qweb.addTemplate("antony", `<foo><t t-raw="0"/></foo>`);
+    qweb.addTemplate("main", `<t><t t-call="antony"><p>antony</p></t></t>`);
+    const expected = "<foo><p>antony</p></foo>";
+    expect(renderToString(qweb, "main")).toBe(expected);
+  });
+
+  test("dynamic t-call", () => {
+    qweb.addTemplate("foo", `<foo><t t-esc="val"/></foo>`);
+    qweb.addTemplate("bar", `<bar><t t-esc="val"/></bar>`);
+    qweb.addTemplate("main", `<div><t t-call="{{template}}"/></div>`);
+    const expected = "<div><foo>foo</foo></div>";
+    expect(renderToString(qweb, "main", { template: "foo", val: "foo" })).toBe(expected);
+    const expected2 = "<div><bar>quux</bar></div>";
+    expect(renderToString(qweb, "main", { template: "bar", val: "quux" })).toBe(expected2);
+    // duplicate call because there was a specific bug with some id that was
+    // incremented each rendering.
+    expect(renderToString(qweb, "main", { template: "bar", val: "quux" })).toBe(expected2);
+  });
 });
 
 describe("foreach", () => {
@@ -1134,6 +1220,63 @@ describe("foreach", () => {
     );
   });
 
+  test("t-call without body in t-foreach in t-foreach", () => {
+    qweb.addTemplate(
+      "test_called",
+      `<t>
+        <t t-set="c" t-value="'x' + '_' + a + '_'+ b" />
+        [<t t-esc="a" />]
+        [<t t-esc="b" />]
+        [<t t-esc="c" />]
+       </t>`
+    );
+    qweb.addTemplate(
+      "test",
+      `<div>
+        <t t-foreach="numbers" t-as="a">
+          <t t-foreach="letters" t-as="b">
+            <t t-call="test_called" />
+          </t>
+          <span t-esc="c"/>
+        </t>
+        <span>[<t t-esc="a" />][<t t-esc="b" />][<t t-esc="c" />]</span>
+      </div>`
+    );
+    const context = { numbers: [1, 2, 3], letters: ["a", "b"] };
+    expect(renderToString(qweb, "test", context)).toBe(
+      "<div> [1] [a] [x_1_a]  [1] [b] [x_1_b] <span></span> [2] [a] [x_2_a]  [2] [b] [x_2_b] <span></span> [3] [a] [x_3_a]  [3] [b] [x_3_b] <span></span><span>[][][]</span></div>"
+    );
+  });
+
+  test("t-call with body in t-foreach in t-foreach", () => {
+    qweb.addTemplate(
+      "test_called",
+      `<t>
+        [<t t-esc="a" />]
+        [<t t-esc="b" />]
+        [<t t-esc="c" />]
+       </t>`
+    );
+    qweb.addTemplate(
+      "test",
+      `<div>
+        <t t-foreach="numbers" t-as="a">
+          <t t-foreach="letters" t-as="b">
+            <t t-call="test_called" >
+              <t t-set="c" t-value="'x' + '_' + a + '_'+ b" />
+            </t>
+          </t>
+          <span t-esc="c"/>
+        </t>
+        <span>[<t t-esc="a" />][<t t-esc="b" />][<t t-esc="c" />]</span>
+      </div>`
+    );
+    const context = { numbers: [1, 2, 3], letters: ["a", "b"] };
+    expect(renderToString(qweb, "test", context)).toBe(
+      "<div> [1] [a] [x_1_a]  [1] [b] [x_1_b] <span></span> [2] [a] [x_2_a]  [2] [b] [x_2_b] <span></span> [3] [a] [x_3_a]  [3] [b] [x_3_b] <span></span><span>[][][]</span></div>"
+    );
+  });
+
   test("throws error if invalid loop expression", () => {
     qweb.addTemplate(
       "test",
@@ -1229,7 +1372,7 @@ describe("t-on", () => {
       {
         add() {
           a = 3;
-        }
+        },
       },
       { handlers: [] }
     );
@@ -1252,7 +1395,7 @@ describe("t-on", () => {
         },
         handleDblClick() {
           steps.push("dblclick");
-        }
+        },
       },
       { handlers: [] }
     );
@@ -1272,7 +1415,7 @@ describe("t-on", () => {
       {
         add(n) {
           a = a + n;
-        }
+        },
       },
       { handlers: [] }
     );
@@ -1289,7 +1432,7 @@ describe("t-on", () => {
       {
         add({ val }) {
           a = a + val;
-        }
+        },
       },
       { handlers: [] }
     );
@@ -1306,7 +1449,7 @@ describe("t-on", () => {
       {
         doSomething(arg) {
           expect(arg).toEqual({});
-        }
+        },
       },
       { handlers: [] }
     );
@@ -1322,7 +1465,7 @@ describe("t-on", () => {
       {
         doSomething(arg) {
           expect(arg).toEqual({});
-        }
+        },
       },
       { handlers: [] }
     );
@@ -1344,7 +1487,7 @@ describe("t-on", () => {
       {
         activate(action) {
           expect(action).toBe("someval");
-        }
+        },
       },
       { handlers: [] }
     );
@@ -1357,7 +1500,7 @@ describe("t-on", () => {
     let owner = {
       add() {
         expect(this).toBe(owner);
-      }
+      },
     };
     const node = renderToDOM(qweb, "test", owner, { handlers: [] });
     (<HTMLElement>node).click();
@@ -1367,8 +1510,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);
@@ -1381,10 +1524,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);
@@ -1396,8 +1539,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);
@@ -1414,8 +1557,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);
@@ -1431,7 +1574,7 @@ describe("t-on", () => {
     let owner = {
       update() {
         expect(this).toBe(owner);
-      }
+      },
     };
 
     const node = renderToDOM(qweb, "main", owner, { handlers: [] });
@@ -1448,7 +1591,7 @@ describe("t-on", () => {
         expect(this).toBe(owner);
         expect(val).toBe(444);
       },
-      value: 444
+      value: 444,
     };
 
     const node = renderToDOM(qweb, "main", owner, { handlers: [] });
@@ -1477,7 +1620,7 @@ describe("t-on", () => {
       onClickPreventedAndStopped(e) {
         expect(e.defaultPrevented).toBe(true);
         expect(e.cancelBubble).toBe(true);
-      }
+      },
     };
     const node = renderToDOM(qweb, "test", owner, { handlers: [] });
 
@@ -1503,7 +1646,7 @@ describe("t-on", () => {
       },
       onClickSelf(e) {
         steps.push("onClickSelf");
-      }
+      },
     };
     const node = renderToDOM(qweb, "test", owner, { handlers: [] });
 
@@ -1527,10 +1670,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);
     });
 
@@ -1552,10 +1695,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);
     });
 
@@ -1583,13 +1726,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: [] });
@@ -1614,7 +1757,7 @@ describe("t-on", () => {
     );
     const node = renderToDOM(qweb, "test", {}, { handlers: [] });
 
-    node.addEventListener("click", e => {
+    node.addEventListener("click", (e) => {
       expect(e.defaultPrevented).toBe(true);
     });
 
@@ -1630,7 +1773,7 @@ describe("t-on", () => {
       text: "Click here",
       onClick() {
         steps.push("onClick");
-      }
+      },
     };
 
     const node = <HTMLElement>renderToDOM(qweb, "test", owner, { handlers: [] });
@@ -1649,7 +1792,7 @@ describe("t-on", () => {
       html: "Click <b>here</b>",
       onClick() {
         steps.push("onClick");
-      }
+      },
     };
 
     const node = <HTMLElement>renderToDOM(qweb, "test", owner, { handlers: [] });
@@ -1676,7 +1819,7 @@ describe("t-on", () => {
       },
       doSomething() {
         steps.push("normal");
-      }
+      },
     };
     const node = renderToDOM(qweb, "test", owner, { handlers: [] });
 
@@ -1749,7 +1892,7 @@ describe("loading templates", () => {
   });
 });
 
-describe("special cases for some boolean html attributes/properties", () => {
+describe("special cases for some specific html attributes/properties", () => {
   test("input type= checkbox, with t-att-checked", () => {
     qweb.addTemplate("test", `<input type="checkbox" t-att-checked="flag"/>`);
     const result = renderToString(qweb, "test", { flag: true });
@@ -1776,6 +1919,76 @@ describe("special cases for some boolean html attributes/properties", () => {
     );
     renderToString(qweb, "test", { flag: true });
   });
+
+  test("input with t-att-value", () => {
+    // render input with initial value
+    qweb.addTemplate("test", `<input  t-att-value="v"/>`);
+    const vnode1 = qweb.render("test", { v: "zucchini" });
+    const vnode2 = patch(document.createElement("input"), vnode1);
+    let elm = vnode2.elm as HTMLInputElement;
+    expect(elm.value).toBe("zucchini");
+
+    // change value manually in input, to simulate user input
+    elm.value = "tomato";
+    expect(elm.value).toBe("tomato");
+
+    // rerender with a different value, and patch actual dom, to check that
+    // input value was properly reset by owl
+    const vnode3 = qweb.render("test", { v: "potato" });
+    patch(vnode2, vnode3);
+    expect(elm.value).toBe("potato");
+  });
+
+  test("input of type checkbox with t-att-indeterminate", () => {
+    qweb.addTemplate("test", `<input type="checkbox" t-att-indeterminate="v"/>`);
+    const vnode1 = qweb.render("test", { v: true });
+    const vnode2 = patch(document.createElement("input"), vnode1);
+    let elm = vnode2.elm as HTMLInputElement;
+    expect(elm.indeterminate).toBe(true);
+  });
+
+  test("textarea with t-att-value", () => {
+    // render input with initial value
+    qweb.addTemplate("test", `<textarea  t-att-value="v"/>`);
+    const vnode1 = qweb.render("test", { v: "zucchini" });
+    const vnode2 = patch(document.createElement("textarea"), vnode1);
+    let elm = vnode2.elm as HTMLInputElement;
+    expect(elm.value).toBe("zucchini");
+
+    // change value manually in textarea, to simulate user textarea
+    elm.value = "tomato";
+    expect(elm.value).toBe("tomato");
+
+    // rerender with a different value, and patch actual dom, to check that
+    // textarea value was properly reset by owl
+    const vnode3 = qweb.render("test", { v: "potato" });
+    patch(vnode2, vnode3);
+    expect(elm.value).toBe("potato");
+  });
+
+  test("select with t-att-value", () => {
+    const template = `
+      <select t-att-value="value">
+        <option value="potato">Potato</option>
+        <option value="tomato">Tomato</option>
+        <option value="onion">Onion</option>
+      </select>`;
+    qweb.addTemplate("test", template);
+    const vnode1 = qweb.render("test", { value: "tomato" });
+    const vnode2 = patch(document.createElement("select"), vnode1);
+    let elm = vnode2.elm as HTMLSelectElement;
+    expect(elm.value).toBe("tomato");
+
+    elm.value = "potato";
+    expect(elm.value).toBe("potato");
+
+    // rerender with a different value, and patch actual dom, to check that
+    // select value was properly reset by owl
+    const vnode3 = qweb.render("test", { value: "onion" });
+    patch(vnode2, vnode3);
+    expect(elm.value).toBe("onion");
+    expect(qweb.templates.test.fn.toString()).toMatchSnapshot();
+  });
 });
 
 describe("whitespace handling", () => {
@@ -1840,7 +2053,7 @@ describe("t-key", () => {
     );
     expect(
       renderToString(qweb, "test", {
-        beers: [{ id: 12, name: "Chimay Rouge" }]
+        beers: [{ id: 12, name: "Chimay Rouge" }],
       })
     ).toMatchSnapshot();
   });
@@ -1953,9 +2166,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>");
@@ -1963,9 +2176,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",
@@ -1980,9 +2193,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",
@@ -1999,6 +2212,17 @@ describe("translation support", () => {
       '<div><p label="mot">mot</p><p title="mot">mot</p><p placeholder="mot">mot</p><p alt="mot">mot</p><p something="word">mot</p></div>'
     );
   });
+
+  test("translation is done on the trimmed text, with extra spaces readded after", () => {
+    const translations = {
+      word: "mot",
+    };
+    const translateFn = jest.fn((expr) => translations[expr] || expr);
+    const qweb = new QWeb({ translateFn });
+    qweb.addTemplate("test", "<div> word </div>");
+    expect(renderToString(qweb, "test")).toBe("<div> mot </div>");
+    expect(translateFn).toHaveBeenCalledWith("word");
+  });
 });
 
 describe("t-key tests", () => {

tests/qweb/qweb_expressions.test.ts

@@ -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,23 +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" }
+      { type: "VALUE", value: "1" },
     ]);
 
     expect(tokenize("a in b")).toEqual([
       { type: "SYMBOL", value: "a" },
       { type: "OPERATOR", value: "in " },
-      { type: "SYMBOL", value: "b" }
+      { type: "SYMBOL", value: "b" },
     ]);
   });
 
@@ -76,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\\""' }]);
   });
@@ -196,4 +196,31 @@ describe("expression evaluation", () => {
     expect(compileExpr("f(...state.list)", {})).toBe("scope['f'](...scope['state'].list)");
     expect(compileExpr("f([...list])", {})).toBe("scope['f']([...scope['list']])");
   });
+
+  test("works with builtin properties", () => {
+    expect(compileExpr("state.constructor.name", {})).toBe("scope['state'].constructor.name");
+  });
+
+  test("works with shortcut object key description", () => {
+    expect(compileExpr("{a}", {})).toBe("{a:scope['a']}");
+    expect(compileExpr("{a,b}", {})).toBe("{a:scope['a'],b:scope['b']}");
+    expect(compileExpr("{a,b:3,c}", {})).toBe("{a:scope['a'],b:3,c:scope['c']}");
+  });
+
+  test("works with short object description and lists ", () => {
+    expect(compileExpr("[a, b]", {})).toBe("[scope['a'],scope['b']]");
+    expect(compileExpr("[a, b, c]", {})).toBe("[scope['a'],scope['b'],scope['c']]");
+    expect(compileExpr("[a, {b, c},d]", {})).toBe(
+      "[scope['a'],{b:scope['b'],c:scope['c']},scope['d']]"
+    );
+    expect(compileExpr("{a:[b, {c, d: e}]}", {})).toBe(
+      "{a:[scope['b'],{c:scope['c'],d:scope['e']}]}"
+    );
+  });
+
+  test("template strings", () => {
+    expect(compileExpr("`hey`", {})).toBe("`hey`");
+    expect(compileExpr("`hey ${you}`", {})).toBe("`hey ${scope['you']}`");
+    expect(compileExpr("`hey ${1 + 2}`", {})).toBe("`hey ${1+2}`");
+  });
 });

tests/qweb/qweb_t_att.test.ts

@@ -0,0 +1,27 @@
+import { QWeb } from "../../src/qweb/index";
+import { renderToString } from "../helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+function render(template, context = {}) {
+  const qweb = new QWeb();
+  qweb.addTemplate("test", template);
+  return renderToString(qweb, "test", context);
+}
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("qweb t-att", () => {
+  test("t-att-class with multiple classes", () => {
+    expect(render(`<div t-att-class="{'a b c': value}" />`, { value: true })).toBe(
+      '<div class="a b c"></div>'
+    );
+    expect(render(`<div t-att-class="{['a b c']: value}" />`, { value: true })).toBe(
+      '<div class="a b c"></div>'
+    );
+  });
+});

tests/qweb/qweb_t_tag.test.ts

@@ -0,0 +1,42 @@
+import { QWeb } from "../../src/qweb/index";
+import { renderToString } from "../helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+function render(template, context = {}) {
+  const qweb = new QWeb();
+  qweb.addTemplate("test", template);
+  return renderToString(qweb, "test", context);
+}
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("qweb t-tag", () => {
+  test("simple usecases", () => {
+    expect(render(`<t t-tag="'div'"></t>`)).toBe("<div></div>");
+    expect(render(`<t t-tag="tag">text</t>`, { tag: "span" })).toBe("<span>text</span>");
+  });
+
+  test("with multiple child nodes", () => {
+    const template = `
+            <t t-tag="tag">
+                pear
+                <span>apple</span>
+                strawberry
+            </t>`;
+    expect(render(template, { tag: "div" })).toBe(
+      "<div> pear <span>apple</span> strawberry </div>"
+    );
+  });
+
+  test("with multiple attributes", () => {
+    const template = `
+            <t t-tag="tag" class="blueberry" taste="raspberry">gooseberry</t>`;
+    const expected = `<div taste=\"raspberry\" class=\"blueberry\">gooseberry</div>`;
+    expect(render(template, { tag: "div" })).toBe(expected);
+  });
+});

tests/router/__snapshots__/link.test.ts.snap

@@ -7,16 +7,16 @@ exports[`Link component can render simple cases 1`] = `
     let utils = this.constructor.utils;
     let scope = Object.create(context);
     let h = this.h;
-    let _4 = utils.toObj({'router-link-active':scope['isActive']});
-    let _5 = scope['href'];
-    let c6 = [], p6 = {key:6,attrs:{href: _5},class:_4,on:{}};
-    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'];
-    if (slot8) {
-        slot8.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c6, parent: extra.parent || context}));
+    let _5 = utils.toClassObj({'router-link-active':scope['isActive']});
+    let _6 = scope['href'];
+    let c7 = [], p7 = {key:7,attrs:{href: _6},class:_5,on:{}};
+    let vn7 = h('a', p7, c7);
+    extra.handlers['click__8__'] = extra.handlers['click__8__'] || function (e) {if (context.__owl__.status === 5){return}utils.getComponent(context)['navigate'](e);};
+    p7.on['click'] = extra.handlers['click__8__'];
+    const slot9 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
+    if (slot9) {
+        slot9.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c7, parent: extra.parent || context}));
     }
-    return vn6;
+    return vn7;
 }"
 `;

tests/router/__snapshots__/route_component.test.ts.snap

@@ -18,7 +18,7 @@ exports[`RouteComponent can render simple cases 1`] = `
             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);
+            let props4 = Object.assign({}, scope['env'].router.currentParams, {});
             if (w4 && w4.__owl__.currentFiber && !w4.__owl__.vnode) {
                 w4.destroy();
                 w4 = false;
@@ -29,7 +29,7 @@ exports[`RouteComponent can render simple cases 1`] = `
                 utils.defineProxy(vn6, pvnode);
             } else {
                 let componentKey4 = \`routeComponent\`;
-                let W4 = context.constructor.components[componentKey4] || QWeb.components[componentKey4]|| scope['routeComponent'];
+                let W4 = scope['routeComponent'] || context.constructor.components[componentKey4] || QWeb.components[componentKey4];
                 if (!W4) {throw new Error('Cannot find the definition of component \\"' + componentKey4 + '\\"')}
                 w4 = new W4(parent, props4);
                 parent.__owl__.cmap[k5] = w4.__owl__.id;

tests/router/link.test.ts

@@ -37,7 +37,7 @@ describe("Link component", () => {
 
     const routes = [
       { name: "about", path: "/about" },
-      { name: "users", path: "/users" }
+      { name: "users", path: "/users" },
     ];
 
     router = new TestRouter(env, routes, { mode: "history" });
@@ -71,7 +71,7 @@ describe("Link component", () => {
 
     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);

tests/router/route_component.test.ts

@@ -41,7 +41,7 @@ describe("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" });
@@ -103,4 +103,28 @@ describe("RouteComponent", () => {
     await app.mount(fixture);
     expect(fixture.innerHTML).toBe("<div><span>Book 1984|124</span></div>");
   });
+
+  test("can render parameterized route where params are not separated by slashes", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="App">
+                <RouteComponent />
+            </div>
+            <span t-name="Book">Book <t t-esc="props.title"/>|<t t-esc="props.val"/></span>
+        </templates>
+    `);
+    class Book extends Component {}
+    class App extends Component {
+      static components = { RouteComponent };
+    }
+
+    const routes = [
+      { name: "book", path: "/#title={{title}}&val={{val.number}}", component: Book },
+    ];
+    router = new TestRouter(env, routes, { mode: "hash" });
+    await router.navigate({ to: "book", params: { title: "1984", val: "123" } });
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>Book 1984|123</span></div>");
+  });
 });

tests/router/router.test.ts

@@ -1,6 +1,6 @@
 import { Destination, RouterEnv, Route } from "../../src/router/router";
 import { makeTestEnv, nextTick } from "../helpers";
-import { TestRouter } from "./test_router";
+import { TestRouter, getRouteParams } from "./test_router";
 
 let env: RouterEnv;
 let router: TestRouter | null = null;
@@ -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"}`);
   });
@@ -60,6 +60,13 @@ describe("router miscellaneous", () => {
     await router.navigate({ to: "users", params: { id: 3 } });
     expect(window.location.href).toBe("http://localhost/test.html#/users/3");
   });
+
+  test("navigate using path and query string should preserve query string", async () => {
+    router = new TestRouter(env, [{ name: "users", path: "/users/{{id}}" }]);
+    await router.navigate({ path: "/users/3?test=1" });
+    expect(window.location.pathname).toBe("/users/3");
+    expect(window.location.search).toBe("?test=1");
+  });
 });
 
 describe("routeToPath", () => {
@@ -107,60 +114,69 @@ describe("destToPath", () => {
 
 describe("getRouteParams", () => {
   test("properly match simple routes", () => {
-    router = new TestRouter(env, []);
     // simple route
-    expect(router["getRouteParams"]({ path: "/home" } as Route, "/home")).toEqual({});
+    expect(getRouteParams({ path: "/home" }, "/home")).toEqual({});
 
     // no match
-    expect(router["getRouteParams"]({ path: "/home" } as Route, "/otherpath")).toEqual(false);
+    expect(getRouteParams({ path: "/home" }, "/otherpath")).toEqual(false);
 
     // fallback route
-    expect(router["getRouteParams"]({ path: "*" } as Route, "somepath")).toEqual({});
+    expect(getRouteParams({ path: "*" }, "somepath")).toEqual({});
+  });
+
+  test("properly match routes with query params", () => {
+    expect(getRouteParams({ path: "/home" }, "/home?test=1")).toEqual({});
+    expect(getRouteParams({ path: "/home" }, "/home?test1=1&test2=2")).toEqual({});
   });
 
   test("properly match simple routes, mode hash", () => {
-    router = new TestRouter(env, [], { mode: "hash" });
     // simple route
-    expect(router["getRouteParams"]({ path: "/home" } as Route, "#/home")).toEqual({});
+    expect(getRouteParams({ path: "/home" }, "#/home")).toEqual({});
 
     // no match
-    expect(router["getRouteParams"]({ path: "/home" } as Route, "#/otherpath")).toEqual(false);
+    expect(getRouteParams({ path: "/home" }, "#/otherpath")).toEqual(false);
 
     // fallback route
-    expect(router["getRouteParams"]({ path: "*" } as Route, "#/somepath")).toEqual({});
+    expect(getRouteParams({ path: "*" }, "#/somepath")).toEqual({});
   });
 
   test("match some parameterized routes", () => {
-    router = new TestRouter(env, []);
-    expect(router["getRouteParams"]({ path: "/invoices/{{id}}" } as Route, "/invoices/3")).toEqual({
-      id: "3"
+    expect(getRouteParams({ path: "/invoices/{{id}}" }, "/invoices/3")).toEqual({
+      id: "3",
     });
   });
 
   test("match some parameterized routes, mode hash", () => {
-    router = new TestRouter(env, [], { mode: "hash" });
-    expect(router["getRouteParams"]({ path: "/invoices/{{id}}" } as Route, "#/invoices/3")).toEqual(
-      {
-        id: "3"
-      }
-    );
+    expect(getRouteParams({ path: "/invoices/{{id}}" }, "#/invoices/3")).toEqual({
+      id: "3",
+    });
   });
 
   test("can convert to number if needed", () => {
-    router = new TestRouter(env, []);
-    expect(
-      router["getRouteParams"]({ path: "/invoices/{{id.number}}" } as Route, "/invoices/3")
-    ).toEqual({
-      id: 3
+    expect(getRouteParams({ path: "/invoices/{{id.number}}" }, "/invoices/3")).toEqual({
+      id: 3,
     });
   });
 
   test("can convert to number if needed, mode: hash", () => {
-    router = new TestRouter(env, [], { mode: "hash" });
+    expect(getRouteParams({ path: "/invoices/{{id.number}}" }, "#/invoices/3")).toEqual({
+      id: 3,
+    });
+  });
+
+  test("can extract params not separated by slashes", () => {
+    expect(getRouteParams({ path: "/books/{{id.number}}-{{name}}" }, "/books/3-1984")).toEqual({
+      id: 3,
+      name: "1984",
+    });
+  });
+
+  test("can extract params not separated by slashes, mode: hash", () => {
     expect(
-      router["getRouteParams"]({ path: "/invoices/{{id.number}}" } as Route, "#/invoices/3")
+      getRouteParams({ path: "books&id={{id.number}}&name={{name}}" }, "#books&id=3&name=1984")
     ).toEqual({
-      id: 3
+      id: 3,
+      name: "1984",
     });
   });
 });
@@ -169,7 +185,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 +198,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 +230,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 +251,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 +271,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("/");

tests/router/test_router.ts

@@ -1,4 +1,5 @@
-import { Router } from "../../src/router/router";
+import { Router, Route, RouterEnv } from "../../src/router/router";
+import { makeTestEnv } from "../helpers";
 import { QWeb } from "../../src/qweb/index";
 
 export class TestRouter extends Router {
@@ -13,3 +14,13 @@ export class TestRouter extends Router {
     }
   }
 }
+
+export function getRouteParams(route: Partial<Route>, path: string) {
+  const env = <RouterEnv>makeTestEnv();
+  const router = new TestRouter(env, [route]);
+  const {
+    routeIds: [routeId],
+    routes,
+  } = router;
+  return router["getRouteParams"](routes[routeId], path);
+}

tests/store.test.ts

@@ -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++);

tests/store_hooks.test.ts

@@ -1,4 +1,4 @@
-import { Component, Env } from "../src/component/component";
+import { Component, Env, mount } from "../src/component/component";
 import { Store, useStore, useDispatch, useGetters, EnvWithStore } from "../src/store";
 import { useState } from "../src/hooks";
 import { xml } from "../src/tags";
@@ -25,7 +25,7 @@ describe("connecting a component to store", () => {
     const actions = {
       addTodo({ state }, msg) {
         state.todos.push({ msg, id: nextId++ });
-      }
+      },
     };
     const store = new Store({ state, actions });
 
@@ -34,7 +34,7 @@ describe("connecting a component to store", () => {
             <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;
@@ -56,7 +56,7 @@ describe("connecting a component to store", () => {
       },
       setNotNull({ state }) {
         state.nullValue = "ok";
-      }
+      },
     };
     const store = new Store({ state, actions });
 
@@ -70,15 +70,15 @@ describe("connecting a component to store", () => {
       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 = useStore((state) => state.nullValue, {
+          onUpdate: (nullValue) => {
             this.nullValue = nullValue;
-          }
+          },
         });
       }
     }
@@ -105,15 +105,15 @@ describe("connecting a component to store", () => {
     class App extends Component {
       static template = xml`<div t-esc="mapAdd"/>`;
       storeProps = {
-        array: useStore(state => {
+        array: useStore((state) => {
           if (state.useSmallArray) {
             return state.smallerArray;
           }
           return state.biggerArray;
-        })
+        }),
       };
       get mapAdd() {
-        return this.storeProps.array.map(a => {
+        return this.storeProps.array.map((a) => {
           return a + 1;
         });
       }
@@ -133,7 +133,7 @@ describe("connecting a component to store", () => {
   test("throw error if no store is found", async () => {
     class App extends Component {
       static template = xml`<div></div>`;
-      todos = useStore(state => state.todos);
+      todos = useStore((state) => state.todos);
     }
 
     let error;
@@ -153,7 +153,7 @@ describe("connecting a component to store", () => {
 
     class App extends Component {
       static template = xml`<div/>`;
-      storeState = useStore(state => state.a);
+      storeState = useStore((state) => state.a);
     }
 
     (<any>env).store = store;
@@ -170,7 +170,7 @@ describe("connecting a component to store", () => {
       doSomething({ state }) {
         state.a = 2;
         state.b = 3;
-      }
+      },
     };
     const store = new Store({ state, actions });
 
@@ -180,8 +180,8 @@ describe("connecting a component to store", () => {
                 <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);
 
@@ -204,7 +204,7 @@ describe("connecting a component to store", () => {
     const actions = {
       addTodo({ state }, msg) {
         state.todos.push({ msg, id: nextId++ });
-      }
+      },
     };
     const store = new Store({ state, actions });
 
@@ -213,7 +213,7 @@ describe("connecting a component to store", () => {
             <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);
 
@@ -241,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 {
       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;
@@ -270,12 +270,12 @@ describe("connecting a component to store", () => {
       },
       incrementA({ state }) {
         state.a++;
-      }
+      },
     };
     const store = new Store({ state, actions });
     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);
 
@@ -303,7 +303,7 @@ describe("connecting a component to store", () => {
     const actions = {
       addTodo({ state }, msg) {
         state.todos.push({ msg, id: nextId++ });
-      }
+      },
     };
     const store = new Store({ state, actions });
 
@@ -312,7 +312,7 @@ describe("connecting a component to store", () => {
             <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();
@@ -331,8 +331,8 @@ describe("connecting a component to store", () => {
       actions: {
         inc({ state }) {
           state.value++;
-        }
-      }
+        },
+      },
     });
     (<any>env).store = store;
 
@@ -342,7 +342,7 @@ describe("connecting a component to store", () => {
               <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();
@@ -360,15 +360,15 @@ 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 {
       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);
       });
     }
 
@@ -395,14 +395,14 @@ 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 {
       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);
       });
     }
 
@@ -412,7 +412,7 @@ describe("connecting a component to store", () => {
           <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;
@@ -431,16 +431,16 @@ 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 });
 
@@ -452,10 +452,10 @@ 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(),
         };
       });
     }
@@ -468,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;
@@ -513,13 +513,13 @@ describe("connecting a component to store", () => {
         </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" }] };
@@ -542,9 +542,9 @@ describe("connecting a component to store", () => {
     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;
-        }
+        },
       });
     }
 
@@ -558,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;
@@ -571,12 +571,12 @@ describe("connecting a component to store", () => {
     app.state.beerId = 2;
     await nextTick();
     expect(fixture.innerHTML).toBe("<div><span>kwak</span></div>");
-    expect(counter).toBe(1);
+    expect(counter).toBe(0);
 
     store.dispatch("renameBeer", { id: 2, name: "orval" });
     await nextTick();
     expect(fixture.innerHTML).toBe("<div><span>orval</span></div>");
-    expect(counter).toBe(2);
+    expect(counter).toBe(1);
   });
 
   test("connected component is properly cleaned up on destroy", async () => {
@@ -609,7 +609,7 @@ 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,
       }));
     }
 
@@ -622,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;
@@ -665,11 +665,11 @@ describe("connecting a component to store", () => {
                 <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,
         };
       });
     }
@@ -689,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;
@@ -747,11 +747,11 @@ describe("connecting a component to store", () => {
     const actions = {
       setValue({ state }, val) {
         state.x.val = val;
-      }
+      },
     };
     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();
@@ -782,11 +782,11 @@ describe("connecting a component to store", () => {
       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,
         };
       });
     }
@@ -795,7 +795,7 @@ describe("connecting a component to store", () => {
     const actions = {
       setCurrent({ state }, c) {
         state.current = c;
-      }
+      },
     };
 
     const store = new Store({ state, actions });
@@ -831,7 +831,7 @@ describe("connecting a component to store", () => {
                 <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 };
       });
@@ -846,7 +846,7 @@ describe("connecting a component to store", () => {
     const actions = {
       setFlagToFalse({ state }) {
         state.flag = false;
-      }
+      },
     };
 
     const store = new Store({ state, actions });
@@ -874,15 +874,15 @@ 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<{}, EnvWithStore> {
@@ -894,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],
         };
       });
 
@@ -914,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 };
       });
@@ -947,15 +947,15 @@ 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<{}, EnvWithStore> {
@@ -967,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],
         };
       });
 
@@ -988,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 };
       });
@@ -1016,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>');
   });
@@ -1026,7 +1026,7 @@ describe("connecting a component to store", () => {
 
     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");
@@ -1040,7 +1040,7 @@ describe("connecting a component to store", () => {
     const actions = {
       setMsg({ state }, c) {
         state.msg = c;
-      }
+      },
     };
 
     const store = new Store({ state, actions });
@@ -1061,7 +1061,7 @@ describe("connecting a component to store", () => {
 
     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 {
@@ -1099,7 +1099,7 @@ describe("connecting a component to store", () => {
 
     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;
       });
@@ -1107,7 +1107,7 @@ describe("connecting a component to store", () => {
     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;
       });
@@ -1118,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;
@@ -1137,18 +1137,18 @@ describe("connecting a component to store", () => {
   test("dispatch an action", async () => {
     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 });
@@ -1185,21 +1185,21 @@ 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 });
 
@@ -1220,7 +1220,7 @@ describe("various scenarios", () => {
                 <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();
@@ -1241,4 +1241,162 @@ describe("various scenarios", () => {
     await nextTick();
     expect(fixture.innerHTML).toMatchSnapshot();
   });
+
+  test("component with store, useState and shouldUpdate=false", async () => {
+    let state: any;
+
+    const store = new Store({ state: { rev: 0 } });
+
+    class Child extends Component {
+      static template = xml`<div><t t-esc="state.word"/><t t-esc="props.name"/></div>`;
+
+      state = useState({ word: "hello" });
+
+      constructor(parent, props) {
+        super(parent, props);
+        state = this.state;
+        useStore((props) => {
+          return 1;
+        });
+      }
+
+      shouldUpdate() {
+        return false;
+      }
+    }
+
+    class Parent extends Component {
+      static template = xml`<div><Child name="state.name"/></div>`;
+      static components = { Child };
+
+      state = useState({ name: "World" });
+
+      constructor(parent, props) {
+        super(parent, props);
+        useStore((props) => store.state.rev);
+      }
+    }
+    (env as any).store = store;
+
+    await mount(Parent, { target: fixture, env });
+    expect(fixture.innerHTML).toBe("<div><div>helloWorld</div></div>");
+
+    store.state.rev++;
+    // this is the key to the bug, it makes Parent be in "render" state but not
+    // yet rendered while the change of state happens
+    await Promise.resolve();
+    state.word = "test";
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div>testWorld</div></div>");
+  });
+
+  test("component with store, useState, shouldUpdate=false and child with shouldupdate false", async () => {
+    let state: any;
+
+    const store = new Store({ state: { rev: 0 } });
+
+    class ChildChild extends Component {
+      static template = xml`<div><t t-esc="props.value"/></div>`;
+
+      shouldUpdate() {
+        return false;
+      }
+    }
+
+    class Child extends Component {
+      static template = xml`<div><t t-esc="state.word"/><t t-esc="props.name"/><ChildChild value="state.value"/></div>`;
+      static components = { ChildChild };
+      state = useState({ word: "hello", value: 3 });
+
+      constructor(parent, props) {
+        super(parent, props);
+        state = this.state;
+        useStore((props) => {
+          return 1;
+        });
+      }
+
+      shouldUpdate() {
+        return false;
+      }
+    }
+
+    class Parent extends Component {
+      static template = xml`<div><Child name="state.name"/></div>`;
+      static components = { Child };
+
+      state = useState({ name: "World" });
+      constructor(parent, props) {
+        super(parent, props);
+        useStore((props) => store.state.rev);
+      }
+    }
+    (env as any).store = store;
+
+    await mount(Parent, { target: fixture, env });
+    expect(fixture.innerHTML).toBe("<div><div>helloWorld<div>3</div></div></div>");
+
+    store.state.rev++;
+    // this is the key to the bug, it makes Parent be in "render" state but not
+    // yet rendered while the change of state happens
+    await Promise.resolve();
+    state.word = "test";
+    state.value = 44;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div>testWorld<div>3</div></div></div>");
+  });
+
+  test("parent/children with store, parent is remounted", async () => {
+    const store = new Store({ state: { a: 1, b: 1 } });
+
+    class Child extends Component {
+      static template = xml`<div><t t-esc="a"/></div>`;
+      a: any;
+      constructor(parent, props) {
+        super(parent, props);
+        this.a = useStore(
+          (state, props) => {
+            return state.a;
+          },
+          {
+            onUpdate: (a) => {
+              this.a = a;
+            },
+          }
+        );
+      }
+    }
+
+    class Parent extends Component {
+      static template = xml`
+        <div>
+          parent: <t t-esc="b"/>
+          <Child/>
+        </div>`;
+      static components = { Child };
+
+      b: any;
+      constructor(parent, props) {
+        super(parent, props);
+        this.b = useStore((state, props) => {
+          return state.b;
+        });
+      }
+    }
+    (env as any).store = store;
+
+    const div = document.createElement("div");
+    fixture.appendChild(div);
+
+    // initial mounting
+    const parent = await mount(Parent, { target: fixture, env });
+    expect(fixture.innerHTML).toBe("<div></div><div> parent: 1<div>1</div></div>");
+
+    // remounting component, then immediately update store.state
+    parent.mount(div);
+    store.state.a++;
+
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div> parent: 1<div>2</div></div></div>");
+  });
 });

tests/tooling/debug_script_1.test.ts

@@ -20,7 +20,7 @@ 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 {
     static template = xml`<div>child</div>`;
@@ -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;
 });

tests/tooling/debug_script_2.test.ts

@@ -19,7 +19,7 @@ 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 {
     static template = xml`<div>child</div>`;
@@ -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;
 });

tests/tooling/debug_script_3.test.ts

@@ -8,7 +8,7 @@ import * as owl from "../../src/index";
 
 import { Component, Env } from "../../src/component/component";
 import { xml } from "../../src/tags";
-import { makeTestFixture, makeTestEnv } from "../helpers";
+import { makeTestFixture, makeTestEnv, nextTick } from "../helpers";
 
 let fixture: HTMLElement = makeTestFixture();
 let env: Env = makeTestEnv();
@@ -19,7 +19,7 @@ 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 {
     static template = xml`<div><t t-esc="state.value"/></div>`;
@@ -31,6 +31,7 @@ test("log a specific message for render method calls if component is not mounted
   parent.unmount();
   parent.state.value = 2;
 
+  await nextTick();
   expect(steps).toEqual([
     "[OWL_DEBUG] Parent<id=1> constructor, props={}",
     "[OWL_DEBUG] Parent<id=1> mount",
@@ -40,7 +41,10 @@ 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)",
+    "[OWL_DEBUG] scheduler: start running tasks queue",
+    "[OWL_DEBUG] Parent<id=1> rendering template",
+    "[OWL_DEBUG] scheduler: stop running tasks queue",
   ]);
   console.log = log;
 });

tests/tooling/debug_script_4.test.ts

@@ -19,7 +19,7 @@ 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);
+  console.log = (arg) => steps.push(arg);
 
   class Child extends Component {
     static template = xml`<span><t t-esc="props.obj.val"/></span>`;
@@ -51,7 +51,7 @@ test("log a sub component with non stringifiable props", async () => {
     "[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"
+    "[OWL_DEBUG] Child<id=2> willUnmount",
   ]);
   console.log = log;
 });

tests/tooling/doc_link_checker.test.ts

@@ -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 -

tools/debug.js

@@ -101,8 +101,8 @@
     component.render = function(...args) {
       const __owl__ = component.__owl__;
       let msg = `render`;
-      if (!__owl__.isMounted && !__owl__.currentFiber) {
-        msg += ` (warning: component is not mounted, this render has no effect)`;
+      if (__owl__.status !== 3 /* mounted */ && !__owl__.currentFiber) {
+        msg += ` (warning: component is not mounted)`;
       }
       log(msg);
       return render(...args);

tools/playground/app.js

@@ -1,5 +1,6 @@
 import { SAMPLES } from "./samples.js";
-const { useState, useRef, onMounted, onWillUnmount } = owl.hooks;
+const { mount, hooks } = owl;
+const { useState, useRef, onMounted, onWillUnmount } = hooks;
 //------------------------------------------------------------------------------
 // Constants, helpers, utils
 //------------------------------------------------------------------------------
@@ -71,7 +72,7 @@ if __name__ == "__main__":
  * Make an iframe, with all the js, css and xml properly injected.
  */
 function makeCodeIframe(js, css, xml) {
-  const sanitizedXML = xml.replace(/<!--[\s\S]*?-->/g, "");
+  const sanitizedXML = xml.replace(/<!--[\s\S]*?-->/g, "").replace(/`/g, '\\\`');
 
 
   // create iframe
@@ -419,9 +420,8 @@ async function start() {
     owl.utils.whenReady()
   ]);
   const qweb = new owl.QWeb({ templates });
-  owl.Component.env = { qweb };
-  const app = new App();
-  app.mount(document.body);
+  const env = { qweb };
+  await mount(App, {target: document.body, env});
 }
 
 start();