[REL] v1.0.0

Finally!!

.gitignore

@@ -1,5 +1,6 @@
 /node_modules
 /dist
+
 npm-debug.log
 
 # misc
@@ -14,5 +15,12 @@ yarn-debug.log*
 yarn-error.log*
 
 package-lock.json
+
+#ide's
 .vscode
+.idea
+
 node_modules
+
+# Extras temp file
+/tools/owl.js

COPYRIGHT

@@ -0,0 +1,14 @@
+
+Most of the files are
+
+  Copyright (c) 2004-2015 Odoo S.A.
+
+Many files also contain contributions from third
+parties. In this case the original copyright of
+the contributions can be traced through the
+history of the source version control system.
+
+When that is not the case, the files contain a prominent
+notice stating the original copyright and applicable
+license, or come with their own dedicated COPYRIGHT
+and/or LICENSE file.

LICENSE

@@ -1,12 +1,9 @@
-
-For copyright information, please see the COPYRIGHT file.
-
-Odoo is published under the GNU LESSER GENERAL PUBLIC LICENSE, Version 3
+OWL is published under the GNU LESSER GENERAL PUBLIC LICENSE, Version 3
 (LGPLv3), as included below. Since the LGPL is a set of additional
 permissions on top of the GPL, the text of the GPL is included at the
 bottom as well.
 
-Some external libraries and contributions bundled with Odoo may be published
+Some external libraries and contributions bundled with OWL may be published
 under other GPL-compatible licenses. For these, please refer to the relevant
 source files and/or license files, in the source code tree.
 

README.md

@@ -1,74 +1,258 @@
-<h1 align="center">🦉 Odoo Web Library 🦉</h1>
+<h1 align="center">🦉 <a href="https://odoo.github.io/owl/">Odoo Web Library</a> 🦉</h1>
+
+_Class based components with hooks, reactive state and concurrent mode_
 
 ## Project Overview
 
-The Odoo Web Library (OWL) is a small 
-UI framework intended to be the basis for the [Odoo](https://www.odoo.com/) Web Client, and hopefully many
-other Odoo related projects. OWL's two key features are:
+The Odoo Web Library (OWL) is a smallish (~<20kb gzipped) UI framework intended to
+be the basis for the [Odoo](https://www.odoo.com/) Web Client. Owl is a modern
+framework, written in Typescript, taking the best ideas from React and Vue in a
+simple and consistent way. Owl's main features are:
 
-- a declarative component system, with QWeb as a template engine, asynchronous rendering, and an underlying virtual dom,
-- and a store (state management solution, loosely inspired by VueX and React/Redux).
+- a declarative component system,
+- a reactivity system based on hooks,
+- a store implementation (for state management),
+- a small frontend router
 
-If you are interested, you can find a discussion on what makes OWL different
-from React and Vue [here](doc/comparison.md)
+Owl components are defined with ES6 classes, they use QWeb templates, an underlying
+virtual dom, integrates beautifully with hooks, and the rendering is asynchronous.
 
-## Try it online!
+**Try it online!** An online playground is available at [https://odoo.github.io/owl/playground](https://odoo.github.io/owl/playground) to let you experiment with the Owl framework. There
+are some code examples to showcase some interesting features.
 
-An online playground is available at [https://odoo.github.io/owl/](https://odoo.github.io/owl/) to let you experiment with the OWL framework.
+Owl is currently mostly stable.  Possible future changes are explained in the
+[roadmap](roadmap.md).
 
-# Example
+## Example
 
-Here is a short example to illustrate interactive widgets:
+Here is a short example to illustrate interactive components:
 
 ```javascript
-class ClickCounter extends owl.Component {
-  inlineTemplate = `
+const { Component, useState } = owl;
+const { xml } = owl.tags;
+
+class Counter extends Component {
+  static template = xml`
+    <button t-on-click="state.value++">
+      Click Me! [<t t-esc="state.value"/>]
+    </button>`;
+
+  state = useState({ value: 0 });
+}
+
+class App extends Component {
+  static template = xml`
+    <div>
+      <span>Hello Owl</span>
+      <Counter />
+    </div>`;
+
+  static components = { Counter };
+}
+
+const app = new App();
+app.mount(document.body);
+```
+
+Note that the counter component is made reactive with the [`useState` hook](doc/reference/hooks.md#usestate).
+Also, all examples here uses the [`xml` helper](doc/reference/tags.md#xml-tag) to define inline templates.
+But this is not mandatory, many applications will load templates separately.
+
+More interesting examples can be found on the
+[playground](https://odoo.github.io/owl/playground) application.
+
+## Design Principles
+
+OWL is designed to be used in highly dynamic applications where changing
+requirements are common and code needs to be maintained by large teams.
+
+- **XML based**: templates are based on the XML format, which allows interesting
+  applications. For example, they could be stored in a database and modified
+  dynamically with `xpaths`.
+- **templates compilation in the browser**: this may not be a good fit for all
+  applications, but if you need to generate dynamically user interfaces in the
+  browser, this is very powerful. For example, a generic form view component
+  could generate a specific form user interface for each various models, from a XML view.
+- **no toolchain required**: this is extremely useful for some applications, if,
+  for various reasons (security/deployment/dynamic modules/specific assets tools),
+  it is not ok to use standard web tools based on `npm`.
+
+Owl is not designed to be fast nor small (even though it is quite good on those
+two topics). It is a no nonsense framework to build applications. There is only
+one way to define components (with classes).
+
+If you are interested in a comparison with React or Vue, you will
+find some more information [here](doc/comparison.md).
+
+## Documentation
+
+A complete documentation for Owl can be found here:
+
+- [Main documentation page](doc/readme.md).
+
+The most important sections are:
+
+- [Tutorial: TodoList application](doc/learning/tutorial_todoapp.md)
+- [QWeb templating language](doc/reference/qweb_templating_language.md)
+- [Component](doc/reference/component.md)
+- [Hooks](doc/reference/hooks.md)
+
+Found an issue in the documentation? A broken link? Some outdated information?
+Submit a PR!
+
+## Installing/Building
+
+Owl can be installed with the following command:
+
+```
+npm install @odoo/owl
+```
+
+If you want to use a simple `<script>` tag, the last release can be downloaded here:
+
+- [owl-1.0.0.js](https://github.com/odoo/owl/releases/download/v1.0.0/owl.js)
+- [owl-1.0.0.min.js](https://github.com/odoo/owl/releases/download/v1.0.0/owl.min.js)
+
+Some npm scripts are available:
+
+| Command          | Description                                        |
+| ---------------- | -------------------------------------------------- |
+| `npm install`    | install every dependency required for this project |
+| `npm run build`  | build a bundle of _owl_ in the _/dist/_ folder     |
+| `npm run minify` | minify the prebuilt owl.js file                    |
+| `npm run test`   | run all (owl) tests                                |
+
+## Quick Overview
+
+Owl components in an application are used to define a (dynamic) tree of components.
+
+```
+        Root
+        /   \
+       A     B
+      / \
+     C   D
+```
+
+**State:** each component can manage its own local state. It is a simple ES6
+class, there are no special rules:
+
+```js
+class Counter extends Component {
+  static template = xml`
     <button t-on-click="increment">
       Click Me! [<t t-esc="state.value"/>]
     </button>`;
 
-  constructor(parent, props) {
-    super(parent, props);
-    this.state = { value: 0 };
+  state = { value: 0 };
+
+  increment() {
+    this.state.value++;
+    this.render();
   }
+}
+```
+
+The example above shows a component with a local state. Note that since there
+is nothing magical to the `state` object, we need to manually call the `render`
+function whenever we update it. This can quickly become annoying (and not
+efficient if we do it too much). There is a better way: using the `useState`
+hook, which transforms an object into a reactive version of itself:
+
+```js
+const { useState } = owl.hooks;
+
+class Counter extends Component {
+  static template = xml`
+    <button t-on-click="increment">
+      Click Me! [<t t-esc="state.value"/>]
+    </button>`;
+
+  state = useState({ value: 0 });
 
   increment() {
     this.state.value++;
   }
 }
-
-const qweb = new owl.QWeb();
-const counter = new ClickCounter({qweb});
-counter.mount(document.body);
 ```
 
-More interesting examples can be found on the [playground](https://odoo.github.io/owl/) application.
+Note that the `t-on-click` handler can even be replaced by an inline statement:
 
-## Installing/Building
+```xml
+    <button t-on-click="state.value++">
+```
 
-If you want to use a simple `<script>` tag, the last release can be downloaded here:
+**Props:** sub components often needs some information from their parents. This
+is done by adding the required information to the template. This will then be
+accessible by the sub component in the `props` object. Note that there is an
+important rule here: the information contained in the `props` object is not
+owned by the sub component, and should never be modified.
 
-- [owl-0.8.0.js](https://odoo.github.io/owl/releases/owl-0.8.0.js)
-- [owl-0.8.0.min.js](https://odoo.github.io/owl/releases/owl-0.8.0.min.js)
+```js
+class Child extends Component {
+  static template = xml`<div>Hello <t t-esc="props.name"/></div>`;
+}
 
-Some npm scripts are available:
+class Parent extends Component {
+  static template = xml`
+    <div>
+        <Child name="'Owl'" />
+        <Child name="'Framework'" />
+    </div>`;
+  static components = { Child };
+}
+```
 
-| Command              | Description                                        |
-| -------------------- | -------------------------------------------------- |
-| `npm install`        | install every dependency required for this project |
-| `npm run build`      | build a bundle of _owl_ in the _/dist/_ folder     |
-| `npm run minify`     | minify the prebuilt owl.js file                    |
-| `npm run test`       | run all tests                                      |
-| `npm run test:watch` | run all tests, and keep a watcher                  |
+**Communication:** there are multiple ways to communicate information between
+components. However, the two most important ways are the following:
 
-## Documentation
+- from parent to children: by using `props`,
+- from a children to one of its parent: by triggering events.
 
-The complete documentation can be found [here](doc/readme.md). The most important sections are:
+The following example illustrate both mechanisms:
 
-- [Quick Start](doc/quick_start.md)
-- [Component](doc/component.md)
-- [Store](doc/store.md)
+```js
+class OrderLine extends Component {
+  static template = xml`
+    <div t-on-click="add">
+        <div><t t-esc="props.line.name"/></div>
+        <div>Quantity: <t t-esc="props.line.quantity"/></div>
+    </div>`;
+
+  add() {
+    this.trigger("add-to-order", { line: props.line });
+  }
+}
+
+class Parent extends Component {
+  static template = xml`
+    <div t-on-add-to-order="addToOrder">
+        <OrderLine
+            t-foreach="orders"
+            t-as="line"
+            line="line" />
+    </div>`;
+  static components = { OrderLine };
+  orders = useState([{ id: 1, name: "Coffee", quantity: 0 }, { id: 2, name: "Tea", quantity: 0 }]);
+
+  addToOrder(event) {
+    const line = event.detail.line;
+    line.quantity++;
+  }
+}
+```
+
+In this example, the `OrderLine` component trigger a `add-to-order` event. This
+will generate a DOM event which will bubble along the DOM tree. It will then be
+intercepted by the parent component, which will then get the line (from the
+`detail` key) and then increment its quantity. See the section on [event handling](doc/reference/component.md#event-handling)
+for more details on how events work.
+
+Note that this example would have also worked if the `OrderLine` component
+directly modifies the `line` object. However, this is not a good practice: this
+only works because the `props` object received by the child component is reactive,
+so the child component is then coupled to the parents implementation.
 
 ## License
 
-OWL is [GPL licensed](./LICENSE).
+OWL is [LGPL licensed](./LICENSE).

doc/architecture/rendering.md

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

doc/architecture/vdom.md

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

doc/comparison.md

@@ -3,30 +3,61 @@
 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, some
+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
 discussed, feel free to open an issue/submit a PR to correct this text.
 
+## Content
+
 - [Size](#size)
+- [Class Based](#class-based)
 - [Tooling/Build Step](#toolingbuild-step)
 - [Templating](#templating)
 - [Asynchronous rendering](#asynchronous-rendering)
 - [Reactiveness](#reactiveness)
 - [State Management](#state-management)
+- [Hooks](#hooks)
 
-### Size
+## Size
 
 OWL is intended to be small and to work at a slightly lower level of abstraction
 than React and Vue. Also, jQuery is not the same kind of framework, but it is interesting to compare.
 
-| Framework                | Size (minified) | Size (minified, gzipped) |
-| ------------------------ | --------------- | ------------------------ |
-| OWL                      | 32kb            | 11kb                     |
-| Vue + VueX               |                 | 30kb                     |
-| React + ReactDOM + Redux |                 | 40kb                     |
-| jQuery                   | 86kb            | 30kb                     |
+| Framework                | Size (minified, gzipped) |
+| ------------------------ | ------------------------ |
+| OWL                      | 18kb                     |
+| Vue + VueX               | 30kb                     |
+| Vue + VueX + Vue Router  | 39kb                     |
+| React + ReactDOM + Redux | 40kb                     |
+| jQuery                   | 30kb                     |
 
-### Tooling/Build step
+Note that those comparisons are not entirely fair, because we do not compare
+the same exact set of features. For example, VueX and Vue Router support more
+advanced use cases.
+
+## Class Based
+
+Both React and Vue moved away from defining components with classes. They prefer
+a more functional approach, in particular, with the new `hooks` mechanisms.
+
+This has some advantages and disadvantages. But the end result is that React
+and Vue both offers multiple different ways of defining new components. In
+contrast, Owl has only one mechanism: class-based components. We believe that Owl
+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,
+both of these are important mechanisms for reusing code. Also, one does not
+exclude the other.
+
+It certainly looks like the world of UI frameworks is moving toward composition,
+for many very good reasons. Owl is still good at composition (for example,
+Owl supports slots, which is the primary mechanism to make generic reusable
+components). But it can also use inheritance (and this is very important since
+templates can also be inherited with `xpaths` transformations).
+
+## Tooling/Build step
 
 OWL is designed to be easy to use in a standalone way. For various reasons,
 Odoo does not want to rely on standard web tools (such as webpack), and OWL can
@@ -36,14 +67,24 @@ be used by simply adding a script tag to a page.
 <script src="owl.min.js" />
 ```
 
-In comparison, React encourages using JSX,
-which necessitate a build step, and most Vue applications uses single file
-components, which also necessitate a build step.
+In comparison, React encourages using JSX, which necessitate a build step, and
+most Vue applications uses single file components, which also necessitate a build step.
 
 On the flipside, external tooling may make it harder to use in some case, but it
 also brings a lot of benefits. And React/Vue have both a large ecosystem.
 
-### Templating
+Note that since Owl is not dependant on any external tool nor libraries, it is
+very easy to integrate into any build toolchain. Also, since we cannot rely on
+additional tools, we made a lot of effort to make the most of the web platform.
+
+For example, Owl uses the standard `xml` parser that comes with every browser.
+Because of that, Owl did not have to write its own template parser. Another
+example is the [`xml`](reference/tags.md#xml-tag) tag helper function, which makes use of
+native template literals to allow in a natural way to write `xml` templates
+directly in the javascript code. This can be easily integrated with editor
+plugins to have autocompletion inside the template.
+
+## Templating
 
 OWL uses its own QWeb engine, which compiles templates on the
 frontend, as they are needed. This is extremely convenient for our use case, in
@@ -65,7 +106,8 @@ into javascript functions. Note that Vue has a separate build which includes the
 template compiler.
 
 In contrast, most React applications do not use a templating language, but write
-some JSX code, which is precompiled into plain JavaScript by a build step.
+some JSX code, which is precompiled into plain JavaScript by a build step. This
+example is done with the (kind of outdated) React class system:
 
 ```jsx
 class Clock extends React.Component {
@@ -84,22 +126,36 @@ This has the advantage of having the full power of Javascript, but is less
 structured than a template language. Note that the tooling is quite impressive:
 there is a syntax highlighter for jsx here on github!
 
-### Asynchronous rendering
+By comparison, here is the equivalent Owl component, written with the
+[`xml`](reference/tags.md#xml-tag) tag helper:
+
+```js
+class Clock extends Component {
+  static template = xml`
+      <div>
+        <h1>Hello, world!</h1>
+        <h2>It is {props.date.toLocaleTimeString()}.</h2>
+      </div>
+    `;
+}
+```
+
+## Asynchronous Rendering
 
 This is actually a big difference between OWL and React/Vue: components in OWL
 are totally asynchronous. They have two asynchronous hooks in their lifecycle:
 
-- `willStart` (before the widget starts rendering)
+- `willStart` (before the component starts rendering)
 - `willUpdateProps` (before new props are set)
 
 Both these methods can be implemented and return a promise. The rendering will
 then wait for these promises to be completed before patching the DOM. This is
-useful for some use cases: for example, a widget may want to fetch an external
-library (a calendar widget may need a specialized calendar rendering library),
+useful for some use cases: for example, a component may want to fetch an external
+library (a calendar component may need a specialized calendar rendering library),
 in its willStart hook.
 
 ```javascript
-class MyCalendarWidget extends owl.Component {
+class MyCalendarComponent extends owl.Component {
     ...
 
     willStart() {
@@ -113,12 +169,14 @@ This may be dangerous (to stop the rendering waiting for the network), but it is
 extremely powerful as well, as demonstrated by the Odoo Web Client.
 
 Lazy loading static libraries can obviously be done with React/Vue, but it is
-more convoluted.
+more convoluted. For example, in Vue, you need to use a dynamic import keyword
+that needs to be transpiled at build time in order for the component to be loaded
+asynchronously (see [the documentation](https://vuejs.org/v2/guide/components-dynamic-async.html#Async-Components)).
 
-### Reactiveness
+## Reactiveness
 
 React has a simple model: whenever the state changes, it is
-replaced with a new state (via the setState method). Then, the DOM is patched.
+replaced with a new state (via the `setState` method). Then, the DOM is patched.
 This is simple, efficient, and a little bit awkward to write.
 
 Vue is a little bit different: it replace magically the properties in the state
@@ -126,10 +184,12 @@ by getters/setters. With that, it can notify components whenever the state that
 they read was changed.
 
 Owl is closer to vue: it also tracks magically the state properties, but it does
-only increment a counter whenever it changes (and a _deep_ counter for each of
-its parents). This assumes that the state is actually a tree.
+only increment an internal counter whenever it changes. Note that it is done
+with a `Proxy`, which means that it is totally transparent to the developers.
+Adding new keys is supported. Once any part of the state has been changed, a
+rendering is scheduled in the next microtask tick (promise queue).
 
-### State Management
+## State Management
 
 Managing the state of an application is a tricky issue. Many solutions have
 been proposed these last few years. It also depends on the kind of application we
@@ -188,7 +248,98 @@ keeps track of who get data, and retrigger a render when it was changed.
 
 **Owl**
 
-Owl store is a little bit like a mix of redux and vuex: it has mutations and
-actions, like VueX, it keeps track of the state changes, but it does not notify
-a component when the state changes.  Instead, components need to connect to the
-store like in redux, with a function that will listen to the relevant state.
+Owl store is a little bit like a mix of redux and vuex: it has actions (but not
+mutations), and like VueX, it keeps track of the state changes. However, it does
+not notify a component when the state changes. Instead, components need to connect
+to the store like in redux, with the `useStore` hook (see the [store documentation](reference/store.md#connecting-a-component)).
+
+```javascript
+const actions = {
+  increment({ state }, val) {
+    state.counter.value += val;
+  }
+};
+
+const state = {
+  counter: { value: 0 }
+};
+const store = new owl.Store({ state, actions });
+
+class Counter extends Component {
+  static template = xml`
+      <button t-name="Counter" t-on-click="dispatch('increment')">
+        Click Me! [<t t-esc="counter.value"/>]
+      </button>`;
+  counter = useStore(state => state.counter);
+  dispatch = useDispatch();
+}
+
+Counter.env.store = store;
+const counter = new Counter();
+```
+
+## Hooks
+
+[Hooks](https://reactjs.org/docs/hooks-intro.html#motivation) recently took over
+the React world. They solve a lot of seemingly unconnected problems: attach
+reusable behavior to a component, in a composable way, extract stateful logic
+from a component or reuse stateful logic between component, without changing your
+component hierarchy.
+
+Here is an example of the React `useState` hook:
+
+```js
+import React, { useState } from "react";
+
+function Example() {
+  // Declare a new state variable, which we'll call "count"
+  const [count, setCount] = useState(0);
+
+  return (
+    <div>
+      <p>You clicked {count} times</p>
+      <button onClick={() => setCount(count + 1)}>Click me</button>
+    </div>
+  );
+}
+```
+
+Because of the way React designed the hooks API, they only work for functional
+components. But in that case, they really are powerful. Every major React library
+is in the process of redesigning their API with hooks (for example,
+[Redux](https://react-redux.js.org/next/api/hooks)).
+
+Vue 2 does not have hooks, but the Vue project is working on its next version,
+which will feature its new [composition API](https://vue-composition-api-rfc.netlify.com/).
+This work is based on the new ideas introduced by React hooks.
+
+From the way React and Vue introduce their hooks, it may look like hooks are not
+compatible with class components. However, this is not the case, as shown by
+Owl [hooks](reference/hooks.md). They are inspired by both React and Vue. For example,
+the `useState` hook is named after React, but its API is closer to the `reactive`
+Vue hook.
+
+Here is what the `Counter` example above look like in Owl:
+
+```js
+import { Component, Owl } from "owl";
+import { xml } from "owl/tags";
+
+class Example extends Component {
+  static template = xml`
+      <div>
+        <p>You clicked {count.value} times</p>
+        <button t-on-click="increment">Click me</button>
+      </div>`;
+
+  count = useState({ value: 0 });
+
+  increment() {
+    this.state.value++;
+  }
+}
+```
+
+Since the Owl framework had hooks from early in its life, its main APIs
+are designed to be interacted with hooks from the start. For example, the
+`Context` and `Store` abstractions.

doc/component.md

@@ -1,126 +0,0 @@
-# Component
-
-The component system is designed to be:
-
-1. **declarative:** the user interface should be described in term of the state
-   of the application, not as a sequence of imperative steps.
-
-2. **composable:** each widget can seamlessly be created in a parent widget by
-   a simple directive in its template.
-
-3. **asynchronous rendering:** the framework will transparently wait for each
-   subwidgets to be ready before applying the rendering. It uses native promises
-   under the hood.
-
-4. **uses QWeb as a template system:** the templates are described in XML
-   and follow the QWeb specification. This is a requirement for Odoo.
-
-Components are the reusable, composable widgets. They are designed to be low
-level, to be declarative, and with asynchronous rendering.
-
-For example:
-
-```javascript
-export class Counter extends Component {
-  template = "counter";
-  state = { counter: 0 };
-
-  constructor(parent, props) {
-    super(parent, props);
-    this.state.counter = props.initialState || 0;
-  }
-
-  increment(delta) {
-    this.state.counter += delta;
-  }
-}
-```
-
-```xml
-    <div t-name="counter">
-      <button t-on-click="increment(-1)">-</button>
-      <span style="font-weight:bold">Value: <t t-esc="state.counter"/></span>
-      <button t-on-click="increment(1)">+</button>
-    </div>`;
-```
-
-## Lifecycle
-
-A solid and robust component system needs useful hooks/methods to help
-developers write components. Here is a description of the lifecycle of a owl
-component:
-
-- **[constructor](#constructor)**
-- **[willStart](#willStart)**
-- **[mounted](#mounted)**
-- **[willPatch](#willPatch)**
-- **[updated](#updated)**
-- **[willUnmount](#willUnmount)**
-
-Note: no hook method should ever be called manually. They are supposed to be
-called by the owl framework whenever it is required.
-
-### constructor
-
-The constructor is not exactly a hook, it is the constructor of the component.
-
-### willStart
-
-willStart is an asynchronous hook that can be implemented to perform some
-action before the initial rendering of a component.
-
-It will be called exactly once before the initial rendering. It is useful
-in some cases, for example, to load external assets (such as a JS library)
-before the widget is rendered. Another use case is to load data from a server.
-
-Note that a slow willStart method will slow down the rendering of the user
-interface. Therefore, some effort should be made to make this method as
-fast as possible.
-
-### mounted
-
-mounted is a hook that is called each time a component is attached to the
-DOM. This is a good place to add some listeners, or to interact with the
-DOM, if the component needs to perform some measure for example.
-
-It is the opposite of _willUnmount_. If a component has been mounted, it will
-be unmounted at some point.
-
-### willUpdateProps
-
-The willUpdateProps is an asynchronous hook, called just before new props
-are set. This is useful if the component needs some asynchronous task
-performed, depending on the props (for example, assuming that the props are
-some record Id, fetching the record data).
-
-This hook is not called during the first render (but willStart is called
-and performs a similar job).
-
-### willPatch
-
-The willPatch hook is called just before the DOM patching process starts.
-It is not called on the initial render. This is useful to get some
-information which are in the DOM. For example, the current position of the
-scrollbar
-
-### patched
-
-This hook is called whenever a component did actually update its props,
-state or env.
-
-This method is not called on the initial render. It is useful to interact
-with the DOM (for example, through an external library) whenever the
-component was patched.
-
-Updating the widget state in this hook is possible, but not encouraged.
-One need to be careful, because updates here will cause rerender, which in
-turn will cause other calls to patched. So, we need to be particularly
-careful at avoiding endless cycles.
-
-### willUnmount
-
-willUnmount is a hook that is called each time just before a component is unmounted from
-the DOM. This is a good place to remove some listeners, for example.
-
-This is the opposite method of _mounted_. The _willUnmount_ method will be
-called in reverse order: first the children, then the parents.

doc/learning/quick_start.md

@@ -0,0 +1,107 @@
+# 🦉 Quick Start 🦉
+
+## Static Server
+
+Let us assume that we have a static server running somewhere. Let us start by
+adding an html page with a few extra files:
+
+```
+my-app/
+    index.html
+    app.css
+    app.js
+    owl-X.Y.Z.js
+    templates.xml
+```
+
+### HTML and CSS
+
+In a file `index.html`:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>My OWL App</title>
+    <link href="app.css" rel="stylesheet" />
+    <script src="owl-X.Y.Z.js"></script>
+  </head>
+  <body>
+    <div id="main"></div>
+    <script src="app.js" type="module"></script>
+  </body>
+</html>
+```
+
+In `app.css`:
+
+```css
+button {
+  color: darkred;
+  font-size: 30px;
+  width: 220px;
+}
+```
+
+Also, let's not forget to add a release of OWL (`owl-X.Y.Z.js`)
+
+### XML
+
+In `templates.xml`:
+
+```xml
+<templates>
+   <button t-name="clickcounter" t-on-click="increment">
+      Click Me! [<t t-esc="state.value"/>]
+    </button>
+</templates>
+```
+
+### JS
+
+To build an application (or a sub-part of an application), we need two things:
+
+- an environment: it is the global context in which we are working. It needs to
+  contain a QWeb instance (preloaded with templates), and anything else that we
+  need. In practice, it could be used to contain some user session information, some
+  configuration keys (for example, isMobile = true/false if we are in mobile mode).
+
+- a description of the user interface: there should be a root component, which can
+  have sub components
+
+Here are a few steps that we may take to get started:
+
+- get the templates
+- create a qweb engine, with the templates
+- create an environment
+- create an instance of the root component
+- mount the root component to a DOM element
+
+Let us now add the javascript to make it work, in `app.js`:
+
+```javascript
+const useState = owl.hooks.useState;
+
+class ClickCounter extends owl.Component {
+  static template = "clickcounter";
+  state = useState({ value: 0 });
+
+  increment() {
+    this.state.value++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadFile("templates.xml");
+  ClickCounter.env = { qweb: new owl.QWeb({ templates }) };
+  const counter = new ClickCounter();
+  const target = document.getElementById("main");
+  await counter.mount(target);
+}
+
+start();
+```

doc/learning/testing_components.md

@@ -0,0 +1,132 @@
+# 🦉 Testing Owl components 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Unit Tests](#unit-tests)
+
+## Overview
+
+It is a good practice to test applications and components to ensure that they
+behave as expected. There are many ways to test a user interface: manual
+testing, integration testing, unit testing, ...
+
+In this section, we will discuss how to write unit tests for components, and
+how to debug them if necessary.
+
+## Unit Tests
+
+Writing unit tests for Owl components really depends on the testing framework
+used in a project. But usually, it involves the following steps:
+
+- create a test file: for example `SomeComponent.test.js`,
+- in that file, import the code for `SomeComponent`,
+- add a test case:
+  - create a real DOM element to use as test fixture,
+  - create a test environment
+  - create an instance of `SomeComponent`, mount it to the fixture
+  - interact with the component and assert some properties.
+
+To help with this, it is useful to have a `helper.js` file that contains some
+common utility functions:
+
+```js
+export function makeTestFixture() {
+  let fixture = document.createElement("div");
+  document.body.appendChild(fixture);
+  return fixture;
+}
+
+export function nextTick() {
+  let requestAnimationFrame = owl.Component.scheduler.requestAnimationFrame;
+  return new Promise(function(resolve) {
+    setTimeout(() => requestAnimationFrame(() => resolve()));
+  });
+}
+
+export function makeTestEnv() {
+    // application specific. It needs a way to load actual templates
+    const templates = ...;
+
+    return {
+        qweb: new QWeb(templates),
+        ..., // each service can be mocked here
+    };
+}
+```
+
+With such a file, a typical test suite for Jest will look like this:
+
+```js
+// in SomeComponent.test.js
+import { SomeComponent } from "../../src/ui/SomeComponent";
+import { nextTick, makeTestFixture, makeTestEnv} from '../helpers';
+
+
+//------------------------------------------------------------------------------
+// Setup
+//------------------------------------------------------------------------------
+let fixture: HTMLElement;
+let env: Env;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  // we set here the default environment for each component created in the test
+  Component.env = env;
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+describe("SomeComponent", () => {
+  test("component behaves as expected", async () => {
+    const props = {...}; // depends on the component
+    const comp = new SomeComponent(null, props);
+    await comp.mount(fixture);
+
+    // do some assertions
+    expect(...).toBe(...);
+
+    fixture.querySelector('button').click();
+    await nextTick();
+
+    // some other assertions
+    expect(...).toBe(...);
+  });
+});
+```
+
+Note that Owl does wait for the next animation frame to actually update the DOM.
+This is why it is necessary to wait with the `nextTick` (or other methods) to
+make sure that the DOM is up-to-date.
+
+It is sometimes useful to wait until Owl is completely done updating components
+(in particular, if we have a highly concurrent user interface). This next
+helper simply polls every 20ms the internal Owl task queue and returns a promise
+which resolves when it is empty:
+
+```js
+function afterUpdates() {
+  return new Promise((resolve, reject) => {
+    let timer = setTimeout(poll, 20);
+    let counter = 0;
+    function poll() {
+      counter++;
+      if (owl.Component.scheduler.tasks.length) {
+        if (counter > 10) {
+          reject(new Error("timeout"));
+        } else {
+          timer = setTimeout(poll);
+        }
+      } else {
+        resolve();
+      }
+    }
+  });
+}
+```

doc/observer.md

@@ -1,2 +0,0 @@
-# Observer
-

doc/quick_start.md

@@ -1,61 +0,0 @@
-# Quick Start
-
-To build an application (or a sub-part of an application), we need two things:
-
-- an environment
-- a root widget
-
-Here are a few steps that may be useful to get started:
-
-- get the templates
-- create a qweb engine, with the templates
-- create an environment
-- create an instance of the root widget
-- mount the root widget to a DOM element
-
-## Simple example
-
-In a oversimplified example, here is what it could look like:
-
-```javascript
-const templates = await loadTemplates();
-
-const qweb = new QWeb();
-qweb.loadTemplates(templates);
-
-const env = {
-  qweb: qweb
-};
-
-const root = new RootWidget(env, { initialState: 17 });
-
-const target = document.getElementById("app");
-root.mount(target);
-```
-
-## Managing state
-
-The environment is propagated to each subchildren. So, it is convenient to use
-to give a reference to some global object. This is potentially very useful
-in a redux-like architecture:
-
-```javascript
-...
-
-const store = new Store();
-
-const env = {
-    qweb: qweb,
-    store: store,
-};
-
-const state = store.getState()
-const root = new RootWidget(env, state);
-
-store.on('state_change', nextState => {
-    root.updateProps(nextState);
-});
-
-const target = document.getElementById('app');
-root.mount(target);
-```

doc/qweb.md

@@ -1,35 +0,0 @@
-# QWeb
-
-QWeb is a template specification. The QWeb class in this repository is:
-
-- an implementation of the QWeb specification
-- which outputs a virtual dom instead of a string
-- and extended with a few extra directives
-
-## QWeb Specification
-
-add here a full description of what QWeb is supposed to be, with some examples
-
-## QWeb Implementation
-
-```javascript
-var qweb = new QWeb();
-qweb.addTemplate("sometemplate", '<div>hello <t t-esc="name"/></div>');
-
-// result is a vnode which represent <div>hello world</div>
-result = qweb.render("sometemplate", { name: "world" });
-```
-
-## QWeb extensions
-
-- t-on directive
-- t-widget, t-props, t-key
-- t-ref
-
-## Note on white spaces
-
-White spaces in a templates are handled in a special way:
-
-- consecutive whitespaces are always condensed to a single whitespace
-- if a whitespace-only text node contains a linebreak, it is ignored
-- the previous rules do not apply if we are in a `<pre>` tag

doc/readme.md

@@ -1,14 +1,77 @@
-# Odoo Web Library Documentation
-
+# 🦉 OWL Documentation 🦉
 
 ## Reference
 
-- [Component](component.md)
-- [QWeb](qweb.md)
-- [Store](store.md)
-- [Observer](observer.md)
-- [Virtual DOM](vdom.md)
+- [Animations](reference/animations.md)
+- [Component](reference/component.md)
+- [Concurrency Model](reference/concurrency_model.md)
+- [Configuration](reference/config.md)
+- [Context](reference/context.md)
+- [Environment](reference/environment.md)
+- [Event Bus](reference/event_bus.md)
+- [Hooks](reference/hooks.md)
+- [Miscellaneous Components](reference/misc.md)
+- [Observer](reference/observer.md)
+- [Props](reference/props.md)
+- [Props Validation](reference/props_validation.md)
+- [QWeb Templating Language](reference/qweb_templating_language.md)
+- [QWeb Engine](reference/qweb_engine.md)
+- [Router](reference/router.md)
+- [Store](reference/store.md)
+- [Tags](reference/tags.md)
+- [Utils](reference/utils.md)
+
+## Learning Resources
+
+- [Quick Start: create an (almost) empty Owl application](learning/quick_start.md)
+- [Tutorial: create a TodoList application](learning/tutorial_todoapp.md)
+- [Testing Owl components](learning/testing_components.md)
 
 ## Miscellaneous
-- [Quick Start](quick_start.md)
+
 - [Comparison with React/Vue](comparison.md)
+- [Tooling](tooling.md)
+- [Templates to start Owl applications (external link)](https://github.com/ged-odoo/owl-templates)
+
+## Architecture
+
+This section explains in more detail the inner workings of Owl. It is targeted
+for developers working on Owl itself.
+
+- [Virtual DOM](architecture/vdom.md)
+- [Rendering](architecture/rendering.md)
+
+## Owl Content
+
+Here is a complete visual representation of everything exported by the `owl`
+global object (so, for example, `Component` is available at `owl.Component`,
+and `EventBus` is exported as `owl.core.EventBus`):
+
+```
+Component                               misc
+Context                                     AsyncRoot
+QWeb                                        Portal
+Store                                   router
+useState                                    Link
+config                                      RouteComponent
+    mode                                    Router
+core                                    tags
+    EventBus                                css
+    Observer                                xml
+hooks                                   utils
+    onWillStart                             debounce
+    onMounted                               escape
+    onWillUpdateProps                       loadJS
+    onWillPatch                             loadFile
+    onPatched                               shallowEqual
+    onWillUnmount                           whenReady
+    useContext
+    useState
+    useRef
+    useSubEnv
+    useStore
+    useDispatch
+    useGetters
+```
+
+Note that for convenience, the `useState` hook is also exported at the root of the `owl` object.

doc/reference/animations.md

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

doc/reference/concurrency_model.md

@@ -0,0 +1,183 @@
+# 🦉 Concurrency Model 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Rendering Components](#rendering-components)
+- [Semantics](#semantics)
+- [Asynchronous Rendering](#asynchronous-rendering)
+
+## Overview
+
+Owl was designed from the very beginning with asynchronous components. This comes
+from the `willStart` and the `willUpdateProps` lifecycle hooks. With these
+methods, it is possible to build complex highly concurrent applications.
+
+Owl concurrent mode has several benefits: it makes it possible to delay the
+rendering until some asynchronous operation is complete, it makes it possible
+to lazy load libraries, while keeping the previous screen completely functional.
+It is also good for performance reasons: Owl uses it to only apply the result of
+many different renderings only once in an animation frame. Owl can cancel
+a rendering that is no longer relevant, restart it, reuse it in some cases.
+
+But even though using concurrency is quite simple (and is the default behaviour),
+asynchrony is difficult, because it introduces an additional dimension that
+vastly increase the complexity of an application. This section will explain
+how Owl manages this complexity, how concurrent rendering works in a general way.
+
+## Rendering Components
+
+The word _rendering_ is a little vague, so, let us explain more precisely the
+process by which Owl components are displayed on a screen.
+
+When a component is mounted or updated, a new rendering is started. It has
+two phases: _virtual rendering_ and _patching_.
+
+### Virtual rendering
+
+This phase represent the process of rendering a template, in memory, which create a virtual representation of the desired component html). The output of this phase is a
+virtual DOM.
+
+It is asynchronous: each subcomponents needs to either be created (so, `willStart`
+will need to be called), or updated (which is done with the `willUpdateProps`
+method). This is completely a recursive process: a component is the root of a
+component tree, and each sub component needs to be (virtually) rendered.
+
+### Patching
+
+Once a rendering is complete, it will be applied on the next animation frame.
+This is done synchronously: the whole component tree is patched to the real
+DOM.
+
+## Semantics
+
+We give here an informal description of the way components are created/updated
+in an application. Here, ordered lists describe actions that are executed
+sequentially, bullet lists describe actions that are executed in parallel.
+
+**Scenario 1: initial rendering** Imagine we want to render the following component tree:
+
+```
+        A
+       / \
+      B   C
+         / \
+        D   E
+```
+
+Here is what happen whenever we mount the root
+component (with some code like `app.mount(document.body)`).
+
+1. `willStart` is called on `A`
+
+2. when it is done, template `A` is rendered.
+
+   - component `B` is created
+     1. `willStart` is called on `B`
+     2. template `B` is rendered
+   - component `C` is created
+     1. `willStart` is called on `C`
+     2. template `C` is rendered
+        - component `D` is created
+          1. `willStart` is called on `D`
+          2. template `D` is rendered
+        - component `E` is created
+          1. `willStart` is called on `E`
+          2. template `E` is rendered
+
+3. each components are patched into a detached DOM element, in the following order:
+   `E`, `D`, `C`, `B`, `A`. (so the actual full DOM tree is created
+   in one pass)
+
+4. the component `A` root element is actually appended to `document.body`
+
+5. The method `mounted` is called recursively on all components in the following
+   order: `E`, `D`, `C`, `B`, `A`.
+
+**Scenario 2: rerendering a component**. Now, let's assume that the user clicked on some
+button in `C`, and this results in a state update, which is supposed to:
+
+- update `D`,
+- remove `E`,
+- add new component `F`.
+
+So, the component tree should look like this:
+
+```
+        A
+       / \
+      B   C
+         / \
+        D   F
+```
+
+Here is what Owl will do:
+
+1. because of a state change, the method `render` is called on `C`
+2. template `C` is rendered again
+
+   - component `D` is updated:
+     1. hook `willUpdateProps` is called on `D` (async)
+     2. template `D` is rerendered
+   - component `F` is created:
+     1. hook `willStart` is called on `F` (async)
+     2. template `F` is rendered
+
+3. `willPatch` hooks are called recursively on components `C`, `D` (not on `F`,
+   because it is not mounted yet)
+
+4. components `F`, `D` are patched in that order
+
+5. component `C` is patched, which will cause recursively:
+
+   1. `willUnmount` hook on `E`
+   2. destruction of `E`,
+
+6. `mounted` hook is called on `F`, `patched` hooks are called on `D`, `C`
+
+Tags are very small helpers to make it easy to write inline templates. There is
+only one currently available tag: `xml`, but we plan to add other tags later,
+such as a `css` tag, which will be used to write [single file components](../tooling.md#single-file-component).
+
+### Asynchronous Rendering
+
+Working with asynchronous code always adds a lot of complexity to a system. Whenever
+different parts of a system are active at the same time, one needs to think
+carefully about all possible interactions. Clearly, this is also true for Owl
+components.
+
+There are two different common problems with Owl asynchronous rendering model:
+
+- any component can delay the rendering (initial and subsequent) of the whole
+  application
+- for a given component, there are two independant situations that will trigger an
+  asynchronous rerendering: a change in the state, or a change in the props.
+  These changes may be done at different times, and Owl has no way of knowing
+  how to reconcile the resulting renderings.
+
+Here are a few tips on how to work with asynchronous components:
+
+1. Minimize the use of asynchronous components!
+2. Maybe move the asynchronous logic in a store, which then triggers (mostly)
+   synchronous renderings
+3. Lazy loading external libraries is a good use case for async rendering. This
+   is mostly fine, because we can assume that it will only takes a fraction of a
+   second, and only once (see [`owl.utils.loadJS`](utils.md#loadjs))
+4. For all the other cases, the [`AsyncRoot`](misc.md#asyncroot) component is there to help you. When
+   this component is met, a new rendering
+   sub tree is created, such that the rendering of that component (and its
+   children) is not tied to the rendering of the rest of the interface. It can
+   be used on an asynchronous component, to prevent it from delaying the
+   rendering of the whole interface, or on a synchronous one, such that its
+   rendering isn't delayed by other (asynchronous) components. Note that this
+   directive has no effect on the first rendering, but only on subsequent ones
+   (triggered by state or props changes).
+
+   ```xml
+   <div t-name="ParentComponent">
+     <SyncChild />
+     <AsyncRoot>
+        <AsyncChild/>
+     </AsyncRoot>
+   </div>
+   ```

doc/reference/config.md

@@ -0,0 +1,27 @@
+# 🦉 Config 🦉
+
+The Owl framework is designed to work in many situations. However, it is
+sometimes necessary to customize some behaviour. This is done by using the
+global `config` object. It currently has one key:
+
+- [`mode`](#mode).
+
+## Mode
+
+By default, Owl is in _production_ mode, this means that it will try to do its
+job fast, and skip some expensive operations. However, it is sometimes necessary
+to have better information on what is going on, this is the purpose
+of the `dev` mode.
+
+Owl has a mode flag, in `owl.config.mode`. Its default value is `prod`, but
+it can be set to `dev`:
+
+```js
+owl.config.mode = "dev";
+```
+
+Note that templates compiled with the `prod` settings will not be recompiled.
+So, changing this setting is best done at startup.
+
+An important job done by the `dev` mode is to validate props for each component
+creation and update. Also, extra props will cause an error.

doc/reference/context.md

@@ -0,0 +1,105 @@
+# 🦉 Context 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Example](#example)
+- [Reference](#reference)
+  - [`Context`](#context)
+  - [`useContext`](#usecontext)
+
+## Overview
+
+The `Context` object provides a way to share data between an arbitrary number
+of components. Usually, data is passed from a parent to its children component,
+but when we have to deal with some mostly global information, this can be
+annoying, since each component will need to pass the information to each children,
+even though some or most of them will not use the information.
+
+With a `Context` object, each component can subscribe (with the `useContext` hook)
+to its state, and will be updated whenever the context state is updated.
+
+## Example
+
+Assume that we have an application with various components which needs to render
+differently depending on the size of the device. Here is how we could proceed
+to make sure that the information is properly shared. First, let us create a
+context, and add it to the environment:
+
+```js
+const deviceContext = new Context({ isMobile: true });
+App.env.deviceContext = deviceContext;
+```
+
+If we want to make it completely responsive, we need to update its value whenever
+the size of the screen is updated:
+
+```js
+const isMobile = () => window.innerWidth <= 768;
+window.addEventListener(
+  "resize",
+  owl.utils.debounce(() => {
+    const state = deviceContext.state;
+    if (state.isMobile !== isMobile()) {
+      state.isMobile = !state.isMobile;
+    }
+  }, 15)
+);
+```
+
+Then, each component that want can subscribe and render differently depending on the
+fact that we are in a mobile or desktop mode.
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+    <div>
+      <t t-if=device.isMobile>
+          some simplified user interface
+      </t>
+      <t t-else="">
+          a more advanced user interface
+      </t>
+    </div>`;
+  device = useContext(this.env.deviceContext);
+}
+```
+
+## Reference
+
+### `Context`
+
+A `Context` object should be created with a state object:
+
+```js
+const someContext = new Context({ some: "key" });
+```
+
+Its state is now available in the `state` key:
+
+```js
+someContext.state.some = "other key";
+```
+
+This is the way some global code (such as the responsive code above) should
+read and update the context state. However, components should not ever read the
+context state directly from the context, they should instead use the `useContext`
+hook to properly register themselves to state changes.
+
+Note that the `Context` hook is different from the React version. For example,
+there is no concept of provider/consumer. So, the `Context` feature does not
+by itself allow the use of a different context state depending on the component
+place in the component tree. However, this functionality can be obtained, if
+necessary, with the use of sub environment.
+
+### `useContext`
+
+The `useContext` hook is the normal way for a component to register themselve
+to context state changes. The `useContext` method returns the context state:
+
+```js
+device = useContext(this.env.deviceContext);
+```
+
+It is a simple observed state (with an owl `Observer`), which contains the shared
+information.

doc/reference/environment.md

@@ -0,0 +1,127 @@
+# 🦉 Environment 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Setting an Environment](#setting-an-environment)
+- [Using a sub environment](#using-a-sub-environment)
+- [Content of an Environment](#content-of-an-environment)
+
+## Overview
+
+An environment is an object which contains a [`QWeb` instance](qweb_engine.md). Whenever
+a root component is created, it is assigned an environment (see
+[below](#setting-an-environment) for more info on this). This environment is
+then automatically given to each sub component (and accessible in the `this.env`
+property).
+
+```
+    Root
+    /  \
+   A    B
+```
+
+This way, all components share the same `QWeb` instance. Owl internally requires
+that the environment has a `qweb` key which maps to a
+[`QWeb`](qweb_engine.md) instance. This is the QWeb instance that will be used to
+render each templates in this specific component tree. Note that if no `QWeb`
+instance is provided, Owl will simply generate it on the fly.
+
+The environment is mostly static. Each application is free to add anything to
+the environment, which is very useful, since this can be accessed by each sub
+component.
+
+## Setting an environment
+
+An Owl application needs an [environment](environment.md) to be executed. The
+environment has an important key: the [QWeb](qweb_engine.md) instance, which will render
+all templates.
+
+Whenever a root component `App` is mounted, Owl will setup a valid environment by
+following the next steps:
+
+- take the `env` object defined on `App.env` (if no `env` was explicitly setup,
+  this will return the empty `env` object defined on `Component`)
+- if `env.qweb` is not set, then Owl will create a `QWeb` instance.
+
+The correct way to customize an environment is to simply set it up on the root
+component class, before the first component is created:
+
+```js
+App.env = {
+    _t: myTranslateFunction,
+    user: {...},
+    services: {
+        ...
+    },
+};
+const app = new App();
+app.mount(document.body);
+```
+
+It is also possible to simply share an environment between all root components,
+by simply doing this:
+
+```js
+Component.env = myEnv; // will be the default env for all components
+```
+
+Note that this environment is the global owl environment for an application. The
+next section explains how to extend an environment for a specific sub component
+and its children.
+
+## Using a sub environment
+
+It is sometimes useful to add one (or more) specific keys to the environment,
+from the perspective of a specific component and its children. In that case, the
+solution presented above will not work, since it sets the global environment.
+
+There is a hook for this situation: [`useSubEnv`](hooks.md#usesubenv).
+
+```js
+class FormComponent extends Component {
+  constructor(parent, props) {
+    super(parent, props);
+    useSubEnv({ myKey: someValue });
+  }
+}
+```
+
+## Content of an Environment
+
+Some good use cases for additional keys in the environment are:
+
+- some configuration keys,
+- session information,
+- generic services (such as doing rpcs, or accessing local storage).
+
+Doing it this way means that components are easily testable: we can simply
+create a test environment with mock services.
+
+For example:
+
+```js
+async function myEnv() {
+  const templates = await loadTemplates();
+  const qweb = new QWeb({ templates });
+  const session = getSession();
+
+  return {
+    _t: myTranslateFunction,
+    session: session,
+    qweb: qweb,
+    services: {
+      localStorage: localStorage,
+      rpc: rpc
+    },
+    debug: false,
+    inMobileMode: true
+  };
+}
+
+async function start() {
+  App.env = await myEnv();
+  const app = new App();
+  await app.mount(document.body);
+}
+```

doc/reference/event_bus.md

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

doc/reference/hooks.md

@@ -0,0 +1,447 @@
+# 🦉 Hooks 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Example: Mouse Position](#example-mouse-position)
+- [Example: Autofocus](#example-autofocus)
+- [Reference](#reference)
+  - [One Rule](#one-rule)
+  - [`useState`](#usestate)
+  - [`onMounted`](#onmounted)
+  - [`onWillUnmount`](#onwillunmount)
+  - [`onWillPatch`](#onwillpatch)
+  - [`onPatched`](#onpatched)
+  - [`onWillStart`](#onwillstart)
+  - [`onWillUpdateProps`](#onwillupdateprops)
+  - [`useContext`](#usecontext)
+  - [`useRef`](#useref)
+  - [`useSubEnv`](#usesubenv)
+  - [`useExternalListener`](#useexternallistener)
+  - [`useStore`](#usestore)
+  - [`useDispatch`](#usedispatch)
+  - [`useGetters`](#usegetters)
+  - [Making customized hooks](#making-customized-hooks)
+
+## Overview
+
+Hooks were popularised by React as a way to solve the following issues:
+
+- help reusing stateful logic between components
+- help organizing code by feature in complex components
+- use state in functional components, without writing a class.
+
+Owl hooks serve the same purpose, except that they work for class components
+(note: React hooks do not work on class components, and maybe because of that,
+there seems to be the misconception that hooks are in opposition to class. This
+is clearly not true, as shown by Owl hooks).
+
+Hooks work beautifully with Owl components: they solve the problems mentioned
+above, and in particular, they are the perfect way to make your component
+reactive.
+
+## Example: mouse position
+
+Here is the classical example of a non trivial hook to track the mouse position.
+
+```js
+const { useState, onMounted, onWillUnmount } = owl.hooks;
+
+// We define here a custom behaviour: this hook tracks the state of the mouse
+// position
+function useMouse() {
+  const position = useState({ x: 0, y: 0 });
+
+  function update(e) {
+    position.x = e.clientX;
+    position.y = e.clientY;
+  }
+  onMounted(() => {
+    window.addEventListener("mousemove", update);
+  });
+  onWillUnmount(() => {
+    window.removeEventListener("mousemove", update);
+  });
+
+  return position;
+}
+
+// Main root component
+class App extends owl.Component {
+  static template = xml`
+    <div t-name="App">
+      <div>Mouse: <t t-esc="mouse.x"/>, <t t-esc="mouse.y"/></div>
+    </div>`;
+
+  // this hooks is bound to the 'mouse' property.
+  mouse = useMouse();
+}
+```
+
+Note that we use the prefix `use` for hooks, just like in React. This is just
+a convention.
+
+## Example: autofocus
+
+Hooks can be combined to create the desired effect. For example, the following
+hook combines the `useRef` hook with the `onPatched` and `onMounted` functions
+to create an easy way to focus an input whenever it appears in the DOM:
+
+```js
+function useAutofocus(name) {
+  let ref = useRef(name);
+  let isInDom = false;
+  function updateFocus() {
+    if (!isInDom && ref.el) {
+      isInDom = true;
+      ref.el.focus();
+    } else if (isInDom && !ref.el) {
+      isInDom = false;
+    }
+  }
+  onPatched(updateFocus);
+  onMounted(updateFocus);
+}
+```
+
+This hook takes the name of a valid `t-ref` directive, which should be present
+in the template. It then checks whenever the component is mounted or patched if
+the reference is not valid, and in this case, it will focus the node element.
+This hook can be used like this:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+    <div>
+        <input />
+        <input t-ref="myinput"/>
+    </div>`;
+
+  constructor(...args) {
+    super(...args);
+    useAutofocus("myinput");
+  }
+}
+```
+
+## Reference
+
+### One rule
+
+There is only one rule: every hook for a component has to be called in the
+constructor (or in class fields):
+
+```js
+// ok
+class SomeComponent extends Component {
+  state = useState({ value: 0 });
+}
+
+// also ok
+class SomeComponent extends Component {
+  constructor(...args) {
+    super(...args);
+    this.state = useState({ value: 0 });
+  }
+}
+
+// not ok: this is executed after the constructor is called
+class SomeComponent extends Component {
+  async willStart() {
+    this.state = useState({ value: 0 });
+  }
+}
+```
+
+As you can see, the `useState` hook does not need to be given a reference to
+the component. This is possible because there is a way to get a reference to the
+current component: the `Component.current` static property is the reference to the
+component instance that is currently being created.
+
+Hooks need to be called in the constructor to ensure that this reference is
+properly set. This is also a good thing for performance reasons (Owl can use
+this to optimize its implementation), and for a clean architecture (this makes
+it easier for developers to understand what is really happening in a component).
+
+### `useState`
+
+The `useState` hook is certainly the most important hook for Owl components:
+this is what allows a component to be reactive, to react to state change.
+
+The `useState` hook has to be given an object or an array, and will return
+an observed version of it (using a `Proxy`).
+
+```javascript
+const { useState } = owl.hooks;
+
+class Counter extends owl.Component {
+  static template = xml`
+    <button t-on-click="increment">
+        Click Me! [<t t-esc="state.value"/>]
+    </button>`;
+
+  state = useState({ value: 0 });
+
+  increment() {
+    this.state.value++;
+  }
+}
+```
+
+It is important to remember that `useState` only works with objects or arrays. It
+is necessary, since Owl needs to react to a change in state.
+
+### `onMounted`
+
+`onMounted` is not a user hook, but is a building block designed to help make useful
+abstractions. `onMounted` registers a callback, which will be called when the component
+is mounted (see example on top of this page).
+
+### `onWillUnmount`
+
+`onWillUnmount` is not a user hook, but is a building block designed to help make useful
+abstractions. `onWillUnmount` registers a callback, which will be called when the component
+is unmounted (see example on top of this page).
+
+### `onWillPatch`
+
+`onWillPatch` is not a user hook, but is a building block designed to help make useful
+abstractions. `onWillPatch` registers a callback, which will be called just
+before the component patched.
+
+### `onPatched`
+
+`onPatched` is not a user hook, but is a building block designed to help make useful
+abstractions. `onPatched` registers a callback, which will be called just
+after the component patched.
+
+### `onWillStart`
+
+`onWillStart` is an asynchronous hook. This means that the function registered
+in the hook will be run just before the component is first rendered and can return a
+promise, to express the fact that it is an asynchronous operation.
+
+Note that if there are more than one `onWillStart` registered callback, then they
+will all be run in parallel.
+
+It can be used to load some initial data. For example, the following hook will
+automatically load some data from the server, and return an object that will
+be ready whenever the component is rendered:
+
+```js
+function useLoader() {
+  const component = Component.current;
+  const record = useState({});
+  onWillStart(async () => {
+    const recordId = component.props.id;
+    Object.assign(record, await fetchSomeRecord(recordId));
+  });
+  return record;
+}
+```
+
+Note that this example does not update the record value whenever props are
+updated. For that situation, we need to use the `onWillUpdateProps` hook.
+
+### `onWillUpdateProps`
+
+Just like `onWillStart`, `onWillUpdateProps` is an asynchronous hook. It is
+designed to be run whenever the component props are updated. This could be
+useful to perform some asynchronous task such as fetching updated data.
+
+```js
+function useLoader() {
+  const component = Component.current;
+  const record = useState({});
+
+  async function updateRecord(id) {
+    Object.assign(record, await fetchSomeRecord(id));
+  }
+
+  onWillStart(() => updateRecord(component.props.id));
+  onWillUpdateProps(nextProps => updateRecord(nextProps.id));
+
+  return record;
+}
+```
+
+Note that if there are more than one `onWillUpdateProps` registered callback,
+then they will all be run in parallel.
+
+### `useContext`
+
+See [`useContext`](context.md#usecontext) for reference documentation.
+
+### `useRef`
+
+The `useRef` hook is useful when we need a way to interact with some inside part
+of a component, rendered by Owl. It can work either on a DOM node, or on a component,
+tagged by the `t-ref` directive:
+
+```xml
+<div>
+    <div t-ref="someDiv"/>
+    <SubComponent t-ref="someComponent"/>
+</div>
+```
+
+In this example, the component will be able to access the `div` and the component
+`SubComponent` using the `useRef` hook:
+
+```js
+class Parent extends Component {
+  subRef = useRef("someComponent");
+  divRef = useRef("someDiv");
+
+  someMethod() {
+    // here, if component is mounted, refs are active:
+    // - this.divRef.el is the div HTMLElement
+    // - this.subRef.comp is the instance of the sub component
+    // - this.subRef.el is the root HTML node of the sub component (i.e. this.subRef.comp.el)
+  }
+}
+```
+
+As shown by the example above, html elements are accessed by using the `el`
+key, and components references are accessed with `comp`.
+
+Notes:
+
+- if used on a component, the reference will be set in the `refs`
+  variable between `willPatch` and `patched`,
+- on a component, accessing `ref.el` will get the root node of the component.
+
+The `t-ref` directive also accepts dynamic values with string interpolation
+(like the [`t-attf-`](qweb_templating_language.md#dynamic-attributes) and
+`t-component` directives). For example,
+
+```xml
+<div t-ref="component_{{someCondition ? '1' : '2'}}"/>
+```
+
+Here, the references need to be set like this:
+
+```js
+this.ref1 = useRef("component_1");
+this.ref2 = useRef("component_2");
+```
+
+References are only guaranteed to be active while the parent component is mounted.
+If this is not the case, accessing `el` or `comp` on it will return `null`.
+
+### `useSubEnv`
+
+The environment is sometimes useful to share some common information between
+all components. But sometimes, we want to _scope_ that knowledge to a subtree.
+
+For example, if we have a form view component, maybe we would like to make some
+`model` object available to all sub components, but not to the whole application.
+This is where the `useSubEnv` hook may be useful: it lets a component add some
+information to the environment in a way that only the component and its children
+can access it:
+
+```js
+class FormComponent extends Component {
+  constructor(...args) {
+    super(...args);
+    const model = makeModel();
+    useSubEnv({ model });
+  }
+}
+```
+
+The `useSubEnv` takes one argument: an object which contains some key/value that
+will be added to the parent environment. Note that it will extend, not replace
+the parent environment. And of course, the parent environment will not be
+affected.
+
+### `useExternalListener`
+
+The `useExternalListener` hook helps solve a very common problem: adding and removing
+a listener on some target whenever a component is mounted/unmounted. For example,
+a dropdown menu (or its parent) may need to listen to a `click` event on `window`
+to be closed:
+
+```js
+useExternalListener(window, "click", this.closeMenu);
+```
+
+### `useStore`
+
+The `useStore` hook is the entry point for a component to connect to the store.
+See the [store documentation](store.md) for more information.
+
+### `useDispatch`
+
+The `useDispatch` hook is the way for components to get a reference to the store
+`dispatch` function. See the [store documentation](store.md) for more information.
+
+### `useGetters`
+
+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.
+
+### Making customized hooks
+
+Hooks are a wonderful way to organize the code of a complex component by feature
+instead of by lifecycle methods. They are like mixins, except that they can be
+easily composed together.
+
+But, like every good things in life, hooks should be used with moderation. They are
+not the solution to every problem.
+
+- they may be overkill: if your component needs to perform some action specific
+  to itself (so, the specific code does not need to be shared), there is nothing
+  wrong with a simple class method:
+
+  ```js
+  // maybe overkill
+  class A extends Component {
+    constructor(...args) {
+      super(...args);
+      useMySpecificHook();
+    }
+  }
+
+  // ok
+  class B extends Component {
+    constructor(...args) {
+      super(...args);
+      this.performSpecificTask();
+    }
+  }
+  ```
+
+  Note that the second solution is easier to extend in sub components.
+
+- they may be harder to test: if a customized hook injects some external side
+  effect dependency, then it is harder to test without doing some non obvious
+  manipulation. For example, assume that we want to give a reference to a
+  router in a `useRouter` hook. We could do this:
+
+  ```js
+  const router = new Router(...);
+
+  function useRouter() {
+      return router;
+  }
+  ```
+
+  As you can see, this does not _hook_ into the internal of the component. It
+  simply returns a global object, which is difficult to mock.
+
+  A better way would be to do something like this: get the reference from the
+  environment.
+
+  ```js
+  function useRouter() {
+    return Component.current.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

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

doc/reference/observer.md

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

doc/reference/props.md

@@ -0,0 +1,97 @@
+# 🦉 Props 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Definition](#definition)
+- [Good Practices](#good-practices)
+- [Dynamic Props](#dynamic-props)
+
+## Overview
+
+In Owl, `props` (short for _properties_) is an object which contains every piece
+of data given to a component by its parent.
+
+```js
+class Child extends Component {
+  static template = xml`<div><t t-esc="props.a"/><t t-esc="props.b"/></div>`;
+}
+
+class Parent extends Component {
+  static template = xml`<div><ComponentA a="state.a" b="'string'"/></div>`;
+  static components = { Child };
+  state = useState({ a: "fromparent" });
+}
+```
+
+In this example, the `Child` component receives two props from its parent: `a`
+and `b`. They are collected into a `props` object by Owl, with each value being
+evaluated in the context of the parent. So, `props.a` is equal to `'fromparent'` and
+`props.b` is equal to `'string'`.
+
+Note that `props` is an object that only makes sense from the perspective of the
+child component.
+
+## Definition
+
+The `props` object is made of every attributes defined on the template, with the
+following exceptions:
+
+- every attribute starting with `t-` are not props (they are QWeb directives),
+- `style` and `class` attributes are excluded as well (they are applied by Owl on
+  the root element of the component).
+
+In the following example:
+
+```xml
+<div>
+    <ComponentA a="state.a" b="'string'"/>
+    <ComponentB t-if="state.flag" model="model"/>
+    <ComponentC style="color:red;" class="left-pane" />
+</div>
+```
+
+the `props` object contains the following keys:
+
+- for `ComponentA`: `a` and `b`,
+- for `ComponentB`: `model`,
+- for `ComponentC`: empty object
+
+## Good Practices
+
+A `props` object is a collection of values that come from the parent. As such,
+they are owned by the parent, and should never be modified by the child:
+
+```js
+class MyComponent extends Component {
+  constructor(parent, props) {
+    super(parent, props);
+    props.a.b = 43; // Never do that!!!
+  }
+}
+```
+
+Props should be considered readonly, from the perspective of the child component.
+If there is a need to modify them, then the request to update them should be
+sent to the parent (for example, with an event).
+
+Any value can go in a props. Strings, objects, classes, or even callbacks could
+be given to a child component (but then, in the case of callbacks, communicating
+with events seems more appropriate).
+
+## Dynamic Props
+
+The `t-props` directive can be used to specify totally dynamic props:
+
+```xml
+<div t-name="ParentComponent">
+    <Child t-props="some.obj"/>
+</div>
+```
+
+```js
+class ParentComponent {
+  static components = { Child };
+  some = { obj: { a: 1, b: 2 } };
+}
+```

doc/reference/props_validation.md

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

doc/reference/qweb_engine.md

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

doc/reference/qweb_templating_language.md

@@ -0,0 +1,548 @@
+# 🦉 QWeb Templating Language🦉
+
+## Content
+
+- [Overview](#overview)
+- [Directives](#directives)
+- [Reference](#reference)
+  - [White Spaces](#white-spaces)
+  - [Root Nodes](#root-nodes)
+  - [Expression Evaluation](#expression-evaluation)
+  - [Static html Nodes](#static-html-nodes)
+  - [Outputting Data](#outputting-data)
+  - [Setting Variables](#setting-variables)
+  - [Conditionals](#conditionals)
+  - [Dynamic Attributes](#dynamic-attributes)
+  - [Loops](#loops)
+  - [Rendering Sub Templates](#rendering-sub-templates)
+  - [Translations](#translations)
+  - [Debugging](#debugging)
+
+## Overview
+
+[QWeb](https://www.odoo.com/documentation/13.0/reference/qweb.html) is the primary
+templating engine used by Odoo. It is based on the XML format, and used
+mostly to generate HTML. In OWL, QWeb templates are compiled into functions that
+generate a virtual dom representation of the HTML.
+
+```xml
+<div>
+    <span t-if="somecondition">Some string</span>
+    <ul t-else="">
+        <li t-foreach="messages" t-as="message">
+            <t t-esc="message"/>
+        </li>
+    </ul>
+</div>
+```
+
+Template directives are specified as XML attributes prefixed with `t-`, for
+instance `t-if` for conditionals, with elements and other attributes being
+rendered directly.
+
+To avoid element rendering, a placeholder element `<t>` is also available, which
+executes its directive but doesn’t generate any output in and of itself.
+
+We present in this section the templating language, including its Owl specific
+extensions.
+
+## Directives
+
+For reference, here is a list of all standard QWeb directives:
+
+| Name                           | Description                                                    |
+| ------------------------------ | -------------------------------------------------------------- |
+| `t-esc`                        | [Outputting safely a value](#outputting-data)                  |
+| `t-raw`                        | [Outputting value, without escaping](#outputting-data)         |
+| `t-set`, `t-value`             | [Setting variables](#setting-variables)                        |
+| `t-if`, `t-elif`, `t-else`,    | [conditionally rendering](#conditionals)                       |
+| `t-foreach`, `t-as`            | [Loops](#loops)                                                |
+| `t-att`, `t-attf-*`, `t-att-*` | [Dynamic attributes](#dynamic-attributes)                      |
+| `t-call`                       | [Rendering sub templates](#rendering-sub-templates)            |
+| `t-debug`, `t-log`             | [Debugging](#debugging)                                        |
+| `t-translation`                | [Disabling the translation of a node](#translations)           |
+| `t-name`                       | [Defining a template (not really a directive)](qweb_engine.md) |
+
+The component system in Owl requires additional directives, to express various
+needs. Here is a list of all Owl specific directives:
+
+| Name                     | Description                                                                     |
+| ------------------------ | ------------------------------------------------------------------------------- |
+| `t-component`, `t-props` | [Defining a sub component](component.md#composition)                            |
+| `t-ref`                  | [Setting a reference to a dom node or a sub component](component.md#references) |
+| `t-key`                  | [Defining a key (to help virtual dom reconciliation)](#loops)                   |
+| `t-on-*`                 | [Event handling](component.md#event-handling)                                   |
+| `t-transition`           | [Defining an animation](animations.md#css-transitions)                          |
+| `t-slot`                 | [Rendering a slot](component.md#slots)                                          |
+| `t-model`                | [Form input bindings](component.md#form-input-bindings)                         |
+
+## Reference
+
+### White Spaces
+
+White spaces in a template are handled in a special way:
+
+- consecutive whitespaces are always condensed to a single whitespace
+- if a whitespace-only text node contains a linebreak, it is ignored
+- the previous rules do not apply if we are in a `<pre>` tag
+
+### Root Nodes
+
+For many reasons, Owl QWeb templates should have a single root node. More
+precisely, the result of a template rendering should have a single root node:
+
+```xml
+<!–– not ok: two root nodes ––>
+<t>
+    <div>foo</div>
+    <div>bar</div>
+</t>
+
+<!–– ok: result has one single root node ––>
+<t>
+    <div t-if="someCondition">foo</div>
+    <span t-else="">bar</span>
+</t>
+```
+
+Extra root nodes will actually be ignored (even though they will be rendered
+in memory).
+
+Note: this does not apply to subtemplates (see the `t-call` directive). In that
+case, they will be inlined in the main template, and can actually have many
+root nodes.
+
+### Expression Evaluation
+
+QWeb expressions are strings that will be processed at compile time. Each variable in
+the javascript expression will be replaced with a lookup in the context (so, the
+component). For example, `a + b.c(d)` will be converted into:
+
+```js
+context["a"] + context["b"].c(context["d"]);
+```
+
+It is useful to explain the various rules that apply on these expressions:
+
+1. it should be a simple expression which returns a value. It cannot be a statement.
+
+   ```xml
+   <div><p t-if="1 + 2 === 3">ok</p></div>
+   ```
+
+   is valid, but the following is not valid:
+
+   ```xml
+   <div><p t-if="console.log(1)">NOT valid</p></div>
+   ```
+
+2. it can use anything in the rendering context (typically, the component):
+
+   ```xml
+   <p t-if="user.birthday === today()">Happy bithday!</p>
+   ```
+
+   is valid, and will read the `user` object from the context, and call the
+   `today` function.
+
+3. it can use a few special operators to avoid using symbols such as `<`, `>`,
+   `&` or `|`. This is useful to make sure that we still write valid XML.
+
+   | Word  | replaced with |
+   | ----- | ------------- |
+   | `and` | `&&`          |
+   | `or`  | `\|\|`        |
+   | `gt`  | `>`           |
+   | `gte` | `>=`          |
+   | `lt`  | `<`           |
+   | `lte` | `<=`          |
+
+   So, one can write this:
+
+   ```xml
+   <div><p t-if="10 + 2 gt 5">ok</p></div>
+   ```
+
+### Static Html Nodes
+
+Normal, regular html nodes are rendered into themselves:
+
+```xml
+  <div>hello</div> <!–– rendered as itself ––>
+```
+
+### Outputting Data
+
+The `t-esc` directive is necessary whenever you want to add a dynamic text
+expression in a template. The text is escaped to avoid security issues.
+
+```xml
+<p><t t-esc="value"/></p>
+```
+
+rendered with the value `value` set to `42` in the rendering context yields:
+
+```html
+<p>42</p>
+```
+
+The `t-raw` directive is almost the same as `t-esc`, but without the escaping.
+This is mostly useful to inject a raw html string somewhere. Obviously, this
+is unsafe to do in general, and should only be used for strings known to be safe.
+
+```xml
+<p><t t-raw="value"/></p>
+```
+
+rendered with the value `value` set to `<span>foo</span>` in the rendering context yields:
+
+```html
+<p><span>foo</span></p>
+```
+
+Note that since the content of the expression is not known beforehand, the `t-raw`
+directive has to parse the html (and convert it to a virtual dom structure) for
+each rendering. So, it will be much slower than a regular template. It is
+therefore advised to limit the use of `t-raw` whenever possible.
+
+### Setting Variables
+
+QWeb allows creating variables from within the template, to memoize a computation (to use it multiple times), give a piece of data a clearer name, ...
+
+This is done via the `t-set` directive, which takes the name of the variable to create. The value to set can be provided in two ways:
+
+1. a `t-value` attribute containing an expression, and the result of its
+   evaluation will be set:
+
+   ```xml
+   <t t-set="foo" t-value="2 + 1"/>
+   <t t-esc="foo"/>
+   ```
+
+   will print `3`. Note that the evaluation is done at rendering time, not at
+   compilte time.
+
+2. if there is no `t-value` attribute, the node’s body is saved and its value is
+   set as the variable’s value:
+
+   ```xml
+   <t t-set="foo">
+       <li>ok</li>
+   </t>
+   <t t-esc="foo"/>
+   ```
+
+   will generate `&lt;li&gt;ok&lt;/li&gt;` (the content is escaped as we used the `t-esc` directive)
+
+The `t-set` directive acts like a regular variable in most programming language.
+It is lexically scoped (inner nodes are sub scopes), can be shadowed, ...
+
+### Conditionals
+
+The `t-if` directive is useful to conditionally render something. It evaluates
+the expression given as attribute value, and then acts accordingly.
+
+```xml
+<div>
+    <t t-if="condition">
+        <p>ok</p>
+    </t>
+</div>
+```
+
+The element is rendered if the condition (evaluated with the current rendering
+context) is true:
+
+```xml
+<div>
+    <p>ok</p>
+</div>
+```
+
+but if the condition is false it is removed from the result:
+
+```xml
+<div>
+</div>
+```
+
+The conditional rendering applies to the bearer of the directive, which does not
+have to be `<t>`:
+
+```xml
+<div>
+    <p t-if="condition">ok</p>
+</div>
+```
+
+will give the same results as the previous example.
+
+Extra conditional branching directives `t-elif` and `t-else` are also available:
+
+```xml
+<div>
+    <p t-if="user.birthday == today()">Happy bithday!</p>
+    <p t-elif="user.login == 'root'">Welcome master!</p>
+    <p t-else="">Welcome!</p>
+</div>
+```
+
+### Dynamic Attributes
+
+One can use the `t-att-` directive to add dynamic attributes. Its main use is to
+evaluate an expression (at rendering time) and bind an attribute to its result:
+
+For example, if we have `id` set to 32 in the rendering context,
+
+```xml
+<div t-att-data-action-id="id"/> <!-- result: <div data-action-id="32"></div> -->
+```
+
+If an expression evaluates to a falsy value, it will not be set at all:
+
+```xml
+<div t-att-foo="false"/>  <!-- result: <div></div> -->
+```
+
+It is sometimes convenient to format an attribute with string interpolation. In
+that case, the `t-attf-` directive can be used. It is useful when we need to mix
+literal and dynamic elements, such as css classes.
+
+```xml
+<div t-attf-foo="a {{value1}} is {{value2}} of {{value3}} ]"/>
+<!-- result if values are set to 1,2 and 3: <div foo="a 0 is 1 of 2 ]"></div> -->
+```
+
+If we need completely dynamic attribute names, then there is an additional
+directive: `t-att`, which takes either an object (with keys mapping to their
+values) or a pair `[key, value]`. For example:
+
+```xml
+<div t-att="{'a': 1, 'b': 2}"/> <!-- result: <div a="1" b="2"></div> -->
+
+<div t-att="['a', 'b']"/> <!-- <div a="b"></div> -->
+```
+
+### Loops
+
+QWeb has an iteration directive `t-foreach` which take an expression returning the
+collection to iterate on, and a second parameter `t-as` providing the name to use
+for the current item of the iteration:
+
+```xml
+<t t-foreach="[1, 2, 3]" t-as="i">
+    <p><t t-esc="i"/></p>
+</t>
+```
+
+will be rendered as:
+
+```xml
+<p>1</p>
+<p>2</p>
+<p>3</p>
+```
+
+Like conditions, `t-foreach` applies to the element bearing the directive’s attribute, and
+
+```xml
+<p t-foreach="[1, 2, 3]" t-as="i">
+    <t t-esc="i"/>
+</p>
+```
+
+is equivalent to the previous example.
+
+`t-foreach` can iterate on an array (the current item will be the current value)
+or an object (the current item will be the current key).
+
+In addition to the name passed via t-as, `t-foreach` provides a few other
+variables for various data points (note: `$as` will be replaced with the name
+passed to `t-as`):
+
+- `$as_value`: the current iteration value, identical to `$as` for lists and
+  integers, but for objects, it provides the value (where `$as` provides the key)
+- `$as_index`: the current iteration index (the first item of the iteration has index 0)
+- `$as_first`: whether the current item is the first of the iteration
+  (equivalent to `$as_index == 0`)
+- `$as_last`: whether the current item is the last of the iteration
+  (equivalent to `$as_index + 1 == $as_size`), requires the iteratee’s size be
+  available
+
+These extra variables provided and all new variables created into the `t-foreach`
+are only available in the scope of the `t-foreach`. If the variable exists outside
+the context of the `t-foreach`, the value is copied at the end of the foreach
+into the global context.
+
+```xml
+<t t-set="existing_variable" t-value="false"/>
+<!-- existing_variable now False -->
+
+<p t-foreach="Array(3)" t-as="i">
+    <t t-set="existing_variable" t-value="true"/>
+    <t t-set="new_variable" t-value="true"/>
+    <!-- existing_variable and new_variable now true -->
+</p>
+
+<!-- existing_variable always true -->
+<!-- new_variable undefined -->
+```
+
+Even though Owl tries to be as declarative as possible, the DOM does not fully
+expose its state declaratively in the DOM tree. For example, the scrolling state,
+the current user selection, the focused element or the state of an input are not
+set as attribute in the DOM tree. This is why we use a virtual dom
+algorithm to keep the actual DOM node as much as possible.
+
+However, in some situations, this is not enough, and we need to help Owl decide
+if an element is actually the same, or is a different element with the same
+properties.
+
+Consider the following situation: we have a list of two items `[{text: "a"}, {text: "b"}]`
+and we render them in this template:
+
+```xml
+<p t-foreach="items" t-as="item"><t t-esc="item.text"/></p>
+```
+
+The result will be two `<p>` tags with text `a` and `b`. Now, if we swap them,
+and rerender the template, Owl needs to know what the intent is:
+
+- should Owl actually swap the DOM nodes,
+- or should it keep the DOM nodes, but with an updated text content?
+
+This might look trivial, but it actually matters. These two possibilities lead
+to different results in some cases. For example, if the user selected the text
+of the first `p`, swapping them will keep the selection while updating the
+text content will not.
+
+There are many other cases where this is important: `input` tags with their
+value, css classes and animations, scroll position...
+
+So, the `t-key` directive is used to give an identity to an element. It allows
+Owl to understand if different elements of a list are actually different or not.
+
+The above example could be modified by adding an ID: `[{id: 1, text: "a"}, {id: 2, text: "b"}]`.
+Then, the template could look like this:
+
+```xml
+<p t-foreach="items" t-as="item" t-key="item.id"><t t-esc="item.text"/></p>
+```
+
+The `t-key` directive is useful for lists (`t-foreach`). A key should be
+a unique number or string (objects will not work: they will be cast to the
+`"[object Object]"` string, which is obviously not unique).
+
+Also, the key can be set on a `t` tag or on its children. The following variations
+are all equivalent:
+
+```xml
+<p t-foreach="items" t-as="item" t-key="item.id">
+  <t t-esc="item.text"/>
+</p>
+
+<t t-foreach="items" t-as="item" t-key="item.id">
+  <p t-esc="item.text"/>
+</t>
+
+<t t-foreach="items" t-as="item">
+  <p t-key="item.id" t-esc="item.text"/>
+</t>
+```
+
+If there is no `t-key` directive, Owl will use the index as a default key.
+
+### Rendering Sub Templates
+
+QWeb templates can be used for top level rendering, but they can also be used
+from within another template (to avoid duplication or give names to parts of
+templates), using the `t-call` directive:
+
+```xml
+<div t-name="other-template">
+    <p><t t-value="var"/></p>
+</div>
+
+<div t-name="main-template">
+    <t t-set="var" t-value="owl"/>
+    <t t-call="other-template"/>
+</div>
+```
+
+will be rendered as `<div><p>owl</p></div>`. This example shows that the sub
+template is rendered with the execution context of the parent. The sub template
+is actually inlined in the main template, but in a sub scope: variables defined
+in the sub template do not escape.
+
+Sometimes, one might want to pass information to the sub template. In that case,
+the content of the body of the `t-call` directive is available as a special
+magic variable `0`:
+
+```xml
+<t t-name="other-template">
+    This template was called with content:
+    <t t-raw="0"/>
+</t>
+
+<div t-name="main-template">
+    <t t-call="other-template">
+        <em>content</em>
+    </t>
+</div>
+```
+
+will result in :
+
+```xml
+<div>
+    This template was called with content:
+    <em>content</em>
+</div>
+```
+
+This can be used to define variables scoped to a sub template:
+
+```xml
+<t t-call="other-template">
+    <t t-set="var" t-value="1"/>
+</t>
+<!-- "var" does not exist here -->
+```
+
+### Translations
+
+By default, QWeb specify that templates should be translated. If this behaviour
+is not wanted, there is a `t-translation` directive which can turn off
+translations (if it is set to the `off` value), with the following rules:
+
+- each text node will be replaced with its translation,
+- each of the following attribute values will be translated as well: `title`,
+  `placeholder`, `label` and `alt`,
+- translating text nodes can be disabled with the special attribute `t-translation`,
+  if its value is `off`.
+
+See [here](qweb_engine.md#translations) for more information on how to setup a
+translate function in Owl QWeb.
+
+### Debugging
+
+The javascript QWeb implementation provides two useful debugging directives:
+
+`t-debug` adds a debugger statement during template rendering:
+
+```xml
+<t t-if="a_test">
+    <t t-debug="">
+</t>
+```
+
+will stop execution if the browser dev tools are open.
+
+`t-log` takes an expression parameter, evaluates the expression during rendering and logs its result with console.log:
+
+```xml
+<t t-set="foo" t-value="42"/>
+<t t-log="foo"/>
+```
+
+will print 42 to the console.

doc/reference/router.md

@@ -0,0 +1,181 @@
+# 🦉 Router 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Example](#example)
+- [Reference](#reference)
+  - [Route Definition](#route-definition)
+  - [Router](#router)
+  - [Navigation Guards](#navigation-guards)
+  - [RouteComponent](#routecomponent)
+  - [Link](#link)
+
+## Overview
+
+It is often useful to organize an application around urls. If the application is
+a single page application, then we need a way to manage those urls in the browser.
+This is why there are many different routers for different frameworks. A generic
+router can do the job just fine, but a specialized router for Owl can give a
+better developer experience.
+
+The Owl router support the following features:
+
+- `history` or `hash` mode
+- declarative routes
+- route redirection
+- navigation guards
+- parameterized routes
+- a `<Link/>` component
+- a `<RouteComponent/>` component
+
+Note that it is still in early stage of developments, and there are probably
+still some issues.
+
+## Example
+
+To use the Owl router, there are some steps that needs to be done:
+
+- declare some routes
+- create a router
+- add it to the environment
+
+```js
+async function protectRoute({ env, to }) {
+  if (!env.session.authUser) {
+    env.session.setNextRoute(to.name);
+    return { to: "SIGN_IN" };
+  }
+  return true;
+}
+
+export const ROUTES = [
+  { name: "LANDING", path: "/", component: Landing },
+  { name: "TASK", path: "/tasks/{{id}}", component: Task },
+  { name: "SIGN_UP", path: "/signup", component: SignUp },
+  { name: "SIGN_IN", path: "/signin", component: SignIn },
+  { name: "ADMIN", path: "/admin", component: Admin, beforeRouteEnter: protectRoute },
+  { name: "ACCOUNT", path: "/account", component: Account, beforeRouteEnter: protectRoute },
+  { name: "UNKNOWN", path: "*", redirect: { to: "LANDING" } }
+];
+
+function makeEnvironment() {
+    ...
+    const env = { qweb };
+    env.session = new Session(env);
+    env.router = new owl.router.Router(env, ROUTES);
+    await env.router.start();
+    return env;
+}
+
+App.env = makeEnvironment();
+// create root component here
+```
+
+Notice that the router needs to be started. This is an asynchronous operation
+because it needs to apply the potential navigation guards on the current route
+(which may or may not mean that the application is redirected to another route).
+
+## Reference
+
+### Route definition
+
+A route need to be defined as an object with the following keys:
+
+- `name` (optional): a (unique) string useful to identify the current route. If not
+  given, it will be assigned an automatic name,
+- `path`: a string describing the url. It can be static: `/admin` or dynamic: `/users/{{id}}`.
+  It also can be `*`, to catch all remaining routes.
+- `component` (optional): an Owl component that will be used by the `t-routecomponent`
+  directive if the route is active
+- `redirect` (optional): should be destination object (with optional keys `path`, `to` and `params`) if given, the application will be redirected to the destination whenever we match this route
+- `beforeRouteEnter`: defines a [navigation guard](#navigation-guards).
+
+### `Router`
+
+The `Router` constructor takes three arguments:
+
+- `env`: a valid environment,
+- a list of routes,
+- an optional object (with the only key `mode` which can be `history` (default
+  value) or `hash`).
+
+`history` will use the browser [History API](https://developer.mozilla.org/en-US/docs/Web/API/History_API) as the mechanism to manage URL.\
+Example: `https://yourdomain.tld/my_custom_route`.\
+For this mechanism to work, you need a way to configure your web server accordingly.
+
+`hash` will manipulate the hash of the URL.\
+Example: `https://yourdomain.tld/index.html#/my_custom_route`.
+
+```js
+const ROUTES = [...];
+const router = new owl.router.Router(env, ROUTES, {mode: 'history'});
+```
+
+Note that the route are defined in a list, and the order matters: the router
+tries to find a match by going down the list.
+
+The router needs to be added to the environment in the `router` sub key.
+
+Once a router is created, it needs to be started. This is necessary to initialize
+its current state to the current URL (and also, to potentially apply any
+navigation guards and/or redirecting).
+
+```js
+await router.start();
+```
+
+Once started, the router will keep track of the current url and reflect its
+value in two keys:
+
+- `router.currentRoute`
+- `router.currentParams`
+
+The router also has a `navigate` method, useful to programmatically change the
+application to another state (and the url):
+
+```js
+router.navigate({ to: "USER", params: { id: 51 } });
+```
+
+### Navigation Guards
+
+Navigation guards are very useful to be able to execute some business logic/
+perform some actions or redirect to other routes whenever the application is
+entering a new route. For example, the following guard checks if there is an
+authenticated user, and if it is not the case, redirect to the sign in route.
+
+```js
+async function protectRoute({ env, to }) {
+  if (!env.session.authUser) {
+    env.session.setNextRoute(to.name);
+    return { to: "SIGN_IN" };
+  }
+  return true;
+}
+```
+
+A navigation guard is a function that returns a promise, which either resolves
+to `true` (the navigation is accepted), or to another destination object.
+
+### `RouteComponent`
+
+The `RouteComponent` component directs Owl to render the component associated
+to the currently active route (if any):
+
+```xml
+<div t-name="App">
+    <NavBar />
+    <RouteComponent />
+</div>
+```
+
+### `Link`
+
+The `Link` component is a Owl component which render as a `<a>` tag with any
+content. It will compute the proper href from its props, and allow Owl to
+properly navigate to a given url if clicked on it.
+
+```xml
+<Link to="'HOME'">Home</Link>
+```

doc/reference/store.md

@@ -0,0 +1,337 @@
+# 🦉 Store 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Example](#example)
+- [Reference](#reference)
+  - [Store](#store)
+  - [Actions](#actions)
+  - [Getters](#getters)
+  - [Connecting a Component](#connecting-a-component)
+  - [`useStore`](#usestore)
+  - [`useDispatch`](#usedispatch)
+  - [`useGetters`](#usegetters)
+  - [Semantics](#semantics)
+  - [Good Practices](#good-practices)
+
+## Overview
+
+Managing the state in an application is not an easy task. In some cases, the
+state of an application can be part of the component tree, in a natural way.
+However, there are situations where some parts of the state need to be displayed
+in various parts of the user interface, and then, it is not obvious which
+component should own which part of the state.
+
+Owl's solution to this issue is a centralized store. It is a class that owns
+some (or all) state, and lets the developer update it in a structured way, with
+`actions`. Owl components can then connect to the store to read their relevant
+state, and they will be rerendered if the state is updated.
+
+Note: Owl store is inspired by React Redux and VueX.
+
+## Example
+
+Here is what a simple store looks like:
+
+```js
+const actions = {
+  addTodo({ state }, message) {
+    state.todos.push({
+      id: state.nextId++,
+      message,
+      isCompleted: false
+    });
+  }
+};
+
+const state = {
+  todos: [],
+  nextId: 1
+};
+
+const store = new owl.Store({ state, actions });
+store.on("update", null, () => console.log(store.state));
+
+// updating the state
+store.dispatch("addTodo", "fix all bugs");
+```
+
+This example shows how a store can be defined and used. Note that in most cases,
+actions will be dispatched by connected components.
+
+## Reference
+
+### `Store`
+
+The store is a simple [`owl.EventBus`](event_bus.md) that triggers `update` events
+whenever its state is changed. Note that these events are triggered only after a
+microtask tick, so only one event will be triggered for any number of state changes in a
+call stack.
+
+Also, it is important to mention that the state is observed (with an `owl.Observer`),
+which is the reason why it is able to know if it was changed. See the
+[Observer](observer.md)'s documentation for more details.
+
+The `Store` class is quite small. It has two public methods:
+
+- its constructor
+- `dispatch`
+
+The constructor takes a configuration object with four (optional) keys:
+
+- the initial state
+- the actions
+- the getters
+- the environment
+
+```javascript
+const config = {
+  state,
+  actions,
+  getters,
+  env
+};
+const store = new Store(config);
+```
+
+### Actions
+
+Actions are used to coordinate state changes. It can be used for both synchronous
+and asynchronous logic.
+
+```js
+const actions = {
+  async login({ state }, info) {
+    state.loginState = "pending";
+    try {
+      const loginInfo = await doSomeRPC("/login/", info);
+      state.loginState = loginInfo;
+    } catch (e) {
+      state.loginState = "error";
+    }
+  }
+};
+```
+
+The first argument to an action method is an object with four keys:
+
+- `state`: the current state of the store content,
+- `dispatch`: a function that can be used to dispatch other actions,
+- `getters`: an object containing all getters defined in the store,
+- `env`: the current environment. This is useful sometimes, in particular if
+  an action needs to apply some side effects (such as performing an rpc), and
+  the `rpc` method is located in the environment.
+
+Actions are called with the `dispatch` method on the store, and can receive an
+arbitrary number of arguments.
+
+```js
+store.dispatch("login", someInfo);
+```
+
+Note that anything returned by an action will also be returned by the `dispatch`
+call.
+
+Also, it is important to be aware that we need to be careful with asynchronous
+logic. Each state change will potentially trigger a rerendering, so we need to
+make sure that we do not have a partially corrupted state. Here is an example that
+is likely not a good idea:
+
+```javascript
+const actions = {
+  async fetchSomeData({ state }, recordId) {
+    state.recordId = recordId;
+    const data = await doSomeRPC("/read/", recordId);
+    state.recordData = data;
+  }
+};
+```
+
+In the previous example, there is a period of time in which the state has a
+`recordId` which does not correspond to the `recordData`. It is more likely that
+we want an atomic update: updating the `recordId` at the same time as the `recordData`
+values:
+
+```javascript
+const actions = {
+  async fetchSomeData({ state }, recordId) {
+    const data = await doSomeRPC("/read/", recordId);
+    state.recordId = recordId;
+    state.recordData = data;
+  }
+};
+```
+
+### Getters
+
+Usually, data contained in the store will be stored in a normalized way. For
+example,
+
+```js
+{
+    posts: [{id: 11, authorId: 4, content: 'Greetings'}],
+    authors: [{id: 4, name: 'John'}]
+}
+```
+
+However, the user interface will probably need some denormalized data like
+
+```js
+{id: 11, author: {id: 4, name: 'John'}, content: 'Greetings'}
+```
+
+This is what `getters` are for: they give a centralized way to process and
+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);
+    return {
+      id,
+      author,
+      content: post.content
+    };
+  }
+};
+
+// somewhere else
+const post = store.getters.getPost(id);
+```
+
+Getters take _at most_ one argument.
+
+Note that getters are not cached.
+
+### Connecting a Component
+
+At some point, we need a way to interact with the store from a component. This
+can be done with the help of the three store hooks:
+
+- [`useStore`](#usestore) to subscribe a component to some part of the store state,
+- [`useDispatch`](#usedispatch) to get a reference to a dispatch function,
+- [`useGetters`](#usegetters) to get a reference to the getters defined in the store.
+
+Assume we have this store:
+
+```javascript
+const actions = {
+  increment({ state }, val) {
+    state.counter.value += val;
+  }
+};
+
+const state = {
+  counter: { value: 0 }
+};
+const store = new owl.Store({ state, actions });
+```
+
+A counter component can then select this value and dispatch an action like this:
+
+```js
+class Counter extends Component {
+  counter = useStore(state => state.counter);
+  dispatch = useDispatch();
+}
+
+const counter = new Counter({ store, qweb });
+```
+
+```xml
+<button t-name="Counter" t-on-click="dispatch('increment')">
+  Click Me! [<t t-esc="counter.value"/>]
+</button>
+```
+
+### `useStore`
+
+The `useStore` hook is used to select some part of the store state. It accepts
+two arguments:
+
+- a selector function, which takes the store state as first argument (and the
+  component props as second argument) and which must return the part of the
+  store state that will be made available and observed for changes,
+- optionally, an object which can have the following optional keys:
+  - a `store` key containing a store object if we want to use another store than
+    the default store,
+  - an `isEqual` key containing an equality function if we want to specialize
+    the comparison (the function must accept two arguments: the previous result
+    and the new result, and must return whether they are equal),
+  - and an `onUpdate` key containing an update function if we want to execute an
+    arbitrary code every time the selected state changes (the function will
+    receive one argument, the new result, and can execute arbitrary code).
+
+If the `useStore` selector returns a sub part of the store state, the component
+will only be rerendered whenever this part of the state changes. Otherwise, it
+will perform a strict equality check (unless the `isEqual` option is defined,
+then it will call it) and will update the component every time this check fails.
+
+Note that if the selector function returns a primitive type, the result of
+`useStore` will be immutable and it will not react to changes. In this case, it
+is important to define the `onUpdate` option to properly update the value
+manually when it changes.
+
+Also, the return value from `useStore` is not supposed to be modified. The store
+state should only be updated with actions.
+
+### `useDispatch`
+
+The `useDispatch` hook is useful when a component needs to be able to dispatch
+actions. It takes an optional argument, which is a store. If not given, it will
+use the store in the environment.
+
+Note that a component does not need to be connected in any other way to the store.
+For example:
+
+```js
+class DoSomethingButton extends Component {
+  static template = xml`<button t-on-click="dispatch('something')">Click</button>`;
+  dispatch = useDispatch();
+}
+```
+
+### `useGetters`
+
+The `useGetters` hook is useful when a component needs to be able to use the
+getters defined in a store. It takes an optional argument, which is a store. If
+not given, it will use the store in the environment.
+
+Note that a component does not need to be connected in any other way to the store.
+For example:
+
+```js
+class InfoButton extends Component {
+  static template = xml`<span><t t-esc="getters.somevalue()"></span>`;
+  getters = useGetters();
+}
+```
+
+### Semantics
+
+The `Store` class and the `useStore` hook try to be smart and to optimize as much
+as possible the rendering and update process. What is important to know is:
+
+- components are always updated in the order of their creation (so, parent
+  before children),
+- they are updated only if they are in the DOM,
+- if a parent is asynchronous, the system will wait for it to complete its
+  update before updating other components,
+- in general, updates are not coordinated. This is not a problem for synchronous
+  components, but if there are many asynchronous components, this could lead to
+  a situation where some part of the UI is updated and some other part of the UI is
+  not updated.
+
+### Good Practices
+
+- avoid asynchronous components as much as possible. Asynchronous components
+  lead to situations where parts of the UI is not updated immediately,
+- do not be afraid to connect many components, parent or children if needed. For
+  example, a `MessageList` component could get a list of ids in its `useStore`
+  call and a `Message` component could get the data of its own
+  message,
+- since the `useStore` function is called for each connected component,
+  for each state update, it is important to make sure that these functions are
+  as fast as possible.

doc/reference/tags.md

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

doc/reference/utils.md

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

doc/store.md

@@ -1,8 +0,0 @@
-# OWL: State Management
-
-Managing the state in an application is not an easy task. Many different
-architectures/designs/systems/... have been created. We propose here to use
-the idea of a central store.
-
-- Store
-- connect

doc/tooling.md

@@ -0,0 +1,117 @@
+# 🦉 Tooling 🦉
+
+## Content
+
+- [Overview](#overview)
+- [Playground](#playground)
+- [Benchmarks](#benchmarks)
+- [Single File Component](#single-file-component)
+- [Debugging Script](#debugging-script)
+
+## Overview
+
+To help work with/improve/learn OWL, there are a few extras tools/settings.
+
+- development mode: enable better error reporting for the developer
+- a playground application: a space to experiment and learn Owl.
+- a benchmarks application: allow comparison with a few common frameworks
+
+The two applications are available in the `tools/` folder, and can be accessed
+by using a static http server. A simple python
+server is available in `server.py`. There is also a npm script to start it:
+`npm run tools` (and its version with a watcher: `npm run tools:watch`).
+
+## Playground
+
+The playground is an important application designed to help learning and
+experimenting with Owl. The last published version of Owl can be tested [online](https://odoo.github.io/owl/playground/).
+
+It is an application similar to `jsFiddle`, but specialized for Owl: there are
+three tabs (`js`, `css` and `xml`), and a simple button `Run` to execute that
+code in an iframe.
+
+## Benchmarks
+
+Note: This is more an internal tool, useful for people working on Owl.
+
+The benchmarks application is a very small application, implemented in different
+frameworks, and in different versions of Owl. This is a simple internal tool,
+useful to compare various performance metrics on some tasks.
+
+## Single File Component
+
+It is very useful to group code by feature instead of by type of file. It makes
+it easier to scale application to larger size.
+
+To do so, Owl has two small helpers that make it easy to define a
+template or a stylesheet inside a javascript (or typescript) file: the
+[`xml`](reference/tags.md#xml-tag) and [`css`](reference/tags.md#css-tag)
+helper.
+
+This means that the template, the style and the javascript code can be defined in
+the same file. For example:
+
+```js
+const { Component } = owl;
+const { xml, css } = owl.tags;
+
+// -----------------------------------------------------------------------------
+// TEMPLATE
+// -----------------------------------------------------------------------------
+const TEMPLATE = xml/* xml */ `
+	<div class="main">
+		<Sidebar/>
+		<Content />
+	</div>`;
+
+// -----------------------------------------------------------------------------
+// STYLE
+// -----------------------------------------------------------------------------
+const STYLE = css/* css */ `
+  .main {
+    display: grid;
+    grid-template-columns: 200px auto;
+  }
+`;
+
+// -----------------------------------------------------------------------------
+// CODE
+// -----------------------------------------------------------------------------
+class Main extends Component {
+  static template = TEMPLATE;
+  static style = STYLE;
+  static components = { Sidebar, Content };
+
+  // rest of component...
+}
+```
+
+Note that the above example has an inline xml comment, just after the `xml` call.
+This is useful for some editor plugins, such as the VS Code addon
+`Comment tagged template`, which, if installed, add syntax highlighting to the
+content of the template string.
+
+## Debugging Script
+
+## Debugging
+
+Non trivial applications become quickly more difficult to understand. It is then
+useful to have a solid understanding of what is going on. To help with that,
+logging useful information is extremely valuable. There is a [javascript file](../tools/debug.js) which can be evaluated in an application.
+
+Once it is executed, it will log a lot of information on each component main hooks. The following code is a minified version to make it easier to copy/paste:
+
+```
+function debugOwl(t,e){let n,o="[OWL_DEBUG]";function r(t){let e;try{e=JSON.stringify(t||{})}catch(t){e="<JSON error>"}return e.length>200&&(e=e.slice(0,200)+"..."),e}if(Object.defineProperty(t.Component,"current",{get:()=>n,set(s){n=s;const i=s.constructor.name;if(e.componentBlackList&&e.componentBlackList.test(i))return;if(e.componentWhiteList&&!e.componentWhiteList.test(i))return;let l;Object.defineProperty(n,"__owl__",{get:()=>l,set(n){!function(n,s,i){let l=`${s}<id=${i}>`,c=t=>console.log(`${o} ${l} ${t}`),u=t=>(!e.methodBlackList||!e.methodBlackList.includes(t))&&!(e.methodWhiteList&&!e.methodWhiteList.includes(t));u("constructor")&&c(`constructor, props=${r(n.props)}`);u("willStart")&&t.hooks.onWillStart(()=>{c("willStart")});u("mounted")&&t.hooks.onMounted(()=>{c("mounted")});u("willUpdateProps")&&t.hooks.onWillUpdateProps(t=>{c(`willUpdateProps, nextprops=${r(t)}`)});u("willPatch")&&t.hooks.onWillPatch(()=>{c("willPatch")});u("patched")&&t.hooks.onPatched(()=>{c("patched")});u("willUnmount")&&t.hooks.onWillUnmount(()=>{c("willUnmount")});const d=n.__render.bind(n);n.__render=function(...t){c("rendering template"),d(...t)};const h=n.render.bind(n);n.render=function(...t){const e=n.__owl__;let o="render";return e.isMounted||e.currentFiber||(o+=" (warning: component is not mounted, this render has no effect)"),c(o),h(...t)};const p=n.mount.bind(n);n.mount=function(...t){return c("mount"),p(...t)}}(s,i,(l=n).id)}})}}),e.logScheduler){let e=t.Component.scheduler.start,n=t.Component.scheduler.stop;t.Component.scheduler.start=function(){this.isRunning||console.log(`${o} scheduler: start running tasks queue`),e.call(this)},t.Component.scheduler.stop=function(){this.isRunning&&console.log(`${o} scheduler: stop running tasks queue`),n.call(this)}}if(e.logStore){let e=t.Store.prototype.dispatch;t.Store.prototype.dispatch=function(t,...n){return console.log(`${o} store: action '${t}' dispatched. Payload: '${r(n)}'`),e.call(this,t,...n)}}}
+debugOwl(owl, {
+  // componentBlackList: /App/,  // regexp
+  // componentWhiteList: /SomeComponent/, // regexp
+  // methodBlackList: ["mounted"], // list of method names
+  // methodWhiteList: ["willStart"], // list of method names
+  logScheduler: false,  // display/mute scheduler logs
+  logStore: true,     // display/mute store logs
+});
+```
+
+Note that it is certainly useful to run this code at some point in an application,
+just to get a feel of what each user action implies, for the framework.

doc/vdom.md

@@ -1,3 +0,0 @@
-# VDom
-
-todo

package.json

@@ -1,49 +1,56 @@
 {
-  "name": "owl",
-  "version": "0.8.0",
+  "name": "@odoo/owl",
+  "version": "1.0.0",
   "description": "Odoo Web Library (OWL)",
-  "main": "src/index.ts",
+  "main": "dist/owl.js",
+  "types": "dist/types/index.d.ts",
+  "prepublish": "npm run buildcommonjs",
+  "files": ["dist/types/", "dist/owl.js"],
+  "engines": {
+    "node": ">=10.15.3"
+  },
   "scripts": {
-    "build:js": "tsc --target esnext --module es6 --outDir dist/owl src/*",
-    "build:js:es5": "tsc --target es5 --module es6 --outDir dist/owl src/*",
+    "build:js": "tsc --target esnext --module es6 --outDir dist/owl",
     "build:bundle": "rollup -c",
     "build": "npm run build:js && npm run build:bundle",
-    "build:es5": "npm run build:js:es5 && 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",
-    "dev": "npm-run-all --parallel \"build:* -- --watch\"",
     "test": "jest",
-    "test:watch": "jest --watch"
+    "test:watch": "jest --watch",
+    "tools:serve": "python3 tools/server.py || python tools/server.py",
+    "tools": "npm run build && npm run tools:serve",
+    "pretools:watch": "npm run build",
+    "tools:watch": "npm-run-all  --parallel tools:serve \"build:* -- --watch\"",
+    "prettier": "prettier {src/*.ts,src/**/*.ts,tests/*.ts,tests/**/*.ts,doc/*.md,doc/**/*.md} --write"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/odoo/owl.git"
   },
   "author": "Odoo",
-  "license": "GPL-3.0-or-later",
+  "license": "LGPL",
   "bugs": {
     "url": "https://github.com/odoo/owl/issues"
   },
   "homepage": "https://github.com/odoo/owl#readme",
+  "dependencies": {},
   "devDependencies": {
     "@types/jest": "^23.3.12",
     "cpx": "^1.5.0",
     "git-rev-sync": "^1.12.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",
     "rollup": "^1.6.0",
     "rollup-plugin-typescript2": "^0.20.1",
     "sass": "^1.16.1",
-    "snabbdom-to-html": "^5.1.1",
     "source-map-support": "^0.5.10",
     "ts-jest": "^23.10.5",
-    "typescript": "^3.2.2",
+    "typescript": "^3.7.2",
     "uglify-es": "^3.3.9"
   },
-  "dependencies": {
-    "jest-environment-jsdom": "^24.7.1",
-    "snabbdom": "^0.7.3"
-  },
   "jest": {
     "roots": [
       "<rootDir>/src",
@@ -62,5 +69,8 @@
       "json",
       "node"
     ]
+  },
+  "prettier": {
+    "printWidth": 100
   }
 }

roadmap.md

@@ -0,0 +1,41 @@
+# 🦉 OWL Roadmap 🦉
+
+- Current version: 1.0.0
+- Status: stable
+
+This roadmap is only an attempt at predicting Owl's future.  Everything may
+change!
+
+
+
+### December 2019
+
+If all goes well, Owl is upgraded to beta status. From now on, no API change,
+even small, is expected (but it still could happen).
+
+### End of 2019
+
+Release v1.0
+
+- API should be stable,
+- we will use semantic versioning,
+- we will maintain a changelog and an upgrade guide.
+
+### 1.x
+
+- add chrome and firefox devtools,
+- add support for single file components,
+- fix every bugs,
+- improve documentation,
+- small backward compatible improvements.
+
+### 2.x (2021? 2022?)
+
+Maybe:
+
+- reimplement vdom to use *block* system, like Vue 3, which should make Owl
+  much faster
+- refactor `QWeb` to use an intermediate representation (some kind of AST) to
+  allow additional optimisations.
+
+

rollup.config.js

@@ -9,6 +9,6 @@ export default {
     format: "iife",
     name: "owl",
     extend: true,
-    outro: `exports._version = '${version}';\nexports._date = '${new Date().toISOString()}';\nexports._hash = '${git.short()}';\nexports._url = 'https://github.com/odoo/owl';`
+    outro: `exports.__info__.version = '${version}';\nexports.__info__.date = '${new Date().toISOString()}';\nexports.__info__.hash = '${git.short()}';\nexports.__info__.url = 'https://github.com/odoo/owl';`
   }
 };

src/component.ts

@@ -1,431 +0,0 @@
-import { EventBus } from "./event_bus";
-import { Observer } from "./observer";
-import { QWeb } from "./qweb";
-import { idGenerator } from "./utils";
-import { h, patch, VNode } from "./vdom";
-
-let getId = idGenerator();
-
-//------------------------------------------------------------------------------
-// Types/helpers
-//------------------------------------------------------------------------------
-
-export interface Env {
-  qweb: QWeb;
-}
-
-export interface Meta<T extends Env, Props> {
-  readonly id: number;
-  vnode: VNode | null;
-  isStarted: boolean;
-  isMounted: boolean;
-  isDestroyed: boolean;
-  parent: Component<T, any, any> | null;
-  children: { [key: number]: Component<T, any, any> };
-  // children mapping: from templateID to widgetID
-  // should it be a map number => Widget?
-  cmap: { [key: number]: number };
-
-  renderId: number;
-  renderProps: Props | null;
-  renderPromise: Promise<VNode> | null;
-  boundHandlers: { [key: number]: any };
-  observer?: Observer;
-}
-
-export interface Type<T> extends Function {
-  new (...args: any[]): T;
-}
-
-//------------------------------------------------------------------------------
-// Widget
-//------------------------------------------------------------------------------
-
-export class Component<
-  T extends Env,
-  Props extends {},
-  State extends {}
-> extends EventBus {
-  readonly __owl__: Meta<Env, Props>;
-  template: string = "default";
-  inlineTemplate: string | null = null;
-
-  get el(): HTMLElement | null {
-    return this.__owl__.vnode ? (<any>this).__owl__.vnode.elm : null;
-  }
-
-  env: T;
-  state?: State;
-  props: Props;
-  refs: {
-    [key: string]: Component<T, any, any> | HTMLElement | undefined;
-  } = {};
-
-  //--------------------------------------------------------------------------
-  // Lifecycle
-  //--------------------------------------------------------------------------
-
-  /**
-   * Creates an instance of Component.
-   *
-   * The root widget of a component tree needs an environment:
-   *
-   * ```javascript
-   *   const root = new RootWidget(env, props);
-   * ```
-   *
-   * Every other widget simply needs a reference to its parent:
-   *
-   * ```javascript
-   *   const child = new SomeWidget(parent, props);
-   * ```
-   *
-   * Note that most of the time, only the root widget needs to be created by
-   * hand.  Other widgets should be created automatically by the framework (with
-   * the t-widget directive in a template)
-   */
-  constructor(parent: Component<T, any, any> | T, props?: Props) {
-    super();
-
-    // is this a good idea?
-    //   Pro: if props is empty, we can create easily a widget
-    //   Con: this is not really safe
-    //   Pro: but creating widget (by a template) is always unsafe anyway
-    this.props = <Props>props || <Props>{};
-    let id: number = getId();
-    let p: Component<T, any, any> | null = null;
-    if (parent instanceof Component) {
-      p = parent;
-      this.env = parent.env;
-      parent.__owl__.children[id] = this;
-    } else {
-      this.env = parent;
-    }
-    this.__owl__ = {
-      id: id,
-      vnode: null,
-      isStarted: false,
-      isMounted: false,
-      isDestroyed: false,
-      parent: p,
-      children: {},
-      cmap: {},
-      renderId: 1,
-      renderPromise: null,
-      renderProps: props || null,
-      boundHandlers: {}
-    };
-  }
-
-  /**
-   * willStart is an asynchronous hook that can be implemented to perform some
-   * action before the initial rendering of a component.
-   *
-   * It will be called exactly once before the initial rendering. It is useful
-   * in some cases, for example, to load external assets (such as a JS library)
-   * before the widget is rendered.
-   *
-   * Note that a slow willStart method will slow down the rendering of the user
-   * interface.  Therefore, some effort should be made to make this method as
-   * fast as possible.
-   *
-   * Note: this method should not be called manually.
-   */
-  async willStart() {}
-
-  /**
-   * mounted is a hook that is called each time a component is attached to the
-   * DOM. This is a good place to add some listeners, or to interact with the
-   * DOM, if the component needs to perform some measure for example.
-   *
-   * Note: this method should not be called manually.
-   *
-   * @see willUnmount
-   */
-  mounted() {}
-
-  /**
-   * The willUpdateProps is an asynchronous hook, called just before new props
-   * are set. This is useful if the component needs some asynchronous task
-   * performed, depending on the props (for example, assuming that the props are
-   * some record Id, fetching the record data).
-   *
-   * This hook is not called during the first render (but willStart is called
-   * and performs a similar job).
-   */
-  async willUpdateProps(nextProps: Props) {}
-
-  /**
-   * The willPatch hook is called just before the DOM patching process starts.
-   * It is not called on the initial render.  This is useful to get some
-   * information which are in the DOM.  For example, the current position of the
-   * scrollbar
-   */
-  willPatch() {}
-
-  /**
-   * This hook is called whenever a component did actually update its props,
-   * state or env.
-   *
-   * This method is not called on the initial render. It is useful to interact
-   * with the DOM (for example, through an external library) whenever the
-   * component was updated.
-   *
-   * Updating the widget state in this hook is possible, but not encouraged.
-   * One need to be careful, because updates here will cause rerender, which in
-   * turn will cause other calls to updated. So, we need to be particularly
-   * careful at avoiding endless cycles.
-   */
-  patched() {}
-
-  /**
-   * willUnmount is a hook that is called each time just before a component is
-   * unmounted from the DOM. This is a good place to remove some listeners, for
-   * example.
-   *
-   * Note: this method should not be called manually.
-   *
-   * @see mounted
-   */
-  willUnmount() {}
-
-  //--------------------------------------------------------------------------
-  // Public
-  //--------------------------------------------------------------------------
-
-  /**
-   * Attach a child widget to a given html element
-   *
-   * This is most of the time not necessary, since widgets should primarily be
-   * created/managed with the t-widget directive in a qweb template.  However,
-   * for the cases where we need more control, this method will do what is
-   * necessary to make sure all the proper hooks are called (for example,
-   * mounted/willUnmount)
-   *
-   * Note that this method makes a few assumptions:
-   * - the child widget is indeed a child of the current widget
-   * - the target is inside the dom of the current widget (typically a ref)
-   */
-  attachChild(child: Component<T, any, any>, target: HTMLElement) {
-    target.appendChild(child.el!);
-    child.__mount();
-  }
-
-  async mount(target: HTMLElement): Promise<void> {
-    const vnode = await this._prepare();
-    if (this.__owl__.isDestroyed) {
-      // widget was destroyed before we get here...
-      return;
-    }
-    this._patch(vnode);
-    target.appendChild(this.el!);
-
-    if (document.body.contains(target)) {
-      this._visitSubTree(w => {
-        if (!w.__owl__.isMounted && this.el!.contains(w.el)) {
-          w.__owl__.isMounted = true;
-          w.mounted();
-          return true;
-        }
-        return false;
-      });
-    }
-  }
-
-  unmount() {
-    if (this.el) {
-      this._visitSubTree(w => {
-        if (w.__owl__.isMounted) {
-          w.willUnmount();
-          w.__owl__.isMounted = false;
-          return true;
-        }
-        return false;
-      });
-      this.el.remove();
-    }
-  }
-
-  async render(force: boolean = false): Promise<void> {
-    if (this.__owl__.isDestroyed) {
-      return;
-    }
-    const renderVDom = this._render(force);
-    const renderId = this.__owl__.renderId;
-    const vnode = await renderVDom;
-    if (renderId === this.__owl__.renderId) {
-      // we only update the vnode and the actual DOM if no other rendering
-      // occurred between now and when the render method was initially called.
-      this._patch(vnode);
-    }
-  }
-
-  destroy() {
-    if (!this.__owl__.isDestroyed) {
-      for (let id in this.__owl__.children) {
-        this.__owl__.children[id].destroy();
-      }
-      if (this.__owl__.isMounted) {
-        this.willUnmount();
-      }
-      if (this.el) {
-        this.el.remove();
-        this.__owl__.isMounted = false;
-        delete this.__owl__.vnode;
-      }
-      if (this.__owl__.parent) {
-        let id = this.__owl__.id;
-        delete this.__owl__.parent.__owl__.children[id];
-        this.__owl__.parent = null;
-      }
-      this.clear();
-      this.__owl__.isDestroyed = true;
-    }
-  }
-
-  shouldUpdate(nextProps: Props): boolean {
-    return true;
-  }
-
-  /**
-   * This method is the correct way to update the environment of a widget. Doing
-   * this will cause a full rerender of the widget and its children, so this is
-   * an operation that should not be done frequently.
-   *
-   * A good usecase for updating the environment would be to update some mostly
-   * static config keys, such as a boolean to determine if we are in mobile
-   * mode or not.
-   */
-  async updateEnv(nextEnv: Partial<T>): Promise<void> {
-    if (this.__owl__.parent && this.__owl__.parent.env === this.env) {
-      this.env = Object.create(this.env);
-    }
-    Object.assign(this.env, nextEnv);
-    if (this.__owl__.isMounted) {
-      await this.render(true);
-    }
-  }
-
-  async updateProps(
-    nextProps: Props,
-    forceUpdate: boolean = false
-  ): Promise<void> {
-    const shouldUpdate = forceUpdate || this.shouldUpdate(nextProps);
-    return shouldUpdate ? this._updateProps(nextProps) : Promise.resolve();
-  }
-
-  set(target: any, key: string | number, value: any) {
-    this.__owl__.observer!.set(target, key, value);
-  }
-
-  //--------------------------------------------------------------------------
-  // Private
-  //--------------------------------------------------------------------------
-
-  async _updateProps(nextProps: Props): Promise<void> {
-    await this.willUpdateProps(nextProps);
-    this.props = nextProps;
-    await this.render();
-  }
-
-  _patch(vnode) {
-    this.__owl__.renderPromise = null;
-    if (this.__owl__.vnode) {
-      this.willPatch();
-      this.__owl__.vnode = patch(this.__owl__.vnode, vnode);
-      this.patched();
-    } else {
-      this.__owl__.vnode = patch(document.createElement(vnode.sel!), vnode);
-    }
-  }
-  async _prepare(): Promise<VNode> {
-    this.__owl__.renderProps = this.props;
-    this.__owl__.renderPromise = this.willStart().then(() => {
-      if (this.__owl__.isDestroyed) {
-        return Promise.resolve(h("div"));
-      }
-      this.__owl__.isStarted = true;
-      if (this.inlineTemplate) {
-        this.env.qweb.addTemplate(
-          this.inlineTemplate,
-          this.inlineTemplate,
-          true
-        );
-      }
-      this._observeState();
-      return this._render();
-    });
-    return this.__owl__.renderPromise;
-  }
-
-  async _render(force: boolean = false): Promise<VNode> {
-    this.__owl__.renderId++;
-    const promises: Promise<void>[] = [];
-    const template = this.inlineTemplate || this.template;
-    if (this.__owl__.observer) {
-      this.__owl__.observer.allowMutations = false;
-    }
-    let vnode = this.env.qweb.render(template, this, {
-      promises,
-      handlers: this.__owl__.boundHandlers,
-      forceUpdate: force
-    });
-    if (this.__owl__.observer) {
-      this.__owl__.observer.allowMutations = true;
-    }
-
-    // this part is critical for the patching process to be done correctly. The
-    // tricky part is that a child widget can be rerendered on its own, which
-    // will update its own vnode representation without the knowledge of the
-    // parent widget.  With this, we make sure that the parent widget will be
-    // able to patch itself properly after
-    vnode.key = this.__owl__.id;
-    this.__owl__.renderProps = this.props;
-    this.__owl__.renderPromise = Promise.all(promises).then(() => vnode);
-    return this.__owl__.renderPromise;
-  }
-
-  /**
-   * Only called by qweb t-widget directive
-   */
-  _mount(vnode: VNode, elm: HTMLElement): VNode {
-    this.__owl__.vnode = patch(elm, vnode);
-    this.__mount();
-    return this.__owl__.vnode;
-  }
-
-  __mount() {
-    if (this.__owl__.isMounted) {
-      return;
-    }
-    this._observeState();
-    if (this.__owl__.parent) {
-      if (this.__owl__.parent!.__owl__.isMounted) {
-        this.__owl__.isMounted = true;
-        this.mounted();
-        const children = this.__owl__.children;
-        for (let id in children) {
-          children[id].__mount();
-        }
-      }
-    }
-  }
-
-  _visitSubTree(callback: (w: Component<T, any, any>) => boolean) {
-    const shouldVisitChildren = callback(this);
-    if (shouldVisitChildren) {
-      const children = this.__owl__.children;
-      for (let id in children) {
-        children[id]._visitSubTree(callback);
-      }
-    }
-  }
-
-  _observeState() {
-    if (this.state) {
-      this.__owl__.observer = new Observer();
-      this.__owl__.observer.observe(this.state);
-      this.__owl__.observer.notifyCB = this.render.bind(this);
-    }
-  }
-}

src/component/component.ts

@@ -0,0 +1,705 @@
+import { Observer } from "../core/observer";
+import { OwlEvent } from "../core/owl_event";
+import { CompiledTemplate, QWeb } from "../qweb/index";
+import { patch, VNode } from "../vdom/index";
+import "./directive";
+import { Fiber } from "./fiber";
+import "./props_validation";
+import { Scheduler, scheduler } from "./scheduler";
+import { activateSheet } from "./styles";
+
+/**
+ * Owl Component System
+ *
+ * This file introduces a declarative and composable component system. It
+ * contains:
+ *
+ * - the Env interface (generic type for the environment)
+ * - the Internal interface (the owl specific metadata attached to a component)
+ * - the Component class
+ */
+
+//------------------------------------------------------------------------------
+// Types/helpers
+//------------------------------------------------------------------------------
+
+/**
+ * An Env (environment) is an object that will be (mostly) shared between all
+ * components of an Owl application.  It is the location which should contain
+ * the qweb instance necessary to render all components.
+ *
+ * Note that it is totally fine to extend the environment with application
+ * specific keys/objects/whatever.  For example, a key `isMobile` (to declare
+ * if we are in "mobile" mode), or a shared bus could be useful.
+ */
+export interface Env {
+  qweb: QWeb;
+  [key: string]: any;
+}
+
+interface MountOptions {
+  position?: "first-child" | "last-child" | "self";
+}
+
+/**
+ * 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
+ * component tree.
+ */
+interface Internal<T extends Env, Props> {
+  // each component has a unique id, useful mostly to handle parent/child
+  // relationships
+  readonly id: number;
+  depth: number;
+  vnode: VNode | null;
+  pvnode: VNode | null;
+  isMounted: boolean;
+  isDestroyed: boolean;
+
+  // parent and children keys are obviously useful to setup the parent-children
+  // relationship.
+  parent: Component<T, any> | null;
+  children: { [key: number]: Component<T, any> };
+  // children mapping: from templateID to componentID. templateID identifies a
+  // place in a template. The t-component directive needs it to be able to get
+  // the component instance back whenever the template is rerendered.
+  cmap: { [key: number]: number };
+
+  currentFiber: Fiber | null;
+  // parentLastFiberId is there to help the parent component to detect, among
+  // its children, those that are not used anymore and thus can be destroyed
+  parentLastFiberId: number;
+
+  // when a rendering is initiated by a parent, it may set variables in 'scope'
+  // (typically when the component is rendered in a slot). We need to
+  // store that information in case the component would be re-rendered later on.
+  scope: any;
+
+  boundHandlers: { [key: number]: any };
+  observer: Observer | null;
+  renderFn: CompiledTemplate;
+  mountedCB: Function | null;
+  willUnmountCB: Function | null;
+  willPatchCB: Function | null;
+  patchedCB: Function | null;
+  willStartCB: Function | null;
+  willUpdatePropsCB: Function | null;
+  classObj: { [key: string]: boolean } | null;
+  refs: { [key: string]: Component<T, any> | HTMLElement | undefined } | null;
+}
+
+export const portalSymbol = Symbol("portal"); // FIXME
+
+//------------------------------------------------------------------------------
+// Component
+//------------------------------------------------------------------------------
+let nextId = 1;
+
+export class Component<T extends Env, Props extends {}> {
+  readonly __owl__: Internal<Env, Props>;
+  static template?: string | null = null;
+  static _template?: string | null = null;
+  static current: Component<any, any> | null = null;
+  static components = {};
+  static props?: any;
+  static defaultProps?: any;
+  static env: any = {};
+  // expose scheduler s.t. it can be mocked for testing purposes
+  static scheduler: Scheduler = scheduler;
+  __target: HTMLElement | undefined;
+
+  /**
+   * The `el` is the root element of the component.  Note that it could be null:
+   * this is the case if the component is not mounted yet, or is destroyed.
+   */
+  get el(): HTMLElement | null {
+    return this.__owl__.vnode ? (<any>this).__owl__.vnode.elm : null;
+  }
+
+  env: T;
+  props: Props;
+
+  //--------------------------------------------------------------------------
+  // Lifecycle
+  //--------------------------------------------------------------------------
+
+  /**
+   * Creates an instance of Component.
+   *
+   * Note that most of the time, only the root component needs to be created by
+   * hand.  Other components should be created automatically by the framework (with
+   * the t-component directive in a template)
+   */
+  constructor(parent?: Component<T, any> | null, props?: Props) {
+    Component.current = this;
+
+    let constr = this.constructor as any;
+    const defaultProps = constr.defaultProps;
+    if (defaultProps) {
+      props = props || ({} as Props);
+      this.__applyDefaultProps(props, defaultProps);
+    }
+    this.props = <Props>props;
+    if (QWeb.dev) {
+      QWeb.utils.validateProps(constr, this.props);
+    }
+
+    const id: number = nextId++;
+    let depth;
+    if (parent) {
+      this.env = parent.env;
+      const __powl__ = parent.__owl__;
+      __powl__.children[id] = this;
+      depth = __powl__.depth + 1;
+    } else {
+      // we are the root component
+      this.env = (this.constructor as any).env;
+      if (!this.env.qweb) {
+        this.env.qweb = new QWeb();
+      }
+      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);
+        }
+      });
+      depth = 0;
+    }
+
+    const qweb = this.env.qweb;
+    const template = constr.template || this.__getTemplate(qweb);
+    this.__owl__ = {
+      id: id,
+      depth: depth,
+      vnode: null,
+      pvnode: null,
+      isMounted: false,
+      isDestroyed: false,
+      parent: parent || null,
+      children: {},
+      cmap: {},
+      currentFiber: null,
+      parentLastFiberId: 0,
+      boundHandlers: {},
+      mountedCB: null,
+      willUnmountCB: null,
+      willPatchCB: null,
+      patchedCB: null,
+      willStartCB: null,
+      willUpdatePropsCB: null,
+      observer: null,
+      renderFn: qweb.render.bind(qweb, template),
+      classObj: null,
+      refs: null,
+      scope: null
+    };
+    if (constr.style) {
+      this.__applyStyles(constr);
+    }
+  }
+
+  /**
+   * willStart is an asynchronous hook that can be implemented to perform some
+   * action before the initial rendering of a component.
+   *
+   * It will be called exactly once before the initial rendering. It is useful
+   * in some cases, for example, to load external assets (such as a JS library)
+   * before the component is rendered.
+   *
+   * Note that a slow willStart method will slow down the rendering of the user
+   * interface.  Therefore, some effort should be made to make this method as
+   * fast as possible.
+   *
+   * Note: this method should not be called manually.
+   */
+  async willStart() {}
+
+  /**
+   * mounted is a hook that is called each time a component is attached to the
+   * DOM. This is a good place to add some listeners, or to interact with the
+   * DOM, if the component needs to perform some measure for example.
+   *
+   * Note: this method should not be called manually.
+   *
+   * @see willUnmount
+   */
+  mounted() {}
+
+  /**
+   * The willUpdateProps is an asynchronous hook, called just before new props
+   * are set. This is useful if the component needs some asynchronous task
+   * performed, depending on the props (for example, assuming that the props are
+   * some record Id, fetching the record data).
+   *
+   * This hook is not called during the first render (but willStart is called
+   * and performs a similar job).
+   */
+  async willUpdateProps(nextProps: Props) {}
+
+  /**
+   * The willPatch hook is called just before the DOM patching process starts.
+   * It is not called on the initial render.  This is useful to get some
+   * information which are in the DOM.  For example, the current position of the
+   * scrollbar
+   */
+  willPatch(): any {}
+
+  /**
+   * This hook is called whenever a component did actually update its props,
+   * state or env.
+   *
+   * This method is not called on the initial render. It is useful to interact
+   * with the DOM (for example, through an external library) whenever the
+   * component was updated.
+   *
+   * Updating the component state in this hook is possible, but not encouraged.
+   * One need to be careful, because updates here will cause rerender, which in
+   * turn will cause other calls to updated. So, we need to be particularly
+   * careful at avoiding endless cycles.
+   */
+  patched() {}
+
+  /**
+   * willUnmount is a hook that is called each time just before a component is
+   * unmounted from the DOM. This is a good place to remove some listeners, for
+   * example.
+   *
+   * Note: this method should not be called manually.
+   *
+   * @see mounted
+   */
+  willUnmount() {}
+
+  /**
+   * catchError is a method called whenever some error happens in the rendering or
+   * lifecycle hooks of a child.
+   *
+   * It needs to be implemented by a component that is designed to handle the
+   * error properly.
+   */
+  catchError?(error?: Error): void;
+
+  //--------------------------------------------------------------------------
+  // Public
+  //--------------------------------------------------------------------------
+
+  /**
+   * Mount the component to a target element.
+   *
+   * This should only be done if the component was created manually. Components
+   * created declaratively in templates are managed by the Owl system.
+   *
+   * 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) {
+      return Promise.resolve();
+    }
+    if (!(target instanceof HTMLElement || target instanceof DocumentFragment)) {
+      let message = `Component '${this.constructor.name}' cannot be mounted: the target is not a valid DOM node.`;
+      message += `\nMaybe the DOM is not ready yet? (in that case, you can use owl.utils.whenReady)`;
+      throw new Error(message);
+    }
+    let inserter =
+      position === "last-child"
+        ? el => target.appendChild(el)
+        : position === "first-child"
+        ? el => target.prepend(el)
+        : el => {};
+    if (position === "self") {
+      this.__target = target as HTMLElement;
+    }
+    const fiber = new Fiber(null, this, false, inserter);
+    fiber.shouldPatch = false;
+    if (!__owl__.vnode) {
+      this.__prepareAndRender(fiber, () => {});
+    } else {
+      this.__render(fiber);
+    }
+    return scheduler.addFiber(fiber);
+  }
+
+  /**
+   * The unmount method is the opposite of the mount method.  It is useful
+   * to call willUnmount calls and remove the component from the DOM.
+   */
+  unmount() {
+    if (this.__owl__.isMounted) {
+      this.__callWillUnmount();
+      this.el!.remove();
+    }
+  }
+
+  /**
+   * The render method is the main entry point to render a component (once it
+   * is ready. This method is not initially called when the component is
+   * rendered the first time).
+   *
+   * This method will cause all its sub components to potentially rerender
+   * themselves.  Note that `render` is not called if a component is updated via
+   * its props.
+   */
+  async render(force: boolean = false): Promise<void> {
+    const __owl__ = this.__owl__;
+    if (!__owl__.isMounted && !__owl__.currentFiber) {
+      // if we get here, this means that the component was either never mounted,
+      // or was unmounted and some state change  triggered a render. Either way,
+      // we do not want to actually render anything in this case.
+      return;
+    }
+    if (__owl__.currentFiber && !__owl__.currentFiber.isRendered) {
+      return scheduler.addFiber(__owl__.currentFiber.root);
+    }
+    // if we aren't mounted at this point, it implies that there is a
+    // currentFiber that is already rendered (isRendered is true), so we are
+    // about to be mounted
+    const isMounted = __owl__.isMounted;
+    const fiber = new Fiber(null, this, force, null);
+    Promise.resolve().then(() => {
+      if (__owl__.isMounted || !isMounted) {
+        // 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
+        // were actually about to be unmounted ; we can thus forget about this
+        // fiber
+        fiber.isCompleted = true;
+        __owl__.currentFiber = null;
+      }
+    });
+    return scheduler.addFiber(fiber);
+  }
+
+  /**
+   * Destroy the component.  This operation is quite complex:
+   *  - it recursively destroy all children
+   *  - call the willUnmount hooks if necessary
+   *  - remove the dom node from the dom
+   *
+   * This should only be called manually if you created the component.  Most
+   * components will be automatically destroyed.
+   */
+  destroy() {
+    const __owl__ = this.__owl__;
+    if (!__owl__.isDestroyed) {
+      const el = this.el;
+      this.__destroy(__owl__.parent);
+      if (el) {
+        el.remove();
+      }
+    }
+  }
+
+  /**
+   * This method is called by the component system whenever its props are
+   * updated. If it returns true, then the component will be rendered.
+   * Otherwise, it will skip the rendering (also, its props will not be updated)
+   */
+  shouldUpdate(nextProps: Props): boolean {
+    return true;
+  }
+
+  /**
+   * Emit a custom event of type 'eventType' with the given 'payload' on the
+   * component's el, if it exists. However, note that the event will only bubble
+   * 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);
+  }
+
+  //--------------------------------------------------------------------------
+  // Private
+  //--------------------------------------------------------------------------
+
+  /**
+   * Private helper to perform a full destroy, from the point of view of an Owl
+   * component. It does not remove the el (this is done only once on the top
+   * level destroyed component, for performance reasons).
+   *
+   * The job of this method is mostly to call willUnmount hooks, and to perform
+   * all necessary internal cleanup.
+   *
+   * Note that it does not call the __callWillUnmount method to avoid visiting
+   * all children many times.
+   */
+  __destroy(parent: Component<any, any> | null) {
+    const __owl__ = this.__owl__;
+    const isMounted = __owl__.isMounted;
+    if (isMounted) {
+      if (__owl__.willUnmountCB) {
+        __owl__.willUnmountCB();
+      }
+      this.willUnmount();
+      __owl__.isMounted = false;
+    }
+    const children = __owl__.children;
+    for (let key in children) {
+      children[key].__destroy(this);
+    }
+    if (parent) {
+      let id = __owl__.id;
+      delete parent.__owl__.children[id];
+      __owl__.parent = null;
+    }
+    __owl__.isDestroyed = true;
+    delete __owl__.vnode;
+    if (__owl__.currentFiber) {
+      __owl__.currentFiber.isCompleted = true;
+    }
+  }
+
+  __callMounted() {
+    const __owl__ = this.__owl__;
+
+    __owl__.isMounted = true;
+    __owl__.currentFiber = null;
+    this.mounted();
+    if (__owl__.mountedCB) {
+      __owl__.mountedCB();
+    }
+  }
+
+  __callWillUnmount() {
+    const __owl__ = this.__owl__;
+    if (__owl__.willUnmountCB) {
+      __owl__.willUnmountCB();
+    }
+    this.willUnmount();
+    __owl__.isMounted = false;
+    if (this.__owl__.currentFiber) {
+      this.__owl__.currentFiber.isCompleted = true;
+      this.__owl__.currentFiber.root.counter = 0;
+    }
+    const children = __owl__.children;
+    for (let id in children) {
+      const comp = children[id];
+      if (comp.__owl__.isMounted) {
+        comp.__callWillUnmount();
+      }
+    }
+  }
+  /**
+   * Private trigger method, allows to choose the component which triggered
+   * the event in the first place
+   */
+  __trigger(component: Component<any, any>, eventType: string, payload?: any) {
+    if (this.el) {
+      const ev = new OwlEvent(component, eventType, {
+        bubbles: true,
+        cancelable: true,
+        detail: payload
+      });
+      const triggerHook = this.env[portalSymbol as any];
+      if (triggerHook) {
+        triggerHook(ev);
+      }
+      this.el.dispatchEvent(ev);
+    }
+  }
+  /**
+   * The __updateProps method is called by the t-component directive whenever
+   * it updates a component (so, when the parent template is rerendered).
+   */
+  async __updateProps(nextProps: Props, parentFiber: Fiber, scope: any): Promise<void> {
+    this.__owl__.scope = scope;
+    const shouldUpdate = parentFiber.force || this.shouldUpdate(nextProps);
+    if (shouldUpdate) {
+      const __owl__ = this.__owl__;
+      const fiber = new Fiber(parentFiber, this, parentFiber.force, null);
+      if (!parentFiber.child) {
+        parentFiber.child = fiber;
+      } else {
+        parentFiber.lastChild!.sibling = fiber;
+      }
+      parentFiber.lastChild = fiber;
+
+      const defaultProps = (<any>this.constructor).defaultProps;
+      if (defaultProps) {
+        this.__applyDefaultProps(nextProps, defaultProps);
+      }
+      if (QWeb.dev) {
+        QWeb.utils.validateProps(this.constructor, nextProps);
+      }
+      await Promise.all([
+        this.willUpdateProps(nextProps),
+        __owl__.willUpdatePropsCB && __owl__.willUpdatePropsCB(nextProps)
+      ]);
+      if (fiber.isCompleted) {
+        return;
+      }
+      this.props = nextProps;
+
+      this.__render(fiber);
+    }
+  }
+
+  /**
+   * Main patching method. We call the virtual dom patch method here to convert
+   * a virtual dom vnode into some actual dom.
+   */
+  __patch(vnode: VNode) {
+    const __owl__ = this.__owl__;
+    if (this.__target) {
+      if (this.__target.tagName.toLowerCase() !== vnode.sel) {
+        throw new Error(
+          `Cannot attach '${this.constructor.name}' to target node (not same tag name)`
+        );
+      }
+      __owl__.vnode = patch(this.__target, vnode);
+      delete this.__target;
+    } else {
+      const target = __owl__.vnode || document.createElement(vnode.sel!);
+      __owl__.vnode = patch(target, vnode);
+    }
+  }
+
+  /**
+   * The __prepare method is only called by the t-component directive, when a
+   * subcomponent is created. It gets its scope, if any, from the
+   * parent template.
+   */
+  __prepare(parentFiber: Fiber, scope: any, cb: CallableFunction): Fiber {
+    this.__owl__.scope = scope;
+    const fiber = new Fiber(parentFiber, this, parentFiber.force, null);
+    fiber.shouldPatch = false;
+    if (!parentFiber.child) {
+      parentFiber.child = fiber;
+    } else {
+      parentFiber.lastChild!.sibling = fiber;
+    }
+    parentFiber.lastChild = fiber;
+    this.__prepareAndRender(fiber, cb);
+    return fiber;
+  }
+
+  /**
+   * Apply the stylesheets defined by the component. Note that we need to make
+   * sure all inherited stylesheets are applied as well.  We then delete the
+   * `style` key from the constructor to make sure we do not apply it again.
+   */
+  private __applyStyles(constr) {
+    while (constr && constr.style) {
+      if (constr.hasOwnProperty("style")) {
+        activateSheet(constr.style, constr.name);
+        delete constr.style;
+      }
+      constr = constr.__proto__;
+    }
+  }
+  __getTemplate(qweb: QWeb): string {
+    let p = (<any>this).constructor;
+    if (!p.hasOwnProperty("_template")) {
+      // here, the component and none of its superclasses defines a static `template`
+      // key. So we fall back on looking for a template matching its name (or
+      // one of its subclass).
+
+      let template: string;
+      while ((template = p.name) && !(template in qweb.templates) && p !== Component) {
+        p = p.__proto__;
+      }
+      if (p === Component) {
+        throw new Error(`Could not find template for component "${this.constructor.name}"`);
+      } else {
+        p._template = template;
+      }
+    }
+    return p._template;
+  }
+  async __prepareAndRender(fiber: Fiber, cb: CallableFunction) {
+    try {
+      await Promise.all([this.willStart(), this.__owl__.willStartCB && this.__owl__.willStartCB()]);
+    } catch (e) {
+      fiber.handleError(e);
+      return Promise.resolve();
+    }
+    if (this.__owl__.isDestroyed) {
+      return Promise.resolve();
+    }
+    if (!fiber.isCompleted) {
+      this.__render(fiber);
+      cb();
+    }
+  }
+
+  __render(fiber: Fiber) {
+    const __owl__ = this.__owl__;
+    if (__owl__.observer) {
+      __owl__.observer.allowMutations = false;
+    }
+    let error;
+    try {
+      let vnode = __owl__.renderFn!(this, {
+        handlers: __owl__.boundHandlers,
+        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();
+        }
+      }
+      if (!vnode) {
+        throw new Error(`Rendering '${this.constructor.name}' did not return anything`);
+      }
+      fiber.vnode = vnode;
+      // we apply here the class information described on the component by the
+      // template (so, something like <MyComponent class="..."/>) to the actual
+      // root vnode
+      if (__owl__.classObj) {
+        const data = vnode.data!;
+        data.class = Object.assign(data.class || {}, __owl__.classObj);
+      }
+    } catch (e) {
+      error = e;
+    }
+    if (__owl__.observer) {
+      __owl__.observer.allowMutations = true;
+    }
+
+    fiber.root.counter--;
+    fiber.isRendered = true;
+    if (error) {
+      fiber.handleError(error);
+    }
+  }
+
+  /**
+   * 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).
+   *
+   * Note that this method does modify in place the props
+   */
+  __applyDefaultProps(props: Object, defaultProps: Object) {
+    for (let propName in defaultProps) {
+      if (props![propName] === undefined) {
+        props![propName] = defaultProps[propName];
+      }
+    }
+  }
+}

src/component/directive.ts

@@ -0,0 +1,427 @@
+import { QWeb } from "../qweb/index";
+import { INTERP_REGEXP } from "../qweb/compilation_context";
+import { makeHandlerCode, MODS_CODE } from "../qweb/extensions";
+
+//------------------------------------------------------------------------------
+// t-component
+//------------------------------------------------------------------------------
+
+const T_COMPONENT_MODS_CODE = Object.assign({}, MODS_CODE, {
+  self: "if (e.target !== vn.elm) {return}"
+});
+
+QWeb.utils.defineProxy = function defineProxy(target, source) {
+  for (let k in source) {
+    Object.defineProperty(target, k, {
+      get() {
+        return source[k];
+      },
+      set(val) {
+        source[k] = val;
+      }
+    });
+  }
+};
+
+/**
+ * The t-component directive is certainly a complicated and hard to maintain piece
+ * of code.  To help you, fellow developer, if you have to maintain it, I offer
+ * you this advice: Good luck...
+ *
+ * Since it is not 'direct' code, but rather code that generates other code, it
+ * is not easy to understand.  To help you, here  is a detailed and commented
+ * explanation of the code generated by the t-component directive for the following
+ * situation:
+ * ```xml
+ *   <Child
+ *      t-key="'somestring'"
+ *      flag="state.flag"
+ *      t-transition="fade"/>
+ * ```
+ *
+ * ```js
+ * // we assign utils on top of the function because it will be useful for
+ * // each components
+ * let utils = this.utils;
+ *
+ * // this is the virtual node representing the parent div
+ * let c1 = [], p1 = { key: 1 };
+ * var vn1 = h("div", p1, c1);
+ *
+ * // t-component directive: we start by evaluating the expression given by t-key:
+ * let key5 = "somestring";
+ *
+ * // def3 is the promise that will contain later either the new component
+ * // creation, or the props update...
+ * let def3;
+ *
+ * // this is kind of tricky: we need here to find if the component was already
+ * // created by a previous rendering.  This is done by checking the internal
+ * // `cmap` (children map) of the parent component: it maps keys to component ids,
+ * // and, then, if there is an id, we look into the children list to get the
+ * // instance
+ * let w4 =
+ *   key5 in context.__owl__.cmap
+ *   ? context.__owl__.children[context.__owl__.cmap[key5]]
+ *   : false;
+ *
+ * // We keep the index of the position of the component in the closure.  We push
+ * // null to reserve the slot, and will replace it later by the component vnode,
+ * // when it will be ready (do not forget that preparing/rendering a component is
+ * // asynchronous)
+ * let _2_index = c1.length;
+ * c1.push(null);
+ *
+ * // we evaluate here the props given to the component. It is done here to be
+ * // able to easily reference it later, and also, it might be an expensive
+ * // computation, so it is certainly better to do it only once
+ * let props4 = { flag: context["state"].flag };
+ *
+ * // If we have a component, currently rendering, but not ready yet, we do not want
+ * // to wait for it to be ready if we can avoid it
+ * if (w4 && w4.__owl__.renderPromise && !w4.__owl__.vnode) {
+ *   // we check if the props are the same.  In that case, we can simply reuse
+ *   // the previous rendering and skip all useless work
+ *   if (utils.shallowEqual(props4, w4.__owl__.renderProps)) {
+ *     def3 = w4.__owl__.renderPromise;
+ *   } else {
+ *     // if the props are not the same, we destroy the component and starts anew.
+ *     // this will be faster than waiting for its rendering, then updating it
+ *     w4.destroy();
+ *     w4 = false;
+ *   }
+ * }
+ *
+ * if (!w4) {
+ *   // in this situation, we need to create a new component.  First step is
+ *   // to get a reference to the class, then create an instance with
+ *   // current context as parent, and the props.
+ *   let W4 = context.component && context.components[componentKey4] || QWeb.component[componentKey4];
+
+ *   if (!W4) {
+ *     throw new Error("Cannot find the definition of component 'child'");
+ *   }
+ *   w4 = new W4(owner, props4);
+ *
+ *   // Whenever we rerender the parent component, we need to be sure that we
+ *   // are able to find the component instance. To do that, we register it to
+ *   // the parent cmap (children map).  Note that the 'template' key is
+ *   // used here, since this is what identify the component from the template
+ *   // perspective.
+ *   context.__owl__.cmap[key5] = w4.__owl__.id;
+ *
+ *   // __prepare is called, to basically call willStart, then render the
+ *   // component
+ *   def3 = w4.__prepare();
+ *
+ *   def3 = def3.then(vnode => {
+ *     // we create here a virtual node for the parent (NOT the component). This
+ *     // means that the vdom of the parent will be stopped here, and from
+ *     // the parent's perspective, it simply is a vnode with no children.
+ *     // However, it shares the same dom element with the component root
+ *     // vnode.
+ *     let pvnode = h(vnode.sel, { key: key5 });
+ *
+ *     // we add hooks to the parent vnode so we can interact with the new
+ *     // component at the proper time
+ *     pvnode.data.hook = {
+ *       insert(vn) {
+ *         // the __mount method will patch the component vdom into the elm vn.elm,
+ *         // then call the mounted hooks. However, suprisingly, the snabbdom
+ *         // patch method actually replace the elm by a new elm, so we need
+ *         // to synchronise the pvnode elm with the resulting elm
+ *         let nvn = w4.__mount(vnode, vn.elm);
+ *         pvnode.elm = nvn.elm;
+ *         // what follows is only present if there are animations on the component
+ *         utils.transitionInsert(vn, "fade");
+ *       },
+ *       remove() {
+ *         // override with empty function to prevent from removing the node
+ *         // directly. It will be removed when destroy is called anyway, which
+ *         // delays the removal if there are animations.
+ *       },
+ *       destroy() {
+ *         // if there are animations, we delay the call to destroy on the
+ *         // component, if not, we call it directly.
+ *         let finalize = () => {
+ *           w4.destroy();
+ *         };
+ *         utils.transitionRemove(vn, "fade", finalize);
+ *       }
+ *     };
+ *     // the pvnode is inserted at the correct position in the div's children
+ *     c1[_2_index] = pvnode;
+ *
+ *     // we keep here a reference to the parent vnode (representing the
+ *     // component, so we can reuse it later whenever we update the component
+ *     w4.__owl__.pvnode = pvnode;
+ *   });
+ * } else {
+ *   // this is the 'update' path of the directive.
+ *   // the call to __updateProps is the actual component update
+ *   // Note that we only update the props if we cannot reuse the previous
+ *   // rendering work (in the case it was rendered with the same props)
+ *   def3 = def3 || w4.__updateProps(props4, extra.forceUpdate, extra.patchQueue);
+ *   def3 = def3.then(() => {
+ *     // if component was destroyed in the meantime, we do nothing (so, this
+ *     // means that the parent's element children list will have a null in
+ *     // the component's position, which will cause the pvnode to be removed
+ *     // when it is patched.
+ *     if (w4.__owl__.isDestroyed) {
+ *       return;
+ *     }
+ *     // like above, we register the pvnode to the children list, so it
+ *     // will not be patched out of the dom.
+ *     let pvnode = w4.__owl__.pvnode;
+ *     c1[_2_index] = pvnode;
+ *   });
+ * }
+ *
+ * // we register the deferred here so the parent can coordinate its patch operation
+ * // with all the children.
+ * extra.promises.push(def3);
+ * return vn1;
+ * ```
+ */
+
+QWeb.addDirective({
+  name: "component",
+  extraNames: ["props"],
+  priority: 100,
+  atNodeEncounter({ ctx, value, node, qweb }): boolean {
+    ctx.addLine(`// Component '${value}'`);
+    ctx.rootContext.shouldDefineQWeb = true;
+    ctx.rootContext.shouldDefineParent = true;
+    ctx.rootContext.shouldDefineUtils = true;
+    ctx.rootContext.shouldDefineScope = true;
+    let hasDynamicProps = node.getAttribute("t-props") ? true : false;
+
+    // t-on- events and t-transition
+    const events: [string, string][] = [];
+    let transition: string = "";
+    const attributes = (<Element>node).attributes;
+    const props: { [key: string]: string } = {};
+    for (let i = 0; i < attributes.length; i++) {
+      const name = attributes[i].name;
+      const value = attributes[i].textContent!;
+      if (name.startsWith("t-on-")) {
+        events.push([name, value]);
+      } else if (name === "t-transition") {
+        transition = value;
+      } else if (!name.startsWith("t-")) {
+        if (name !== "class" && name !== "style") {
+          // this is a prop!
+          props[name] = ctx.formatExpression(value) || "undefined";
+        }
+      }
+    }
+
+    // computing the props string representing the props object
+    let propStr = Object.keys(props)
+      .map(k => k + ":" + props[k])
+      .join(",");
+    let componentID = ctx.generateID();
+
+    const templateKey = ctx.generateTemplateKey();
+    let ref = node.getAttribute("t-ref");
+    let refExpr = "";
+    let refKey: string = "";
+    if (ref) {
+      ctx.rootContext.shouldDefineRefs = true;
+      refKey = `ref${ctx.generateID()}`;
+      ctx.addLine(`const ${refKey} = ${ctx.interpolate(ref)};`);
+      refExpr = `context.__owl__.refs[${refKey}] = w${componentID};`;
+    }
+    let finalizeComponentCode = `w${componentID}.destroy();`;
+    if (ref) {
+      finalizeComponentCode += `delete context.__owl__.refs[${refKey}];`;
+    }
+    if (transition) {
+      finalizeComponentCode = `let finalize = () => {
+          ${finalizeComponentCode}
+        };
+        delete w${componentID}.__owl__.transitionInserted;
+        utils.transitionRemove(vn, '${transition}', finalize);`;
+    }
+
+    let createHook = "";
+    let classAttr = node.getAttribute("class");
+    let tattClass = node.getAttribute("t-att-class");
+    let styleAttr = node.getAttribute("style");
+    let tattStyle = node.getAttribute("t-att-style");
+    if (tattStyle) {
+      const attVar = `_${ctx.generateID()}`;
+      ctx.addLine(`const ${attVar} = ${ctx.formatExpression(tattStyle)};`);
+      tattStyle = attVar;
+    }
+    let classObj = "";
+    if (classAttr || tattClass || styleAttr || tattStyle || events.length) {
+      if (classAttr) {
+        let classDef = classAttr
+          .trim()
+          .split(/\s+/)
+          .map(a => `'${a}':true`)
+          .join(",");
+        classObj = `_${ctx.generateID()}`;
+        ctx.addLine(`let ${classObj} = {${classDef}};`);
+      }
+      if (tattClass) {
+        let tattExpr = ctx.formatExpression(tattClass);
+        if (tattExpr[0] !== "{" || tattExpr[tattExpr.length - 1] !== "}") {
+          tattExpr = `utils.toObj(${tattExpr})`;
+        }
+        if (classAttr) {
+          ctx.addLine(`Object.assign(${classObj}, ${tattExpr})`);
+        } else {
+          classObj = `_${ctx.generateID()}`;
+          ctx.addLine(`let ${classObj} = ${tattExpr};`);
+        }
+      }
+      let eventsCode = events
+        .map(function([name, value]) {
+          const { event, handler } = makeHandlerCode(
+            ctx,
+            name,
+            value,
+            false,
+            T_COMPONENT_MODS_CODE
+          );
+          return `vn.elm.addEventListener('${event}', ${handler});`;
+        })
+        .join("");
+      const styleExpr = tattStyle || (styleAttr ? `'${styleAttr}'` : false);
+      const styleCode = styleExpr ? `vn.elm.style = ${styleExpr};` : "";
+      createHook = `vnode.data.hook = {create(_, vn){${styleCode}${eventsCode}}};`;
+    }
+
+    ctx.addLine(
+      `let w${componentID} = ${templateKey} in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[${templateKey}]] : false;`
+    );
+    let shouldProxy = !ctx.parentNode;
+    if (shouldProxy) {
+      let id = ctx.generateID();
+      ctx.rootContext.rootNode = id;
+      shouldProxy = true;
+      ctx.rootContext.shouldDefineResult = true;
+      ctx.addLine(`let vn${id} = {};`);
+      ctx.addLine(`result = vn${id};`);
+    }
+    if (hasDynamicProps) {
+      const dynamicProp = ctx.formatExpression(node.getAttribute("t-props")!);
+      ctx.addLine(`let props${componentID} = Object.assign({${propStr}}, ${dynamicProp});`);
+    } else {
+      ctx.addLine(`let props${componentID} = {${propStr}};`);
+    }
+    ctx.addIf(
+      `w${componentID} && w${componentID}.__owl__.currentFiber && !w${componentID}.__owl__.vnode`
+    );
+    ctx.addLine(`w${componentID}.destroy();`);
+    ctx.addLine(`w${componentID} = false;`);
+    ctx.closeIf();
+
+    let registerCode = "";
+    if (shouldProxy) {
+      registerCode = `utils.defineProxy(vn${ctx.rootNode}, pvnode);`;
+    }
+
+    // SLOTS
+    const hasSlots = node.childNodes.length;
+
+    let scope = hasSlots ? `Object.assign(Object.create(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};});`;
+    }
+    ctx.addLine(
+      `w${componentID}.__updateProps(props${componentID}, extra.fiber, ${scope})${styleCode};`
+    );
+    ctx.addLine(`let pvnode = w${componentID}.__owl__.pvnode;`);
+    if (registerCode) {
+      ctx.addLine(registerCode);
+    }
+    if (ctx.parentNode) {
+      ctx.addLine(`c${ctx.parentNode}.push(pvnode);`);
+    }
+
+    ctx.addElse();
+
+    // new component
+    let dynamicFallback = "";
+    if (!value.match(INTERP_REGEXP)) {
+      dynamicFallback = `|| ${ctx.formatExpression(value)}`;
+    }
+    const interpValue = ctx.interpolate(value);
+    ctx.addLine(`let componentKey${componentID} = ${interpValue};`);
+    ctx.addLine(
+      `let W${componentID} = context.constructor.components[componentKey${componentID}] || QWeb.components[componentKey${componentID}]${dynamicFallback};`
+    );
+
+    // maybe only do this in dev mode...
+    ctx.addLine(
+      `if (!W${componentID}) {throw new Error('Cannot find the definition of component "' + componentKey${componentID} + '"')}`
+    );
+    ctx.addLine(`w${componentID} = new W${componentID}(parent, props${componentID});`);
+    if (transition) {
+      ctx.addLine(`const __patch${componentID} = w${componentID}.__patch;`);
+      ctx.addLine(
+        `w${componentID}.__patch = fiber => {__patch${componentID}.call(w${componentID}, fiber); if(!w${componentID}.__owl__.transitionInserted){w${componentID}.__owl__.transitionInserted = true;utils.transitionInsert(w${componentID}.__owl__.vnode, '${transition}');}};`
+      );
+    }
+    ctx.addLine(`parent.__owl__.cmap[${templateKey}] = w${componentID}.__owl__.id;`);
+
+    if (hasSlots) {
+      const clone = <Element>node.cloneNode(true);
+      const slotNodes = clone.querySelectorAll("[t-set]");
+      const slotId = QWeb.nextSlotId++;
+      ctx.addLine(`w${componentID}.__owl__.slotId = ${slotId};`);
+      if (slotNodes.length) {
+        for (let i = 0, length = slotNodes.length; i < length; i++) {
+          const slotNode = slotNodes[i];
+          slotNode.parentElement!.removeChild(slotNode);
+          const key = slotNode.getAttribute("t-set")!;
+          slotNode.removeAttribute("t-set");
+          const slotFn = qweb._compile(`slot_${key}_template`, slotNode, ctx);
+          QWeb.slots[`${slotId}_${key}`] = slotFn;
+        }
+      }
+      if (clone.childNodes.length) {
+        const t = clone.ownerDocument!.createElement("t");
+        for (let child of Object.values(clone.childNodes)) {
+          t.appendChild(child);
+        }
+        const slotFn = qweb._compile(`slot_default_template`, t, ctx);
+        QWeb.slots[`${slotId}_default`] = slotFn;
+      }
+    }
+
+    ctx.addLine(
+      `let fiber = w${componentID}.__prepare(extra.fiber, ${scope}, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; ${createHook}});`
+    );
+    // hack: specify empty remove hook to prevent the node from being removed from the DOM
+    const insertHook = refExpr ? `insert(vn) {${refExpr}},` : "";
+    ctx.addLine(
+      `let pvnode = h('dummy', {key: ${templateKey}, hook: {${insertHook}remove() {},destroy(vn) {${finalizeComponentCode}}}});`
+    );
+    if (registerCode) {
+      ctx.addLine(registerCode);
+    }
+    if (ctx.parentNode) {
+      ctx.addLine(`c${ctx.parentNode}.push(pvnode);`);
+    }
+    ctx.addLine(`w${componentID}.__owl__.pvnode = pvnode;`);
+
+    ctx.closeIf();
+
+    if (classObj) {
+      ctx.addLine(`w${componentID}.__owl__.classObj=${classObj};`);
+    }
+
+    ctx.addLine(`w${componentID}.__owl__.parentLastFiberId = extra.fiber.id;`);
+
+    return true;
+  }
+});

src/component/fiber.ts

@@ -0,0 +1,286 @@
+import { h, VNode } from "../vdom/index";
+import { Component } from "./component";
+import { scheduler } from "./scheduler";
+
+/**
+ * Owl Fiber Class
+ *
+ * Fibers are small abstractions designed to contain all the internal state
+ * associated with a "rendering work unit", relative to a specific component.
+ *
+ * A rendering will cause the creation of a fiber for each impacted components.
+ *
+ * Fibers capture all that necessary information, which is critical to owl
+ * asynchronous rendering pipeline. Fibers can be cancelled, can be in different
+ * states and in general determine the state of the rendering.
+ */
+
+export class Fiber {
+  static nextId: number = 1;
+  id: number = Fiber.nextId++;
+
+  // The force attribute determines if a rendering should bypass the `shouldUpdate`
+  // method potentially implemented by a component. It is usually set to false.
+  force: boolean;
+
+  // isCompleted means that the rendering corresponding to this fiber's work is
+  // done, either because the component has been mounted or patched, or because
+  // fiber has been cancelled.
+  isCompleted: boolean = false;
+
+  // the fibers corresponding to component updates (updateProps) need to call
+  // the willPatch and patched hooks from the corresponding component. However,
+  // fibers corresponding to a new component do not need to do that. So, the
+  // shouldPatch hook is the boolean that we check whenever we need to apply
+  // a patch.
+  shouldPatch: boolean = true;
+
+  // isRendered is the last state of a fiber. If true, this means that it has
+  // been rendered and is inert (so, it should not be taken into account when
+  // counting the number of active fibers).
+  isRendered: boolean = false;
+
+  // the counter number is a critical information. It is only necessary for a
+  // root fiber.  For that fiber, this number counts the number of active sub
+  // fibers.  When that number reaches 0, the fiber can be applied by the
+  // scheduler.
+  counter: number = 0;
+
+  inserter: (el: HTMLElement) => void | null;
+
+  scope: any;
+
+  component: Component<any, any>;
+  vnode: VNode | null = null;
+
+  root: Fiber;
+  child: Fiber | null = null;
+  sibling: Fiber | null = null;
+  lastChild: Fiber | null = null;
+  parent: Fiber | null = null;
+
+  error?: Error;
+
+  constructor(parent: Fiber | null, component: Component<any, any>, force, inserter) {
+    this.component = component;
+    this.force = force;
+    this.inserter = inserter;
+
+    const __owl__ = component.__owl__;
+    this.scope = __owl__.scope;
+
+    this.root = parent ? parent.root : this;
+    this.parent = parent;
+
+    let oldFiber = __owl__.currentFiber;
+    if (oldFiber && !oldFiber.isCompleted) {
+      if (oldFiber.root === oldFiber && !parent) {
+        // both oldFiber and this fiber are root fibers
+        this._reuseFiber(oldFiber);
+        return oldFiber;
+      } else {
+        this._remapFiber(oldFiber);
+      }
+    }
+
+    this.root.counter++;
+
+    __owl__.currentFiber = this;
+  }
+
+  /**
+   * When the oldFiber is not completed yet, and both oldFiber and this fiber
+   * are root fibers, we want to reuse the oldFiber instead of creating a new
+   * one. Doing so will guarantee that the initiator(s) of those renderings will
+   * be notified (the promise will resolve) when the last rendering will be done.
+   *
+   * This function thus assumes that oldFiber is a root fiber.
+   */
+  _reuseFiber(oldFiber: Fiber) {
+    oldFiber.cancel(); // cancel children fibers
+    oldFiber.isCompleted = false; // keep the root fiber alive
+    oldFiber.isRendered = false; // the fiber has to be re-rendered
+    if (oldFiber.child) {
+      // remove relation to children
+      oldFiber.child.parent = null;
+      oldFiber.child = null;
+      oldFiber.lastChild = null;
+    }
+    oldFiber.counter = 1; // re-initialize counter
+    oldFiber.id = Fiber.nextId++;
+  }
+
+  /**
+   * In some cases, a rendering initiated at some component can detect that it
+   * should be part of a larger rendering initiated somewhere up the component
+   * tree.  In that case, it needs to cancel the previous rendering and
+   * remap itself as a part of the current parent rendering.
+   */
+  _remapFiber(oldFiber: Fiber) {
+    oldFiber.cancel();
+    this.shouldPatch = oldFiber.shouldPatch;
+    if (oldFiber === oldFiber.root) {
+      oldFiber.counter++;
+    }
+    if (oldFiber.parent && !this.parent) {
+      // re-map links
+      this.parent = oldFiber.parent;
+      this.root = this.parent.root;
+      this.sibling = oldFiber.sibling;
+      if (this.parent.lastChild === oldFiber) {
+        this.parent.lastChild = this;
+      }
+      if (this.parent.child === oldFiber) {
+        this.parent.child = this;
+      } else {
+        let current = this.parent.child!;
+        while (true) {
+          if (current.sibling === oldFiber) {
+            current.sibling = this;
+            break;
+          }
+          current = current.sibling!;
+        }
+      }
+    }
+  }
+
+  /**
+   * This function has been taken from
+   * https://medium.com/react-in-depth/the-how-and-why-on-reacts-usage-of-linked-list-in-fiber-67f1014d0eb7
+   */
+  _walk(doWork: (f: Fiber) => Fiber | null) {
+    let root = this;
+    let current: Fiber = this;
+    while (true) {
+      const child = doWork(current);
+      if (child) {
+        current = child;
+        continue;
+      }
+      if (current === root) {
+        return;
+      }
+      while (!current.sibling) {
+        if (!current.parent || current.parent === root) {
+          return;
+        }
+        current = current.parent;
+      }
+      current = current.sibling;
+    }
+  }
+
+  /**
+   * Successfully complete the work of the fiber: call the mount or patch hooks
+   * and patch the DOM. This function is called once the fiber and its children
+   * are ready, and the scheduler decides to process it.
+   */
+  complete() {
+    let component = this.component;
+    this.isCompleted = true;
+    if (!this.inserter && !component.__owl__.isMounted) {
+      return;
+    }
+
+    // build patchQueue
+    const patchQueue: Fiber[] = [];
+    const doWork: (Fiber) => Fiber | null = function(f) {
+      patchQueue.push(f);
+      return f.child;
+    };
+    this._walk(doWork);
+    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();
+        }
+        component.willPatch();
+      }
+    }
+
+    // call __patch on each fiber of (reversed) patchQueue
+    for (let i = patchLen - 1; i >= 0; i--) {
+      const fiber = patchQueue[i];
+      component = fiber.component;
+      component.__patch(fiber.vnode!);
+      if (!fiber.shouldPatch && (!fiber.inserter || i !== 0)) {
+        component.__owl__.pvnode!.elm = component.__owl__.vnode!.elm;
+      }
+      component.__owl__.currentFiber = null;
+    }
+
+    // insert into the DOM (mount case)
+    let inDOM = false;
+    if (this.inserter) {
+      this.inserter(this.component.el!);
+      inDOM = document.body.contains(this.component.el);
+      this.component.env.qweb.trigger("dom-appended");
+    }
+
+    // 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.inserter) {
+        component.patched();
+        if (component.__owl__.patchedCB) {
+          component.__owl__.patchedCB();
+        }
+      } else if (this.inserter ? inDOM : true) {
+        component.__callMounted();
+      }
+    }
+  }
+
+  /**
+   * Cancel a fiber and all its children.
+   */
+  cancel() {
+    this._walk(f => {
+      if (!f.isRendered) {
+        f.root.counter--;
+      }
+      f.isCompleted = true;
+      return f.child;
+    });
+  }
+
+  /**
+   * This is the global error handler for errors occurring in Owl main lifecycle
+   * methods.  Caught errors are triggered on the QWeb instance, and are
+   * potentially given to some parent component which implements `catchError`.
+   *
+   * If there are no such component, we destroy everything. This is better than
+   * being in a corrupted state.
+   */
+  handleError(error: Error) {
+    let component = this.component;
+    this.vnode = component.__owl__.vnode || h("div");
+
+    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 {
+      // 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();
+    }
+  }
+}

src/component/props_validation.ts

@@ -0,0 +1,115 @@
+import { QWeb } from "../qweb/index";
+
+//------------------------------------------------------------------------------
+// Prop validation helper
+//------------------------------------------------------------------------------
+
+/**
+ * Validate the component props (or next props) against the (static) props
+ * description.  This is potentially an expensive operation: it may needs to
+ * visit recursively the props and all the children to check if they are valid.
+ * This is why it is only done in 'dev' mode.
+ */
+
+QWeb.utils.validateProps = function(Widget, props: Object) {
+  const propsDef = (<any>Widget).props;
+  if (propsDef instanceof Array) {
+    // list of strings (prop names)
+    for (let i = 0, l = propsDef.length; i < l; i++) {
+      const propName = propsDef[i];
+      if (propName[propName.length - 1] === "?") {
+        // optional prop
+        break;
+      }
+      if (!(propName in props)) {
+        throw new Error(`Missing props '${propsDef[i]}' (component '${Widget.name}')`);
+      }
+    }
+    for (let key in props) {
+      if (!propsDef.includes(key) && !propsDef.includes(key + "?")) {
+        throw new Error(`Unknown prop '${key}' given to component '${Widget.name}'`);
+      }
+    }
+  } else if (propsDef) {
+    // propsDef is an object now
+    for (let propName in propsDef) {
+      if (props[propName] === undefined) {
+        if (propsDef[propName] && !propsDef[propName].optional) {
+          throw new Error(`Missing props '${propName}' (component '${Widget.name}')`);
+        } else {
+          break;
+        }
+      }
+      let isValid;
+      try {
+        isValid = isValidProp(props[propName], propsDef[propName]);
+      } catch (e) {
+        e.message = `Invalid prop '${propName}' in component ${Widget.name} (${e.message})`;
+        throw e;
+      }
+      if (!isValid) {
+        throw new Error(`Invalid Prop '${propName}' in component '${Widget.name}'`);
+      }
+    }
+    for (let propName in props) {
+      if (!(propName in propsDef)) {
+        throw new Error(`Unknown prop '${propName}' given to component '${Widget.name}'`);
+      }
+    }
+  }
+};
+
+/**
+ * Check if an invidual prop value matches its (static) prop definition
+ */
+function isValidProp(prop, propDef): boolean {
+  if (propDef === true) {
+    return true;
+  }
+  if (typeof propDef === "function") {
+    // Check if a value is constructed by some Constructor.  Note that there is a
+    // slight abuse of language: we want to consider primitive values as well.
+    //
+    // So, even though 1 is not an instance of Number, we want to consider that
+    // it is valid.
+    if (typeof prop === "object") {
+      return prop instanceof propDef;
+    }
+    return typeof prop === propDef.name.toLowerCase();
+  } else if (propDef instanceof Array) {
+    // If this code is executed, this means that we want to check if a prop
+    // matches at least one of its descriptor.
+    let result = false;
+    for (let i = 0, iLen = propDef.length; i < iLen; i++) {
+      result = result || isValidProp(prop, propDef[i]);
+    }
+    return result;
+  }
+  // propsDef is an object
+  if (propDef.optional && prop === undefined) {
+    return true;
+  }
+  let result = propDef.type ? isValidProp(prop, propDef.type) : true;
+  if (propDef.validate) {
+    result = result && propDef.validate(prop);
+  }
+  if (propDef.type === Array && propDef.element) {
+    for (let i = 0, iLen = prop.length; i < iLen; i++) {
+      result = result && isValidProp(prop[i], propDef.element);
+    }
+  }
+  if (propDef.type === Object && propDef.shape) {
+    const shape = propDef.shape;
+    for (let key in shape) {
+      result = result && isValidProp(prop[key], shape[key]);
+    }
+    if (result) {
+      for (let propName in prop) {
+        if (!(propName in shape)) {
+          throw new Error(`unknown prop '${propName}'`);
+        }
+      }
+    }
+  }
+  return result;
+}

src/component/scheduler.ts

@@ -0,0 +1,102 @@
+import { Fiber } from "./fiber";
+
+/**
+ * Owl Scheduler Class
+ *
+ * The scheduler is the part of Owl that will effectively apply a rendering
+ * whenever a fiber is ready.
+ *
+ * Briefly, it can be used to register root fibers.  Whenever there is an
+ * active root fiber, it will poll continuously each animation frame (so, about
+ * once every 16ms) and whenever a root fiber is ready, it will apply it.
+ */
+
+interface Task {
+  fiber: Fiber;
+  callback: (err?: Error) => void;
+}
+
+export class Scheduler {
+  tasks: Task[] = [];
+  isRunning: boolean = false;
+  requestAnimationFrame: typeof window.requestAnimationFrame;
+
+  constructor(requestAnimationFrame) {
+    this.requestAnimationFrame = requestAnimationFrame;
+  }
+
+  start() {
+    this.isRunning = true;
+    this.scheduleTasks();
+  }
+
+  stop() {
+    this.isRunning = false;
+  }
+
+  addFiber(fiber): Promise<void> {
+    // if the fiber was remapped into a larger rendering fiber, it may not be a
+    // root fiber.  But we only want to register root fibers
+    fiber = fiber.root;
+    return new Promise((resolve, reject) => {
+      if (fiber.error) {
+        return reject(fiber.error);
+      }
+      this.tasks.push({
+        fiber,
+        callback: () => {
+          if (fiber.error) {
+            return reject(fiber.error);
+          }
+          resolve();
+        }
+      });
+      if (!this.isRunning) {
+        this.start();
+      }
+    });
+  }
+
+  /**
+   * Process all current tasks. This only applies to the fibers that are ready.
+   * Other tasks are left unchanged.
+   */
+  flush() {
+    let tasks = this.tasks;
+    this.tasks = [];
+    tasks = tasks.filter(task => {
+      if (task.fiber.isCompleted) {
+        task.callback();
+        return false;
+      }
+      if (task.fiber.counter === 0) {
+        if (!task.fiber.error) {
+          try {
+            task.fiber.complete();
+          } catch (e) {
+            task.fiber.handleError(e);
+          }
+        }
+        task.callback();
+        return false;
+      }
+      return true;
+    });
+    this.tasks = tasks.concat(this.tasks);
+    if (this.tasks.length === 0) {
+      this.stop();
+    }
+  }
+
+  scheduleTasks() {
+    this.requestAnimationFrame(() => {
+      this.flush();
+      if (this.isRunning) {
+        this.scheduleTasks();
+      }
+    });
+  }
+}
+
+const raf = window.requestAnimationFrame.bind(window);
+export const scheduler = new Scheduler(raf);

src/component/styles.ts

@@ -0,0 +1,70 @@
+/**
+ * Owl Style System
+ *
+ * This files contains the Owl code related to processing (extended) css strings
+ * and creating/adding <style> tags to the document head.
+ */
+
+export const STYLESHEETS: { [id: string]: HTMLStyleElement } = {};
+
+export function processSheet(str: string): string {
+  const tokens = str.split(/(\{|\}|;)/).map(s => s.trim());
+  const selectorStack: string[][] = [];
+  const parts: string[] = [];
+  let rules: string[] = [];
+  function generateSelector(stackIndex: number, parentSelector?: string) {
+    const parts: string[] = [];
+    for (const selector of selectorStack[stackIndex]) {
+      let part = (parentSelector && parentSelector + " " + selector) || selector;
+      if (part.includes("&")) {
+        part = selector.replace(/&/g, parentSelector || "");
+      }
+      if (stackIndex < selectorStack.length - 1) {
+        part = generateSelector(stackIndex + 1, part);
+      }
+      parts.push(part);
+    }
+    return parts.join(", ");
+  }
+  function generateRules() {
+    if (rules.length) {
+      parts.push(generateSelector(0) + " {");
+      parts.push(...rules);
+      parts.push("}");
+      rules = [];
+    }
+  }
+  while (tokens.length) {
+    let token = tokens.shift()!;
+    if (token === "}") {
+      generateRules();
+      selectorStack.pop();
+    } else {
+      if (tokens[0] === "{") {
+        generateRules();
+        selectorStack.push(token.split(/\s*,\s*/));
+        tokens.shift();
+      }
+      if (tokens[0] === ";") {
+        rules.push("  " + token + ";");
+      }
+    }
+  }
+  return parts.join("\n");
+}
+export function registerSheet(id: string, css: string) {
+  const sheet = document.createElement("style");
+  sheet.innerHTML = processSheet(css);
+  STYLESHEETS[id] = sheet;
+}
+
+export function activateSheet(id, name) {
+  const sheet = STYLESHEETS[id];
+  if (!sheet) {
+    throw new Error(
+      `Invalid css stylesheet for component '${name}'. Did you forget to use the 'css' tag helper?`
+    );
+  }
+  sheet.setAttribute("component", name);
+  document.head.appendChild(sheet);
+}

src/config.ts

@@ -0,0 +1,30 @@
+import { QWeb } from "./qweb/index";
+
+/**
+ * This file creates and exports the OWL 'config' object, with keys:
+ *  - 'mode': 'prod' or 'dev',
+ *  - 'env': the environment to use in root components.
+ */
+
+interface Config {
+  mode: string;
+}
+
+export const config = {} as Config;
+
+Object.defineProperty(config, "mode", {
+  get() {
+    return QWeb.dev ? "dev" : "prod";
+  },
+  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.`
+      );
+    } else {
+      console.log(`Owl is now running in 'prod' mode.`);
+    }
+  }
+});

src/context.ts

@@ -0,0 +1,148 @@
+import { Component } from "./component/component";
+import { scheduler } from "./component/scheduler";
+import { EventBus } from "./core/event_bus";
+import { Observer } from "./core/observer";
+
+/**
+ * The `Context` object provides a way to share data between an arbitrary number
+ * of component. Usually, data is passed from a parent to its children component,
+ * but when we have to deal with some mostly global information, this can be
+ * annoying, since each component will need to pass the information to each
+ * children, even though some or most of them will not use the information.
+ *
+ * With a `Context` object, each component can subscribe (with the `useContext`
+ * hook) to its state, and will be updated whenever the context state is updated.
+ */
+
+function partitionBy<T>(arr: T[], fn: (t: T) => boolean) {
+  let lastGroup: T[] | false = false;
+  let lastValue;
+  return arr.reduce((acc: T[][], cur) => {
+    let curVal = fn(cur);
+    if (lastGroup) {
+      if (curVal === lastValue) {
+        lastGroup.push(cur);
+      } else {
+        lastGroup = false;
+      }
+    }
+    if (!lastGroup) {
+      lastGroup = [cur];
+      acc.push(lastGroup);
+    }
+    lastValue = curVal;
+    return acc;
+  }, []);
+}
+
+export class Context extends EventBus {
+  state: any;
+  observer: Observer;
+  rev: number = 1;
+  // mapping from component id to last observed context id
+  mapping: { [componentId: number]: number } = {};
+
+  constructor(state: Object = {}) {
+    super();
+    this.observer = new Observer();
+    this.observer.notifyCB = () => {
+      // notify components in the next microtask tick to ensure that subscribers
+      // are notified only once for all changes that occur in the same micro tick
+      let rev = this.rev;
+      return Promise.resolve().then(() => {
+        if (rev === this.rev) {
+          this.__notifyComponents();
+        }
+      });
+    };
+    this.state = this.observer.observe(state);
+    this.subscriptions.update = [];
+  }
+
+  /**
+   * Instead of using trigger to emit an update event, we actually implement
+   * our own function to do that.  The reason is that we need to be smarter than
+   * a simple trigger function: we need to wait for parent components to be
+   * done before doing children components.  More precisely, if an update
+   * as an effect of destroying a children, we do not want to call any code
+   * from the child, and certainly not render it.
+   *
+   * This method implements a simple grouping algorithm by depth. If we have
+   * connected components of depths [2, 4,4,4,4, 3,8,8], the Context will notify
+   * them in the following groups: [2], [4,4,4,4], [3], [8,8]. Each group will
+   * be updated sequentially, but each components in a given group will be done in
+   * parallel.
+   *
+   * This is a very simple algorithm, but it avoids checking if a given
+   * component is a child of another.
+   */
+  async __notifyComponents() {
+    const rev = ++this.rev;
+    const subscriptions = this.subscriptions.update;
+    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));
+      // 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
+      // flush the scheduler.  This will force the scheduler to check
+      // immediately if they are done, which will cause their rendering
+      // promise to resolve earlier, which means that there is a chance of
+      // processing the next group in the same frame.
+      scheduler.flush();
+      await Promise.all(proms);
+    }
+  }
+}
+
+/**
+ * The`useContext` hook is the normal way for a component to register themselve
+ * to context state changes. The `useContext` method returns the context state
+ */
+export function useContext(ctx: Context): any {
+  const component: Component<any, any> = Component.current!;
+  return useContextWithCB(ctx, component, component.render.bind(component));
+}
+
+export function useContextWithCB(ctx: Context, component: Component<any, any>, method): any {
+  const __owl__ = component.__owl__;
+  const id = __owl__.id;
+  const mapping = ctx.mapping;
+  if (id in mapping) {
+    return ctx.state;
+  }
+  if (!__owl__.observer) {
+    __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) {
+    mapping[id] = ctx.rev;
+    return renderFn(comp, params);
+  };
+  ctx.on("update", component, async contextRev => {
+    if (mapping[id] < contextRev) {
+      mapping[id] = contextRev;
+      await method();
+    }
+  });
+  const __destroy = component.__destroy;
+  component.__destroy = parent => {
+    ctx.off("update", component);
+    delete mapping[id];
+    __destroy.call(component, parent);
+  };
+  return ctx.state;
+}

src/core/event_bus.ts

@@ -3,7 +3,8 @@
  * - emit events
  * - add/remove listeners.
  *
- * This is a useful pattern of communication in some cases.
+ * This is a useful pattern of communication in many cases.  For OWL, each
+ * components and stores are event buses.
  */
 
 //------------------------------------------------------------------------------
@@ -28,7 +29,7 @@ export class EventBus {
    * Add a listener for the 'eventType' events.
    *
    * Note that the 'owner' of this event can be anything, but will more likely
-   * be a widget or a class. The idea is that the callback will be called with
+   * be a component or a class. The idea is that the callback will be called with
    * the proper owner bound.
    *
    * Also, the owner should be kind of unique. This will be used to remove the
@@ -63,7 +64,8 @@ export class EventBus {
    */
   trigger(eventType: string, ...args: any[]) {
     const subs = this.subscriptions[eventType] || [];
-    for (let sub of subs) {
+    for (let i = 0, iLen = subs.length; i < iLen; i++) {
+      const sub = subs[i];
       sub.callback.call(sub.owner, ...args);
     }
   }

src/core/observer.ts

@@ -0,0 +1,94 @@
+/**
+ * Owl Observer
+ *
+ * This code contains the logic that allows Owl to observe and react to state
+ * changes.
+ *
+ * This is a Observer class that can observe any JS values.  The way it works
+ * can be summarized thusly:
+ * - primitive values are not observed at all
+ * - Objects and arrays are observed by replacing them with a Proxy
+ * - each object/array metadata are tracked in a weakmap, and keep a revision
+ *   number
+ *
+ * Note that this code is loosely inspired by Vue.
+ */
+
+//------------------------------------------------------------------------------
+// Observer
+//------------------------------------------------------------------------------
+export class Observer {
+  rev: number = 1;
+  allowMutations: boolean = true;
+  weakMap: WeakMap<any, any> = new WeakMap();
+
+  notifyCB() {}
+
+  observe<T>(value: T, parent?: any): T {
+    if (value === null || typeof value !== "object" || value instanceof Date) {
+      // fun fact: typeof null === 'object'
+      return value;
+    }
+    let metadata = this.weakMap.get(value) || this._observe(value, parent);
+    return metadata.proxy;
+  }
+
+  revNumber(value): number {
+    const metadata = this.weakMap.get(value);
+    return metadata ? metadata.rev : 0;
+  }
+
+  _observe(value, parent) {
+    var self = this;
+
+    const proxy = new Proxy(value, {
+      get(target, k) {
+        const targetValue = target[k];
+        return self.observe(targetValue, value);
+      },
+      set(target, key: string, newVal): boolean {
+        const value = target[key];
+        if (newVal !== value) {
+          if (!self.allowMutations) {
+            throw new Error(
+              `Observed state cannot be changed here! (key: "${key}", val: "${newVal}")`
+            );
+          }
+          self._updateRevNumber(target);
+          target[key] = newVal;
+          self.notifyCB();
+        }
+        return true;
+      },
+      deleteProperty(target, key) {
+        if (key in target) {
+          delete target[key];
+          self._updateRevNumber(target);
+          self.notifyCB();
+        }
+        return true;
+      }
+    });
+
+    const metadata = {
+      value,
+      proxy,
+      rev: this.rev,
+      parent
+    };
+
+    this.weakMap.set(value, metadata);
+    this.weakMap.set(metadata.proxy, metadata);
+    return metadata;
+  }
+
+  _updateRevNumber(target: any) {
+    this.rev++;
+    let metadata = this.weakMap.get(target);
+    let parent = target;
+    do {
+      metadata = this.weakMap.get(parent);
+      metadata.rev++;
+    } while ((parent = metadata.parent) && parent !== target);
+  }
+}

src/core/owl_event.ts

@@ -0,0 +1,15 @@
+import { Component } from "../component/component";
+
+/**
+ * We define here OwlEvent, a subclass of CustomEvent, with an additional
+ * attribute:
+ *  - originalComponent: the component that triggered the event
+ */
+
+export class OwlEvent<T> extends CustomEvent<T> {
+  originalComponent: Component<any, any>;
+  constructor(component, eventType, options) {
+    super(eventType, options);
+    this.originalComponent = component;
+  }
+}

src/hooks.ts

@@ -0,0 +1,157 @@
+import { Component } from "./component/component";
+import { Observer } from "./core/observer";
+
+/**
+ * Owl Hook System
+ *
+ * This file introduces the concept of hooks, similar to React or Vue hooks.
+ * We have currently an implementation of:
+ * - useState (reactive state)
+ * - onMounted
+ * - onWillUnmount
+ * - useRef
+ */
+
+// -----------------------------------------------------------------------------
+// useState
+// -----------------------------------------------------------------------------
+
+/**
+ * This is the main way a component can be made reactive.  The useState hook
+ * will return an observed object (or array).  Changes to that value will then
+ * trigger a rerendering of the current component.
+ */
+export function useState<T>(state: T): T {
+  const component: Component<any, any> = Component.current!;
+  const __owl__ = component.__owl__;
+  if (!__owl__.observer) {
+    __owl__.observer = new Observer();
+    __owl__.observer.notifyCB = component.render.bind(component);
+  }
+  return __owl__.observer.observe(state);
+}
+
+// -----------------------------------------------------------------------------
+// Life cycle hooks
+// -----------------------------------------------------------------------------
+function makeLifecycleHook(method: string, reverse: boolean = false) {
+  if (reverse) {
+    return function(cb) {
+      const component: Component<any, any> = Component.current!;
+      if (component.__owl__[method]) {
+        const current = component.__owl__[method];
+        component.__owl__[method] = function() {
+          current.call(component);
+          cb.call(component);
+        };
+      } else {
+        component.__owl__[method] = cb;
+      }
+    };
+  } else {
+    return function(cb) {
+      const component: Component<any, any> = Component.current!;
+      if (component.__owl__[method]) {
+        const current = component.__owl__[method];
+        component.__owl__[method] = function() {
+          cb.call(component);
+          current.call(component);
+        };
+      } else {
+        component.__owl__[method] = cb;
+      }
+    };
+  }
+}
+
+function makeAsyncHook(method: string) {
+  return function(cb) {
+    const component: Component<any, any> = Component.current!;
+    if (component.__owl__[method]) {
+      const current = component.__owl__[method];
+      component.__owl__[method] = function(...args) {
+        return Promise.all[(current.call(component, ...args), cb.call(component, ...args))];
+      };
+    } else {
+      component.__owl__[method] = cb;
+    }
+  };
+}
+
+export const onMounted = makeLifecycleHook("mountedCB", true);
+export const onWillUnmount = makeLifecycleHook("willUnmountCB");
+export const onWillPatch = makeLifecycleHook("willPatchCB");
+export const onPatched = makeLifecycleHook("patchedCB", true);
+
+export const onWillStart = makeAsyncHook("willStartCB");
+export const onWillUpdateProps = makeAsyncHook("willUpdatePropsCB");
+
+// -----------------------------------------------------------------------------
+// useRef
+// -----------------------------------------------------------------------------
+
+/**
+ * The purpose of this hook is to allow components to get a reference to a sub
+ * html node or component.
+ */
+interface Ref {
+  el: HTMLElement | null;
+  comp: Component<any, any> | null;
+}
+
+export function useRef(name: string): Ref {
+  const __owl__ = Component.current!.__owl__;
+  return {
+    get el(): HTMLElement | null {
+      const val = __owl__.refs && __owl__.refs[name];
+      if (val instanceof HTMLElement) {
+        return val;
+      } else if (val instanceof Component) {
+        return val.el;
+      }
+      return null;
+    },
+    get comp(): Component<any, any> | null {
+      const val = __owl__.refs && __owl__.refs[name];
+      return val instanceof Component ? val : null;
+    }
+  };
+}
+
+// -----------------------------------------------------------------------------
+// useSubEnv
+// -----------------------------------------------------------------------------
+
+/**
+ * This hook is a simple way to let components use a sub environment.  Note that
+ * like for all hooks, it is important that this is only called in the
+ * constructor method.
+ */
+export function useSubEnv(nextEnv) {
+  const component = Component.current!;
+  component.env = Object.assign(Object.create(component.env), nextEnv);
+}
+
+// -----------------------------------------------------------------------------
+// useExternalListener
+// -----------------------------------------------------------------------------
+
+/**
+ * When a component needs to listen to DOM Events on element(s) that are not
+ * part of his hierarchy, we can use the `useExternalListener` hook.
+ * It will correctly add and remove the event listener, whenever the
+ * component is mounted and unmounted.
+ *
+ * Example:
+ *  a menu needs to listen to the click on window to be closed automatically
+ *
+ * Usage:
+ *  in the constructor of the OWL component that needs to be notified,
+ *  `useExternalListener(window, 'click', this._doSomething);`
+ * */
+export function useExternalListener(target: HTMLElement, eventName: string, handler, eventParams?) {
+  const boundHandler = handler.bind(Component.current);
+
+  onMounted(() => target.addEventListener(eventName, boundHandler, eventParams));
+  onWillUnmount(() => target.removeEventListener(eventName, boundHandler, eventParams));
+}

src/index.ts

@@ -1,7 +1,40 @@
-export { Component } from "./component";
-export { EventBus } from "./event_bus";
-export { QWeb } from "./qweb";
-export { connect, Store } from "./store";
+/**
+ * This file is the main file packaged by rollup (see rollup.config.js).  From
+ * this file, we export all public owl elements.
+ *
+ * Note that dynamic values, such as a date or a commit hash are added by rollup
+ */
+import { EventBus } from "./core/event_bus";
+import { Observer } from "./core/observer";
+import { QWeb } from "./qweb/index";
+import { config } from "./config";
+import * as _store from "./store";
 import * as _utils from "./utils";
+import * as _tags from "./tags";
+import { AsyncRoot } from "./misc/async_root";
+import { Portal } from "./misc/portal";
+import * as _hooks from "./hooks";
+import * as _context from "./context";
+import { Link } from "./router/link";
+import { RouteComponent } from "./router/route_component";
+import { Router } from "./router/router";
 
+export { Component } from "./component/component";
+export { QWeb };
+export { config };
+
+export const Context = _context.Context;
+export const useState = _hooks.useState;
+export const core = { EventBus, Observer };
+export const router = { Router, RouteComponent, Link };
+export const Store = _store.Store;
 export const utils = _utils;
+export const tags = _tags;
+export const misc = { AsyncRoot, Portal };
+export const hooks = Object.assign({}, _hooks, {
+  useContext: _context.useContext,
+  useDispatch: _store.useDispatch,
+  useGetters: _store.useGetters,
+  useStore: _store.useStore
+});
+export const __info__ = {};

src/misc/async_root.ts

@@ -0,0 +1,19 @@
+import { Component } from "../component/component";
+import { xml } from "../tags";
+
+/**
+ * AsyncRoot
+ *
+ * Owl is by default asynchronous, and the user interface will wait for all its
+ * subcomponents to be rendered before updating the DOM. This is most of the
+ * time what we want, but in some cases, it makes sense to "detach" a component
+ * from this coordination.  This is the goal of the AsyncRoot component.
+ */
+
+export class AsyncRoot extends Component<any, any> {
+  static template = xml`<t t-slot="default"/>`;
+
+  async __updateProps(nextProps, parentFiber) {
+    this.render(parentFiber.force);
+  }
+}

src/misc/portal.ts

@@ -0,0 +1,167 @@
+import { Component, portalSymbol } from "../component/component";
+import { VNode, patch } from "../vdom/index";
+import { xml } from "../tags";
+import { OwlEvent } from "../core/owl_event";
+import { useSubEnv } from "../hooks";
+
+/**
+ * Portal
+ *
+ * The Portal component allows to render a part of a component outside it's DOM.
+ * It is for example useful for dialogs: for css reasons, dialogs are in general
+ * placed in a specific spot of the DOM (e.g. directly in the body). With the
+ * Portal, a component can conditionally specify in its tempate that it contains
+ * a dialog, and where this dialog should be inserted in the DOM.
+ *
+ * The Portal component ensures that the communication between the content of
+ * the Portal and its parent properly works: business events reaching the Portal
+ * are re-triggered on an empty <portal> node located in the parent's DOM.
+ */
+
+export class Portal extends Component<any, any> {
+  static template = xml`<portal><t t-slot="default"/></portal>`;
+  static props = {
+    target: {
+      type: String
+    }
+  };
+
+  // boolean to indicate whether or not we must listen to 'dom-appended' event
+  // to hook on the moment when the target is inserted into the DOM (because it
+  // is not when the portal is rendered)
+  doTargetLookUp: boolean = true;
+  // set of encountered events that need to be redirected
+  _handledEvents: Set<string> = new Set();
+  // function that will be the event's tunnel (needs to be an arrow function to
+  // avoid having to rebind `this`)
+  _handlerTunnel: (f: OwlEvent<any>) => void = (ev: OwlEvent<any>) => {
+    ev.stopPropagation();
+    this.__trigger(ev.originalComponent, ev.type, ev.detail);
+  };
+  // Storing the parent's env
+  parentEnv: any = null;
+  // represents the element that is moved somewhere else
+  portal: VNode | null = null;
+  // the target where we will move `portal`
+  target: HTMLElement | null = null;
+
+  constructor(parent, props) {
+    super(parent, props);
+    this.parentEnv = parent ? parent.env : {};
+    // 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 => {
+        if (!this._handledEvents.has(ev.type)) {
+          this.portal!.elm!.addEventListener(ev.type, this._handlerTunnel);
+          this._handledEvents.add(ev.type);
+        }
+      }
+    });
+  }
+  /**
+   * Override to revert back to a classic Component's structure
+   *
+   * @override
+   */
+  __callWillUnmount() {
+    super.__callWillUnmount();
+    this.el!.appendChild(this.portal!.elm!);
+    this.doTargetLookUp = true;
+  }
+  /**
+   * At each DOM change, we must ensure that the portal contains exactly one
+   * child
+   */
+  __checkVNodeStructure(vnode: VNode) {
+    const children = vnode.children!;
+    let countRealNodes = 0;
+    for (let child of children) {
+      if ((child as VNode).sel) {
+        countRealNodes++;
+      }
+    }
+    if (countRealNodes !== 1) {
+      throw new Error(`Portal must have exactly one non-text child (has ${countRealNodes})`);
+    }
+  }
+  /**
+   * Ensure the target is still there at whichever time we render
+   */
+  __checkTargetPresence() {
+    if (!this.target || !document.contains(this.target)) {
+      throw new Error(`Could not find any match for "${this.props.target}"`);
+    }
+  }
+  /**
+   * Move the portal's element to the target
+   */
+  __deployPortal() {
+    this.__checkTargetPresence();
+    this.target!.appendChild(this.portal!.elm!);
+  }
+  /**
+   * Override to remove from the DOM the element we have teleported
+   *
+   * @override
+   */
+  __destroy(parent) {
+    if (this.portal && this.portal.elm) {
+      const displacedElm = this.portal.elm!;
+      const parent = displacedElm.parentNode;
+      if (parent) {
+        parent.removeChild(displacedElm);
+      }
+    }
+    super.__destroy(parent);
+  }
+  /**
+   * Override to patch the element that has been teleported
+   *
+   * @override
+   */
+  __patch(vnode) {
+    if (this.doTargetLookUp) {
+      const target = document.querySelector(this.props.target);
+      if (!target) {
+        this.env.qweb.on("dom-appended", this, () => {
+          this.doTargetLookUp = false;
+          this.env.qweb.off("dom-appended", this);
+          this.target = document.querySelector(this.props.target);
+          this.__deployPortal();
+        });
+      } else {
+        this.doTargetLookUp = false;
+        this.target = target;
+      }
+    }
+    this.__checkVNodeStructure(vnode);
+    const shouldDeploy =
+      (!this.portal || this.el!.contains(this.portal.elm!)) && !this.doTargetLookUp;
+
+    if (!this.doTargetLookUp && !shouldDeploy) {
+      // Only on pure patching, provided the
+      // this.target's parent has not been unmounted
+      this.__checkTargetPresence();
+    }
+
+    const portalPatch = this.portal ? this.portal : document.createElement(vnode.children[0].sel);
+    this.portal = patch(portalPatch, vnode.children![0] as VNode);
+    vnode.children = [];
+
+    super.__patch(vnode);
+
+    if (shouldDeploy) {
+      this.__deployPortal();
+    }
+  }
+  /**
+   * Override to set the env
+   */
+  __trigger(component: Component<any, any>, eventType: string, payload?: any) {
+    const env = this.env;
+    this.env = this.parentEnv;
+    super.__trigger(component, eventType, payload);
+    this.env = env;
+  }
+}

src/observer.ts

@@ -1,142 +0,0 @@
-//------------------------------------------------------------------------------
-// Observer
-//------------------------------------------------------------------------------
-
-const methodsToPatch = [
-  "push",
-  "pop",
-  "shift",
-  "unshift",
-  "splice",
-  "sort",
-  "reverse"
-];
-
-const ArrayProto = Array.prototype;
-const ModifiedArrayProto = Object.create(ArrayProto);
-
-for (let method of methodsToPatch) {
-  const initialMethod = ArrayProto[method];
-  ModifiedArrayProto[method] = function(...args) {
-    if (!this.__observer__.allowMutations) {
-      throw new Error(`Array cannot be changed here")`);
-    }
-    this.__observer__.notifyChange();
-    this.__owl__.rev++;
-    let parent = this;
-    do {
-      parent.__owl__.deepRev++;
-    } while ((parent = parent.__owl__.parent));
-    let inserted;
-    switch (method) {
-      case "push":
-      case "unshift":
-        inserted = args;
-        break;
-      case "splice":
-        inserted = args.slice(2);
-        break;
-    }
-    if (inserted) {
-      for (let elem of inserted) {
-        this.__observer__.observe(elem, this);
-      }
-    }
-    return initialMethod.call(this, ...args);
-  };
-}
-
-export class Observer {
-  rev: number = 1;
-  allowMutations: boolean = true;
-  dirty: boolean = false;
-
-  notifyCB() {}
-  notifyChange() {
-    this.rev++;
-    this.dirty = true;
-    Promise.resolve().then(() => {
-      if (this.dirty) {
-        this.dirty = false;
-        this.notifyCB();
-      }
-    });
-  }
-
-  observe(value: any, parent?: any) {
-    if (value === null) {
-      // fun fact: typeof null === 'object'
-      return;
-    }
-    if (typeof value !== "object") {
-      return;
-    }
-    if ("__owl__" in value) {
-      // already observed
-      value.__owl__.parent = parent;
-      return;
-    }
-    if (Array.isArray(value)) {
-      this._observeArr(value, parent);
-    } else {
-      this._observeObj(value, parent);
-    }
-  }
-
-  set(target: any, key: number | string, value: any) {
-    this._addProp(target, key, value);
-    target.__owl__.rev++;
-    this.notifyChange();
-  }
-
-  _observeObj<T extends { __owl__?: any }>(obj: T, parent?: any) {
-    const keys = Object.keys(obj);
-    obj.__owl__ = { rev: 1, deepRev: 1, parent };
-    Object.defineProperty(obj, "__owl__", { enumerable: false });
-    for (let key of keys) {
-      this._addProp(obj, key, obj[key]);
-    }
-  }
-
-  _observeArr(arr: Array<any>, parent?: any) {
-    (<any>arr).__owl__ = { rev: 1, deepRev: 1, parent };
-    Object.defineProperty(arr, "__owl__", { enumerable: false });
-    (<any>arr).__proto__ = Object.create(ModifiedArrayProto);
-    (<any>arr).__proto__.__observer__ = this;
-    for (let i = 0; i < arr.length; i++) {
-      this.observe(arr[i], arr);
-    }
-  }
-
-  _addProp<T extends { __owl__?: any }>(
-    obj: T,
-    key: string | number,
-    value: any
-  ) {
-    var self = this;
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      get() {
-        return value;
-      },
-      set(newVal) {
-        if (newVal !== value) {
-          if (!self.allowMutations) {
-            throw new Error(
-              `Observed state cannot be changed here! (key: "${key}", val: "${newVal}")`
-            );
-          }
-          value = newVal;
-          self.observe(newVal, obj);
-          obj.__owl__.rev!++;
-          let parent = obj;
-          do {
-            parent.__owl__.deepRev++;
-          } while ((parent = parent.__owl__.parent) && parent !== obj);
-          self.notifyChange();
-        }
-      }
-    });
-    this.observe(value, obj);
-  }
-}

src/qweb/base_directives.ts

@@ -0,0 +1,380 @@
+import { CompilationContext } from "./compilation_context";
+import { QWeb } from "./qweb";
+import { htmlToVDOM } from "../vdom/html_to_vdom";
+import { QWebVar } from "./expression_parser";
+
+/**
+ * Owl QWeb Directives
+ *
+ * This file contains the implementation of most standard QWeb directives:
+ * - t-esc
+ * - t-raw
+ * - t-set/t-value
+ * - t-if/t-elif/t-else
+ * - t-call
+ * - t-foreach/t-as
+ * - t-debug
+ * - t-log
+ */
+
+//------------------------------------------------------------------------------
+// t-esc and t-raw
+//------------------------------------------------------------------------------
+QWeb.utils.htmlToVDOM = htmlToVDOM;
+
+function compileValueNode(value: any, node: Element, qweb: QWeb, ctx: CompilationContext) {
+  ctx.rootContext.shouldDefineScope = true;
+  if (value === "0") {
+    if (ctx.parentNode) {
+      // the 'zero' magical symbol is where we can find the result of the rendering
+      // of  the body of the t-call.
+      ctx.rootContext.shouldDefineUtils = true;
+      const zeroArgs = ctx.escaping
+        ? `{text: utils.vDomToString(scope[utils.zero])}`
+        : `...scope[utils.zero]`;
+      ctx.addLine(`c${ctx.parentNode}.push(${zeroArgs});`);
+    }
+    return;
+  }
+
+  let exprID: string;
+  if (typeof value === "string") {
+    exprID = `_${ctx.generateID()}`;
+    ctx.addLine(`let ${exprID} = ${ctx.formatExpression(value)};`);
+  } else {
+    exprID = `scope.${value.id}`;
+  }
+  ctx.addIf(`${exprID} != null`);
+
+  if (ctx.escaping) {
+    let protectID;
+    if (value.hasBody) {
+      protectID = ctx.startProtectScope();
+      ctx.addLine(
+        `${exprID} = ${exprID} instanceof utils.VDomArray ? utils.vDomToString(${exprID}) : ${exprID};`
+      );
+    }
+    if (ctx.parentTextNode) {
+      ctx.addLine(`vn${ctx.parentTextNode}.text += ${exprID};`);
+    } else if (ctx.parentNode) {
+      ctx.addLine(`c${ctx.parentNode}.push({text: ${exprID}});`);
+    } else {
+      let nodeID = ctx.generateID();
+      ctx.rootContext.rootNode = nodeID;
+      ctx.rootContext.parentTextNode = nodeID;
+      ctx.addLine(`let vn${nodeID} = {text: ${exprID}};`);
+      if (ctx.rootContext.shouldDefineResult) {
+        ctx.addLine(`result = vn${nodeID}`);
+      }
+    }
+    if (value.hasBody) {
+      ctx.stopProtectScope(protectID);
+    }
+  } else {
+    ctx.rootContext.shouldDefineUtils = true;
+    if (value.hasBody) {
+      ctx.addLine(
+        `const vnodeArray = ${exprID} instanceof utils.VDomArray ? ${exprID} : utils.htmlToVDOM(${exprID});`
+      );
+      ctx.addLine(`c${ctx.parentNode}.push(...vnodeArray);`);
+    } else {
+      ctx.addLine(`c${ctx.parentNode}.push(...utils.htmlToVDOM(${exprID}));`);
+    }
+  }
+  if (node.childNodes.length) {
+    ctx.addElse();
+    qweb._compileChildren(node, ctx);
+  }
+
+  ctx.closeIf();
+}
+
+QWeb.addDirective({
+  name: "esc",
+  priority: 70,
+  atNodeEncounter({ node, qweb, ctx }): boolean {
+    let value = ctx.getValue(node.getAttribute("t-esc")!);
+    compileValueNode(value, node, qweb, ctx.subContext("escaping", true));
+    return true;
+  }
+});
+
+QWeb.addDirective({
+  name: "raw",
+  priority: 80,
+  atNodeEncounter({ node, qweb, ctx }): boolean {
+    let value = ctx.getValue(node.getAttribute("t-raw")!);
+    compileValueNode(value, node, qweb, ctx);
+    return true;
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-set
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "set",
+  extraNames: ["value"],
+  priority: 60,
+  atNodeEncounter({ node, qweb, ctx }): boolean {
+    ctx.rootContext.shouldDefineScope = true;
+    const variable = node.getAttribute("t-set")!;
+    let value = node.getAttribute("t-value")!;
+    ctx.variables[variable] = ctx.variables[variable] || ({} as QWebVar);
+    let qwebvar = ctx.variables[variable];
+    const hasBody = node.hasChildNodes();
+
+    qwebvar.id = variable;
+    qwebvar.expr = `scope.${variable}`;
+    if (value) {
+      const formattedValue = ctx.formatExpression(value);
+      let scopeExpr = `scope`;
+      if (ctx.protectedScopeNumber) {
+        ctx.rootContext.shouldDefineUtils = true;
+        scopeExpr = `utils.getScope(scope, '${variable}')`;
+      }
+      ctx.addLine(`${scopeExpr}.${variable} = ${formattedValue};`);
+      qwebvar.value = formattedValue;
+    }
+
+    if (hasBody) {
+      ctx.rootContext.shouldDefineUtils = true;
+      if (value) {
+        ctx.addIf(`!(${qwebvar.expr})`);
+      }
+      const tempParentNodeID = ctx.generateID();
+      const _parentNode = ctx.parentNode;
+      ctx.parentNode = tempParentNodeID;
+
+      ctx.addLine(`let c${tempParentNodeID} = new utils.VDomArray();`);
+      const nodeCopy = node.cloneNode(true) as Element;
+      for (let attr of ["t-set", "t-value", "t-if", "t-else", "t-elif"]) {
+        nodeCopy.removeAttribute(attr);
+      }
+      qweb._compileNode(nodeCopy, ctx);
+
+      ctx.addLine(`${qwebvar.expr} = c${tempParentNodeID}`);
+      qwebvar.value = `c${tempParentNodeID}`;
+      qwebvar.hasBody = true;
+
+      ctx.parentNode = _parentNode;
+      if (value) {
+        ctx.closeIf();
+      }
+    }
+    return true;
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-if, t-elif, t-else
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "if",
+  priority: 20,
+  atNodeEncounter({ node, ctx }): boolean {
+    let cond = ctx.getValue(node.getAttribute("t-if")!);
+    ctx.addIf(typeof cond === "string" ? ctx.formatExpression(cond) : `scope.${cond.id!}`);
+    return false;
+  },
+  finalize({ ctx }) {
+    ctx.closeIf();
+  }
+});
+
+QWeb.addDirective({
+  name: "elif",
+  priority: 30,
+  atNodeEncounter({ node, ctx }): boolean {
+    let cond = ctx.getValue(node.getAttribute("t-elif")!);
+    ctx.addLine(
+      `else if (${typeof cond === "string" ? ctx.formatExpression(cond) : `scope.${cond.id}`}) {`
+    );
+    ctx.indent();
+    return false;
+  },
+  finalize({ ctx }) {
+    ctx.closeIf();
+  }
+});
+
+QWeb.addDirective({
+  name: "else",
+  priority: 40,
+  atNodeEncounter({ ctx }): boolean {
+    ctx.addLine(`else {`);
+    ctx.indent();
+    return false;
+  },
+  finalize({ ctx }) {
+    ctx.closeIf();
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-call
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "call",
+  priority: 50,
+  atNodeEncounter({ node, qweb, ctx }): boolean {
+    // Step 1: sanity checks
+    // ------------------------------------------------
+    ctx.rootContext.shouldDefineScope = true;
+    ctx.rootContext.shouldDefineUtils = true;
+    if (node.nodeName !== "t") {
+      throw new Error("Invalid tag for t-call directive (should be 't')");
+    }
+    const subTemplate = node.getAttribute("t-call")!;
+    const nodeTemplate = qweb.templates[subTemplate];
+    if (!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;
+    }
+
+    // Step 3: compile t-call body if necessary
+    // ------------------------------------------------
+    let hasBody = node.hasChildNodes();
+    let protectID;
+    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);
+      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 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});`);
+    } 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(`result = result[0]`);
+    }
+
+    // Step 5: restore previous scope
+    // ------------------------------------------------
+    if (hasBody) {
+      ctx.stopProtectScope(protectID);
+      ctx.dedent();
+      ctx.addLine(`}`);
+    }
+
+    return true;
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-foreach
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "foreach",
+  extraNames: ["as"],
+  priority: 10,
+  atNodeEncounter({ node, qweb, ctx }): boolean {
+    ctx.rootContext.shouldDefineScope = true;
+    ctx = ctx.subContext("loopNumber", ctx.loopNumber + 1);
+    const elems = node.getAttribute("t-foreach")!;
+    const name = node.getAttribute("t-as")!;
+    let arrayID = ctx.generateID();
+    ctx.addLine(`let _${arrayID} = ${ctx.formatExpression(elems)};`);
+    ctx.addLine(`if (!_${arrayID}) { throw new Error('QWeb error: Invalid loop expression')}`);
+    let keysID = ctx.generateID();
+    let valuesID = ctx.generateID();
+    ctx.addLine(`let _${keysID} = _${valuesID} = _${arrayID};`);
+    ctx.addIf(`!(_${arrayID} instanceof Array)`);
+    ctx.addLine(`_${keysID} = Object.keys(_${arrayID});`);
+    ctx.addLine(`_${valuesID} = Object.values(_${arrayID});`);
+    ctx.closeIf();
+    ctx.addLine(`let _length${keysID} = _${keysID}.length;`);
+    let varsID = ctx.startProtectScope(true);
+    const loopVar = `i${ctx.loopNumber}`;
+    ctx.addLine(`for (let ${loopVar} = 0; ${loopVar} < _length${keysID}; ${loopVar}++) {`);
+    ctx.indent();
+
+    ctx.addLine(`scope.${name}_first = ${loopVar} === 0`);
+    ctx.addLine(`scope.${name}_last = ${loopVar} === _length${keysID} - 1`);
+    ctx.addLine(`scope.${name}_index = ${loopVar}`);
+    ctx.addLine(`scope.${name} = _${keysID}[${loopVar}]`);
+    ctx.addLine(`scope.${name}_value = _${valuesID}[${loopVar}]`);
+    const nodeCopy = <Element>node.cloneNode(true);
+    let shouldWarn =
+      !nodeCopy.hasAttribute("t-key") &&
+      node.children.length === 1 &&
+      node.children[0].tagName !== "t" &&
+      !node.children[0].hasAttribute("t-key");
+    if (shouldWarn) {
+      console.warn(
+        `Directive t-foreach should always be used with a t-key! (in template: '${ctx.templateName}')`
+      );
+    }
+    if (nodeCopy.hasAttribute("t-key")) {
+      const expr = ctx.formatExpression(nodeCopy.getAttribute("t-key")!);
+      ctx.addLine(`let key${ctx.loopNumber} = ${expr};`);
+      nodeCopy.removeAttribute("t-key");
+    } else {
+      ctx.addLine(`let key${ctx.loopNumber} = i${ctx.loopNumber};`);
+    }
+
+    nodeCopy.removeAttribute("t-foreach");
+    qweb._compileNode(nodeCopy, ctx);
+    ctx.dedent();
+    ctx.addLine("}");
+    ctx.stopProtectScope(varsID);
+    return true;
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-debug
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "debug",
+  priority: 1,
+  atNodeEncounter({ ctx }) {
+    ctx.addLine("debugger;");
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-log
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "log",
+  priority: 1,
+  atNodeEncounter({ ctx, value }) {
+    const expr = ctx.formatExpression(value);
+    ctx.addLine(`console.log(${expr})`);
+  }
+});

src/qweb/compilation_context.ts

@@ -0,0 +1,210 @@
+import { compileExpr, compileExprToArray, QWebVar } from "./expression_parser";
+
+export const INTERP_REGEXP = /\{\{.*?\}\}/g;
+//------------------------------------------------------------------------------
+// Compilation Context
+//------------------------------------------------------------------------------
+
+export class CompilationContext {
+  static nextID: number = 1;
+  code: string[] = [];
+  variables: { [key: string]: QWebVar } = {};
+  escaping: boolean = false;
+  parentNode: number | null | string = null;
+  parentTextNode: number | null = null;
+  rootNode: number | null = null;
+  indentLevel: number = 0;
+  rootContext: CompilationContext;
+  shouldDefineParent: boolean = false;
+  shouldDefineScope: boolean = false;
+  protectedScopeNumber: number = 0;
+  shouldDefineQWeb: boolean = false;
+  shouldDefineUtils: boolean = false;
+  shouldDefineRefs: boolean = false;
+  shouldDefineResult: boolean = true;
+  loopNumber: number = 0;
+  inPreTag: boolean = false;
+  templateName: string;
+  allowMultipleRoots: boolean = false;
+  hasParentWidget: boolean = false;
+  hasKey0: boolean = false;
+  keyStack: boolean[] = [];
+
+  constructor(name?: string) {
+    this.rootContext = this;
+    this.templateName = name || "noname";
+    this.addLine("let h = this.h;");
+  }
+
+  generateID(): number {
+    return CompilationContext.nextID++;
+  }
+
+  /**
+   * This method generates a "template key", which is basically a unique key
+   * which depends on the currently set keys, and on the iteration numbers (if
+   * we are in a loop).
+   *
+   * Such a key is necessary when we need to associate an id to some element
+   * generated by a template (for example, a component)
+   */
+  generateTemplateKey(prefix: string = ""): string {
+    const id = this.generateID();
+    if (this.loopNumber === 0 && !this.hasKey0) {
+      return `'${prefix}__${id}__'`;
+    }
+    let key = `\`${prefix}__${id}__`;
+    let start = this.hasKey0 ? 0 : 1;
+    for (let i = start; i < this.loopNumber + 1; i++) {
+      key += `\${key${i}}__`;
+    }
+    this.addLine(`let k${id} = ${key}\`;`);
+    return `k${id}`;
+  }
+
+  generateCode(): string[] {
+    if (this.shouldDefineResult) {
+      this.code.unshift("    let result;");
+    }
+
+    if (this.shouldDefineScope) {
+      this.code.unshift("    let scope = Object.create(context);");
+    }
+    if (this.shouldDefineRefs) {
+      this.code.unshift("    context.__owl__.refs = context.__owl__.refs || {};");
+    }
+    if (this.shouldDefineParent) {
+      if (this.hasParentWidget) {
+        this.code.unshift("    let parent = extra.parent;");
+      } else {
+        this.code.unshift("    let parent = context;");
+      }
+    }
+    if (this.shouldDefineQWeb) {
+      this.code.unshift("    let QWeb = this.constructor;");
+    }
+    if (this.shouldDefineUtils) {
+      this.code.unshift("    let utils = this.constructor.utils;");
+    }
+    return this.code;
+  }
+
+  withParent(node: number): CompilationContext {
+    if (
+      !this.allowMultipleRoots &&
+      this === this.rootContext &&
+      (this.parentNode || this.parentTextNode)
+    ) {
+      throw new Error("A template should not have more than one root node");
+    }
+    if (!this.rootContext.rootNode) {
+      this.rootContext.rootNode = node;
+    }
+    if (!this.parentNode && this.rootContext.shouldDefineResult) {
+      this.addLine(`result = vn${node};`);
+    }
+    return this.subContext("parentNode", node);
+  }
+
+  subContext(key: keyof CompilationContext, value: any): CompilationContext {
+    const newContext = Object.create(this);
+    newContext[key] = value;
+    return newContext;
+  }
+
+  indent() {
+    this.rootContext.indentLevel++;
+  }
+
+  dedent() {
+    this.rootContext.indentLevel--;
+  }
+
+  addLine(line: string): number {
+    const prefix = new Array(this.indentLevel + 2).join("    ");
+    this.code.push(prefix + line);
+    return this.code.length - 1;
+  }
+
+  addIf(condition: string) {
+    this.addLine(`if (${condition}) {`);
+    this.indent();
+  }
+
+  addElse() {
+    this.dedent();
+    this.addLine("} else {");
+    this.indent();
+  }
+
+  closeIf() {
+    this.dedent();
+    this.addLine("}");
+  }
+
+  getValue(val: any): QWebVar | string {
+    return val in this.variables ? this.getValue(this.variables[val]) : val;
+  }
+
+  /**
+   * Prepare an expression for being consumed at render time.  Its main job
+   * is to
+   * - replace unknown variables by a lookup in the context
+   * - replace already defined variables by their internal name
+   */
+  formatExpression(expr: string): string {
+    this.rootContext.shouldDefineScope = true;
+    return compileExpr(expr, this.variables);
+  }
+  captureExpression(expr: string): string {
+    this.rootContext.shouldDefineScope = true;
+    const argId = this.generateID();
+    const tokens = compileExprToArray(expr, this.variables);
+    const done = new Set();
+    return tokens
+      .map(tok => {
+        if (tok.varName) {
+          if (!done.has(tok.varName)) {
+            done.add(tok.varName);
+            this.addLine(`const ${tok.varName}_${argId} = ${tok.value};`);
+          }
+          tok.value = `${tok.varName}_${argId}`;
+        }
+        return tok.value;
+      })
+      .join("");
+  }
+
+  /**
+   * Perform string interpolation on the given string. Note that if the whole
+   * string is an expression, it simply returns it (formatted and enclosed in
+   * parentheses).
+   * For instance:
+   *   'Hello {{x}}!' -> `Hello ${x}`
+   *   '{{x ? 'a': 'b'}}' -> (x ? 'a' : 'b')
+   */
+  interpolate(s: string): string {
+    let matches = s.match(INTERP_REGEXP);
+    if (matches && matches[0].length === s.length) {
+      return `(${this.formatExpression(s.slice(2, -2))})`;
+    }
+
+    let r = s.replace(/\{\{.*?\}\}/g, s => "${" + this.formatExpression(s.slice(2, -2)) + "}");
+    return "`" + r + "`";
+  }
+  startProtectScope(codeBlock?: boolean): number {
+    const protectID = this.generateID();
+    this.rootContext.protectedScopeNumber++;
+    this.rootContext.shouldDefineScope = true;
+    const scopeExpr = codeBlock
+      ? `Object.create(scope);`
+      : `Object.assign(Object.create(context), scope);`;
+    this.addLine(`let _origScope${protectID} = scope;`);
+    this.addLine(`scope = ${scopeExpr}`);
+    return protectID;
+  }
+  stopProtectScope(protectID: number) {
+    this.rootContext.protectedScopeNumber--;
+    this.addLine(`scope = _origScope${protectID};`);
+  }
+}

src/qweb/expression_parser.ts

@@ -0,0 +1,289 @@
+/**
+ * Owl QWeb Expression Parser
+ *
+ * Owl needs in various contexts to be able to understand the structure of a
+ * string representing a javascript expression.  The usual goal is to be able
+ * to rewrite some variables.  For example, if a template has
+ *
+ *  ```xml
+ *  <t t-if="computeSomething({val: state.val})">...</t>
+ * ```
+ *
+ * this needs to be translated in something like this:
+ *
+ * ```js
+ *   if (context["computeSomething"]({val: context["state"].val})) { ... }
+ * ```
+ *
+ * This file contains the implementation of an extremely naive tokenizer/parser
+ * and evaluator for javascript expressions.  The supported grammar is basically
+ * only expressive enough to understand the shape of objects, of arrays, and
+ * various operators.
+ */
+
+//------------------------------------------------------------------------------
+// Misc types, constants and helpers
+//------------------------------------------------------------------------------
+
+const RESERVED_WORDS = "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,this,eval,void,Math,RegExp,Array,Object,Date".split(
+  ","
+);
+
+const WORD_REPLACEMENT = {
+  and: "&&",
+  or: "||",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+
+export interface QWebVar {
+  id: string; // foo
+  expr: string; // scope.foo (local variables => only foo)
+  value?: string; // 1 + 3
+  hasBody?: boolean;
+}
+
+//------------------------------------------------------------------------------
+// Tokenizer
+//------------------------------------------------------------------------------
+type TKind =
+  | "LEFT_BRACE"
+  | "RIGHT_BRACE"
+  | "LEFT_BRACKET"
+  | "RIGHT_BRACKET"
+  | "LEFT_PAREN"
+  | "RIGHT_PAREN"
+  | "COMMA"
+  | "VALUE"
+  | "SYMBOL"
+  | "OPERATOR"
+  | "COLON";
+
+interface Token {
+  type: TKind;
+  value: string;
+  originalValue?: string;
+  size?: number;
+  varName?: string;
+}
+
+const STATIC_TOKEN_MAP: { [key: string]: TKind } = {
+  "{": "LEFT_BRACE",
+  "}": "RIGHT_BRACE",
+  "[": "LEFT_BRACKET",
+  "]": "RIGHT_BRACKET",
+  ":": "COLON",
+  ",": "COMMA",
+  "(": "LEFT_PAREN",
+  ")": "RIGHT_PAREN"
+};
+
+// note that the space after typeof is relevant. It makes sure that the formatted
+// expression has a space after typeof
+const OPERATORS = "...,.,===,==,+,!==,!=,!,||,&&,>=,>,<=,<,?,-,*,/,%,typeof ,=>,=,;,in ".split(",");
+
+type Tokenizer = (expr: string) => Token | false;
+
+let tokenizeString: Tokenizer = function(expr) {
+  let s = expr[0];
+  let start = s;
+  if (s !== "'" && s !== '"') {
+    return false;
+  }
+  let i = 1;
+  let cur;
+  while (expr[i] && expr[i] !== start) {
+    cur = expr[i];
+    s += cur;
+    if (cur === "\\") {
+      i++;
+      cur = expr[i];
+      if (!cur) {
+        throw new Error("Invalid expression");
+      }
+      s += cur;
+    }
+    i++;
+  }
+  if (expr[i] !== start) {
+    throw new Error("Invalid expression");
+  }
+  s += start;
+  return { type: "VALUE", value: s };
+};
+
+let tokenizeNumber: Tokenizer = function(expr) {
+  let s = expr[0];
+  if (s && s.match(/[0-9]/)) {
+    let i = 1;
+    while (expr[i] && expr[i].match(/[0-9]|\./)) {
+      s += expr[i];
+      i++;
+    }
+    return { type: "VALUE", value: s };
+  } else {
+    return false;
+  }
+};
+
+let tokenizeSymbol: Tokenizer = function(expr) {
+  let s = expr[0];
+  if (s && s.match(/[a-zA-Z_\$]/)) {
+    let i = 1;
+    while (expr[i] && expr[i].match(/\w/)) {
+      s += expr[i];
+      i++;
+    }
+    if (s in WORD_REPLACEMENT) {
+      return { type: "OPERATOR", value: WORD_REPLACEMENT[s], size: s.length };
+    }
+    return { type: "SYMBOL", value: s };
+  } else {
+    return false;
+  }
+};
+
+const tokenizeStatic: Tokenizer = function(expr) {
+  const char = expr[0];
+  if (char && char in STATIC_TOKEN_MAP) {
+    return { type: STATIC_TOKEN_MAP[char], value: char };
+  }
+  return false;
+};
+
+const tokenizeOperator: Tokenizer = function(expr) {
+  for (let op of OPERATORS) {
+    if (expr.startsWith(op)) {
+      return { type: "OPERATOR", value: op };
+    }
+  }
+  return false;
+};
+
+const TOKENIZERS = [
+  tokenizeString,
+  tokenizeNumber,
+  tokenizeOperator,
+  tokenizeSymbol,
+  tokenizeStatic
+];
+
+/**
+ * Convert a javascript expression (as a string) into a list of tokens. For
+ * example: `tokenize("1 + b")` will return:
+ * ```js
+ *  [
+ *   {type: "VALUE", value: "1"},
+ *   {type: "OPERATOR", value: "+"},
+ *   {type: "SYMBOL", value: "b"}
+ * ]
+ * ```
+ */
+export function tokenize(expr: string): Token[] {
+  const result: Token[] = [];
+  let token: boolean | Token = true;
+
+  while (token) {
+    expr = expr.trim();
+    if (expr) {
+      for (let tokenizer of TOKENIZERS) {
+        token = tokenizer(expr);
+        if (token) {
+          result.push(token);
+          expr = expr.slice(token.size || token.value.length);
+          break;
+        }
+      }
+    } else {
+      token = false;
+    }
+  }
+  if (expr.length) {
+    throw new Error(`Tokenizer error: could not tokenize "${expr}"`);
+  }
+  return result;
+}
+
+//------------------------------------------------------------------------------
+// Expression "evaluator"
+//------------------------------------------------------------------------------
+
+/**
+ * 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
+ * proper lookups in the context.
+ *
+ * Usually, this kind of code would be very simple to do if we had an AST (so,
+ * if we had a javascript parser), since then, we would only need to find the
+ * variables and replace them.  However, a parser is more complicated, and there
+ * are no standard builtin parser API.
+ *
+ * Since this method is applied to simple javasript expressions, and the work to
+ * be done is actually quite simple, we actually can get away with not using a
+ * parser, which helps with the code size.
+ *
+ * Here is the heuristic used by this method to determine if a token is a
+ * variable:
+ * - by default, all symbols are considered a variable
+ * - unless the previous token is a dot (in that case, this is a property: `a.b`)
+ * - or if the previous token is a left brace or a comma, and the next token is
+ *   a colon (in that case, this is an object key: `{a: b}`)
+ *
+ * Some specific code is also required to support arrow functions. If we detect
+ * the arrow operator, then we add the current (or some previous tokens) token to
+ * the list of variables so it does not get replaced by a lookup in the context
+ */
+export function 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 token = tokens[i];
+    let prevToken = tokens[i - 1];
+    let nextToken = tokens[i + 1];
+    let isVar = token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value);
+    if (token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value)) {
+      if (prevToken) {
+        if (prevToken.type === "OPERATOR" && prevToken.value === ".") {
+          isVar = false;
+        } else if (prevToken.type === "LEFT_BRACE" || prevToken.type === "COMMA") {
+          if (nextToken && nextToken.type === "COLON") {
+            isVar = false;
+          }
+        }
+      }
+    }
+    if (nextToken && nextToken.type === "OPERATOR" && nextToken.value === "=>") {
+      if (token.type === "RIGHT_PAREN") {
+        let j = i - 1;
+        while (j > 0 && tokens[j].type !== "LEFT_PAREN") {
+          if (tokens[j].type === "SYMBOL" && tokens[j].originalValue) {
+            tokens[j].value = tokens[j].originalValue!;
+            scope[tokens[j].value] = { id: tokens[j].value, expr: tokens[j].value };
+          }
+          j--;
+        }
+      } else {
+        scope[token.value] = { id: token.value, expr: token.value };
+      }
+    }
+
+    if (isVar) {
+      token.varName = token.value;
+      if (token.value in scope && "id" in scope[token.value]) {
+        token.value = scope[token.value].expr!;
+      } else {
+        token.originalValue = token.value;
+        token.value = `scope['${token.value}']`;
+      }
+    }
+  }
+  return tokens;
+}
+
+export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): string {
+  return compileExprToArray(expr, scope)
+    .map(t => t.value)
+    .join("");
+}

src/qweb/extensions.ts

@@ -0,0 +1,323 @@
+import { VNode } from "../vdom/index";
+import { QWeb } from "./qweb";
+
+/**
+ * Owl QWeb Extensions
+ *
+ * This file contains the implementation of non standard QWeb directives, added
+ * by Owl and that will only work on Owl projects:
+ *
+ * - t-on
+ * - t-ref
+ * - t-transition
+ * - t-mounted
+ * - t-slot
+ * - t-model
+ */
+
+//------------------------------------------------------------------------------
+// t-on
+//------------------------------------------------------------------------------
+// these are pieces of code that will be injected into the event handler if
+// modifiers are specified
+export const MODS_CODE = {
+  prevent: "e.preventDefault();",
+  self: "if (e.target !== this.elm) {return}",
+  stop: "e.stopPropagation();"
+};
+
+interface HandlerInfo {
+  event: string;
+  handler: string;
+}
+
+const FNAMEREGEXP = /^[$A-Z_][0-9A-Z_$]*$/i;
+
+export function makeHandlerCode(
+  ctx,
+  fullName,
+  value,
+  putInCache: boolean,
+  modcodes = MODS_CODE
+): HandlerInfo {
+  const [event, ...mods] = fullName.slice(5).split(".");
+  if (!event) {
+    throw new Error("Missing event name with t-on directive");
+  }
+  let code: string;
+  // check if it is a method with no args, a method with args or an expression
+  let args: string = "";
+  const name: string = value.replace(/\(.*\)/, function(_args) {
+    args = _args.slice(1, -1);
+    return "";
+  });
+  const isMethodCall = name.match(FNAMEREGEXP);
+
+  // then generate code
+  if (isMethodCall) {
+    ctx.rootContext.shouldDefineUtils = true;
+    const comp = `utils.getComponent(context)`;
+    if (args) {
+      const argId = ctx.generateID();
+      ctx.addLine(`let args${argId} = [${ctx.formatExpression(args)}];`);
+      code = `${comp}['${name}'](...args${argId}, e);`;
+      putInCache = false;
+    } else {
+      code = `${comp}['${name}'](e);`;
+    }
+  } else {
+    // if we get here, then it is an expression
+    // we need to capture every variable in it
+    putInCache = false;
+    code = ctx.captureExpression(value);
+  }
+  const modCode = mods.map(mod => modcodes[mod]).join("");
+  let handler = `function (e) {if (!context.__owl__.isMounted){return}${modCode}${code}}`;
+  if (putInCache) {
+    const key = ctx.generateTemplateKey(event);
+    ctx.addLine(`extra.handlers[${key}] = extra.handlers[${key}] || ${handler};`);
+    handler = `extra.handlers[${key}]`;
+  }
+  return { event, handler };
+}
+
+QWeb.addDirective({
+  name: "on",
+  priority: 90,
+  atNodeCreation({ ctx, fullName, value, nodeID }) {
+    const { event, handler } = makeHandlerCode(ctx, fullName, value, true);
+    ctx.addLine(`p${nodeID}.on['${event}'] = ${handler};`);
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-ref
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "ref",
+  priority: 95,
+  atNodeCreation({ ctx, value, addNodeHook }) {
+    ctx.rootContext.shouldDefineRefs = true;
+    const refKey = `ref${ctx.generateID()}`;
+    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) {
+  requestAnimationFrame(() => requestAnimationFrame(cb));
+};
+
+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
+  const dup = elm.parentElement && elm.parentElement!.querySelector(`*[data-owl-key='${vn.key}']`);
+  if (dup) {
+    dup.remove();
+  }
+
+  elm.classList.add(name + "-enter");
+  elm.classList.add(name + "-enter-active");
+  elm.classList.remove(name + "-leave-active");
+  elm.classList.remove(name + "-leave-to");
+  const finalize = () => {
+    elm.classList.remove(name + "-enter-active");
+    elm.classList.remove(name + "-enter-to");
+  };
+  this.nextFrame(() => {
+    elm.classList.remove(name + "-enter");
+    elm.classList.add(name + "-enter-to");
+    whenTransitionEnd(elm, finalize);
+  });
+};
+
+QWeb.utils.transitionRemove = function(vn: VNode, name: string, rm: () => void) {
+  const elm = <HTMLElement>vn.elm;
+  elm.setAttribute("data-owl-key", vn.key!);
+
+  elm.classList.add(name + "-leave");
+  elm.classList.add(name + "-leave-active");
+  const finalize = () => {
+    if (!elm.classList.contains(name + "-leave-active")) {
+      return;
+    }
+    elm.classList.remove(name + "-leave-active");
+    elm.classList.remove(name + "-leave-to");
+    rm();
+  };
+  this.nextFrame(() => {
+    elm.classList.remove(name + "-leave");
+    elm.classList.add(name + "-leave-to");
+    whenTransitionEnd(elm, finalize);
+  });
+};
+
+function getTimeout(delays: Array<string>, durations: Array<string>): number {
+  /* istanbul ignore next */
+  while (delays.length < durations.length) {
+    delays = delays.concat(delays);
+  }
+
+  return Math.max.apply(
+    null,
+    durations.map((d, i) => {
+      return toMs(d) + toMs(delays[i]);
+    })
+  );
+}
+
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s: string): number {
+  return Number(s.slice(0, -1).replace(",", ".")) * 1000;
+}
+
+function whenTransitionEnd(elm: HTMLElement, cb) {
+  const styles = window.getComputedStyle(elm);
+  const delays: Array<string> = (styles.transitionDelay || "").split(", ");
+  const durations: Array<string> = (styles.transitionDuration || "").split(", ");
+  const timeout: number = getTimeout(delays, durations);
+  if (timeout > 0) {
+    elm.addEventListener("transitionend", cb, { once: true });
+  } else {
+    cb();
+  }
+}
+
+QWeb.addDirective({
+  name: "transition",
+  priority: 96,
+  atNodeCreation({ ctx, value, addNodeHook }) {
+    ctx.rootContext.shouldDefineUtils = true;
+    let name = value;
+    const hooks = {
+      insert: `utils.transitionInsert(vn, '${name}');`,
+      remove: `utils.transitionRemove(vn, '${name}', rm);`
+    };
+    for (let hookName in hooks) {
+      addNodeHook(hookName, hooks[hookName]);
+    }
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-slot
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "slot",
+  priority: 80,
+  atNodeEncounter({ ctx, value, node, qweb }): boolean {
+    const slotKey = ctx.generateID();
+    ctx.addLine(
+      `const slot${slotKey} = this.constructor.slots[context.__owl__.slotId + '_' + '${value}'];`
+    );
+    ctx.addIf(`slot${slotKey}`);
+    let parentNode = `c${ctx.parentNode}`;
+    if (!ctx.parentNode) {
+      ctx.rootContext.shouldDefineResult = true;
+      ctx.rootContext.shouldDefineUtils = true;
+      parentNode = `children${ctx.generateID()}`;
+      ctx.addLine(`let ${parentNode}= []`);
+      ctx.addLine(`result = {}`);
+    }
+    ctx.addLine(
+      `slot${slotKey}.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: ${parentNode}, parent: extra.parent || context}));`
+    );
+    if (!ctx.parentNode) {
+      ctx.addLine(`utils.defineProxy(result, ${parentNode}[0]);`);
+    }
+    if (node.hasChildNodes()) {
+      ctx.addElse();
+      const nodeCopy = <Element>node.cloneNode(true);
+      nodeCopy.removeAttribute("t-slot");
+      qweb._compileNode(nodeCopy, ctx);
+    }
+    ctx.closeIf();
+    return true;
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-model
+//------------------------------------------------------------------------------
+QWeb.utils.toNumber = function(val: string): number | string {
+  const n = parseFloat(val);
+  return isNaN(n) ? val : n;
+};
+
+QWeb.addDirective({
+  name: "model",
+  priority: 42,
+  atNodeCreation({ ctx, nodeID, value, node, fullName, addNodeHook }) {
+    const type = node.getAttribute("type");
+    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};`);
+
+    expr = `expr${nodeID}.${expr.slice(index + 1)}`;
+    const key = ctx.generateTemplateKey();
+    if (node.tagName === "select") {
+      ctx.addLine(`p${nodeID}.props = {value: ${expr}};`);
+      addNodeHook("create", `n.elm.value=${expr};`);
+      event = "change";
+      handler = `(ev) => {${expr} = ev.target.value}`;
+    } else if (type === "checkbox") {
+      ctx.addLine(`p${nodeID}.props = {checked: ${expr}};`);
+      handler = `(ev) => {${expr} = ev.target.checked}`;
+    } else if (type === "radio") {
+      const nodeValue = node.getAttribute("value")!;
+      ctx.addLine(`p${nodeID}.props = {checked:${expr} === '${nodeValue}'};`);
+      handler = `(ev) => {${expr} = ev.target.value}`;
+      event = "click";
+    } else {
+      ctx.addLine(`p${nodeID}.props = {value: ${expr}};`);
+      const trimCode = fullName.includes(".trim") ? ".trim()" : "";
+      let valueCode = `ev.target.value${trimCode}`;
+      if (fullName.includes(".number")) {
+        ctx.rootContext.shouldDefineUtils = true;
+        valueCode = `utils.toNumber(${valueCode})`;
+      }
+      handler = `(ev) => {${expr} = ${valueCode}}`;
+    }
+    ctx.addLine(`extra.handlers[${key}] = extra.handlers[${key}] || (${handler});`);
+    ctx.addLine(`p${nodeID}.on['${event}'] = extra.handlers[${key}];`);
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-key
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "key",
+  priority: 45,
+  atNodeEncounter({ ctx, value, node }) {
+    if (ctx.loopNumber === 0) {
+      ctx.keyStack.push(ctx.rootContext.hasKey0);
+      ctx.rootContext.hasKey0 = true;
+    }
+    ctx.addLine("{");
+    ctx.indent();
+    ctx.addLine(`let key${ctx.loopNumber} = ${ctx.formatExpression(value)};`);
+  },
+  finalize({ ctx }) {
+    ctx.dedent();
+    ctx.addLine("}");
+    if (ctx.loopNumber === 0) {
+      ctx.rootContext.hasKey0 = ctx.keyStack.pop() as boolean;
+    }
+  }
+});

src/qweb/index.ts

@@ -0,0 +1,4 @@
+import "./base_directives";
+import "./extensions";
+
+export { CompiledTemplate, QWeb } from "./qweb";

src/qweb/qweb.ts

@@ -0,0 +1,819 @@
+import { EventBus } from "../core/event_bus";
+import { h, patch, VNode } from "../vdom/index";
+import { CompilationContext } from "./compilation_context";
+import { shallowEqual, escape } from "../utils";
+import { addNS } from "../vdom/vdom";
+
+/**
+ * Owl QWeb Engine
+ *
+ * In this file, you will find a QWeb engine/template compiler.  It is the core
+ * of how Owl component works.
+ *
+ * Briefly, Owl QWeb compiles XML templates into functions that output a virtual
+ * DOM representation.
+ *
+ * We have here:
+ * - a CompilationContext class, which is an internal object that contains all
+ *   compilation specific information, while a template is being compiled.
+ * - a QWeb class: this is the code of the QWeb compiler.
+ *
+ * Note that this file does not contain the implementation of the QWeb
+ * directives (see qweb_directives.ts and qweb_extensions.ts).
+ */
+
+//------------------------------------------------------------------------------
+// Types
+//------------------------------------------------------------------------------
+export type EvalContext = { [key: string]: any };
+export type CompiledTemplate = (context: EvalContext, extra: any) => VNode;
+
+interface Template {
+  elem: Element;
+  fn: CompiledTemplate;
+}
+
+interface CompilationInfo {
+  node: Element;
+  qweb: QWeb;
+  ctx: CompilationContext;
+  fullName: string;
+  value: string;
+}
+
+interface NodeCreationCompilationInfo extends CompilationInfo {
+  nodeID: number;
+  addNodeHook: Function;
+}
+
+export interface Directive {
+  name: string;
+  extraNames?: string[];
+  priority: number;
+  // if return true, then directive is fully applied and there is no need to
+  // keep processing node. Otherwise, we keep going.
+  atNodeEncounter?(info: CompilationInfo): boolean | void;
+  atNodeCreation?(info: NodeCreationCompilationInfo): void;
+  finalize?(info: CompilationInfo): void;
+}
+
+interface QWebConfig {
+  templates?: string;
+  translateFn?(text: string): string;
+}
+
+//------------------------------------------------------------------------------
+// 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 NODE_HOOKS_PARAMS = {
+  create: "(_, n)",
+  insert: "vn",
+  remove: "(vn, rm)",
+  destroy: "()"
+};
+
+interface Utils {
+  toObj(expr: any): Object;
+  shallowEqual(p1: Object, p2: Object): boolean;
+  [key: string]: any;
+}
+
+function isComponent(obj) {
+  return obj && obj.hasOwnProperty("__owl__");
+}
+
+const UTILS: Utils = {
+  zero: Symbol("zero"),
+  toObj(expr) {
+    if (typeof expr === "string") {
+      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;
+  },
+  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("");
+  },
+  getComponent(obj) {
+    while (obj && !isComponent(obj)) {
+      obj = obj.__proto__;
+    }
+    return obj;
+  },
+  getScope(obj, property: string) {
+    const obj0 = obj;
+    while (obj && !obj.hasOwnProperty(property)) {
+      const newObj = obj.__proto__;
+      if (!newObj || isComponent(newObj)) {
+        return obj0;
+      }
+      obj = newObj;
+    }
+    return obj;
+  }
+};
+
+function parseXML(xml: string): Document {
+  const parser = new DOMParser();
+
+  const doc = parser.parseFromString(xml, "text/xml");
+  if (doc.getElementsByTagName("parsererror").length) {
+    let msg = "Invalid XML in template.";
+    const parsererrorText = doc.getElementsByTagName("parsererror")[0].textContent;
+    if (parsererrorText) {
+      msg += "\nThe parser has produced the following error message:\n" + parsererrorText;
+      const re = /\d+/g;
+      const firstMatch = re.exec(parsererrorText);
+      if (firstMatch) {
+        const lineNumber = Number(firstMatch[0]);
+        const line = xml.split("\n")[lineNumber - 1];
+        const secondMatch = re.exec(parsererrorText);
+        if (line && secondMatch) {
+          const columnIndex = Number(secondMatch[0]) - 1;
+          if (line[columnIndex]) {
+            msg +=
+              `\nThe error might be located at xml line ${lineNumber} column ${columnIndex}\n` +
+              `${line}\n${"-".repeat(columnIndex - 1)}^`;
+          }
+        }
+      }
+    }
+    throw new Error(msg);
+  }
+  return doc;
+}
+
+//------------------------------------------------------------------------------
+// QWeb rendering engine
+//------------------------------------------------------------------------------
+
+export class QWeb extends EventBus {
+  templates: { [name: string]: Template };
+  static utils = UTILS;
+  static components = Object.create(null);
+
+  static DIRECTIVE_NAMES: { [key: string]: 1 } = {
+    name: 1,
+    att: 1,
+    attf: 1,
+    translation: 1
+  };
+  static DIRECTIVES: Directive[] = [];
+
+  static TEMPLATES: { [name: string]: Template } = {};
+
+  static nextId: number = 1;
+
+  h = h;
+  // dev mode enables better error messages or more costly validations
+  static dev: boolean = false;
+
+  // 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 = {};
+
+  isUpdating: boolean = false;
+  translateFn?: QWebConfig["translateFn"];
+
+  constructor(config: QWebConfig = {}) {
+    super();
+    this.templates = Object.create(QWeb.TEMPLATES);
+    if (config.templates) {
+      this.addTemplates(config.templates);
+    }
+    if (config.translateFn) {
+      this.translateFn = config.translateFn;
+    }
+  }
+
+  static addDirective(directive: Directive) {
+    if (directive.name in QWeb.DIRECTIVE_NAMES) {
+      throw new Error(`Directive "${directive.name} already registered`);
+    }
+    QWeb.DIRECTIVES.push(directive);
+    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));
+    }
+  }
+
+  static registerComponent(name: string, Component: any) {
+    if (QWeb.components[name]) {
+      throw new Error(`Component '${name}' has already been registered`);
+    }
+    QWeb.components[name] = Component;
+  }
+
+  /**
+   * Register globally a template.  All QWeb instances will obtain their
+   * templates from their own template map, and then, from the global static
+   * TEMPLATES property.
+   */
+  static registerTemplate(name: string, template: string) {
+    if (QWeb.TEMPLATES[name]) {
+      throw new Error(`Template '${name}' has already been registered`);
+    }
+    const qweb = new QWeb();
+    qweb.addTemplate(name, template);
+    QWeb.TEMPLATES[name] = qweb.templates[name];
+  }
+
+  /**
+   * Add a template to the internal template map.  Note that it is not
+   * immediately compiled.
+   */
+  addTemplate(name: string, xmlString: string, allowDuplicate?: boolean) {
+    if (allowDuplicate && name in this.templates) {
+      return;
+    }
+    const doc = parseXML(xmlString);
+    if (!doc.firstChild) {
+      throw new Error("Invalid template (should not be empty)");
+    }
+    this._addTemplate(name, <Element>doc.firstChild);
+  }
+
+  /**
+   * Load templates from a xml (as a string or xml document).  This will look up
+   * for the first <templates> tag, and will consider each child of this as a
+   * template, with the name given by the t-name attribute.
+   */
+  addTemplates(xmlstr: string | Document) {
+    const doc = typeof xmlstr === "string" ? parseXML(xmlstr) : xmlstr;
+    const templates = doc.getElementsByTagName("templates")[0];
+    if (!templates) {
+      return;
+    }
+    for (let elem of <any>templates.children) {
+      const name = elem.getAttribute("t-name");
+      this._addTemplate(name, elem);
+    }
+  }
+
+  _addTemplate(name: string, elem: Element) {
+    if (name in this.templates) {
+      throw new Error(`Template ${name} already defined`);
+    }
+    this._processTemplate(elem);
+    const template = {
+      elem,
+      fn: function(this: QWeb, context, extra) {
+        const compiledFunction = this._compile(name, elem);
+        template.fn = compiledFunction;
+        return compiledFunction.call(this, context, extra);
+      }
+    };
+    this.templates[name] = template;
+  }
+
+  _processTemplate(elem: Element) {
+    let tbranch = elem.querySelectorAll("[t-elif], [t-else]");
+    for (let i = 0, ilen = tbranch.length; i < ilen; i++) {
+      let node = tbranch[i];
+      let prevElem = node.previousElementSibling!;
+      let pattr = function(name) {
+        return prevElem.getAttribute(name);
+      };
+      let nattr = function(name) {
+        return +!!node.getAttribute(name);
+      };
+      if (prevElem && (pattr("t-if") || pattr("t-elif"))) {
+        if (pattr("t-foreach")) {
+          throw new Error(
+            "t-if cannot stay at the same level as t-foreach when using t-elif or t-else"
+          );
+        }
+        if (
+          ["t-if", "t-elif", "t-else"].map(nattr).reduce(function(a, b) {
+            return a + b;
+          }) > 1
+        ) {
+          throw new Error("Only one conditional branching directive is allowed per node");
+        }
+        // All text nodes between branch nodes are removed
+        let textNode;
+        while ((textNode = node.previousSibling) !== prevElem) {
+          if (textNode.nodeValue.trim().length) {
+            throw new Error("text is not allowed between branching directives");
+          }
+          textNode.remove();
+        }
+      } else {
+        throw new Error(
+          "t-elif and t-else directives must be preceded by a t-if or t-elif directive"
+        );
+      }
+    }
+  }
+  /**
+   * Render a template
+   *
+   * @param {string} name the template should already have been added
+   */
+  render(name: string, context: EvalContext = {}, extra: any = null): VNode {
+    const template = this.templates[name];
+    if (!template) {
+      throw new Error(`Template ${name} does not exist`);
+    }
+    return template.fn.call(this, context, extra);
+  }
+
+  /**
+   * Render a template to a html string.
+   *
+   * Note that this is more limited than the `render` method: it is not suitable
+   * to render a full component tree, since this is an asynchronous operation.
+   * This method can only render templates without components.
+   */
+  renderToString(name: string, context: EvalContext = {}, extra?: any): string {
+    const vnode = this.render(name, context, extra);
+    if (vnode.sel === undefined) {
+      return vnode.text!;
+    }
+    const node = document.createElement(vnode.sel);
+    const elem = patch(node, vnode).elm as HTMLElement;
+    function escapeTextNodes(node) {
+      if (node.nodeType === 3) {
+        node.textContent = escape(node.textContent);
+      }
+      for (let n of node.childNodes) {
+        escapeTextNodes(n);
+      }
+    }
+    escapeTextNodes(elem);
+    return elem.outerHTML;
+  }
+
+  /**
+   * Force all widgets connected to this QWeb instance to rerender themselves.
+   *
+   * This method is mostly useful for external code that want to modify the
+   * application in some cases.  For example, a router plugin.
+   */
+  forceUpdate() {
+    this.isUpdating = true;
+    Promise.resolve().then(() => {
+      if (this.isUpdating) {
+        this.isUpdating = false;
+        this.trigger("update");
+      }
+    });
+  }
+
+  _compile(
+    name: string,
+    elem: Element,
+    parentContext?: CompilationContext,
+    defineKey?: boolean
+  ): CompiledTemplate {
+    const isDebug = elem.attributes.hasOwnProperty("t-debug");
+    const ctx = new CompilationContext(name);
+    if (elem.tagName !== "t") {
+      ctx.shouldDefineResult = false;
+    }
+    if (parentContext) {
+      ctx.variables = Object.create(parentContext.variables);
+      ctx.parentNode = parentContext.parentNode || ctx.generateID();
+      ctx.allowMultipleRoots = true;
+      ctx.hasParentWidget = true;
+      ctx.shouldDefineResult = false;
+      ctx.addLine(`let c${ctx.parentNode} = extra.parentNode;`);
+      if (defineKey) {
+        ctx.addLine(`let key0 = extra.key || "";`);
+        ctx.hasKey0 = true;
+      }
+    }
+    this._compileNode(elem, ctx);
+
+    if (!parentContext) {
+      if (ctx.shouldDefineResult) {
+        ctx.addLine(`return result;`);
+      } else {
+        if (!ctx.rootNode) {
+          throw new Error(`A template should have one root node (${ctx.templateName})`);
+        }
+        ctx.addLine(`return vn${ctx.rootNode};`);
+      }
+    }
+
+    let code = ctx.generateCode();
+    const templateName = ctx.templateName.replace(/`/g, "'").slice(0, 200);
+    code.unshift(`    // Template name: "${templateName}"`);
+
+    let template;
+    try {
+      template = new Function("context, extra", code.join("\n")) as CompiledTemplate;
+    } catch (e) {
+      console.groupCollapsed(`Invalid Code generated by ${templateName}`);
+      console.warn(code.join("\n"));
+      console.groupEnd();
+      throw new Error(
+        `Invalid generated code while compiling template '${templateName}': ${e.message}`
+      );
+    }
+    if (isDebug) {
+      const tpl = this.templates[name];
+      if (tpl) {
+        const msg = `Template: ${tpl.elem.outerHTML}\nCompiled code:\n${template.toString()}`;
+        console.log(msg);
+      }
+    }
+    return template;
+  }
+
+  /**
+   * Generate code from an xml node
+   *
+   */
+  _compileNode(node: ChildNode, ctx: CompilationContext) {
+    if (!(node instanceof Element)) {
+      // this is a text node, there are no directive to apply
+      let text = node.textContent!;
+      if (!ctx.inPreTag) {
+        if (lineBreakRE.test(text) && !text.trim()) {
+          return;
+        }
+        text = text.replace(whitespaceRE, " ");
+      }
+      if (this.translateFn) {
+        if ((node.parentNode as any).getAttribute("t-translation") !== "off") {
+          text = this.translateFn(text);
+        }
+      }
+      if (ctx.parentNode) {
+        if (node.nodeType === 3) {
+          ctx.addLine(`c${ctx.parentNode}.push({text: \`${text}\`});`);
+        } else if (node.nodeType === 8) {
+          ctx.addLine(`c${ctx.parentNode}.push(h('!', \`${text}\`));`);
+        }
+      } else if (ctx.parentTextNode) {
+        ctx.addLine(`vn${ctx.parentTextNode}.text += \`${text}\`;`);
+      } else {
+        // this is an unusual situation: this text node is the result of the
+        // template rendering.
+        let nodeID = ctx.generateID();
+        ctx.addLine(`let vn${nodeID} = {text: \`${text}\`};`);
+        ctx.addLine(`result = vn${nodeID};`);
+        ctx.rootContext.rootNode = nodeID;
+        ctx.rootContext.parentTextNode = nodeID;
+      }
+      return;
+    }
+
+    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" ... />
+      node.setAttribute("t-component", node.tagName);
+    } else if (node.tagName !== "t" && node.hasAttribute("t-component")) {
+      throw new Error(
+        `Directive 't-component' can only be used on <t> nodes (used on a <${node.tagName}>)`
+      );
+    }
+    const attributes = (<Element>node).attributes;
+
+    const validDirectives: {
+      directive: Directive;
+      value: string;
+      fullName: string;
+    }[] = [];
+
+    const finalizers: typeof validDirectives = [];
+
+    // maybe this is not optimal: we iterate on all attributes here, and again
+    // just after for each directive.
+    for (let i = 0; i < attributes.length; i++) {
+      let attrName = attributes[i].name;
+      if (attrName.startsWith("t-")) {
+        let dName = attrName.slice(2).split(/-|\./)[0];
+        if (!(dName in QWeb.DIRECTIVE_NAMES)) {
+          throw new Error(`Unknown QWeb directive: '${attrName}'`);
+        }
+        if (node.tagName !== "t" && (attrName === "t-esc" || attrName === "t-raw")) {
+          const tNode = document.createElement("t");
+          tNode.setAttribute(attrName, node.getAttribute(attrName)!);
+          for (let child of Array.from(node.childNodes)) {
+            tNode.appendChild(child);
+          }
+          node.appendChild(tNode);
+          node.removeAttribute(attrName);
+        }
+      }
+    }
+
+    const DIR_N = QWeb.DIRECTIVES.length;
+    const ATTR_N = attributes.length;
+    let withHandlers = false;
+    for (let i = 0; i < DIR_N; i++) {
+      let directive = QWeb.DIRECTIVES[i];
+      let fullName;
+      let value;
+      for (let j = 0; j < ATTR_N; j++) {
+        const name = attributes[j].name;
+        if (
+          name === "t-" + directive.name ||
+          name.startsWith("t-" + directive.name + "-") ||
+          name.startsWith("t-" + directive.name + ".")
+        ) {
+          fullName = name;
+          value = attributes[j].textContent;
+          validDirectives.push({ directive, value, fullName });
+          if (directive.name === "on" || directive.name === "model") {
+            withHandlers = true;
+          }
+        }
+      }
+    }
+
+    for (let { directive, value, fullName } of validDirectives) {
+      if (directive.finalize) {
+        finalizers.push({ directive, value, fullName });
+      }
+      if (directive.atNodeEncounter) {
+        const isDone = directive.atNodeEncounter({
+          node,
+          qweb: this,
+          ctx,
+          fullName,
+          value
+        });
+        if (isDone) {
+          for (let { directive, value, fullName } of finalizers) {
+            directive.finalize!({ node, qweb: this, ctx, fullName, value });
+          }
+          return;
+        }
+      }
+    }
+
+    if (node.nodeName !== "t") {
+      let nodeID = this._compileGenericNode(node, ctx, withHandlers);
+      ctx = ctx.withParent(nodeID);
+      let nodeHooks = {};
+      let addNodeHook = function(hook, handler) {
+        nodeHooks[hook] = nodeHooks[hook] || [];
+        nodeHooks[hook].push(handler);
+      };
+
+      for (let { directive, value, fullName } of validDirectives) {
+        if (directive.atNodeCreation) {
+          directive.atNodeCreation({
+            node,
+            qweb: this,
+            ctx,
+            fullName,
+            value,
+            nodeID,
+            addNodeHook
+          });
+        }
+      }
+
+      if (Object.keys(nodeHooks).length) {
+        ctx.addLine(`p${nodeID}.hook = {`);
+        for (let hook in nodeHooks) {
+          ctx.addLine(`  ${hook}: ${NODE_HOOKS_PARAMS[hook]} => {`);
+          for (let handler of nodeHooks[hook]) {
+            ctx.addLine(`    ${handler}`);
+          }
+          ctx.addLine(`  },`);
+        }
+        ctx.addLine(`};`);
+      }
+    }
+    if (node.nodeName === "pre") {
+      ctx = ctx.subContext("inPreTag", true);
+    }
+
+    this._compileChildren(node, ctx);
+    // svg support
+    // we hadd svg namespace if it is a svg or if it is a g, but only if it is
+    // the root node.  This is the easiest way to support svg sub components:
+    // they need to have a g tag as root. Otherwise, we would need a complete
+    // list of allowed svg tags.
+    const shouldAddNS =
+      node.nodeName === "svg" || (node.nodeName === "g" && ctx.rootNode === ctx.parentNode);
+    if (shouldAddNS) {
+      ctx.rootContext.shouldDefineUtils = true;
+      ctx.addLine(`utils.addNameSpace(vn${ctx.parentNode});`);
+    }
+
+    for (let { directive, value, fullName } of finalizers) {
+      directive.finalize!({ node, qweb: this, ctx, fullName, value });
+    }
+  }
+
+  _compileGenericNode(
+    node: ChildNode,
+    ctx: CompilationContext,
+    withHandlers: boolean = true
+  ): number {
+    // nodeType 1 is generic tag
+    if (node.nodeType !== 1) {
+      throw new Error("unsupported node type");
+    }
+    const attributes = (<Element>node).attributes;
+    const attrs: string[] = [];
+    const props: string[] = [];
+    const tattrs: number[] = [];
+
+    function handleBooleanProps(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;
+      }
+      if (isProp) {
+        props.push(`${key}: _${val}`);
+      }
+    }
+    let classObj = "";
+
+    for (let i = 0; i < attributes.length; i++) {
+      let name = attributes[i].name;
+      let value = attributes[i].textContent!;
+
+      if (this.translateFn && TRANSLATABLE_ATTRS.includes(name)) {
+        value = this.translateFn(value);
+      }
+
+      // regular attributes
+      if (!name.startsWith("t-") && !(<Element>node).getAttribute("t-attf-" + name)) {
+        const attID = ctx.generateID();
+        if (name === "class") {
+          if ((value = value.trim())) {
+            let classDef = value
+              .split(/\s+/)
+              .map(a => `'${a}':true`)
+              .join(",");
+            classObj = `_${ctx.generateID()}`;
+            ctx.addLine(`let ${classObj} = {${classDef}};`);
+          }
+        } else {
+          ctx.addLine(`let _${attID} = '${value}';`);
+          if (!name.match(/^[a-zA-Z]+$/)) {
+            // attribute contains 'non letters' => we want to quote it
+            name = '"' + name + '"';
+          }
+          attrs.push(`${name}: _${attID}`);
+          handleBooleanProps(name, attID);
+        }
+      }
+
+      // dynamic attributes
+      if (name.startsWith("t-att-")) {
+        let attName = name.slice(6);
+        const v = ctx.getValue(value);
+        let formattedValue = typeof v === "string" ? ctx.formatExpression(v) : `scope.${v.id}`;
+
+        if (attName === "class") {
+          ctx.rootContext.shouldDefineUtils = true;
+          formattedValue = `utils.toObj(${formattedValue})`;
+          if (classObj) {
+            ctx.addLine(`Object.assign(${classObj}, ${formattedValue})`);
+          } else {
+            classObj = `_${ctx.generateID()}`;
+            ctx.addLine(`let ${classObj} = ${formattedValue};`);
+          }
+        } else {
+          const attID = ctx.generateID();
+          if (!attName.match(/^[a-zA-Z]+$/)) {
+            // attribute contains 'non letters' => we want to quote it
+            attName = '"' + attName + '"';
+          }
+          // we need to combine dynamic with non dynamic attributes:
+          // class="a" t-att-class="'yop'" should be rendered as class="a yop"
+          const attValue = (<Element>node).getAttribute(attName);
+          if (attValue) {
+            const attValueID = ctx.generateID();
+            ctx.addLine(`let _${attValueID} = ${formattedValue};`);
+            formattedValue = `'${attValue}' + (_${attValueID} ? ' ' + _${attValueID} : '')`;
+            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 (name.startsWith("t-attf-")) {
+        let attName = name.slice(7);
+        if (!attName.match(/^[a-zA-Z]+$/)) {
+          // attribute contains 'non letters' => we want to quote it
+          attName = '"' + attName + '"';
+        }
+        const formattedExpr = ctx.interpolate(value);
+        const attID = ctx.generateID();
+        let staticVal = (<Element>node).getAttribute(attName);
+        if (staticVal) {
+          ctx.addLine(`let _${attID} = '${staticVal} ' + ${formattedExpr};`);
+        } else {
+          ctx.addLine(`let _${attID} = ${formattedExpr};`);
+        }
+        attrs.push(`${attName}: _${attID}`);
+      }
+
+      // t-att= attributes
+      if (name === "t-att") {
+        let id = ctx.generateID();
+        ctx.addLine(`let _${id} = ${ctx.formatExpression(value!)};`);
+        tattrs.push(id);
+      }
+    }
+    let nodeID = ctx.generateID();
+    let key = ctx.loopNumber || ctx.hasKey0 ? `\`\${key${ctx.loopNumber}}_${nodeID}\`` : nodeID;
+    const parts = [`key:${key}`];
+    if (attrs.length + tattrs.length > 0) {
+      parts.push(`attrs:{${attrs.join(",")}}`);
+    }
+    if (props.length > 0) {
+      parts.push(`props:{${props.join(",")}}`);
+    }
+    if (classObj) {
+      parts.push(`class:${classObj}`);
+    }
+    if (withHandlers) {
+      parts.push(`on:{}`);
+    }
+
+    ctx.addLine(`let c${nodeID} = [], p${nodeID} = {${parts.join(",")}};`);
+    for (let id of tattrs) {
+      ctx.addIf(`_${id} instanceof Array`);
+      ctx.addLine(`p${nodeID}.attrs[_${id}[0]] = _${id}[1];`);
+      ctx.addElse();
+      ctx.addLine(`for (let key in _${id}) {`);
+      ctx.indent();
+      ctx.addLine(`p${nodeID}.attrs[key] = _${id}[key];`);
+      ctx.dedent();
+      ctx.addLine(`}`);
+      ctx.closeIf();
+    }
+    ctx.addLine(`let vn${nodeID} = h('${node.nodeName}', p${nodeID}, c${nodeID});`);
+    if (ctx.parentNode) {
+      ctx.addLine(`c${ctx.parentNode}.push(vn${nodeID});`);
+    } else if (ctx.loopNumber || ctx.hasKey0) {
+      ctx.rootContext.shouldDefineResult = true;
+      ctx.addLine(`result = vn${nodeID};`);
+    }
+
+    return nodeID;
+  }
+
+  _compileChildren(node: ChildNode, ctx: CompilationContext) {
+    if (node.childNodes.length > 0) {
+      for (let child of Array.from(node.childNodes)) {
+        this._compileNode(child, ctx);
+      }
+    }
+  }
+}

src/router/link.ts

@@ -0,0 +1,48 @@
+import { Component } from "../component/component";
+import { xml } from "../tags";
+import { Destination, RouterEnv } from "./router";
+
+type Props = Destination;
+
+export class Link<Env extends RouterEnv> extends Component<Env, Props> {
+  static template = xml`
+    <a  t-att-class="{'router-link-active': isActive }"
+        t-att-href="href"
+        t-on-click="navigate">
+        <t t-slot="default"/>
+    </a>
+  `;
+
+  href: string = this.env.router.destToPath(this.props);
+
+  async willUpdateProps(nextProps) {
+    this.href = this.env.router.destToPath(nextProps);
+  }
+
+  get isActive() {
+    if (this.env.router.mode === "hash") {
+      return (<any>document.location).hash === this.href;
+    }
+    return (<any>document.location).pathname === this.href;
+  }
+
+  navigate(ev) {
+    // don't redirect with control keys
+    if (ev.metaKey || ev.altKey || ev.ctrlKey || ev.shiftKey) {
+      return;
+    }
+    // don't redirect on right click
+    if (ev.button !== undefined && ev.button !== 0) {
+      return;
+    }
+    // don't redirect if `target="_blank"`
+    if (ev.currentTarget && ev.currentTarget.getAttribute) {
+      const target = ev.currentTarget.getAttribute("target");
+      if (/\b_blank\b/i.test(target)) {
+        return;
+      }
+    }
+    ev.preventDefault();
+    this.env.router.navigate(this.props);
+  }
+}

src/router/route_component.ts

@@ -0,0 +1,18 @@
+import { Component } from "../component/component";
+import { xml } from "../tags";
+
+export class RouteComponent extends Component<any, {}> {
+  static template = xml`
+    <t>
+        <t
+            t-if="routeComponent"
+            t-component="routeComponent"
+            t-key="env.router.currentRouteName"
+            t-props="env.router.currentParams" />
+    </t>
+  `;
+
+  get routeComponent(): any {
+    return this.env.router.currentRoute && this.env.router.currentRoute.component;
+  }
+}

src/router/router.ts

@@ -0,0 +1,275 @@
+import { Env } from "../component/component";
+import { QWeb } from "../qweb/index";
+import { shallowEqual } from "../utils";
+
+type NavigationGuard = (info: {
+  env: Env;
+  to: Route | null;
+  from: Route | null;
+}) => boolean | Destination;
+
+export interface Route {
+  name: string;
+  path: string;
+  component?: any;
+  redirect?: Destination;
+  params: string[];
+  beforeRouteEnter?: NavigationGuard;
+}
+
+export type RouteParams = { [key: string]: string | number };
+
+export interface RouterEnv extends Env {
+  router: Router;
+}
+
+export interface Destination {
+  path?: string;
+  to?: string;
+  params?: RouteParams;
+}
+
+interface PositiveMatchResult {
+  type: "match";
+  route: Route;
+  params: RouteParams;
+}
+
+interface NegativeMatchResult {
+  type: "nomatch";
+}
+
+interface CancelledMatch {
+  type: "cancelled";
+}
+
+type MatchResult = PositiveMatchResult | NegativeMatchResult | CancelledMatch;
+
+interface Options {
+  mode: Router["mode"];
+}
+
+const paramRegexp = /\{\{(.*?)\}\}/;
+
+export class Router {
+  currentRoute: Route | null = null;
+  currentParams: RouteParams | null = null;
+  mode: "history" | "hash";
+
+  routes: { [id: string]: Route };
+  routeIds: string[];
+  env: RouterEnv;
+
+  constructor(env: Env, routes: Partial<Route>[], options: Options = { mode: "history" }) {
+    env.router = this;
+    this.mode = options.mode;
+    this.env = env as RouterEnv;
+
+    this.routes = {};
+    this.routeIds = [];
+    let nextId = 1;
+    for (let partialRoute of routes) {
+      if (!partialRoute.name) {
+        partialRoute.name = "__route__" + nextId++;
+      }
+      if (partialRoute.component) {
+        QWeb.registerComponent("__component__" + partialRoute.name, partialRoute.component);
+      }
+      if (partialRoute.redirect) {
+        this.validateDestination(partialRoute.redirect);
+      }
+      partialRoute.params = partialRoute.path ? findParams(partialRoute.path) : [];
+      this.routes[partialRoute.name] = partialRoute as Route;
+      this.routeIds.push(partialRoute.name);
+    }
+  }
+
+  //--------------------------------------------------------------------------
+  // Public API
+  //--------------------------------------------------------------------------
+
+  async start() {
+    (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);
+    }
+    const result = await this.matchAndApplyRules(this.currentPath());
+    if (result.type === "match") {
+      this.currentRoute = result.route;
+      this.currentParams = result.params;
+      const currentPath = this.routeToPath(result.route, result.params);
+      if (currentPath !== this.currentPath()) {
+        this.setUrlFromPath(currentPath);
+      }
+    }
+  }
+
+  async navigate(to: Destination): Promise<boolean> {
+    const path = this.destToPath(to);
+    return this._navigate(path);
+  }
+  async _navigate(path: string, ev?: any): Promise<boolean> {
+    const initialName = this.currentRouteName;
+    const initialParams = this.currentParams;
+    const result = await this.matchAndApplyRules(path);
+    if (result.type === "match") {
+      const finalPath = this.routeToPath(result.route, result.params);
+      const isPopStateEvent = ev && ev instanceof PopStateEvent;
+      if (!isPopStateEvent) {
+        this.setUrlFromPath(finalPath);
+      }
+      this.currentRoute = result.route;
+      this.currentParams = result.params;
+    } else if (result.type === "nomatch") {
+      this.currentRoute = null;
+      this.currentParams = null;
+    }
+    const didChange =
+      this.currentRouteName !== initialName || !shallowEqual(this.currentParams, initialParams);
+    if (didChange) {
+      this.env.qweb.forceUpdate();
+      return true;
+    }
+    return false;
+  }
+
+  destToPath(dest: Destination): string {
+    this.validateDestination(dest);
+    return dest.path || this.routeToPath(this.routes[dest.to!], dest.params!);
+  }
+
+  get currentRouteName(): string | null {
+    return this.currentRoute && this.currentRoute.name;
+  }
+
+  //--------------------------------------------------------------------------
+  // Private helpers
+  //--------------------------------------------------------------------------
+
+  private setUrlFromPath(path: string) {
+    const separator = this.mode === "hash" ? location.pathname : "";
+    const url = location.origin + separator + path;
+    if (url !== window.location.href) {
+      window.history.pushState({}, path, url);
+    }
+  }
+
+  private validateDestination(dest: Destination) {
+    if ((!dest.path && !dest.to) || (dest.path && dest.to)) {
+      throw new Error(`Invalid destination: ${JSON.stringify(dest)}`);
+    }
+  }
+
+  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("/");
+  }
+
+  private currentPath(): string {
+    let result = this.mode === "history" ? window.location.pathname : window.location.hash.slice(1);
+    return result || "/";
+  }
+
+  private match(path: string): MatchResult {
+    for (let routeId of this.routeIds) {
+      let route = this.routes[routeId];
+      let params = this.getRouteParams(route, path);
+      if (params) {
+        return {
+          type: "match",
+          route: route,
+          params: params
+        };
+      }
+    }
+    return { type: "nomatch" };
+  }
+
+  private async matchAndApplyRules(path: string): Promise<MatchResult> {
+    const result = this.match(path);
+    if (result.type === "match") {
+      return this.applyRules(result);
+    }
+    return result;
+  }
+
+  private async applyRules(matchResult: PositiveMatchResult): Promise<MatchResult> {
+    const route = matchResult.route;
+    if (route.redirect) {
+      const path = this.destToPath(route.redirect);
+      return this.matchAndApplyRules(path);
+    }
+    if (route.beforeRouteEnter) {
+      const result = await route.beforeRouteEnter({
+        env: this.env,
+        from: this.currentRoute,
+        to: route
+      });
+      if (result === false) {
+        return { type: "cancelled" };
+      } else if (result !== true) {
+        // we want to navigate to another destination
+        const path = this.destToPath(result);
+        return this.matchAndApplyRules(path);
+      }
+    }
+
+    return matchResult;
+  }
+
+  private getRouteParams(route: Route, path: string): RouteParams | false {
+    if (route.path === "*") {
+      return {};
+    }
+    if (path.startsWith("#")) {
+      path = path.slice(1);
+    }
+    const descrParts = route.path.split("/");
+    const targetParts = path.split("/");
+    const l = descrParts.length;
+    if (l !== targetParts.length) {
+      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;
+      }
+    }
+    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]);
+    }
+  } while (m);
+  return result;
+}

src/store.ts

@@ -1,218 +1,159 @@
-import { Component } from "./component";
-import { EventBus } from "./event_bus";
-import { Observer } from "./observer";
+import { Component } from "./component/component";
+import { Env } from "./component/component";
+import { Context, useContextWithCB } from "./context";
+import { onWillUpdateProps } from "./hooks";
+
+/**
+ * Owl Store
+ *
+ * We have here:
+ * - a Store class
+ * - useStore hook
+ * - useDispatch hook
+ * - useGetters hook
+ *
+ * The Owl store is our answer to the problem of managing complex state across
+ * components. The main idea is that the store owns some state, allow external
+ * code to modify it through actions, and for each state changes,
+ * connected component will be notified, and updated if necessary.
+ *
+ * Note that this code is partly inspired by VueX and React/Redux
+ */
 
 //------------------------------------------------------------------------------
 // Store Definition
 //------------------------------------------------------------------------------
 
+export type Action = ({ state, dispatch, env, getters }, ...payload: any) => any;
+export type Getter = ({ state: any, getters }, payload?) => any;
+
 interface StoreConfig {
-  env?: any;
+  env?: Env;
   state?: any;
-  actions?: any;
-  mutations?: { [name: string]: any };
+  actions?: { [name: string]: Action };
+  getters?: { [name: string]: Getter };
 }
 
-interface StoreOption {
-  debug?: boolean;
-}
-
-export class Store extends EventBus {
-  state: any;
+export class Store extends Context {
   actions: any;
-  mutations: any;
-  _commitLevel: number = 0;
-  history: any[] = [];
-  debug: boolean;
   env: any;
-  observer: Observer;
-  set: any;
+  getters: { [name: string]: (payload?) => any };
+  updateFunctions: { [key: number]: (() => boolean)[] };
 
-  constructor(config: StoreConfig, options: StoreOption = {}) {
-    super();
-    this.debug = options.debug || false;
-    this.state = config.state || {};
+  constructor(config: StoreConfig) {
+    super(config.state);
     this.actions = config.actions;
-    this.mutations = config.mutations;
     this.env = config.env;
-    this.observer = new Observer();
-    this.observer.notifyCB = this.trigger.bind(this, "update");
-    this.observer.allowMutations = false;
-    this.observer.observe(this.state);
-
-    if (this.debug) {
-      this.history.push({ state: this.state });
+    this.getters = {};
+    this.updateFunctions = [];
+    if (config.getters) {
+      const firstArg = {
+        state: this.state,
+        getters: this.getters
+      };
+      for (let g in config.getters) {
+        this.getters[g] = config.getters[g].bind(this, firstArg);
+      }
     }
-    this.set = this.observer.set.bind(this.observer);
   }
 
-  dispatch(action, payload?: any): Promise<void> | void {
+  dispatch(action: string, ...payload: any): Promise<void> | void {
     if (!this.actions[action]) {
       throw new Error(`[Error] action ${action} is undefined`);
     }
     const result = this.actions[action](
       {
-        commit: this.commit.bind(this),
         dispatch: this.dispatch.bind(this),
         env: this.env,
-        state: this.state
-      },
-      payload
-    );
-    if (result instanceof Promise) {
-      return new Promise((resolve, reject) => {
-        result.then(() => resolve());
-        result.catch(reject);
-      });
-    }
-  }
-
-  commit(type, payload?: any) {
-    if (!this.mutations[type]) {
-      throw new Error(`[Error] mutation ${type} is undefined`);
-    }
-    this._commitLevel++;
-    this.observer.allowMutations = true;
-
-    const res = this.mutations[type].call(
-      null,
-      {
-        commit: this.commit.bind(this),
         state: this.state,
-        set: this.set
+        getters: this.getters
       },
-      payload
+      ...payload
     );
+    return result;
+  }
+}
 
-    if (this._commitLevel === 1) {
-      this.observer.allowMutations = false;
-      if (this.debug) {
-        this.history.push({
-          state: this.state,
-          mutation: type,
-          payload: payload
+interface SelectorOptions {
+  store?: Store;
+  isEqual?: (a: any, b: any) => boolean;
+  onUpdate?: (result: any) => any;
+}
+
+const isStrictEqual = (a, b) => a === b;
+
+export function useStore(selector, options: SelectorOptions = {}): any {
+  const component: Component<any, any> = Component.current!;
+  const componentId = component.__owl__.id;
+  const store = options.store || (component.env.store as Store);
+  if (!(store instanceof Store)) {
+    throw new Error(`No store found when connecting '${component.constructor.name}'`);
+  }
+  let result = selector(store.state, component.props);
+  const hashFn = store.observer.revNumber.bind(store.observer);
+  let revNumber = hashFn(result);
+  const isEqual = options.isEqual || isStrictEqual;
+  if (!store.updateFunctions[componentId]) {
+    store.updateFunctions[componentId] = [];
+  }
+  function selectCompareUpdate(state, props): boolean {
+    const oldResult = result;
+    result = selector(state, props);
+    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 {
+    return selectCompareUpdate(store!.state, component.props);
   });
-      }
-    }
-    this._commitLevel--;
-    return res;
-  }
-}
 
-//------------------------------------------------------------------------------
-// Connect function
-//------------------------------------------------------------------------------
-
-function revNumber<T extends Object>(o: T): number {
-  if (o !== null && typeof o === "object" && (<any>o).__owl__) {
-    return (<any>o).__owl__.rev;
+  useContextWithCB(store, component, function(): Promise<void> | void {
+    let shouldRender = false;
+    for (let fn of store.updateFunctions[componentId]) {
+      shouldRender = fn() || shouldRender;
     }
-  return 0;
-}
-
-function deepRevNumber<T extends Object>(o: T): number {
-  if (o !== null && typeof o === "object" && (<any>o).__owl__) {
-    return (<any>o).__owl__.deepRev;
-  }
-  return 0;
-}
-
-export function connect(mapStateToProps, options: any = {}) {
-  let hashFunction = options.hashFunction || null;
-
-  if (!hashFunction) {
-    let deep = "deep" in options ? options.deep : true;
-    let defaultRevFunction = deep ? deepRevNumber : revNumber;
-    hashFunction = function({ storeProps }, options) {
-      const { currentStoreProps } = options;
-      if ("__owl__" in storeProps) {
-        return defaultRevFunction(storeProps);
-      }
-      let hash = 0;
-      for (let key in storeProps) {
-        const val = storeProps[key];
-        const hashVal = defaultRevFunction(val);
-        if (hashVal === 0) {
-          if (val !== currentStoreProps[key]) {
-            options.didChange = true;
-          }
-        } else {
-          hash += hashVal;
-        }
-      }
-      return hash;
-    };
-  }
-
-  return function(Comp) {
-    return class extends Comp {
-      constructor(parent, props?: any) {
-        const env = parent instanceof Component ? parent.env : parent;
-        const ownProps = Object.assign({}, props || {});
-        const storeProps = mapStateToProps(env.store.state, ownProps);
-        const mergedProps = Object.assign({}, props || {}, storeProps);
-        super(parent, mergedProps);
-        this.__owl__.ownProps = ownProps;
-        this.__owl__.currentStoreProps = storeProps;
-        this.__owl__.storeHash = hashFunction(
-          {
-            state: env.store.state,
-            storeProps: storeProps,
-            revNumber,
-            deepRevNumber
-          },
-          {
-            currentStoreProps: storeProps
-          }
-        );
-      }
-      mounted() {
-        this.env.store.on("update", this, () => {
-          const ownProps = this.__owl__.ownProps;
-          const storeProps = mapStateToProps(this.env.store.state, ownProps);
-          const options: any = {
-            currentStoreProps: this.__owl__.currentStoreProps
-          };
-          const storeHash = hashFunction(
-            {
-              state: this.env.store.state,
-              storeProps: storeProps,
-              revNumber,
-              deepRevNumber
-            },
-            options
-          );
-          let didChange = options.didChange;
-          if (storeHash !== this.__owl__.storeHash) {
-            didChange = true;
-            this.__owl__.storeHash = storeHash;
-          }
-          if (didChange) {
-            this.__owl__.currentStoreProps = storeProps;
-            this.updateProps(ownProps, false);
+    if (shouldRender) {
+      return component.render();
     }
   });
-        super.mounted();
-      }
-      willUnmount() {
-        this.env.store.off("update", this);
-        super.willUnmount();
-      }
-      updateProps(nextProps, forceUpdate) {
-        if (this.__owl__.ownProps !== nextProps) {
-          this.__owl__.currentStoreProps = mapStateToProps(
-            this.env.store.state,
-            nextProps
-          );
-        }
-        this.__owl__.ownProps = nextProps;
-        const mergedProps = Object.assign(
-          {},
-          nextProps,
-          this.__owl__.currentStoreProps
-        );
-        return super.updateProps(mergedProps, forceUpdate);
-      }
-    };
+  onWillUpdateProps(props => {
+    selectCompareUpdate(store.state, props);
+  });
+
+  const __destroy = component.__destroy;
+  component.__destroy = parent => {
+    delete store.updateFunctions[componentId];
+    __destroy.call(component, parent);
   };
+
+  if (typeof result !== "object" || result === null) {
+    return result;
+  }
+  return new Proxy(result, {
+    get(target, k) {
+      return result[k];
+    },
+    set(target, k, v) {
+      throw new Error("Store state should only be modified through actions");
+    },
+    has(target, k) {
+      return k in result;
+    }
+  });
+}
+
+export function useDispatch(store?: Store): Store["dispatch"] {
+  store = store || (Component.current!.env.store as Store);
+  return store.dispatch.bind(store);
+}
+
+export function useGetters(store?: Store): Store["getters"] {
+  store = store || (Component.current!.env.store as Store);
+  return store.getters;
 }

src/tags.ts

@@ -0,0 +1,44 @@
+import { QWeb } from "./qweb/index";
+import { registerSheet } from "./component/styles";
+
+/**
+ * Owl Tags
+ *
+ * We have here a (very) small collection of tag functions:
+ *
+ * - xml
+ *
+ * The plan is to add a few other tags such as css, globalcss.
+ */
+
+/**
+ * XML tag helper for defining templates.  With this, one can simply define
+ * an inline template with just the template xml:
+ * ```js
+ *   class A extends Component {
+ *     static template = xml`<div>some template</div>`;
+ *   }
+ * ```
+ */
+export function xml(strings, ...args) {
+  const name = `__template__${QWeb.nextId++}`;
+  const value = String.raw(strings, ...args);
+  QWeb.registerTemplate(name, value);
+  return name;
+}
+
+/**
+ * CSS tag helper for defining inline stylesheets.  With this, one can simply define
+ * an inline stylesheet with just the following code:
+ * ```js
+ *   class A extends Component {
+ *     static style = css`.component-a { color: red; }`;
+ *   }
+ * ```
+ */
+export function css(strings, ...args) {
+  const name = `__sheet__${QWeb.nextId++}`;
+  const value = String.raw(strings, ...args);
+  registerSheet(name, value);
+  return name;
+}

src/utils.ts

@@ -1,3 +1,56 @@
+/**
+ * Owl Utils
+ *
+ * We have here a small collection of utility functions:
+ *
+ * - whenReady
+ * - loadJS
+ * - loadFile
+ * - escape
+ * - debounce
+ */
+
+export function whenReady(fn?: any) {
+  return new Promise(function(resolve) {
+    if (document.readyState !== "loading") {
+      resolve();
+    } else {
+      document.addEventListener("DOMContentLoaded", resolve, false);
+    }
+  }).then(fn || function() {});
+}
+
+const loadedScripts: { [key: string]: Promise<void> } = {};
+
+export function loadJS(url: string): Promise<void> {
+  if (url in loadedScripts) {
+    return loadedScripts[url];
+  }
+  const promise: Promise<void> = new Promise(function(resolve, reject) {
+    const script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src = url;
+    script.onload = function() {
+      resolve();
+    };
+    script.onerror = function() {
+      reject(`Error loading file '${url}'`);
+    };
+    const head = document.head || document.getElementsByTagName("head")[0];
+    head.appendChild(script);
+  });
+  loadedScripts[url] = promise;
+  return promise;
+}
+
+export async function loadFile(url: string): Promise<string> {
+  const result = await fetch(url);
+  if (!result.ok) {
+    throw new Error("Error while fetching xml templates");
+  }
+  return await result.text();
+}
+
 export function escape(str: string | number | undefined): string {
   if (str === undefined) {
     return "";
@@ -5,54 +58,9 @@ export function escape(str: string | number | undefined): string {
   if (typeof str === "number") {
     return String(str);
   }
-  return str
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&#x27;")
-    .replace(/`/g, "&#x60;");
-}
-
-/**
- * Remove trailing and leading spaces
- */
-export function htmlTrim(s: string): string {
-  let result = s.replace(/(^\s+|\s+$)/g, "");
-  if (s[0] === " ") {
-    result = " " + result;
-  }
-  if (result !== " " && s[s.length - 1] === " ") {
-    result = result + " ";
-  }
-  return result;
-}
-
-/**
- * Create a function that will generate unique id numbers
- */
-export function idGenerator(): () => number {
-  let nextID = 1;
-  return () => nextID++;
-}
-
-export type HashFn = (args: any[]) => string;
-
-export function memoize<R, T extends (...args: any[]) => R>(
-  f: T,
-  hash?: HashFn
-): T {
-  if (!hash) {
-    hash = args => args.map(a => String(a)).join(",");
-  }
-  let cache: { [key: string]: R } = {};
-  function memoizedFunction(...args: any[]) {
-    let hashValue = hash!(args);
-    if (!(hashValue in cache)) {
-      cache[hashValue] = f(...args);
-    }
-    return cache[hashValue];
-  }
-  return memoizedFunction as T;
+  const p = document.createElement("p");
+  p.textContent = str;
+  return p.innerHTML;
 }
 
 /**
@@ -63,11 +71,7 @@ export function memoize<R, T extends (...args: any[]) => R>(
  *
  * Inspired by https://davidwalsh.name/javascript-debounce-function
  */
-export function debounce(
-  func: Function,
-  wait: number,
-  immediate?: boolean
-): Function {
+export function debounce(func: Function, wait: number, immediate?: boolean): Function {
   let timeout;
   return function(this: any) {
     const context = this;
@@ -87,89 +91,11 @@ export function debounce(
   };
 }
 
-interface Tree<T> {
-  children: T[];
-}
-
-/**
- * Find a node in a tree.
- *
- * This will traverse the tree (depth first) and return the first child that
- * matches the predicate, if any
- */
-export function findInTree<T extends Tree<T>>(
-  tree: T,
-  predicate: (t: T) => boolean
-): T | null {
-  if (predicate(tree)) {
-    return tree;
-  }
-  for (let child of tree.children) {
-    let match = findInTree(child, predicate);
-    if (match) {
-      return match;
+export function shallowEqual(p1, p2): boolean {
+  for (let k in p1) {
+    if (p1[k] !== p2[k]) {
+      return false;
     }
   }
-  return null;
-}
-
-export function patch(C: any, patchName: string, patch: any) {
-  const proto = C.prototype;
-  if (!proto.__patches) {
-    proto.__patches = {
-      origMethods: {},
-      patches: {},
-      current: []
-    };
-  }
-  if (proto.__patches.patches[patchName]) {
-    throw new Error(`Patch [${patchName}] already exists`);
-  }
-  proto.__patches.patches[patchName] = patch;
-  applyPatch(proto, patch);
-  proto.__patches.current.push(patchName);
-
-  function applyPatch(proto, patch) {
-    Object.keys(patch).forEach(function(methodName) {
-      const method = patch[methodName];
-      if (typeof method === "function") {
-        const original = proto[methodName];
-        if (!(methodName in proto.__patches.origMethods)) {
-          proto.__patches.origMethods[methodName] = original;
-        }
-        proto[methodName] = function(...args) {
-          this._super = original;
-          return method.call(this, ...args);
-        };
-      }
-    });
-  }
-}
-
-export function unpatch(C: any, patchName: string) {
-  const proto = C.prototype;
-  const patchInfo = proto.__patches;
-  delete proto.__patches;
-
-  // reset to original
-  for (let k in patchInfo.origMethods) {
-    proto[k] = patchInfo.origMethods[k];
-  }
-
-  // apply other patches
-  for (let name of patchInfo.current) {
-    if (name !== patchName) {
-      patch(C, name, patchInfo.patches[name]);
-    }
-  }
-}
-
-export async function loadTemplates(url: string): Promise<string> {
-  const result = await fetch(url);
-  if (!result.ok) {
-    throw new Error("Error while fetching xml templates");
-  }
-  let templates = await result.text();
-  templates = templates.replace(/<!--[\s\S]*?-->/g, "");
-  return templates;
+  return true;
 }

src/vdom/html_to_vdom.ts

@@ -0,0 +1,27 @@
+import { VNode, h } from "./vdom";
+
+const parser = new DOMParser();
+
+export function htmlToVDOM(html: string): VNode[] {
+  const doc = parser.parseFromString(html, "text/html");
+  const result: VNode[] = [];
+  for (let child of doc.body.childNodes) {
+    result.push(htmlToVNode(child));
+  }
+  return result;
+}
+
+function htmlToVNode(node: ChildNode): VNode {
+  if (!(node instanceof Element)) {
+    return { text: node.textContent! } as VNode;
+  }
+  const attrs = {};
+  for (let attr of node.attributes) {
+    attrs[attr.name] = attr.textContent;
+  }
+  const children: VNode[] = [];
+  for (let c of node.childNodes) {
+    children.push(htmlToVNode(c));
+  }
+  return h((node as Element).tagName, { attrs }, children);
+}

src/vdom/index.ts

@@ -0,0 +1,9 @@
+import { attrsModule, classModule, eventListenersModule, propsModule } from "./modules";
+import { init } from "./vdom";
+//------------------------------------------------------------------------------
+// patch
+//------------------------------------------------------------------------------
+
+export { h, VNode } from "./vdom";
+
+export const patch = init([eventListenersModule, attrsModule, propsModule, classModule]);

src/vdom/modules.ts

@@ -0,0 +1,234 @@
+import { Module, VNode, VNodeData } from "./vdom";
+
+//------------------------------------------------------------------------------
+// module/props.ts
+//------------------------------------------------------------------------------
+
+function updateProps(oldVnode: VNode, vnode: VNode): void {
+  var key: string,
+    cur: any,
+    old: any,
+    elm = vnode.elm,
+    oldProps = (oldVnode.data as VNodeData).props,
+    props = (vnode.data as VNodeData).props;
+
+  if (!oldProps && !props) return;
+  if (oldProps === props) return;
+  oldProps = oldProps || {};
+  props = props || {};
+
+  for (key in oldProps) {
+    if (!props[key]) {
+      delete (elm as any)[key];
+    }
+  }
+  for (key in props) {
+    cur = props[key];
+    old = oldProps[key];
+    if (old !== cur && (key !== "value" || (elm as any)[key] !== cur)) {
+      (elm as any)[key] = cur;
+    }
+  }
+}
+
+export const propsModule = {
+  create: updateProps,
+  update: updateProps
+} as Module;
+
+//------------------------------------------------------------------------------
+// module/eventlisteners.ts
+//------------------------------------------------------------------------------
+
+function invokeHandler(handler: any, vnode?: VNode, event?: Event): void {
+  if (typeof handler === "function") {
+    // call function handler
+    handler.call(vnode, event, vnode);
+  } else if (typeof handler === "object") {
+    // call handler with arguments
+    if (typeof handler[0] === "function") {
+      // special case for single argument for performance
+      if (handler.length === 2) {
+        handler[0].call(vnode, handler[1], event, vnode);
+      } else {
+        var args = handler.slice(1);
+        args.push(event);
+        args.push(vnode);
+        handler[0].apply(vnode, args);
+      }
+    } else {
+      // call multiple handlers
+      for (let i = 0, iLen = handler.length; i < iLen; i++) {
+        invokeHandler(handler[i], vnode, event);
+      }
+    }
+  }
+}
+
+function handleEvent(event: Event, vnode: VNode) {
+  var name = event.type,
+    on = (vnode.data as VNodeData).on;
+
+  // call event handler(s) if exists
+  if (on && on[name]) {
+    invokeHandler(on[name], vnode, event);
+  }
+}
+
+function createListener() {
+  return function handler(event: Event) {
+    handleEvent(event, (handler as any).vnode);
+  };
+}
+
+function updateEventListeners(oldVnode: VNode, vnode?: VNode): void {
+  var oldOn = (oldVnode.data as VNodeData).on,
+    oldListener = (oldVnode as any).listener,
+    oldElm: Element = oldVnode.elm as Element,
+    on = vnode && (vnode.data as VNodeData).on,
+    elm: Element = (vnode && vnode.elm) as Element,
+    name: string;
+
+  // optimization for reused immutable handlers
+  if (oldOn === on) {
+    return;
+  }
+
+  // remove existing listeners which no longer used
+  if (oldOn && oldListener) {
+    // if element changed or deleted we remove all existing listeners unconditionally
+    if (!on) {
+      for (name in oldOn) {
+        // remove listener if element was changed or existing listeners removed
+        oldElm.removeEventListener(name, oldListener, false);
+      }
+    } else {
+      for (name in oldOn) {
+        // remove listener if existing listener removed
+        if (!on[name]) {
+          oldElm.removeEventListener(name, oldListener, false);
+        }
+      }
+    }
+  }
+
+  // add new listeners which has not already attached
+  if (on) {
+    // reuse existing listener or create new
+    var listener = ((vnode as any).listener = (oldVnode as any).listener || createListener());
+    // update vnode for listener
+    listener.vnode = vnode;
+
+    // if element changed or added we add all needed listeners unconditionally
+    if (!oldOn) {
+      for (name in on) {
+        // add listener if element was changed or new listeners added
+        elm.addEventListener(name, listener, false);
+      }
+    } else {
+      for (name in on) {
+        // add listener if new listener added
+        if (!oldOn[name]) {
+          elm.addEventListener(name, listener, false);
+        }
+      }
+    }
+  }
+}
+
+export const eventListenersModule = {
+  create: updateEventListeners,
+  update: updateEventListeners,
+  destroy: updateEventListeners
+} as Module;
+
+//------------------------------------------------------------------------------
+// attributes.ts
+//------------------------------------------------------------------------------
+
+const xlinkNS = "http://www.w3.org/1999/xlink";
+const xmlNS = "http://www.w3.org/XML/1998/namespace";
+const colonChar = 58;
+const xChar = 120;
+
+function updateAttrs(oldVnode: VNode, vnode: VNode): void {
+  var key: string,
+    elm: Element = vnode.elm as Element,
+    oldAttrs = (oldVnode.data as VNodeData).attrs,
+    attrs = (vnode.data as VNodeData).attrs;
+
+  if (!oldAttrs && !attrs) return;
+  if (oldAttrs === attrs) return;
+  oldAttrs = oldAttrs || {};
+  attrs = attrs || {};
+
+  // update modified attributes, add new attributes
+  for (key in attrs) {
+    const cur = attrs[key];
+    const old = oldAttrs[key];
+    if (old !== cur) {
+      if (cur === true) {
+        elm.setAttribute(key, "");
+      } else if (cur === false) {
+        elm.removeAttribute(key);
+      } else {
+        if (key.charCodeAt(0) !== xChar) {
+          elm.setAttribute(key, cur);
+        } else if (key.charCodeAt(3) === colonChar) {
+          // Assume xml namespace
+          elm.setAttributeNS(xmlNS, key, cur);
+        } else if (key.charCodeAt(5) === colonChar) {
+          // Assume xlink namespace
+          elm.setAttributeNS(xlinkNS, key, cur);
+        } else {
+          elm.setAttribute(key, cur);
+        }
+      }
+    }
+  }
+  // remove removed attributes
+  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)
+  // the other option is to remove all attributes with value == undefined
+  for (key in oldAttrs) {
+    if (!(key in attrs)) {
+      elm.removeAttribute(key);
+    }
+  }
+}
+
+export const attrsModule = {
+  create: updateAttrs,
+  update: updateAttrs
+} as Module;
+
+//------------------------------------------------------------------------------
+// class.ts
+//------------------------------------------------------------------------------
+function updateClass(oldVnode: VNode, vnode: VNode): void {
+  var cur: any,
+    name: string,
+    elm: Element,
+    oldClass = (oldVnode.data as VNodeData).class,
+    klass = (vnode.data as VNodeData).class;
+
+  if (!oldClass && !klass) return;
+  if (oldClass === klass) return;
+  oldClass = oldClass || {};
+  klass = klass || {};
+
+  elm = vnode.elm as Element;
+
+  for (name in oldClass) {
+    if (name && !klass[name]) {
+      elm.classList.remove(name);
+    }
+  }
+  for (name in klass) {
+    cur = klass[name];
+    if (cur !== oldClass[name]) {
+      (elm.classList as any)[cur ? "add" : "remove"](name);
+    }
+  }
+}
+
+export const classModule = { create: updateClass, update: updateClass } as Module;

src/vdom/vdom.ts

@@ -1,12 +1,47 @@
+/**
+ * Owl VDOM
+ *
+ * This file contains an implementation of a virtual DOM, which is a system that
+ * can generate in-memory representations of a DOM tree, compare them, and
+ * eventually change a concrete DOM tree to match its representation, in an
+ * hopefully efficient way.
+ *
+ * Note that this code is a fork of Snabbdom, slightly tweaked/optimized for our
+ * needs (see https://github.com/snabbdom/snabbdom).
+ *
+ * The main exported values are:
+ * - interface VNode
+ * - h function (a helper function to generate a vnode)
+ * - patch function (to apply a vnode to an actual DOM node)
+ */
 
 // because those in TypeScript are too restrictive: https://github.com/Microsoft/TSJS-lib-generator/pull/237
 declare global {
   interface Element {
     setAttribute(name: string, value: string | number | boolean): void;
-    setAttributeNS(namespaceURI: string, qualifiedName: string, value: string | number | boolean): void;
+    setAttributeNS(
+      namespaceURI: string,
+      qualifiedName: string,
+      value: string | number | boolean
+    ): void;
   }
 }
 
+type Props = Record<string, any>;
+type Attrs = Record<string, string | number | boolean>;
+type On = { [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void } & {
+  [event: string]: EventListener;
+};
+
+export interface Module {
+  pre: PreHook;
+  create: CreateHook;
+  update: UpdateHook;
+  destroy: DestroyHook;
+  remove: RemoveHook;
+  post: PostHook;
+}
+
 //------------------------------------------------------------------------------
 // vnode.ts
 //------------------------------------------------------------------------------
@@ -21,15 +56,13 @@ export interface VNode {
   key: Key | undefined;
 }
 
-interface VNodeData {
+export interface VNodeData {
   props?: Props;
   attrs?: Attrs;
   on?: On;
   hook?: Hooks;
   key?: Key;
   ns?: string; // for SVGs
-  fn?: () => VNode; // for thunks
-  args?: Array<any>; // for thunks
   [key: string]: any; // for any other 3rd party module
 }
 
@@ -41,14 +74,7 @@ function vnode(
   elm: Element | Text | undefined
 ): VNode {
   let key = data === undefined ? undefined : data.key;
-  return {
-    sel: sel,
-    data: data,
-    children: children,
-    text: text,
-    elm: elm,
-    key: key
-  };
+  return { sel, data, children, text, elm, key };
 }
 
 //------------------------------------------------------------------------------
@@ -75,7 +101,7 @@ function isVnode(vnode: any): vnode is VNode {
 
 type KeyToIndexMap = { [key: string]: number };
 
-type ArraysOf<T> = { [K in keyof T]: (T[K])[] };
+type ArraysOf<T> = { [K in keyof T]: T[K][] };
 
 type ModuleHooks = ArraysOf<Module>;
 
@@ -98,14 +124,7 @@ function createKeyToOldIdx(
   return map;
 }
 
-const hooks: (keyof Module)[] = [
-  "create",
-  "update",
-  "remove",
-  "destroy",
-  "pre",
-  "post"
-];
+const hooks: (keyof Module)[] = ["create", "update", "remove", "destroy", "pre", "post"];
 
 export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
   let i: number,
@@ -127,13 +146,7 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
   function emptyNodeAt(elm: Element) {
     const id = elm.id ? "#" + elm.id : "";
     const c = elm.className ? "." + elm.className.split(" ").join(".") : "";
-    return vnode(
-      api.tagName(elm).toLowerCase() + id + c,
-      {},
-      [],
-      undefined,
-      elm
-    );
+    return vnode(api.tagName(elm).toLowerCase() + id + c, {}, [], undefined, elm);
   }
 
   function createRmCb(childElm: Node, listeners: number) {
@@ -147,6 +160,7 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
 
   function createElm(vnode: VNode, insertedVnodeQueue: VNodeQueue): Node {
     let i: any,
+      iLen: number,
       data = vnode.data;
     if (data !== undefined) {
       if (isDef((i = data.hook)) && isDef((i = i.init))) {
@@ -162,25 +176,15 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
       }
       vnode.elm = api.createComment(vnode.text as string);
     } else if (sel !== undefined) {
-      // Parse selector
-      const hashIdx = sel.indexOf("#");
-      const dotIdx = sel.indexOf(".", hashIdx);
-      const hash = hashIdx > 0 ? hashIdx : sel.length;
-      const dot = dotIdx > 0 ? dotIdx : sel.length;
-      const tag =
-        hashIdx !== -1 || dotIdx !== -1
-          ? sel.slice(0, Math.min(hash, dot))
-          : sel;
-      const elm = (vnode.elm =
+      const elm =
+        vnode.elm ||
+        (vnode.elm =
           isDef(data) && isDef((i = (data as VNodeData).ns))
-          ? api.createElementNS(i, tag)
-          : api.createElement(tag));
-      if (hash < dot) elm.setAttribute("id", sel.slice(hash + 1, dot));
-      if (dotIdx > 0)
-        elm.setAttribute("class", sel.slice(dot + 1).replace(/\./g, " "));
-      for (i = 0; i < cbs.create.length; ++i) cbs.create[i](emptyNode, vnode);
+            ? api.createElementNS(i, sel)
+            : api.createElement(sel));
+      for (i = 0, iLen = cbs.create.length; i < iLen; ++i) cbs.create[i](emptyNode, vnode);
       if (array(children)) {
-        for (i = 0; i < children.length; ++i) {
+        for (i = 0, iLen = children.length; i < iLen; ++i) {
           const ch = children[i];
           if (ch != null) {
             api.appendChild(elm, createElm(ch as VNode, insertedVnodeQueue));
@@ -218,13 +222,15 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
 
   function invokeDestroyHook(vnode: VNode) {
     let i: any,
+      iLen: number,
       j: number,
+      jLen: number,
       data = vnode.data;
     if (data !== undefined) {
       if (isDef((i = data.hook)) && isDef((i = i.destroy))) i(vnode);
-      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);
+      for (i = 0, iLen = cbs.destroy.length; i < iLen; ++i) cbs.destroy[i](vnode);
       if (vnode.children !== undefined) {
-        for (j = 0; j < vnode.children.length; ++j) {
+        for (j = 0, jLen = vnode.children.length; j < jLen; ++j) {
           i = vnode.children[j];
           if (i != null && typeof i !== "string") {
             invokeDestroyHook(i);
@@ -242,6 +248,7 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
   ): void {
     for (; startIdx <= endIdx; ++startIdx) {
       let i: any,
+        iLen: number,
         listeners: number,
         rm: () => void,
         ch = vnodes[startIdx];
@@ -250,12 +257,8 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
           invokeDestroyHook(ch);
           listeners = cbs.remove.length + 1;
           rm = createRmCb(ch.elm as Node, listeners);
-          for (i = 0; i < cbs.remove.length; ++i) cbs.remove[i](ch, rm);
-          if (
-            isDef((i = ch.data)) &&
-            isDef((i = i.hook)) &&
-            isDef((i = i.remove))
-          ) {
+          for (i = 0, iLen = cbs.remove.length; i < iLen; ++i) cbs.remove[i](ch, rm);
+          if (isDef((i = ch.data)) && isDef((i = i.hook)) && isDef((i = i.remove))) {
             i(ch, rm);
           } else {
             rm();
@@ -317,11 +320,7 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
       } else if (sameVnode(oldEndVnode, newStartVnode)) {
         // Vnode moved left
         patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
-        api.insertBefore(
-          parentElm,
-          oldEndVnode.elm as Node,
-          oldStartVnode.elm as Node
-        );
+        api.insertBefore(parentElm, oldEndVnode.elm as Node, oldStartVnode.elm as Node);
         oldEndVnode = oldCh[--oldEndIdx];
         newStartVnode = newCh[++newStartIdx];
       } else {
@@ -348,11 +347,7 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
           } else {
             patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);
             oldCh[idxInOld] = undefined as any;
-            api.insertBefore(
-              parentElm,
-              elmToMove.elm as Node,
-              oldStartVnode.elm as Node
-            );
+            api.insertBefore(parentElm, elmToMove.elm as Node, oldStartVnode.elm as Node);
           }
           newStartVnode = newCh[++newStartIdx];
         }
@@ -361,31 +356,16 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
     if (oldStartIdx <= oldEndIdx || newStartIdx <= newEndIdx) {
       if (oldStartIdx > oldEndIdx) {
         before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm;
-        addVnodes(
-          parentElm,
-          before,
-          newCh,
-          newStartIdx,
-          newEndIdx,
-          insertedVnodeQueue
-        );
+        addVnodes(parentElm, before, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
       } else {
         removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
       }
     }
   }
 
-  function patchVnode(
-    oldVnode: VNode,
-    vnode: VNode,
-    insertedVnodeQueue: VNodeQueue
-  ) {
-    let i: any, hook: any;
-    if (
-      isDef((i = vnode.data)) &&
-      isDef((hook = i.hook)) &&
-      isDef((i = hook.prepatch))
-    ) {
+  function patchVnode(oldVnode: VNode, vnode: VNode, insertedVnodeQueue: VNodeQueue) {
+    let i: any, iLen: number, hook: any;
+    if (isDef((i = vnode.data)) && isDef((hook = i.hook)) && isDef((i = hook.prepatch))) {
       i(oldVnode, vnode);
     }
     const elm = (vnode.elm = oldVnode.elm as Node);
@@ -393,19 +373,14 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
     let ch = vnode.children;
     if (oldVnode === vnode) return;
     if (vnode.data !== undefined) {
-      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);
+      for (i = 0, iLen = cbs.update.length; i < iLen; ++i) cbs.update[i](oldVnode, vnode);
       i = vnode.data.hook;
       if (isDef(i) && isDef((i = i.update))) i(oldVnode, vnode);
     }
     if (isUndef(vnode.text)) {
       if (isDef(oldCh) && isDef(ch)) {
         if (oldCh !== ch)
-          updateChildren(
-            elm,
-            oldCh as Array<VNode>,
-            ch as Array<VNode>,
-            insertedVnodeQueue
-          );
+          updateChildren(elm, oldCh as Array<VNode>, ch as Array<VNode>, insertedVnodeQueue);
       } else if (isDef(ch)) {
         if (isDef(oldVnode.text)) api.setTextContent(elm, "");
         addVnodes(
@@ -417,23 +392,13 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
           insertedVnodeQueue
         );
       } else if (isDef(oldCh)) {
-        removeVnodes(
-          elm,
-          oldCh as Array<VNode>,
-          0,
-          (oldCh as Array<VNode>).length - 1
-        );
+        removeVnodes(elm, oldCh as Array<VNode>, 0, (oldCh as Array<VNode>).length - 1);
       } else if (isDef(oldVnode.text)) {
         api.setTextContent(elm, "");
       }
     } else if (oldVnode.text !== vnode.text) {
       if (isDef(oldCh)) {
-        removeVnodes(
-          elm,
-          oldCh as Array<VNode>,
-          0,
-          (oldCh as Array<VNode>).length - 1
-        );
+        removeVnodes(elm, oldCh as Array<VNode>, 0, (oldCh as Array<VNode>).length - 1);
       }
       api.setTextContent(elm, vnode.text as string);
     }
@@ -443,9 +408,9 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
   }
 
   return function patch(oldVnode: VNode | Element, vnode: VNode): VNode {
-    let i: number, elm: Node, parent: Node;
+    let i: number, iLen: number, elm: Node, parent: Node;
     const insertedVnodeQueue: VNodeQueue = [];
-    for (i = 0; i < cbs.pre.length; ++i) cbs.pre[i]();
+    for (i = 0, iLen = cbs.pre.length; i < iLen; ++i) cbs.pre[i]();
 
     if (!isVnode(oldVnode)) {
       oldVnode = emptyNodeAt(oldVnode);
@@ -465,12 +430,12 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
       }
     }
 
-    for (i = 0; i < insertedVnodeQueue.length; ++i) {
+    for (i = 0, iLen = insertedVnodeQueue.length; i < iLen; ++i) {
       (((insertedVnodeQueue[i].data as VNodeData).hook as Hooks).insert as any)(
         insertedVnodeQueue[i]
       );
     }
-    for (i = 0; i < cbs.post.length; ++i) cbs.post[i]();
+    for (i = 0, iLen = cbs.post.length; i < iLen; ++i) cbs.post[i]();
     return vnode;
   };
 }
@@ -491,21 +456,13 @@ interface DOMAPI {
   createElementNS: (namespaceURI: string, qualifiedName: string) => Element;
   createTextNode: (text: string) => Text;
   createComment: (text: string) => Comment;
-  insertBefore: (
-    parentNode: Node,
-    newNode: Node,
-    referenceNode: Node | null
-  ) => void;
+  insertBefore: (parentNode: Node, newNode: Node, referenceNode: Node | null) => void;
   removeChild: (node: Node, child: Node) => void;
   appendChild: (node: Node, child: Node) => void;
   parentNode: (node: Node) => Node;
   nextSibling: (node: Node) => Node;
   tagName: (elm: Element) => string;
   setTextContent: (node: Node, text: string | null) => void;
-  getTextContent: (node: Node) => string | null;
-  isElement: (node: Node) => node is Element;
-  isText: (node: Node) => node is Text;
-  isComment: (node: Node) => node is Comment;
 }
 
 function createElement(tagName: any): HTMLElement {
@@ -524,11 +481,7 @@ function createComment(text: string): Comment {
   return document.createComment(text);
 }
 
-function insertBefore(
-  parentNode: Node,
-  newNode: Node,
-  referenceNode: Node | null
-): void {
+function insertBefore(parentNode: Node, newNode: Node, referenceNode: Node | null): void {
   parentNode.insertBefore(newNode, referenceNode);
 }
 
@@ -556,22 +509,6 @@ function setTextContent(node: Node, text: string | null): void {
   node.textContent = text;
 }
 
-function getTextContent(node: Node): string | null {
-  return node.textContent;
-}
-
-function isElement(node: Node): node is Element {
-  return node.nodeType === 1;
-}
-
-function isText(node: Node): node is Text {
-  return node.nodeType === 3;
-}
-
-function isComment(node: Node): node is Comment {
-  return node.nodeType === 8;
-}
-
 const htmlDomApi = {
   createElement,
   createElementNS,
@@ -583,11 +520,7 @@ const htmlDomApi = {
   parentNode,
   nextSibling,
   tagName,
-  setTextContent,
-  getTextContent,
-  isElement,
-  isText,
-  isComment
+  setTextContent
 } as DOMAPI;
 
 //------------------------------------------------------------------------------
@@ -625,21 +558,19 @@ type VNodeChildElement = VNode | string | number | undefined | null;
 type ArrayOrElement<T> = T | T[];
 type VNodeChildren = ArrayOrElement<VNodeChildElement>;
 
-function addNS(
-  data: any,
-  children: VNodes | undefined,
-  sel: string | undefined
-): void {
+export function addNS(data: any, children: VNodes | undefined, sel: string | undefined): void {
+  if (sel === "dummy") {
+    // we do not need to add the namespace on dummy elements, they come from a
+    // subcomponent, which will handle the namespace itself
+    return;
+  }
   data.ns = "http://www.w3.org/2000/svg";
   if (sel !== "foreignObject" && children !== undefined) {
-    for (let i = 0; i < children.length; ++i) {
-      let childData = children[i].data;
+    for (let i = 0, iLen = children.length; i < iLen; ++i) {
+      const child = children[i];
+      let childData = child.data;
       if (childData !== undefined) {
-        addNS(
-          childData,
-          (children[i] as VNode).children as VNodes,
-          children[i].sel
-        );
+        addNS(childData, (child as VNode).children as VNodes, child.sel);
       }
     }
   }
@@ -653,7 +584,8 @@ export function h(sel: any, b?: any, c?: any): VNode {
   var data: VNodeData = {},
     children: any,
     text: any,
-    i: number;
+    i: number,
+    iLen: number;
   if (c !== undefined) {
     data = b;
     if (array(c)) {
@@ -675,247 +607,10 @@ export function h(sel: any, b?: any, c?: any): VNode {
     }
   }
   if (children !== undefined) {
-    for (i = 0; i < children.length; ++i) {
+    for (i = 0, iLen = children.length; i < iLen; ++i) {
       if (primitive(children[i]))
-        children[i] = vnode(
-          undefined,
-          undefined,
-          undefined,
-          children[i],
-          undefined
-        );
+        children[i] = vnode(undefined, undefined, undefined, children[i], undefined);
     }
   }
-  if (
-    sel[0] === "s" &&
-    sel[1] === "v" &&
-    sel[2] === "g" &&
-    (sel.length === 3 || sel[3] === "." || sel[3] === "#")
-  ) {
-    addNS(data, children, sel);
-  }
   return vnode(sel, data, children, text, undefined);
 }
-
-//------------------------------------------------------------------------------
-// module/props.ts
-//------------------------------------------------------------------------------
-type Props = Record<string, any>;
-
-function updateProps(oldVnode: VNode, vnode: VNode): void {
-  var key: string,
-    cur: any,
-    old: any,
-    elm = vnode.elm,
-    oldProps = (oldVnode.data as VNodeData).props,
-    props = (vnode.data as VNodeData).props;
-
-  if (!oldProps && !props) return;
-  if (oldProps === props) return;
-  oldProps = oldProps || {};
-  props = props || {};
-
-  for (key in oldProps) {
-    if (!props[key]) {
-      delete (elm as any)[key];
-    }
-  }
-  for (key in props) {
-    cur = props[key];
-    old = oldProps[key];
-    if (old !== cur && (key !== "value" || (elm as any)[key] !== cur)) {
-      (elm as any)[key] = cur;
-    }
-  }
-}
-
-export const propsModule = {
-  create: updateProps,
-  update: updateProps
-} as Module;
-
-//------------------------------------------------------------------------------
-// module/module.ts
-//------------------------------------------------------------------------------
-interface Module {
-  pre: PreHook;
-  create: CreateHook;
-  update: UpdateHook;
-  destroy: DestroyHook;
-  remove: RemoveHook;
-  post: PostHook;
-}
-
-//------------------------------------------------------------------------------
-// module/eventlisteners.ts
-//------------------------------------------------------------------------------
-type On = {
-  [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void
-} & {
-  [event: string]: EventListener;
-};
-
-function invokeHandler(handler: any, vnode?: VNode, event?: Event): void {
-  if (typeof handler === "function") {
-    // call function handler
-    handler.call(vnode, event, vnode);
-  } else if (typeof handler === "object") {
-    // call handler with arguments
-    if (typeof handler[0] === "function") {
-      // special case for single argument for performance
-      if (handler.length === 2) {
-        handler[0].call(vnode, handler[1], event, vnode);
-      } else {
-        var args = handler.slice(1);
-        args.push(event);
-        args.push(vnode);
-        handler[0].apply(vnode, args);
-      }
-    } else {
-      // call multiple handlers
-      for (var i = 0; i < handler.length; i++) {
-        invokeHandler(handler[i], vnode, event);
-      }
-    }
-  }
-}
-
-function handleEvent(event: Event, vnode: VNode) {
-  var name = event.type,
-    on = (vnode.data as VNodeData).on;
-
-  // call event handler(s) if exists
-  if (on && on[name]) {
-    invokeHandler(on[name], vnode, event);
-  }
-}
-
-function createListener() {
-  return function handler(event: Event) {
-    handleEvent(event, (handler as any).vnode);
-  };
-}
-
-function updateEventListeners(oldVnode: VNode, vnode?: VNode): void {
-  var oldOn = (oldVnode.data as VNodeData).on,
-    oldListener = (oldVnode as any).listener,
-    oldElm: Element = oldVnode.elm as Element,
-    on = vnode && (vnode.data as VNodeData).on,
-    elm: Element = (vnode && vnode.elm) as Element,
-    name: string;
-
-  // optimization for reused immutable handlers
-  if (oldOn === on) {
-    return;
-  }
-
-  // remove existing listeners which no longer used
-  if (oldOn && oldListener) {
-    // if element changed or deleted we remove all existing listeners unconditionally
-    if (!on) {
-      for (name in oldOn) {
-        // remove listener if element was changed or existing listeners removed
-        oldElm.removeEventListener(name, oldListener, false);
-      }
-    } else {
-      for (name in oldOn) {
-        // remove listener if existing listener removed
-        if (!on[name]) {
-          oldElm.removeEventListener(name, oldListener, false);
-        }
-      }
-    }
-  }
-
-  // add new listeners which has not already attached
-  if (on) {
-    // reuse existing listener or create new
-    var listener = ((vnode as any).listener =
-      (oldVnode as any).listener || createListener());
-    // update vnode for listener
-    listener.vnode = vnode;
-
-    // if element changed or added we add all needed listeners unconditionally
-    if (!oldOn) {
-      for (name in on) {
-        // add listener if element was changed or new listeners added
-        elm.addEventListener(name, listener, false);
-      }
-    } else {
-      for (name in on) {
-        // add listener if new listener added
-        if (!oldOn[name]) {
-          elm.addEventListener(name, listener, false);
-        }
-      }
-    }
-  }
-}
-
-export const eventListenersModule = {
-  create: updateEventListeners,
-  update: updateEventListeners,
-  destroy: updateEventListeners
-} as Module;
-
-//------------------------------------------------------------------------------
-// attributes.ts
-//------------------------------------------------------------------------------
-type Attrs = Record<string, string | number | boolean>;
-
-const xlinkNS = "http://www.w3.org/1999/xlink";
-const xmlNS = "http://www.w3.org/XML/1998/namespace";
-const colonChar = 58;
-const xChar = 120;
-
-function updateAttrs(oldVnode: VNode, vnode: VNode): void {
-  var key: string,
-    elm: Element = vnode.elm as Element,
-    oldAttrs = (oldVnode.data as VNodeData).attrs,
-    attrs = (vnode.data as VNodeData).attrs;
-
-  if (!oldAttrs && !attrs) return;
-  if (oldAttrs === attrs) return;
-  oldAttrs = oldAttrs || {};
-  attrs = attrs || {};
-
-  // update modified attributes, add new attributes
-  for (key in attrs) {
-    const cur = attrs[key];
-    const old = oldAttrs[key];
-    if (old !== cur) {
-      if (cur === true) {
-        elm.setAttribute(key, "");
-      } else if (cur === false) {
-        elm.removeAttribute(key);
-      } else {
-        if (key.charCodeAt(0) !== xChar) {
-          elm.setAttribute(key, cur);
-        } else if (key.charCodeAt(3) === colonChar) {
-          // Assume xml namespace
-          elm.setAttributeNS(xmlNS, key, cur);
-        } else if (key.charCodeAt(5) === colonChar) {
-          // Assume xlink namespace
-          elm.setAttributeNS(xlinkNS, key, cur);
-        } else {
-          elm.setAttribute(key, cur);
-        }
-      }
-    }
-  }
-  // remove removed attributes
-  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)
-  // the other option is to remove all attributes with value == undefined
-  for (key in oldAttrs) {
-    if (!(key in attrs)) {
-      elm.removeAttribute(key);
-    }
-  }
-}
-
-export const attrsModule = {
-  create: updateAttrs,
-  update: updateAttrs
-} as Module;
-
-export const patch = init([eventListenersModule, attrsModule, propsModule]);

tests/__snapshots__/animations.test.ts.snap

@@ -0,0 +1,179 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`animations t-transition combined with component 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"Parent\\"
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    // Component 'Child'
+    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let props2 = {};
+    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+        w2.destroy();
+        w2 = false;
+    }
+    if (w2) {
+        w2.__updateProps(props2, extra.fiber, undefined);
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`Child\`;
+        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        const __patch2 = w2.__patch;
+        w2.__patch = fiber => {__patch2.call(w2, fiber); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
+        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {let finalize = () => {
+          w2.destroy();
+        };
+        delete w2.__owl__.transitionInserted;
+        utils.transitionRemove(vn, 'chimay', finalize);}}});
+        c1.push(pvnode);
+        w2.__owl__.pvnode = pvnode;
+    }
+    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
+exports[`animations t-transition combined with t-component and t-if 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"Parent\\"
+    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);
+    if (scope['state'].display) {
+        // Component 'Child'
+        let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+        let props2 = {};
+        if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+            w2.destroy();
+            w2 = false;
+        }
+        if (w2) {
+            w2.__updateProps(props2, extra.fiber, undefined);
+            let pvnode = w2.__owl__.pvnode;
+            c1.push(pvnode);
+        } else {
+            let componentKey2 = \`Child\`;
+            let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+            if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+            w2 = new W2(parent, props2);
+            const __patch2 = w2.__patch;
+            w2.__patch = fiber => {__patch2.call(w2, fiber); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
+            parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+            let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+            let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {let finalize = () => {
+          w2.destroy();
+        };
+        delete w2.__owl__.transitionInserted;
+        utils.transitionRemove(vn, 'chimay', finalize);}}});
+            c1.push(pvnode);
+            w2.__owl__.pvnode = pvnode;
+        }
+        w2.__owl__.parentLastFiberId = extra.fiber.id;
+    }
+    return vn1;
+}"
+`;
+
+exports[`animations t-transition combined with t-component, remove and re-add before transitionend 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);
+    if (scope['state'].flag) {
+        // Component 'Child'
+        let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+        let props2 = {};
+        if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+            w2.destroy();
+            w2 = false;
+        }
+        if (w2) {
+            w2.__updateProps(props2, extra.fiber, undefined);
+            let pvnode = w2.__owl__.pvnode;
+            c1.push(pvnode);
+        } else {
+            let componentKey2 = \`Child\`;
+            let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+            if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+            w2 = new W2(parent, props2);
+            const __patch2 = w2.__patch;
+            w2.__patch = fiber => {__patch2.call(w2, fiber); if(!w2.__owl__.transitionInserted){w2.__owl__.transitionInserted = true;utils.transitionInsert(w2.__owl__.vnode, 'chimay');}};
+            parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+            let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+            let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {let finalize = () => {
+          w2.destroy();
+        };
+        delete w2.__owl__.transitionInserted;
+        utils.transitionRemove(vn, 'chimay', finalize);}}});
+            c1.push(pvnode);
+            w2.__owl__.pvnode = pvnode;
+        }
+        w2.__owl__.parentLastFiberId = extra.fiber.id;
+    }
+    return vn1;
+}"
+`;
+
+exports[`animations t-transition with no delay/duration 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let utils = this.constructor.utils;
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('span', p1, c1);
+    p1.hook = {
+      insert: vn => {
+        utils.transitionInsert(vn, 'jupiler');
+      },
+      remove: (vn, rm) => {
+        utils.transitionRemove(vn, 'jupiler', rm);
+      },
+    };
+    c1.push({text: \`blue\`});
+    return vn1;
+}"
+`;
+
+exports[`animations t-transition, on a simple node (insert) 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"test\\"
+    let utils = this.constructor.utils;
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('span', p1, c1);
+    p1.hook = {
+      insert: vn => {
+        utils.transitionInsert(vn, 'chimay');
+      },
+      remove: (vn, rm) => {
+        utils.transitionRemove(vn, 'chimay', rm);
+      },
+    };
+    c1.push({text: \`blue\`});
+    return vn1;
+}"
+`;

tests/__snapshots__/component.test.ts.snap

@@ -1,155 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`composition sub widgets with some state rendered in a loop 1`] = `
-"function anonymous(context,extra
-) {
-    let owner = context;
-    context = Object.create(context);
-    var h = this.utils.h;
-    var c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
-    var _2 = context['state'].numbers;
-    if (!_2) { throw new Error('QWeb error: Invalid loop expression')}
-    if (typeof _2 === 'number') { _2 = Array.from(Array(_2).keys())}
-    var _3 = _2 instanceof Array ? _2 : Object.keys(_2);
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
-    for (let i = 0; i < _3.length; i++) {
-        context.number_first = i === 0;
-        context.number_last = i === _3.length - 1;
-        context.number_parity = i % 2 === 0 ? 'even' : 'odd';
-        context.number_index = i;
-        context.number = _3[i];
-        context.number_value = _4[i];
-        //WIDGET
-        let key8 = context['number'];
-        let _5_index = c1.length;
-        c1.push(null);
-        let def6;
-        let w7 = key8 in context.__owl__.cmap ? context.__owl__.children[context.__owl__.cmap[key8]] : false;
-        let props7 = {};
-        let isNew7 = !w7;
-        if (w7 && w7.__owl__.renderPromise) {
-            if (w7.__owl__.isStarted) {
-                def6 = w7.updateProps(props7, extra.forceUpdate);
-            } else {
-                isNew7 = true
-                if (props7 === w7.__owl__.renderProps) {
-                    def6 = w7.__owl__.renderPromise;
-                } else {
-                    w7.destroy();
-                    w7 = false
-                }
-            }
-        }
-        if (!def6) {
-            if (w7) {
-                def6 = w7.updateProps(props7, extra.forceUpdate);
-            } else {
-                w7 = new context.widgets['ChildWidget'](owner, props7);
-                context.__owl__.cmap[key8] = w7.__owl__.id;
-                def6 = w7._prepare();
-            }
-        }
-        if (isNew7) {
-            def6 = def6.then(vnode=>{let pvnode=h(vnode.sel, {key: key8});c1[_5_index]=pvnode;pvnode.data.hook = {insert(vn){let nvn=w7._mount(vnode, vn.elm);pvnode.elm=nvn.elm;},remove(){w7.destroy()},destroy(){w7.destroy()}}; w7.__owl__.pvnode = pvnode;});
-        } else {
-            def6 = def6.then(()=>{if (w7.__owl__.isDestroyed) {return};let vnode;if (!w7.__owl__.vnode){vnode=w7.__owl__.pvnode} else { vnode=h(w7.__owl__.vnode.sel, {key: key8});vnode.elm=w7.el;vnode.data.hook = {insert(a){a.elm.parentNode.replaceChild(w7.el,a.elm);a.elm=w7.el;w7.__mount();},remove(){w7.destroy()}, destroy() {w7.destroy()}}}c1[_5_index]=vnode;});
-        }
-        extra.promises.push(def6);
-    }
-    return vn1;
-}"
-`;
-
-exports[`random stuff/miscellaneous snapshotting compiled code 1`] = `
-"function anonymous(context,extra
-) {
-    let owner = context;
-    var h = this.utils.h;
-    var c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
-    //WIDGET
-    let key5 = 'somestring';
-    let _2_index = c1.length;
-    c1.push(null);
-    let def3;
-    let w4 = key5 in context.__owl__.cmap ? context.__owl__.children[context.__owl__.cmap[key5]] : false;
-    let props4 = {flag: context['state'].flag};
-    let isNew4 = !w4;
-    if (w4 && w4.__owl__.renderPromise) {
-        if (w4.__owl__.isStarted) {
-            def3 = w4.updateProps(props4, extra.forceUpdate);
-        } else {
-            isNew4 = true
-            if (props4 === w4.__owl__.renderProps) {
-                def3 = w4.__owl__.renderPromise;
-            } else {
-                w4.destroy();
-                w4 = false
-            }
-        }
-    }
-    if (!def3) {
-        if (w4) {
-            def3 = w4.updateProps(props4, extra.forceUpdate);
-        } else {
-            w4 = new context.widgets['child'](owner, props4);
-            context.__owl__.cmap[key5] = w4.__owl__.id;
-            def3 = w4._prepare();
-        }
-    }
-    if (isNew4) {
-        def3 = def3.then(vnode=>{let pvnode=h(vnode.sel, {key: key5});c1[_2_index]=pvnode;pvnode.data.hook = {insert(vn){let nvn=w4._mount(vnode, vn.elm);pvnode.elm=nvn.elm;},remove(){w4.destroy()},destroy(){w4.destroy()}}; w4.__owl__.pvnode = pvnode;});
-    } else {
-        def3 = def3.then(()=>{if (w4.__owl__.isDestroyed) {return};let vnode;if (!w4.__owl__.vnode){vnode=w4.__owl__.pvnode} else { vnode=h(w4.__owl__.vnode.sel, {key: key5});vnode.elm=w4.el;vnode.data.hook = {insert(a){a.elm.parentNode.replaceChild(w4.el,a.elm);a.elm=w4.el;w4.__mount();},remove(){w4.destroy()}, destroy() {w4.destroy()}}}c1[_2_index]=vnode;});
-    }
-    extra.promises.push(def3);
-    return vn1;
-}"
-`;
-
-exports[`random stuff/miscellaneous t-props should not be undefined (snapshotting) 1`] = `
-"function anonymous(context,extra
-) {
-    let owner = context;
-    var h = this.utils.h;
-    var c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
-    //WIDGET
-    let _2_index = c1.length;
-    c1.push(null);
-    let def3;
-    let w4 = 4 in context.__owl__.cmap ? context.__owl__.children[context.__owl__.cmap[4]] : false;
-    let props4 = {};
-    let isNew4 = !w4;
-    if (w4 && w4.__owl__.renderPromise) {
-        if (w4.__owl__.isStarted) {
-            def3 = w4.updateProps(props4, extra.forceUpdate);
-        } else {
-            isNew4 = true
-            if (props4 === w4.__owl__.renderProps) {
-                def3 = w4.__owl__.renderPromise;
-            } else {
-                w4.destroy();
-                w4 = false
-            }
-        }
-    }
-    if (!def3) {
-        if (w4) {
-            def3 = w4.updateProps(props4, extra.forceUpdate);
-        } else {
-            w4 = new context.widgets['child'](owner, props4);
-            context.__owl__.cmap[4] = w4.__owl__.id;
-            def3 = w4._prepare();
-        }
-    }
-    if (isNew4) {
-        def3 = def3.then(vnode=>{let pvnode=h(vnode.sel, {key: 4});c1[_2_index]=pvnode;pvnode.data.hook = {insert(vn){let nvn=w4._mount(vnode, vn.elm);pvnode.elm=nvn.elm;},remove(){w4.destroy()},destroy(){w4.destroy()}}; w4.__owl__.pvnode = pvnode;});
-    } else {
-        def3 = def3.then(()=>{if (w4.__owl__.isDestroyed) {return};let vnode;if (!w4.__owl__.vnode){vnode=w4.__owl__.pvnode} else { vnode=h(w4.__owl__.vnode.sel, {key: 4});vnode.elm=w4.el;vnode.data.hook = {insert(a){a.elm.parentNode.replaceChild(w4.el,a.elm);a.elm=w4.el;w4.__mount();},remove(){w4.destroy()}, destroy() {w4.destroy()}}}c1[_2_index]=vnode;});
-    }
-    extra.promises.push(def3);
-    return vn1;
-}"
-`;

tests/__snapshots__/store.test.ts.snap

@@ -1,13 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`connecting a component to store connecting a component works 1`] = `"<div></div>"`;
-
-exports[`connecting a component to store connecting a component works 2`] = `"<div><span>hello</span></div>"`;
-
-exports[`connecting a component to store deep and shallow connecting a component 1`] = `"<div><span>Kasteel</span></div>"`;
-
-exports[`connecting a component to store deep and shallow connecting a component 2`] = `"<div><span>Kasteel</span></div>"`;
-
-exports[`connecting a component to store deep and shallow connecting a component 3`] = `"<div><span>Bertinchamps</span></div>"`;
-
-exports[`connecting a component to store deep and shallow connecting a component 4`] = `"<div><span>Kasteel</span></div>"`;

tests/__snapshots__/store_hooks.test.ts.snap

@@ -0,0 +1,5 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`various scenarios scenarios with async store updates and some components events 1`] = `"<div><button>Do stuff</button><div><span>Attachment 100</span><span>Name: text.txt</span></div></div>"`;
+
+exports[`various scenarios scenarios with async store updates and some components events 2`] = `"<div><button>Do stuff</button></div>"`;

tests/animations.test.ts

@@ -0,0 +1,429 @@
+import { Component, Env } from "../src/component/component";
+import { QWeb } from "../src/qweb/index";
+import { useState, useRef } from "../src/hooks";
+import { xml } from "../src/tags";
+import {
+  makeDeferred,
+  makeTestFixture,
+  makeTestEnv,
+  patchNextFrame,
+  renderToDOM,
+  unpatchNextFrame,
+  nextTick
+} from "./helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - qweb: a new QWeb instance
+// - env: a WEnv, necessary to create new components
+// - cssEl: a stylesheet injected into the dom
+
+let fixture: HTMLElement;
+let qweb: QWeb;
+let env: Env;
+let cssEl: HTMLElement;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+  qweb = new QWeb();
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+class Widget extends Component<any, any> {}
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("animations", () => {
+  beforeEach(() => {
+    cssEl = document.createElement("style");
+    let css = `
+      .chimay-enter-active, .chimay-leave-active {
+        transition-property: opacity;
+        transition-duration: 0.1s;
+      }
+      .chimay-enter, .chimay-leave-to {
+        opacity: 0;
+      }
+    `;
+    cssEl.textContent = css.trim();
+    document.head.appendChild(cssEl);
+  });
+
+  afterEach(() => {
+    document.head.removeChild(cssEl);
+    unpatchNextFrame();
+  });
+
+  test("t-transition, on a simple node (insert)", async () => {
+    expect.assertions(5);
+    qweb.addTemplate("test", `<span t-transition="chimay">blue</span>`);
+
+    let def = makeDeferred();
+    patchNextFrame(cb => {
+      expect(node.className).toBe("chimay-enter chimay-enter-active");
+      cb();
+      expect(node.className).toBe("chimay-enter-active chimay-enter-to");
+      def.resolve();
+    });
+    let node: HTMLElement = <HTMLElement>renderToDOM(qweb, "test");
+
+    expect(node.className).toBe("chimay-enter chimay-enter-active");
+    await def; // wait for the mocked repaint to be done
+    node.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(node.className).toBe("");
+  });
+
+  test("t-transition with no delay/duration", async () => {
+    expect.assertions(4);
+    qweb.addTemplate("test", `<span t-transition="jupiler">blue</span>`);
+
+    let def = makeDeferred();
+    patchNextFrame(cb => {
+      expect(node.className).toBe("jupiler-enter jupiler-enter-active");
+      cb();
+      expect(node.className).toBe("");
+      def.resolve();
+    });
+    let node: HTMLElement = <HTMLElement>renderToDOM(qweb, "test");
+    expect(node.className).toBe("jupiler-enter jupiler-enter-active");
+    await def;
+  });
+
+  test("t-transition on a conditional node", async () => {
+    expect.assertions(7);
+
+    env.qweb.addTemplate(
+      "TestWidget",
+      `<div><span t-if="!state.hide" t-transition="chimay">blue</span></div>`
+    );
+    class TestWidget extends Widget {
+      state = useState({ hide: false });
+    }
+    const widget = new TestWidget();
+
+    // insert widget into the DOM
+    let def = makeDeferred();
+    var spanNode;
+    patchNextFrame(cb => {
+      expect(spanNode.className).toBe("chimay-enter chimay-enter-active");
+      cb();
+      expect(spanNode.className).toBe("chimay-enter-active chimay-enter-to");
+      def.resolve();
+    });
+    await widget.mount(fixture);
+    spanNode = widget.el!.children[0];
+    expect(spanNode.className).toBe("chimay-enter chimay-enter-active");
+    await def; // wait for the mocked repaint to be done
+    spanNode.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(spanNode.className).toBe("");
+
+    // remove span from the DOM
+    def = makeDeferred();
+    widget.state.hide = true;
+    patchNextFrame(cb => {
+      expect(spanNode.className).toBe("chimay-leave chimay-leave-active");
+      cb();
+      expect(spanNode.className).toBe("chimay-leave-active chimay-leave-to");
+      def.resolve();
+    });
+    await def; // wait for the mocked repaint to be done
+    spanNode.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(spanNode.className).toBe("");
+  });
+
+  test("t-transition combined with t-ref", async () => {
+    expect.assertions(5);
+
+    env.qweb.addTemplate(
+      "TestWidget",
+      `<div><span t-ref="span" t-transition="chimay">blue</span></div>`
+    );
+    class TestWidget extends Widget {
+      state = useState({ hide: false });
+      span = useRef("span");
+    }
+    const widget = new TestWidget();
+
+    // insert widget into the DOM
+    let def = makeDeferred();
+    var spanNode;
+    patchNextFrame(cb => {
+      expect(spanNode.className).toBe("chimay-enter chimay-enter-active");
+      cb();
+      expect(spanNode.className).toBe("chimay-enter-active chimay-enter-to");
+      def.resolve();
+    });
+    await widget.mount(fixture);
+    spanNode = widget.el!.children[0];
+    expect(widget.span.el).toBe(spanNode);
+    expect(spanNode.className).toBe("chimay-enter chimay-enter-active");
+    await def; // wait for the mocked repaint to be done
+    spanNode.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(spanNode.className).toBe("");
+  });
+
+  test("t-transition combined with component", async () => {
+    expect.assertions(5);
+
+    env.qweb.addTemplate("Parent", `<div><Child t-transition="chimay"/></div>`);
+    env.qweb.addTemplate("Child", `<span>blue</span>`);
+    class Child extends Widget {}
+    class Parent extends Widget {
+      static components = { Child: Child };
+    }
+    const widget = new Parent();
+
+    let def = makeDeferred();
+    var spanNode;
+    patchNextFrame(cb => {
+      expect(fixture.innerHTML).toBe(
+        '<div><span class="chimay-enter chimay-enter-active">blue</span></div>'
+      );
+      cb();
+      expect(fixture.innerHTML).toBe(
+        '<div><span class="chimay-enter-active chimay-enter-to">blue</span></div>'
+      );
+      def.resolve();
+    });
+    await widget.mount(fixture);
+    spanNode = widget.el!.children[0];
+
+    expect(env.qweb.templates.Parent.fn.toString()).toMatchSnapshot();
+    expect(fixture.innerHTML).toBe(
+      '<div><span class="chimay-enter chimay-enter-active">blue</span></div>'
+    );
+
+    await def; // wait for the mocked repaint to be done
+    spanNode.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(fixture.innerHTML).toBe('<div><span class="">blue</span></div>');
+  });
+
+  test("t-transition combined with t-component and t-if", async () => {
+    expect.assertions(8);
+
+    env.qweb.addTemplate(
+      "Parent",
+      `<div><t t-if="state.display" t-component="Child" t-transition="chimay"/></div>`
+    );
+    env.qweb.addTemplate("Child", `<span>blue</span>`);
+    class Child extends Widget {}
+    class Parent extends Widget {
+      static components = { Child: Child };
+      state = useState({ display: true });
+    }
+    const widget = new Parent();
+
+    let def = makeDeferred();
+    var spanNode;
+    patchNextFrame(cb => {
+      expect(fixture.innerHTML).toBe(
+        '<div><span class="chimay-enter chimay-enter-active">blue</span></div>'
+      );
+      cb();
+      expect(fixture.innerHTML).toBe(
+        '<div><span class="chimay-enter-active chimay-enter-to">blue</span></div>'
+      );
+      def.resolve();
+    });
+    await widget.mount(fixture);
+    spanNode = widget.el!.children[0];
+
+    expect(env.qweb.templates.Parent.fn.toString()).toMatchSnapshot();
+    expect(fixture.innerHTML).toBe(
+      '<div><span class="chimay-enter chimay-enter-active">blue</span></div>'
+    );
+
+    await def; // wait for the mocked repaint to be done
+    spanNode.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(fixture.innerHTML).toBe('<div><span class="">blue</span></div>');
+
+    // remove span from the DOM
+    def = makeDeferred();
+    widget.state.display = false;
+    patchNextFrame(cb => {
+      expect(fixture.innerHTML).toBe(
+        '<div><span class="chimay-leave chimay-leave-active" data-owl-key="__3__">blue</span></div>'
+      );
+      cb();
+      expect(fixture.innerHTML).toBe(
+        '<div><span class="chimay-leave-active chimay-leave-to" data-owl-key="__3__">blue</span></div>'
+      );
+      def.resolve();
+    });
+    await def; // wait for the mocked repaint to be done
+    spanNode.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(fixture.innerHTML).toBe("<div></div>");
+  });
+
+  test("t-transition, remove and re-add before transitionend", async () => {
+    expect.assertions(11);
+
+    env.qweb.addTemplates(
+      `<templates>
+        <div t-name="Parent">
+          <button t-on-click="toggle">Toggle</button>
+          <span t-if="state.flag" t-transition="chimay">blue</span>
+        </div>
+      </templates>`
+    );
+    class Parent extends Widget {
+      state = useState({ flag: false });
+
+      toggle() {
+        this.state.flag = !this.state.flag;
+      }
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+    let button = widget.el!.querySelector("button");
+
+    let def = makeDeferred();
+    let phase = "enter";
+    patchNextFrame(cb => {
+      let spans = fixture.querySelectorAll("span");
+      expect(spans.length).toBe(1);
+      expect(spans[0].className).toBe(`chimay-${phase} chimay-${phase}-active`);
+      cb();
+      expect(spans[0].className).toBe(`chimay-${phase}-active chimay-${phase}-to`);
+      def.resolve();
+    });
+
+    // click display the span
+    button!.click();
+    await def; // wait for the mocked repaint to be done
+    widget.el!.querySelector("span")!.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(fixture.innerHTML).toBe('<div><button>Toggle</button><span class="">blue</span></div>');
+
+    // click to remove the span, and click again to re-add it before transitionend
+    def = makeDeferred();
+    phase = "leave";
+    button!.click();
+
+    await def; // wait for the mocked repaint to be done
+    def = makeDeferred();
+    phase = "enter";
+    button!.click();
+
+    await def; // wait for the mocked repaint to be done
+    widget.el!.querySelector("span")!.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(fixture.innerHTML).toBe('<div><button>Toggle</button><span class="">blue</span></div>');
+  });
+
+  test("t-transition combined with t-component, remove and re-add before transitionend", async () => {
+    expect.assertions(12);
+
+    class Child extends Widget {
+      static template = xml`<span>blue</span>`;
+    }
+    class Parent extends Widget {
+      static template = xml`
+        <div t-name="Parent">
+          <t t-if="state.flag" t-component="Child" t-transition="chimay"/>
+        </div>`;
+      static components = { Child };
+      state = useState({ flag: false });
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+    expect(env.qweb.templates[Parent.template].fn.toString()).toMatchSnapshot();
+
+    let def = makeDeferred();
+    let phase = "enter";
+    patchNextFrame(cb => {
+      let spans = fixture.querySelectorAll("span");
+      expect(spans.length).toBe(1);
+      expect(spans[0].className).toBe(`chimay-${phase} chimay-${phase}-active`);
+      cb();
+      expect(spans[0].className).toBe(`chimay-${phase}-active chimay-${phase}-to`);
+      def.resolve();
+    });
+
+    // display the span
+    widget.state.flag = true;
+    await def; // wait for the mocked repaint to be done
+    widget.el!.querySelector("span")!.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(fixture.innerHTML).toBe('<div><span class="">blue</span></div>');
+
+    // click to remove the span, and click again to re-add it before transitionend
+    def = makeDeferred();
+    phase = "leave";
+
+    widget.state.flag = false;
+
+    await def; // wait for the mocked repaint to be done
+    def = makeDeferred();
+    phase = "enter";
+    widget.state.flag = true;
+
+    await def; // wait for the mocked repaint to be done
+    widget.el!.querySelector("span")!.dispatchEvent(new Event("transitionend")); // mock end of css transition
+    expect(fixture.innerHTML).toBe('<div><span class="" data-owl-key="__3__">blue</span></div>');
+  });
+
+  test("transitionInsert is called the correct amount of times", async () => {
+    const oldTransitionInsert = QWeb.utils.transitionInsert;
+    QWeb.utils.transitionInsert = jest.fn(oldTransitionInsert);
+
+    class Child extends Widget {
+      static template = xml`<span>blue</span>`;
+    }
+    class Parent extends Widget {
+      static template = xml`
+        <div t-name="Parent">
+          <Child t-if="state.flag" t-transition="chimay"/>
+        </div>`;
+      static components = { Child };
+      state = useState({ flag: false });
+    }
+
+    patchNextFrame(cb => cb());
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+
+    widget.state.flag = true;
+
+    await nextTick();
+    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();
+    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();
+    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();
+    widget.state.flag = true;
+    await nextTick();
+
+    expect(QWeb.utils.transitionInsert).toBeCalledTimes(3);
+    widget.el!.querySelector("span")!.dispatchEvent(new Event("transitionend"));
+    expect(fixture.innerHTML).toBe('<div><span class="" data-owl-key="__3__">blue</span></div>');
+    QWeb.utils.transitionInsert = oldTransitionInsert;
+  });
+});

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

@@ -0,0 +1,39 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`props validation props are validated in dev mode (code snapshot) 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"App\\"
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    // Component 'Child'
+    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let props2 = {message:1};
+    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+        w2.destroy();
+        w2 = false;
+    }
+    if (w2) {
+        w2.__updateProps(props2, extra.fiber, undefined);
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`Child\`;
+        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Child'];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        let fiber = w2.__prepare(extra.fiber, undefined, () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        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;
+}"
+`;

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

@@ -0,0 +1,488 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`t-slot directive can define and call slots 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"Parent\\"
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = [], p1 = {key:1};
+    let vn1 = h('div', p1, c1);
+    // Component 'Dialog'
+    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let props2 = {};
+    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+        w2.destroy();
+        w2 = false;
+    }
+    if (w2) {
+        w2.__updateProps(props2, extra.fiber, Object.assign(Object.create(context), scope));
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`Dialog\`;
+        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Dialog'];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        w2.__owl__.slotId = 1;
+        let fiber = w2.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
+        c1.push(pvnode);
+        w2.__owl__.pvnode = pvnode;
+    }
+    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
+exports[`t-slot directive can define and call slots 2`] = `
+"function anonymous(context, extra
+) {
+    // 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 c9 = [], p9 = {key:9};
+    let vn9 = h('div', p9, c9);
+    c6.push(vn9);
+    const slot10 = this.constructor.slots[context.__owl__.slotId + '_' + 'footer'];
+    if (slot10) {
+        slot10.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c9, parent: extra.parent || context}));
+    }
+    return vn6;
+}"
+`;
+
+exports[`t-slot directive can define and call slots 3`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_header_template\\"
+    let h = this.h;
+    let c1 = extra.parentNode;
+    let c4 = [], p4 = {key:4};
+    let vn4 = h('span', p4, c4);
+    c1.push(vn4);
+    c4.push({text: \`header\`});
+}"
+`;
+
+exports[`t-slot directive can define and call slots 4`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_footer_template\\"
+    let h = this.h;
+    let c1 = extra.parentNode;
+    let c5 = [], p5 = {key:5};
+    let vn5 = h('span', p5, c5);
+    c1.push(vn5);
+    c5.push({text: \`footer\`});
+}"
+`;
+
+exports[`t-slot directive content is the default slot 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_default_template\\"
+    let h = this.h;
+    let c1 = extra.parentNode;
+    let c4 = [], p4 = {key:4};
+    let vn4 = h('span', p4, c4);
+    c1.push(vn4);
+    c4.push({text: \`sts rocks\`});
+}"
+`;
+
+exports[`t-slot directive dafault slots can define a default content 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}));
+    } else {
+        c4.push({text: \`default content\`});
+    }
+    return vn4;
+}"
+`;
+
+exports[`t-slot directive default slot work with text nodes 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_default_template\\"
+    let h = this.h;
+    let c1 = extra.parentNode;
+    c1.push({text: \`sts rocks\`});
+}"
+`;
+
+exports[`t-slot directive multiple roots are allowed in a default slot 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_default_template\\"
+    let h = this.h;
+    let c1 = extra.parentNode;
+    let c4 = [], p4 = {key:4};
+    let vn4 = h('span', p4, c4);
+    c1.push(vn4);
+    c4.push({text: \`sts\`});
+    let c5 = [], p5 = {key:5};
+    let vn5 = h('span', p5, c5);
+    c1.push(vn5);
+    c5.push({text: \`rocks\`});
+}"
+`;
+
+exports[`t-slot directive multiple roots are allowed in a named slot 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_content_template\\"
+    let h = this.h;
+    let c1 = extra.parentNode;
+    let c4 = [], p4 = {key:4};
+    let vn4 = h('span', p4, c4);
+    c1.push(vn4);
+    c4.push({text: \`sts\`});
+    let c5 = [], p5 = {key:5};
+    let vn5 = h('span', p5, c5);
+    c1.push(vn5);
+    c5.push({text: \`rocks\`});
+}"
+`;
+
+exports[`t-slot directive named slots can define a default content 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 + '_' + 'header'];
+    if (slot5) {
+        slot5.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: c4, parent: extra.parent || context}));
+    } else {
+        c4.push({text: \`default content\`});
+    }
+    return vn4;
+}"
+`;
+
+exports[`t-slot directive refs are properly bound in slots 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_footer_template\\"
+    let utils = this.constructor.utils;
+    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 = {
+      create: (_, n) => {
+        context.__owl__.refs[ref10] = n.elm;
+      },
+      destroy: () => {
+        delete context.__owl__.refs[ref10];
+      },
+    };
+    c8.push({text: \`do something\`});
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_footer_template\\"
+    let utils = this.constructor.utils;
+    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\`});
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context, part 2 1`] = `
+"function anonymous(context, extra
+) {
+    // 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}));
+    }
+    return vn12;
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context, part 2 2`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"App\\"
+    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 = [], p2 = {key:2};
+    let vn2 = h('u', p2, c2);
+    c1.push(vn2);
+    let _3 = scope['state'].users;
+    if (!_3) { throw new Error('QWeb error: Invalid loop expression')}
+    let _4 = _5 = _3;
+    if (!(_3 instanceof Array)) {
+        _4 = Object.keys(_3);
+        _5 = Object.values(_3);
+    }
+    let _length4 = _4.length;
+    let _origScope6 = scope;
+    scope = Object.create(scope);
+    for (let i1 = 0; i1 < _length4; i1++) {
+        scope.user_first = i1 === 0
+        scope.user_last = i1 === _length4 - 1
+        scope.user_index = i1
+        scope.user = _4[i1]
+        scope.user_value = _5[i1]
+        let key1 = scope['user'].id;
+        let c7 = [], p7 = {key:\`\${key1}_7\`};
+        let vn7 = h('li', p7, c7);
+        c2.push(vn7);
+        // Component 'Link'
+        let k9 = \`__9__\${key1}__\`;
+        let w8 = k9 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k9]] : false;
+        let props8 = {to:'/user/'+scope['user'].id};
+        if (w8 && w8.__owl__.currentFiber && !w8.__owl__.vnode) {
+            w8.destroy();
+            w8 = false;
+        }
+        if (w8) {
+            w8.__updateProps(props8, extra.fiber, Object.assign(Object.create(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'];
+            if (!W8) {throw new Error('Cannot find the definition of component \\"' + componentKey8 + '\\"')}
+            w8 = new W8(parent, props8);
+            parent.__owl__.cmap[k9] = w8.__owl__.id;
+            w8.__owl__.slotId = 1;
+            let fiber = w8.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+            let pvnode = h('dummy', {key: k9, hook: {remove() {},destroy(vn) {w8.destroy();}}});
+            c7.push(pvnode);
+            w8.__owl__.pvnode = pvnode;
+        }
+        w8.__owl__.parentLastFiberId = extra.fiber.id;
+    }
+    scope = _origScope6;
+    return vn1;
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context, part 2 3`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_default_template\\"
+    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});
+    }
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context, part 3 1`] = `
+"function anonymous(context, extra
+) {
+    // 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}));
+    }
+    return vn11;
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context, part 3 2`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"App\\"
+    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 = [], p2 = {key:2};
+    let vn2 = h('u', p2, c2);
+    c1.push(vn2);
+    let _3 = scope['state'].users;
+    if (!_3) { throw new Error('QWeb error: Invalid loop expression')}
+    let _4 = _5 = _3;
+    if (!(_3 instanceof Array)) {
+        _4 = Object.keys(_3);
+        _5 = Object.values(_3);
+    }
+    let _length4 = _4.length;
+    let _origScope6 = scope;
+    scope = Object.create(scope);
+    for (let i1 = 0; i1 < _length4; i1++) {
+        scope.user_first = i1 === 0
+        scope.user_last = i1 === _length4 - 1
+        scope.user_index = i1
+        scope.user = _4[i1]
+        scope.user_value = _5[i1]
+        let key1 = scope['user'].id;
+        let c7 = [], p7 = {key:\`\${key1}_7\`};
+        let vn7 = h('li', p7, c7);
+        c2.push(vn7);
+        utils.getScope(scope, 'userdescr').userdescr = 'User '+scope['user'].name;
+        // Component 'Link'
+        let k9 = \`__9__\${key1}__\`;
+        let w8 = k9 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[k9]] : false;
+        let props8 = {to:'/user/'+scope['user'].id};
+        if (w8 && w8.__owl__.currentFiber && !w8.__owl__.vnode) {
+            w8.destroy();
+            w8 = false;
+        }
+        if (w8) {
+            w8.__updateProps(props8, extra.fiber, Object.assign(Object.create(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'];
+            if (!W8) {throw new Error('Cannot find the definition of component \\"' + componentKey8 + '\\"')}
+            w8 = new W8(parent, props8);
+            parent.__owl__.cmap[k9] = w8.__owl__.id;
+            w8.__owl__.slotId = 1;
+            let fiber = w8.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+            let pvnode = h('dummy', {key: k9, hook: {remove() {},destroy(vn) {w8.destroy();}}});
+            c7.push(pvnode);
+            w8.__owl__.pvnode = pvnode;
+        }
+        w8.__owl__.parentLastFiberId = extra.fiber.id;
+    }
+    scope = _origScope6;
+    return vn1;
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context, part 3 3`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_default_template\\"
+    let scope = Object.create(context);
+    let h = this.h;
+    let c7 = extra.parentNode;
+    if (scope.userdescr != null) {
+        c7.push({text: scope.userdescr});
+    }
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context, part 4 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"App\\"
+    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);
+    scope.userdescr = 'User '+scope['state'].user.name;
+    // Component 'Link'
+    let w2 = '__3__' in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap['__3__']] : false;
+    let props2 = {to:'/user/'+scope['state'].user.id};
+    if (w2 && w2.__owl__.currentFiber && !w2.__owl__.vnode) {
+        w2.destroy();
+        w2 = false;
+    }
+    if (w2) {
+        w2.__updateProps(props2, extra.fiber, Object.assign(Object.create(context), scope));
+        let pvnode = w2.__owl__.pvnode;
+        c1.push(pvnode);
+    } else {
+        let componentKey2 = \`Link\`;
+        let W2 = context.constructor.components[componentKey2] || QWeb.components[componentKey2]|| scope['Link'];
+        if (!W2) {throw new Error('Cannot find the definition of component \\"' + componentKey2 + '\\"')}
+        w2 = new W2(parent, props2);
+        parent.__owl__.cmap['__3__'] = w2.__owl__.id;
+        w2.__owl__.slotId = 1;
+        let fiber = w2.__prepare(extra.fiber, Object.assign(Object.create(context), scope), () => { const vnode = fiber.vnode; pvnode.sel = vnode.sel; });
+        let pvnode = h('dummy', {key: '__3__', hook: {remove() {},destroy(vn) {w2.destroy();}}});
+        c1.push(pvnode);
+        w2.__owl__.pvnode = pvnode;
+    }
+    w2.__owl__.parentLastFiberId = extra.fiber.id;
+    return vn1;
+}"
+`;
+
+exports[`t-slot directive slots are rendered with proper context, part 4 2`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"slot_default_template\\"
+    let scope = Object.create(context);
+    let h = this.h;
+    let c1 = extra.parentNode;
+    if (scope.userdescr != null) {
+        c1.push({text: scope.userdescr});
+    }
+}"
+`;
+
+exports[`t-slot directive template can just return a slot 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__2\\"
+    let utils = this.constructor.utils;
+    let result;
+    let h = this.h;
+    const slot6 = this.constructor.slots[context.__owl__.slotId + '_' + 'default'];
+    if (slot6) {
+        let children7= []
+        result = {}
+        slot6.call(this, context.__owl__.scope, Object.assign({}, extra, {parentNode: children7, parent: extra.parent || context}));
+        utils.defineProxy(result, children7[0]);
+    }
+    return result;
+}"
+`;

tests/component/props_validation.test.ts

@@ -0,0 +1,843 @@
+import { Component, Env } from "../../src/component/component";
+import { makeTestFixture, makeTestEnv, nextTick } from "../helpers";
+import { useState } from "../../src/hooks";
+import { QWeb } from "../../src/qweb";
+import { xml } from "../../src/tags";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+let fixture: HTMLElement;
+let env: Env;
+let dev: boolean = false;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+  dev = QWeb.dev;
+  QWeb.dev = true;
+});
+
+afterEach(() => {
+  fixture.remove();
+  QWeb.dev = dev;
+});
+
+class Widget extends Component<any, any> {}
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+describe("props validation", () => {
+  test("validation is only done in dev mode", async () => {
+    class TestWidget extends Widget {
+      static props = ["message"];
+      static template = xml`<div>hey</div>`;
+    }
+    class Parent extends Widget {
+      static components = { TestWidget };
+      static template = xml`<div><TestWidget /></div>`;
+    }
+
+    let error;
+    QWeb.dev = true;
+    try {
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe(`Missing props 'message' (component 'TestWidget')`);
+
+    error = undefined;
+
+    QWeb.dev = false;
+    try {
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+  });
+
+  test("props: list of strings", async () => {
+    class TestWidget extends Widget {
+      static props = ["message"];
+      static template = xml`<div>hey</div>`;
+    }
+    class Parent extends Widget {
+      static components = { TestWidget };
+      static template = xml`<div><TestWidget /></div>`;
+    }
+
+    let error;
+    try {
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe(`Missing props 'message' (component 'TestWidget')`);
+  });
+
+  test("validate simple types", async () => {
+    const Tests = [
+      { type: Number, ok: 1, ko: "1" },
+      { type: Boolean, ok: true, ko: "1" },
+      { type: String, ok: "1", ko: 1 },
+      { type: Object, ok: {}, ko: "1" },
+      { type: Date, ok: new Date(), ko: "1" },
+      { type: Function, ok: () => {}, ko: "1" }
+    ];
+
+    let props;
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="p"/></div>`;
+      get p() {
+        return props.p;
+      }
+    }
+    for (let test of Tests) {
+      let TestWidget = class extends Widget {
+        static template = xml`<div>hey</div>`;
+        static props = { p: test.type };
+      };
+      Parent.components = { TestWidget };
+
+      let error;
+      props = {};
+      try {
+        const p = new Parent();
+        await p.mount(fixture);
+      } catch (e) {
+        error = e;
+      }
+      expect(error).toBeDefined();
+      expect(error.message).toBe(`Missing props 'p' (component '_a')`);
+
+      error = undefined;
+      props = { p: test.ok };
+      try {
+        const p = new Parent();
+        await p.mount(fixture);
+      } catch (e) {
+        error = e;
+      }
+      expect(error).toBeUndefined();
+
+      props = { p: test.ko };
+      try {
+        const p = new Parent();
+        await p.mount(fixture);
+      } catch (e) {
+        error = e;
+      }
+      expect(error).toBeDefined();
+      expect(error.message).toBe("Invalid Prop 'p' in component '_a'");
+    }
+  });
+
+  test("validate simple types, alternate form", async () => {
+    const Tests = [
+      { type: Number, ok: 1, ko: "1" },
+      { type: Boolean, ok: true, ko: "1" },
+      { type: String, ok: "1", ko: 1 },
+      { type: Object, ok: {}, ko: "1" },
+      { type: Date, ok: new Date(), ko: "1" },
+      { type: Function, ok: () => {}, ko: "1" }
+    ];
+
+    let props;
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="p"/></div>`;
+      get p() {
+        return props.p;
+      }
+    }
+    for (let test of Tests) {
+      let TestWidget = class extends Component<any, any> {
+        static props = { p: { type: test.type } };
+        static template = xml`<div>hey</div>`;
+      };
+      Parent.components = { TestWidget };
+
+      let error;
+      props = {};
+      try {
+        const p = new Parent();
+        await p.mount(fixture);
+      } catch (e) {
+        error = e;
+      }
+      expect(error).toBeDefined();
+      expect(error.message).toBe(`Missing props 'p' (component '_a')`);
+
+      error = undefined;
+      props = { p: test.ok };
+      try {
+        const p = new Parent();
+        await p.mount(fixture);
+      } catch (e) {
+        error = e;
+      }
+      expect(error).toBeUndefined();
+
+      props = { p: test.ko };
+      try {
+        const p = new Parent();
+        await p.mount(fixture);
+      } catch (e) {
+        error = e;
+      }
+      expect(error).toBeDefined();
+      expect(error.message).toBe("Invalid Prop 'p' in component '_a'");
+    }
+  });
+
+  test("can validate a prop with multiple types", async () => {
+    class TestWidget extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      static props = { p: [String, Boolean] };
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="p"/></div>`;
+      static components = { TestWidget };
+      get p() {
+        return props.p;
+      }
+    }
+
+    let error;
+    let props;
+    try {
+      props = { p: "string" };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: true };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: 1 };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'p' in component 'TestWidget'");
+  });
+
+  test("can validate an optional props", async () => {
+    class TestWidget extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      static props = { p: { type: String, optional: true } };
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="p"/></div>`;
+      static components = { TestWidget };
+      get p() {
+        return props.p;
+      }
+    }
+
+    let error;
+    let props;
+    try {
+      props = { p: "key" };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = {};
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: 1 };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'p' in component 'TestWidget'");
+  });
+
+  test("can validate an array with given primitive type", async () => {
+    class TestWidget extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      static props = { p: { type: Array, element: String } };
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="p"/></div>`;
+      static components = { TestWidget };
+      get p() {
+        return props.p;
+      }
+    }
+
+    let error;
+    let props;
+    try {
+      props = { p: [] };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: ["string"] };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: [1] };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+
+    error = undefined;
+    try {
+      props = { p: ["string", 1] };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+  });
+
+  test("can validate an array with multiple sub element types", async () => {
+    class TestWidget extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      static props = { p: { type: Array, element: [String, Boolean] } };
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="p"/></div>`;
+      static components = { TestWidget };
+      get p() {
+        return props.p;
+      }
+    }
+
+    let error;
+    let props;
+    try {
+      props = { p: [] };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: ["string"] };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: [false, true, "string"] };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: [true, 1] };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'p' in component 'TestWidget'");
+  });
+
+  test("can validate an object with simple shape", async () => {
+    class TestWidget extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      static props = {
+        p: { type: Object, shape: { id: Number, url: String } }
+      };
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="p"/></div>`;
+      static components = { TestWidget };
+      get p() {
+        return props.p;
+      }
+    }
+
+    let error;
+    let props;
+    try {
+      props = { p: { id: 1, url: "url" } };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: { id: 1, url: "url", extra: true } };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid prop 'p' in component TestWidget (unknown prop 'extra')");
+
+    try {
+      props = { p: { id: "1", url: "url" } };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'p' in component 'TestWidget'");
+
+    error = undefined;
+    try {
+      props = { p: { id: 1 } };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'p' in component 'TestWidget'");
+  });
+
+  test("can validate recursively complicated prop def", async () => {
+    class TestWidget extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      static props = {
+        p: {
+          type: Object,
+          shape: {
+            id: Number,
+            url: [Boolean, { type: Array, element: Number }]
+          }
+        }
+      };
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="p"/></div>`;
+      static components = { TestWidget };
+      get p() {
+        return props.p;
+      }
+    }
+
+    let error;
+    let props;
+    try {
+      props = { p: { id: 1, url: true } };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: { id: 1, url: [12] } };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      props = { p: { id: 1, url: [12, true] } };
+      const p = new Parent();
+      await p.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'p' in component 'TestWidget'");
+  });
+
+  test("can validate optional attributes in nested sub props", () => {
+    class TestComponent extends Component<any, any> {
+      static props = {
+        myprop: {
+          type: Array,
+          element: {
+            type: Object,
+            shape: {
+              num: { type: Number, optional: true }
+            }
+          }
+        }
+      };
+    }
+    let error;
+    try {
+      QWeb.utils.validateProps(TestComponent, { myprop: [{}] });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      QWeb.utils.validateProps(TestComponent, { myprop: [{ a: 1 }] });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe(
+      "Invalid prop 'myprop' in component TestComponent (unknown prop 'a')"
+    );
+  });
+
+  test("can validate with a custom validator", () => {
+    class TestComponent extends Component<any, any> {
+      static props = {
+        size: {
+          validate: e => ["small", "medium", "large"].includes(e)
+        }
+      };
+    }
+    let error;
+    try {
+      QWeb.utils.validateProps(TestComponent, { size: "small" });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+
+    try {
+      QWeb.utils.validateProps(TestComponent, { size: "abcdef" });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'size' in component 'TestComponent'");
+  });
+
+  test("can validate with a custom validator, and a type", () => {
+    const validator = jest.fn(n => 0 <= n && n <= 10);
+    class TestComponent extends Component<any, any> {
+      static props = {
+        n: {
+          type: Number,
+          validate: validator
+        }
+      };
+    }
+    let error;
+    try {
+      QWeb.utils.validateProps(TestComponent, { n: 3 });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+    expect(validator).toBeCalledTimes(1);
+
+    try {
+      QWeb.utils.validateProps(TestComponent, { n: "str" });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'n' in component 'TestComponent'");
+    expect(validator).toBeCalledTimes(1);
+
+    error = null;
+    try {
+      QWeb.utils.validateProps(TestComponent, { n: 100 });
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Invalid Prop 'n' in component 'TestComponent'");
+    expect(validator).toBeCalledTimes(2);
+  });
+
+  test("props are validated in dev mode (code snapshot)", async () => {
+    env.qweb.addTemplates(`
+      <templates>
+        <div t-name="App">
+          <Child message="1"/>
+        </div>
+        <div t-name="Child"><t t-esc="props.message"/></div>
+      </templates>`);
+
+    class Child extends Widget {
+      static props = ["message"];
+    }
+    class App extends Widget {
+      static components = { Child };
+    }
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>1</div></div>");
+    // need to make sure there are 2 call to update props. one at component
+    // creation, and one at update time.
+    expect(env.qweb.templates.App.fn.toString()).toMatchSnapshot();
+  });
+
+  test("props: list of strings with optional props", async () => {
+    class TestWidget extends Widget {
+      static props = ["message", "someProp?"];
+    }
+
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { someProp: 1 });
+    }).toThrow();
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { message: 1 });
+    }).not.toThrow();
+  });
+
+  test("props: can be defined with a boolean", async () => {
+    class TestWidget extends Widget {
+      static props = { message: true };
+    }
+
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, {});
+    }).toThrow();
+  });
+
+  test("props with type array, and no element", async () => {
+    class TestWidget extends Widget {
+      static props = { myprop: { type: Array } };
+    }
+
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { myprop: [1] });
+    }).not.toThrow();
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { myprop: 1 });
+    }).toThrow(`Invalid Prop 'myprop' in component 'TestWidget'`);
+  });
+
+  test("props with type object, and no shape", async () => {
+    class TestWidget extends Widget {
+      static props = { myprop: { type: Object } };
+    }
+
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { myprop: { a: 3 } });
+    }).not.toThrow();
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { myprop: false });
+    }).toThrow(`Invalid Prop 'myprop' in component 'TestWidget'`);
+  });
+
+  test("props: extra props cause an error", async () => {
+    class TestWidget extends Widget {
+      static props = ["message"];
+    }
+
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { message: 1, flag: true });
+    }).toThrow();
+  });
+
+  test("props: extra props cause an error, part 2", async () => {
+    class TestWidget extends Widget {
+      static props = { message: true };
+    }
+
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { message: 1, flag: true });
+    }).toThrow();
+  });
+
+  test("props: optional prop do not cause an error", async () => {
+    class TestWidget extends Widget {
+      static props = ["message?"];
+    }
+
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { message: 1 });
+    }).not.toThrow();
+  });
+
+  test("optional prop do not cause an error if value is undefined", async () => {
+    class TestWidget extends Widget {
+      static props = { message: { type: String, optional: true } };
+    }
+
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { message: undefined });
+    }).not.toThrow();
+    expect(() => {
+      QWeb.utils.validateProps(TestWidget, { message: null });
+    }).toThrow();
+  });
+
+  test("missing required boolean prop causes an error", async () => {
+    class TestWidget extends Widget {
+      static props = ["p"];
+      static template = xml`<span><t t-if="props.p">hey</t></span>`;
+    }
+
+    class App extends Widget {
+      static template = xml`<div><TestWidget/></div>`;
+      static components = { TestWidget };
+    }
+
+    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 'p' (component 'TestWidget')");
+  });
+
+  test("props are validated whenever component is updated", async () => {
+    let error;
+    class TestWidget extends Component<any, any> {
+      static props = { p: { type: Number } };
+      static template = xml`<div><t t-esc="props.p"/></div>`;
+
+      async __updateProps() {
+        try {
+          await Component.prototype.__updateProps.apply(this, arguments);
+        } catch (e) {
+          error = e;
+        }
+      }
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="state.p"/></div>`;
+      static components = { TestWidget };
+      state: any = useState({ p: 1 });
+    }
+
+    const w = new Parent();
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>1</div></div>");
+
+    w.state.p = undefined;
+    await nextTick();
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Missing props 'p' (component 'TestWidget')");
+  });
+
+  test("default values are applied before validating props at update", async () => {
+    class TestWidget extends Component<any, any> {
+      static props = { p: { type: Number } };
+      static template = xml`<div><t t-esc="props.p"/></div>`;
+      static defaultProps = { p: 4 };
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget p="state.p"/></div>`;
+      static components = { TestWidget };
+      state: any = useState({ p: 1 });
+    }
+
+    const w = new Parent();
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>1</div></div>");
+
+    w.state.p = undefined;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div>4</div></div>");
+  });
+});
+
+describe("default props", () => {
+  test("can set default values", async () => {
+    class TestWidget extends Component<any, any> {
+      static defaultProps = { p: 4 };
+      static template = xml`<div><t t-esc="props.p"/></div>`;
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><TestWidget /></div>`;
+      static components = { TestWidget };
+    }
+
+    const w = new Parent();
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>4</div></div>");
+  });
+
+  test("default values are also set whenever component is updated", async () => {
+    class TestWidget extends Widget {
+      static template = xml`<div><t t-esc="props.p"/></div>`;
+      static defaultProps = { p: 4 };
+    }
+    class Parent extends Widget {
+      static template = xml`<div><TestWidget p="state.p"/></div>`;
+      static components = { TestWidget };
+      state: any = useState({ p: 1 });
+    }
+
+    const w = new Parent();
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>1</div></div>");
+
+    w.state.p = undefined;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><div>4</div></div>");
+  });
+
+  test("can set default required boolean values", async () => {
+    class TestWidget extends Widget {
+      static props = ["p", "q"];
+      static defaultProps = { p: true, q: false };
+      static template = xml`<span><t t-if="props.p">hey</t><t t-if="!props.q">hey</t></span>`;
+    }
+
+    class App extends Widget {
+      static template = xml`<div><TestWidget/></div>`;
+      static components = { TestWidget };
+    }
+
+    const w = new App(undefined, {});
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>heyhey</span></div>");
+  });
+});

tests/component/slots.test.ts

@@ -0,0 +1,876 @@
+import { Component, Env } from "../../src/component/component";
+import { QWeb } from "../../src/qweb/qweb";
+import { xml } from "../../src/tags";
+import { useState, useRef } from "../../src/hooks";
+import { makeTestFixture, makeTestEnv, nextTick } from "../helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - env: a WEnv, necessary to create new components
+
+let fixture: HTMLElement;
+let env: Env;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+function children(w: Component<any, any>): Component<any, any>[] {
+  const childrenMap = w.__owl__.children;
+  return Object.keys(childrenMap).map(id => childrenMap[id]);
+}
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("t-slot directive", () => {
+  test("can define and call slots", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+               <Dialog>
+                  <t t-set="header"><span>header</span></t>
+                  <t t-set="footer"><span>footer</span></t>
+               </Dialog>
+            </div>
+            <div t-name="Dialog">
+              <div><t t-slot="header"/></div>
+              <div><t t-slot="footer"/></div>
+            </div>
+          </templates>
+      `);
+    class Dialog extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(
+      "<div><div><div><span>header</span></div><div><span>footer</span></div></div></div>"
+    );
+    expect(env.qweb.templates.Parent.fn.toString()).toMatchSnapshot();
+    expect(env.qweb.templates.Dialog.fn.toString()).toMatchSnapshot();
+    expect(QWeb.slots["1_header"].toString()).toMatchSnapshot();
+    expect(QWeb.slots["1_footer"].toString()).toMatchSnapshot();
+  });
+
+  test("named slots can define a default content", async () => {
+    class Dialog extends Component<any, any> {
+      static template = xml`
+          <span>
+            <t t-slot="header">default content</t>
+          </span>`;
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Dialog/></div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>default content</span></div>");
+    expect(env.qweb.templates[Dialog.template].fn.toString()).toMatchSnapshot();
+  });
+
+  test("dafault slots can define a default content", async () => {
+    class Dialog extends Component<any, any> {
+      static template = xml`
+          <span>
+            <t t-slot="default">default content</t>
+          </span>`;
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Dialog/></div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>default content</span></div>");
+    expect(env.qweb.templates[Dialog.template].fn.toString()).toMatchSnapshot();
+  });
+
+  test("default content is not rendered if slot is provided", async () => {
+    class Dialog extends Component<any, any> {
+      static template = xml`
+          <span>
+            <t t-slot="default">default content</t>
+          </span>`;
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Dialog>hey</Dialog></div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>hey</span></div>");
+  });
+
+  test("default content is not rendered if named slot is provided", async () => {
+    class Dialog extends Component<any, any> {
+      static template = xml`
+          <span>
+            <t t-slot="header">default content</t>
+          </span>`;
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Dialog><t t-set="header">hey</t></Dialog></div>`;
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>hey</span></div>");
+  });
+
+  test("slots are rendered with proper context", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+              <span class="counter"><t t-esc="state.val"/></span>
+              <Dialog>
+                <t t-set="footer"><button t-on-click="doSomething">do something</button></t>
+              </Dialog>
+            </div>
+            <span t-name="Dialog"><t t-slot="footer"/></span>
+          </templates>
+      `);
+    class Dialog extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Dialog };
+      state = useState({ val: 0 });
+      doSomething() {
+        this.state.val++;
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(
+      '<div><span class="counter">0</span><span><button>do something</button></span></div>'
+    );
+
+    fixture.querySelector("button")!.click();
+    await nextTick();
+
+    expect(fixture.innerHTML).toBe(
+      '<div><span class="counter">1</span><span><button>do something</button></span></div>'
+    );
+    expect(QWeb.slots["1_footer"].toString()).toMatchSnapshot();
+  });
+
+  test("slots are rendered with proper context, part 2", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+              <a t-name="Link" t-att-href="props.to">
+                  <t t-slot="default"/>
+              </a>
+              <div t-name="App">
+                  <u><li t-foreach="state.users" t-as="user" t-key="user.id">
+                      <Link to="'/user/' + user.id">User <t t-esc="user.name"/></Link>
+                  </li></u>
+              </div>
+          </templates>
+      `);
+    class Link extends Component<any, any> {}
+
+    class App extends Component<any, any> {
+      state = useState({
+        users: [
+          { id: 1, name: "Aaron" },
+          { id: 2, name: "David" }
+        ]
+      });
+      static components = { Link };
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(
+      '<div><u><li><a href="/user/1">User Aaron</a></li><li><a href="/user/2">User David</a></li></u></div>'
+    );
+    expect(env.qweb.templates.Link.fn.toString()).toMatchSnapshot();
+    expect(env.qweb.templates.App.fn.toString()).toMatchSnapshot();
+
+    // test updateprops here
+    app.state.users[1].name = "Mathieu";
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div><u><li><a href="/user/1">User Aaron</a></li><li><a href="/user/2">User Mathieu</a></li></u></div>'
+    );
+    expect(QWeb.slots["1_default"].toString()).toMatchSnapshot();
+  });
+
+  test("slots are rendered with proper context, part 3", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+              <a t-name="Link" t-att-href="props.to">
+                  <t t-slot="default"/>
+              </a>
+              <div t-name="App">
+                  <u><li t-foreach="state.users" t-as="user" t-key="user.id" >
+                      <t t-set="userdescr" t-value="'User ' + user.name"/>
+                      <Link to="'/user/' + user.id"><t t-esc="userdescr"/></Link>
+                  </li></u>
+              </div>
+          </templates>
+      `);
+    class Link extends Component<any, any> {}
+
+    class App extends Component<any, any> {
+      state = useState({
+        users: [
+          { id: 1, name: "Aaron" },
+          { id: 2, name: "David" }
+        ]
+      });
+      static components = { Link };
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(
+      '<div><u><li><a href="/user/1">User Aaron</a></li><li><a href="/user/2">User David</a></li></u></div>'
+    );
+    expect(env.qweb.templates.Link.fn.toString()).toMatchSnapshot();
+    expect(env.qweb.templates.App.fn.toString()).toMatchSnapshot();
+
+    // test updateprops here
+    app.state.users[1].name = "Mathieu";
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      '<div><u><li><a href="/user/1">User Aaron</a></li><li><a href="/user/2">User Mathieu</a></li></u></div>'
+    );
+    expect(QWeb.slots["1_default"].toString()).toMatchSnapshot();
+  });
+
+  test("slots are rendered with proper context, part 4", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+              <a t-name="Link" t-att-href="props.to">
+                  <t t-slot="default"/>
+              </a>
+              <div t-name="App">
+                  <t t-set="userdescr" t-value="'User ' + state.user.name"/>
+                  <Link to="'/user/' + state.user.id"><t t-esc="userdescr"/></Link>
+              </div>
+          </templates>
+      `);
+    class Link extends Component<any, any> {}
+
+    class App extends Component<any, any> {
+      state = useState({ user: { id: 1, name: "Aaron" } });
+      static components = { Link };
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+
+    expect(fixture.innerHTML).toBe('<div><a href="/user/1">User Aaron</a></div>');
+
+    expect(env.qweb.templates.App.fn.toString()).toMatchSnapshot();
+
+    // test updateprops here
+    app.state.user.name = "David";
+    await nextTick();
+    expect(fixture.innerHTML).toBe('<div><a href="/user/1">User David</a></div>');
+    expect(QWeb.slots["1_default"].toString()).toMatchSnapshot();
+  });
+
+  test("refs are properly bound in slots", async () => {
+    class Dialog extends Component<any, any> {
+      static template = xml`<span><t t-slot="footer"/></span>`;
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`
+            <div>
+              <span class="counter"><t t-esc="state.val"/></span>
+              <Dialog>
+                <t t-set="footer"><button t-ref="myButton" t-on-click="doSomething">do something</button></t>
+              </Dialog>
+            </div>
+          `;
+      static components = { Dialog };
+      state = useState({ val: 0 });
+      button = useRef("myButton");
+      doSomething() {
+        this.state.val++;
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(
+      '<div><span class="counter">0</span><span><button>do something</button></span></div>'
+    );
+
+    parent.button.el!.click();
+    await nextTick();
+
+    expect(fixture.innerHTML).toBe(
+      '<div><span class="counter">1</span><span><button>do something</button></span></div>'
+    );
+    expect(QWeb.slots["1_footer"].toString()).toMatchSnapshot();
+  });
+
+  test("content is the default slot", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+               <Dialog>
+                  <span>sts rocks</span>
+               </Dialog>
+            </div>
+            <div t-name="Dialog"><t t-slot="default"/></div>
+          </templates>
+      `);
+    class Dialog extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><div><span>sts rocks</span></div></div>");
+    expect(QWeb.slots["1_default"].toString()).toMatchSnapshot();
+  });
+
+  test("default slot work with text nodes", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+               <Dialog>sts rocks</Dialog>
+            </div>
+            <div t-name="Dialog"><t t-slot="default"/></div>
+          </templates>
+      `);
+    class Dialog extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><div>sts rocks</div></div>");
+    expect(QWeb.slots["1_default"].toString()).toMatchSnapshot();
+  });
+
+  test("multiple roots are allowed in a named slot", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+               <Dialog>
+                  <t t-set="content">
+                      <span>sts</span>
+                      <span>rocks</span>
+                  </t>
+               </Dialog>
+            </div>
+            <div t-name="Dialog"><t t-slot="content"/></div>
+          </templates>
+      `);
+    class Dialog extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><div><span>sts</span><span>rocks</span></div></div>");
+    expect(QWeb.slots["1_content"].toString()).toMatchSnapshot();
+  });
+
+  test("multiple roots are allowed in a default slot", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+               <Dialog>
+                  <span>sts</span>
+                  <span>rocks</span>
+               </Dialog>
+            </div>
+            <div t-name="Dialog"><t t-slot="default"/></div>
+          </templates>
+      `);
+    class Dialog extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><div><span>sts</span><span>rocks</span></div></div>");
+    expect(QWeb.slots["1_default"].toString()).toMatchSnapshot();
+  });
+
+  test("missing slots are ignored", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+              <Dialog/>
+            </div>
+            <span t-name="Dialog">
+              <t t-slot="default"/>
+              <span>some content</span>
+              <t t-slot="footer"/>
+            </span>
+          </templates>
+      `);
+    class Dialog extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span><span>some content</span></span></div>");
+  });
+
+  test("t-debug on a t-set (defining a slot)", async () => {
+    const consoleLog = console.log;
+    console.log = jest.fn();
+
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+              <Dialog><t t-set="content" t-debug="">abc</t></Dialog>
+            </div>
+            <span t-name="Dialog">
+              <t t-slot="content"/>
+            </span>
+          </templates>
+      `);
+    class Dialog extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Dialog };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(console.log).toHaveBeenCalledTimes(0);
+    console.log = consoleLog;
+  });
+
+  test("slot preserves properly parented relationship", async () => {
+    env.qweb.addTemplates(`
+          <templates>
+            <div t-name="Parent">
+               <Child>
+                  <GrandChild/>
+               </Child>
+            </div>
+            <div t-name="Child"><t t-slot="default"/></div>
+            <div t-name="GrandChild">Grand Child</div>
+          </templates>
+      `);
+    class Child extends Component<any, any> {}
+    class GrandChild extends Component<any, any> {}
+    class Parent extends Component<any, any> {
+      static components = { Child, GrandChild };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><div><div>Grand Child</div></div></div>");
+
+    const parentChildren = children(parent);
+    expect(parentChildren.length).toBe(1);
+    expect(parentChildren[0]).toBeInstanceOf(Child);
+
+    const childrenChildren = children(parentChildren[0]);
+    expect(childrenChildren.length).toBe(1);
+    expect(childrenChildren[0]).toBeInstanceOf(GrandChild);
+  });
+
+  test("nested slots: evaluation context and parented relationship", async () => {
+    let slot;
+    class Slot extends Component<any, any> {
+      static template = xml`<span t-esc="props.val"/>`;
+      constructor(parent, props) {
+        super(parent, props);
+        slot = this;
+      }
+    }
+    class GrandChild extends Component<any, any> {
+      static template = xml`<div><t t-slot="default"/></div>`;
+    }
+    class Child extends Component<any, any> {
+      static components = { GrandChild };
+      static template = xml`
+          <GrandChild>
+            <t t-slot="default"/>
+          </GrandChild>`;
+    }
+    class Parent extends Component<any, any> {
+      static components = { Child, Slot };
+      static template = xml`<Child><Slot val="state.val"/></Child>`;
+      state = useState({ val: 3 });
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><span>3</span></div>");
+    expect(slot.__owl__.parent).toBeInstanceOf(GrandChild);
+  });
+
+  test("slot are properly rendered if inner props are changed", async () => {
+    env.qweb.addTemplates(`
+      <templates>
+          <div t-name="SomeComponent">
+              SC:<t t-esc="props.val"/>
+          </div>
+  
+  
+          <div t-name="GenericComponent">
+              <t t-slot="default" />
+          </div>
+  
+          <div t-name="App">
+              <button t-on-click="inc">Inc[<t t-esc="state.val"/>]</button>
+              <GenericComponent>
+                  <SomeComponent val="state.val"/>
+              </GenericComponent>
+          </div>
+      </templates>
+      `);
+    class SomeComponent extends Component<any, any> {}
+    class GenericComponent extends Component<any, any> {}
+    class App extends Component<any, any> {
+      static components = { GenericComponent, SomeComponent };
+      state = useState({ val: 4 });
+
+      inc() {
+        this.state.val++;
+      }
+    }
+    const app = new App();
+    await app.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><button>Inc[4]</button><div><div> SC:4</div></div></div>");
+    (<any>fixture.querySelector("button")).click();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><button>Inc[5]</button><div><div> SC:5</div></div></div>");
+  });
+
+  test("slots and wrapper components", async () => {
+    class Link extends Component<any, any> {
+      static template = xml`
+          <a href="abc">
+              <t t-slot="default"/>
+          </a>`;
+    }
+
+    class A extends Component<any, any> {
+      static template = xml`<Link>hey</Link>`;
+      static components = { Link: Link };
+    }
+
+    const a = new A();
+    await a.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(`<a href="abc">hey</a>`);
+  });
+
+  test("template can just return a slot", async () => {
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="props.value"/></span>`;
+    }
+    class SlotComponent extends Component<any, any> {
+      static template = xml`<t t-slot="default"/>`;
+    }
+
+    class Parent extends Component<any, any> {
+      static template = xml`
+          <div>
+              <SlotComponent><Child value="state.value"/></SlotComponent>
+          </div>`;
+      static components = { SlotComponent, Child };
+      state = useState({ value: 3 });
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>3</span></div>");
+
+    expect(QWeb.TEMPLATES[SlotComponent.template].fn.toString()).toMatchSnapshot();
+
+    parent.state.value = 5;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>5</span></div>");
+  });
+
+  test("multiple slots containing components", async () => {
+    class C extends Component<any, any> {
+      static template = xml`<span><t t-esc="props.val"/></span>`;
+    }
+    class B extends Component<any, any> {
+      static template = xml`<div><t t-slot="s1"/><t t-slot="s2"/></div>`;
+    }
+    class A extends Component<any, any> {
+      static template = xml`
+          <B>
+            <t t-set="s1"><C val="1"/></t>
+            <t t-set="s2"><C val="2"/></t>
+          </B>`;
+      static components = { B, C };
+    }
+
+    const a = new A();
+    await a.mount(fixture);
+
+    expect(fixture.innerHTML).toBe(`<div><span>1</span><span>2</span></div>`);
+  });
+
+  test("slots in t-foreach and re-rendering", async () => {
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="state.val"/><t t-slot="default"/></span>`;
+      state = useState({ val: "A" });
+      mounted() {
+        this.state.val = "B";
+      }
+    }
+    class Parent extends Component<any, any> {
+      static components = { Child };
+      static template = xml`
+          <div>
+            <t t-foreach="Array(2)" t-as="n" t-key="n_index">
+              <Child><t t-esc="n_index"/></Child>
+            </t>
+          </div>`;
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>A0</span><span>A1</span></div>");
+
+    await nextTick(); // wait for the changes triggered in mounted to be applied
+    expect(fixture.innerHTML).toBe("<div><span>B0</span><span>B1</span></div>");
+  });
+
+  test("slots in t-foreach with t-set and re-rendering", async () => {
+    class Child extends Component<any, any> {
+      static template = xml`
+          <span>
+            <t t-esc="state.val"/>
+            <t t-slot="default"/>
+          </span>`;
+      state = useState({ val: "A" });
+      mounted() {
+        this.state.val = "B";
+      }
+    }
+    class ParentWidget extends Component<any, any> {
+      static components = { Child };
+      static template = xml`
+          <div>
+            <t t-foreach="Array(2)" t-as="n" t-key="n_index">
+              <t t-set="dummy" t-value="n_index"/>
+              <Child><t t-esc="dummy"/></Child>
+            </t>
+          </div>`;
+    }
+
+    const widget = new ParentWidget();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>A0</span><span>A1</span></div>");
+
+    await nextTick(); // wait for changes triggered in mounted to be applied
+    expect(fixture.innerHTML).toBe("<div><span>B0</span><span>B1</span></div>");
+  });
+
+  test("nested slots in same template", async () => {
+    let child, child2, child3;
+    class Child extends Component<any, any> {
+      static template = xml`
+          <span id="c1">
+            <div>
+              <t t-slot="default"/>
+            </div>
+          </span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        child = this;
+      }
+    }
+    class Child2 extends Component<any, any> {
+      static template = xml`
+          <span id="c2">
+            <t t-slot="default"/>
+          </span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        child2 = this;
+      }
+    }
+    class Child3 extends Component<any, any> {
+      static template = xml`
+          <span>Child 3</span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        child3 = this;
+      }
+    }
+    class Parent extends Component<any, any> {
+      static components = { Child, Child2, Child3 };
+      static template = xml`
+          <span id="parent">
+            <Child>
+              <Child2>
+                <Child3/>
+              </Child2>
+            </Child>
+          </span>`;
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe(
+      '<span id="parent"><span id="c1"><div><span id="c2"><span>Child 3</span></span></div></span></span>'
+    );
+
+    expect(child3.__owl__.parent).toStrictEqual(child2);
+    expect(child2.__owl__.parent).toStrictEqual(child);
+    expect(child.__owl__.parent).toStrictEqual(widget);
+  });
+
+  test("t-slot nested within another slot", async () => {
+    let portal, modal, child3;
+    class Child3 extends Component<any, any> {
+      static template = xml`
+          <span>Child 3</span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        child3 = this;
+      }
+    }
+    class Modal extends Component<any, any> {
+      static template = xml`
+          <span id="modal">
+            <t t-slot="default"/>
+          </span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        modal = this;
+      }
+    }
+    class Portal extends Component<any, any> {
+      static template = xml`
+          <span id="portal">
+            <t t-slot="default"/>
+          </span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        portal = this;
+      }
+    }
+    class Dialog extends Component<any, any> {
+      static components = { Modal, Portal };
+      static template = xml`
+          <span id="c2">
+            <Modal>
+              <Portal>
+                <t t-slot="default"/>
+              </Portal>
+             </Modal>
+          </span>`;
+    }
+    class Parent extends Component<any, any> {
+      static components = { Child3, Dialog };
+      static template = xml`
+          <span id="c1">
+            <Dialog>
+              <Child3/>
+            </Dialog>
+          </span>`;
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe(
+      '<span id="c1"><span id="c2"><span id="modal"><span id="portal"><span>Child 3</span></span></span></span></span>'
+    );
+
+    expect(child3.__owl__.parent).toStrictEqual(portal);
+    expect(portal.__owl__.parent).toStrictEqual(modal);
+  });
+
+  test("t-slot supports many instances", async () => {
+    let child3;
+    class Child3 extends Component<any, any> {
+      static template = xml`
+          <span>Child 3</span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        child3 = this;
+      }
+    }
+    class Dialog extends Component<any, any> {
+      static template = xml`
+          <span id="c2">
+            <t t-slot="default"/>
+          </span>`;
+    }
+    class Parent extends Component<any, any> {
+      static components = { Child3, Dialog };
+      static template = xml`
+          <span id="c1">
+            <Dialog>
+              <Child3 val="state.lol"/>
+            </Dialog>
+          </span>`;
+      state = { lol: "k" };
+    }
+
+    const widget = new Parent();
+    await widget.mount(fixture);
+    expect(child3.props.val).toBe("k");
+
+    const widget_1 = new Parent();
+    widget_1.state.lol = "m";
+    await widget_1.mount(fixture);
+    expect(child3.props.val).toBe("m");
+  });
+
+  test("slots in slots, with vars", async () => {
+    class B extends Component<any, any> {
+      static template = xml`<span><t t-slot="default"/></span>`;
+    }
+    class A extends Component<any, any> {
+      static template = xml`
+          <div>
+            <B>
+              <t t-slot="default"/>
+            </B>
+          </div>`;
+      static components = { B };
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`
+          <div>
+            <t t-set="test" t-value="state.name"/>
+            <A>
+              <p>hey<t t-esc="test"/></p>
+            </A>
+          </div>`;
+      static components = { A };
+      state = { name: "aaron" };
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div><span><p>heyaaron</p></span></div></div>");
+  });
+});

tests/component/styles.test.ts

@@ -0,0 +1,170 @@
+import { Component, Env } from "../../src/component/component";
+import { processSheet } from "../../src/component/styles";
+import { xml, css } from "../../src/tags";
+import { makeTestFixture, makeTestEnv } from "../helpers";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - env: an Env, necessary to create new components
+
+let fixture: HTMLElement;
+let env: Env;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+  document.head.innerHTML = "";
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("styles and component", () => {
+  test("can define an inline stylesheet", async () => {
+    class App extends Component<any, any> {
+      static template = xml`<div class="app">text</div>`;
+      static style = css`
+        .app {
+          color: red;
+        }
+      `;
+    }
+    expect(document.head.innerHTML).toBe("");
+    const app = new App();
+
+    expect(document.head.innerHTML).toBe(`<style component=\"App\">.app {
+  color: red;
+}</style>`);
+
+    await app.mount(fixture);
+    const style = getComputedStyle(app.el!);
+    expect(style.color).toBe("red");
+    expect(fixture.innerHTML).toBe('<div class="app">text</div>');
+  });
+
+  test("inherited components properly apply css", async () => {
+    class App extends Component<any, any> {
+      static template = xml`<div class="app">text</div>`;
+      static style = css`
+        .app {
+          color: red;
+        }
+      `;
+    }
+    class SubApp extends App {
+      static style = css`
+        .app {
+          font-weight: bold;
+        }
+      `;
+    }
+    expect(document.head.innerHTML).toBe("");
+    const app = new SubApp();
+
+    expect(document.head.innerHTML).toBe(`<style component=\"SubApp\">.app {
+  font-weight: bold;
+}</style><style component=\"App\">.app {
+  color: red;
+}</style>`);
+
+    await app.mount(fixture);
+    const style = getComputedStyle(app.el!);
+    expect(style.color).toBe("red");
+    expect(style.fontWeight).toBe("bold");
+    expect(fixture.innerHTML).toBe('<div class="app">text</div>');
+  });
+
+  test("get a meaningful error message if css helper is missing", async () => {
+    class App extends Component<any, any> {
+      static template = xml`<div class="app">text</div>`;
+      static style = `.app {color: red;}`;
+    }
+    let error;
+    try {
+      new App();
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe(
+      "Invalid css stylesheet for component 'App'. Did you forget to use the 'css' tag helper?"
+    );
+  });
+
+  test("inline stylesheets are processed", async () => {
+    class App extends Component<any, any> {
+      static template = xml`<div class="app">text</div>`;
+      static style = css`
+        .app {
+          color: red;
+          .some-class {
+            font-weight: bold;
+            width: 40px;
+          }
+
+          display: block;
+        }
+      `;
+    }
+    new App();
+
+    expect(document.head.querySelector("style")!.innerHTML).toBe(`.app {
+  color: red;
+}
+.app .some-class {
+  font-weight: bold;
+  width: 40px;
+}
+.app {
+  display: block;
+}`);
+  });
+
+  test("properly handle rules with commas", async () => {
+    const sheet = processSheet(`.parent-a, .parent-b {
+      .child-a, .child-b {
+        color: red;
+      }
+    }`);
+
+    expect(sheet)
+      .toBe(`.parent-a .child-a, .parent-a .child-b, .parent-b .child-a, .parent-b .child-b {
+  color: red;
+}`);
+  });
+
+  test("handle & selector", async () => {
+    let sheet = processSheet(`.btn {
+      &.danger {
+        color: red;
+      }
+    }`);
+
+    expect(sheet).toBe(`.btn.danger {
+  color: red;
+}`);
+
+    sheet = processSheet(`.some-class {
+      &.btn {
+        .other-class ~ & {
+          color: red;
+        }
+      }
+    }`);
+
+    expect(sheet).toBe(`.other-class ~ .some-class.btn {
+  color: red;
+}`);
+  });
+});

tests/context.test.ts

@@ -0,0 +1,339 @@
+import { makeDeferred, makeTestEnv, makeTestFixture, nextTick } from "./helpers";
+import { Component } from "../src/component/component";
+import { Context, useContext } from "../src/context";
+import { xml } from "../src/tags";
+import { useState } from "../src/hooks";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - a test env, necessary to create components, that is set as env
+
+let fixture: HTMLElement;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  Component.env = makeTestEnv();
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("Context", () => {
+  test("very simple use, with initial value", async () => {
+    const testContext = new Context({ value: 123 });
+
+    class Test extends Component<any, any> {
+      static template = xml`<div><t t-esc="contextObj.value"/></div>`;
+      contextObj = useContext(testContext);
+    }
+    const test = new Test();
+    await test.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>123</div>");
+  });
+
+  test("useContext hook is reactive, for one component", async () => {
+    const testContext = new Context({ value: 123 });
+
+    class Test extends Component<any, any> {
+      static template = xml`<div><t t-esc="contextObj.value"/></div>`;
+      contextObj = useContext(testContext);
+    }
+    const test = new Test();
+    await test.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>123</div>");
+    test.contextObj.value = 321;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div>321</div>");
+  });
+
+  test("two components can subscribe to same context", async () => {
+    const testContext = new Context({ value: 123 });
+
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="contextObj.value"/></span>`;
+      contextObj = useContext(testContext);
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Child /><Child /></div>`;
+      static components = { Child };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>123</span><span>123</span></div>");
+    testContext.state.value = 321;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>321</span><span>321</span></div>");
+  });
+
+  test("two async components are updated in parallel", async () => {
+    const testContext = new Context({ value: 123 });
+    const def = makeDeferred();
+    const steps: string[] = [];
+
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="contextObj.value"/></span>`;
+      contextObj = useContext(testContext);
+      async render() {
+        steps.push("render");
+        await def;
+        return super.render();
+      }
+    }
+
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Child /><Child /></div>`;
+      static components = { Child };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>123</span><span>123</span></div>");
+    testContext.state.value = 321;
+    await nextTick();
+    expect(steps).toEqual(["render", "render"]);
+    expect(fixture.innerHTML).toBe("<div><span>123</span><span>123</span></div>");
+    def.resolve();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>321</span><span>321</span></div>");
+  });
+
+  test("two async components on two levels are updated (mostly) in parallel", async () => {
+    const testContext = new Context({ value: 123 });
+    const def = makeDeferred();
+    const steps: string[] = [];
+
+    class SlowComp extends Component<any, any> {
+      static template = xml`<p><t t-esc="props.value"/></p>`;
+      willUpdateProps() {
+        return def;
+      }
+    }
+    class Child extends Component<any, any> {
+      static template = xml`<span><SlowComp value="contextObj.value"/></span>`;
+      static components = { SlowComp };
+      contextObj = useContext(testContext);
+
+      render() {
+        steps.push("render");
+        return super.render();
+      }
+    }
+
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Child /><Child /></div>`;
+      static components = { Child };
+    }
+
+    class App extends Component<any, any> {
+      static template = xml`<div><Child /><Parent /></div>`;
+      static components = { Child, Parent };
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe(
+      "<div><span><p>123</p></span><div><span><p>123</p></span><span><p>123</p></span></div></div>"
+    );
+    testContext.state.value = 321;
+    await nextTick();
+    expect(steps).toEqual(["render"]);
+    expect(fixture.innerHTML).toBe(
+      "<div><span><p>123</p></span><div><span><p>123</p></span><span><p>123</p></span></div></div>"
+    );
+    def.resolve();
+    await nextTick();
+    // we need to wait for an extra tick because it could happen (even though it
+    // is rare) that the second batch of renderings is not done yet, because
+    // the initial promise has been given to the macrotask queue, so a small
+    // delay happens.
+    await nextTick();
+    expect(steps).toEqual(["render", "render", "render"]);
+    expect(fixture.innerHTML).toBe(
+      "<div><span><p>321</p></span><div><span><p>321</p></span><span><p>321</p></span></div></div>"
+    );
+  });
+
+  test("one components can subscribe twice to same context", async () => {
+    const testContext = new Context({ a: 1, b: 2 });
+    const steps: string[] = [];
+
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="contextObj1.a"/><t t-esc="contextObj2.b"/></span>`;
+      contextObj1 = useContext(testContext);
+      contextObj2 = useContext(testContext);
+      __render(fiber) {
+        steps.push("child");
+        return super.__render(fiber);
+      }
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Child /></div>`;
+      static components = { Child };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>12</span></div>");
+    expect(steps).toEqual(["child"]);
+    testContext.state.a = 3;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>32</span></div>");
+    expect(steps).toEqual(["child", "child"]);
+  });
+
+  test("parent and children subscribed to same context", async () => {
+    const testContext = new Context({ a: 123, b: 321 });
+    const steps: string[] = [];
+
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="contextObj.a"/></span>`;
+      contextObj = useContext(testContext);
+      __render(fiber) {
+        steps.push("child");
+        return super.__render(fiber);
+      }
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Child /><t t-esc="contextObj.b"/></div>`;
+      static components = { Child };
+      contextObj = useContext(testContext);
+      __render(fiber) {
+        steps.push("parent");
+        return super.__render(fiber);
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>123</span>321</div>");
+    expect(steps).toEqual(["parent", "child"]);
+
+    parent.contextObj.a = 124;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>124</span>321</div>");
+
+    // we only  want one render from the child here, not two
+    expect(steps).toEqual(["parent", "child", "parent", "child"]);
+  });
+
+  test("destroyed component is inactive", async () => {
+    const testContext = new Context({ a: 123 });
+    const steps: string[] = [];
+
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="contextObj.a"/></span>`;
+      contextObj = useContext(testContext);
+      __render(fiber) {
+        steps.push("child");
+        return super.__render(fiber);
+      }
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Child t-if="state.flag"/></div>`;
+      static components = { Child };
+      state = useState({ flag: true });
+      __render(fiber) {
+        steps.push("parent");
+        return super.__render(fiber);
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>123</span></div>");
+    expect(steps).toEqual(["parent", "child"]);
+    expect(testContext.subscriptions.update.length).toBe(1);
+
+    parent.state.flag = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div></div>");
+    expect(steps).toEqual(["parent", "child", "parent"]);
+    // kind of whitebox...
+    // we make sure we do not have any pending subscriptions to the 'update'
+    // event
+    expect(testContext.subscriptions.update.length).toBe(0);
+  });
+
+  test("destroyed component before being mounted is inactive", async () => {
+    const testContext = new Context({ a: 123 });
+
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="contextObj.a"/></span>`;
+      contextObj = useContext(testContext);
+      willStart() {
+        return makeDeferred();
+      }
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`<div><Child t-if="state.flag"/></div>`;
+      static components = { Child };
+      state = useState({ flag: true });
+    }
+
+    const parent = new Parent();
+    const prom = parent.mount(fixture);
+    await nextTick(); // wait for Child to be instantiated
+    expect(testContext.subscriptions.update.length).toBe(1);
+    parent.state.flag = false;
+    await prom;
+    expect(fixture.innerHTML).toBe("<div></div>");
+    // kind of whitebox...
+    // we make sure we do not have any pending subscriptions to the 'update'
+    // event
+    expect(testContext.subscriptions.update.length).toBe(0);
+  });
+
+  test("concurrent renderings", async () => {
+    const testContext = new Context({ x: { n: 1 }, key: "x" });
+    const def = makeDeferred();
+    let stateC;
+    class ComponentC extends Component<any, any> {
+      static template = xml`<span><t t-esc="context[props.key].n"/><t t-esc="state.x"/></span>`;
+      context = useContext(testContext);
+      state = useState({ x: "a" });
+
+      constructor(parent, props) {
+        super(parent, props);
+        stateC = this.state;
+      }
+    }
+    class ComponentB extends Component<any, any> {
+      static components = { ComponentC };
+      static template = xml`<p><ComponentC key="props.key"/></p>`;
+
+      willUpdateProps() {
+        return def;
+      }
+    }
+    class ComponentA extends Component<any, any> {
+      static components = { ComponentB };
+      static template = xml`<div><ComponentB key="context.key"/></div>`;
+      context = useContext(testContext);
+    }
+
+    const component = new ComponentA();
+    await component.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><p><span>1a</span></p></div>");
+    testContext.state.key = "y";
+    testContext.state.y = { n: 2 };
+    delete testContext.state.x;
+    await nextTick();
+
+    expect(fixture.innerHTML).toBe("<div><p><span>1a</span></p></div>");
+    stateC.x = "b";
+    await nextTick();
+
+    expect(fixture.innerHTML).toBe("<div><p><span>1a</span></p></div>");
+    def.resolve();
+    await nextTick();
+
+    expect(fixture.innerHTML).toBe("<div><p><span>2b</span></p></div>");
+  });
+});

tests/core/event_bus.test.ts

@@ -1,4 +1,4 @@
-import { EventBus } from "../src/event_bus";
+import { EventBus } from "../../src/core/event_bus";
 
 describe("event bus behaviour", () => {
   test("can subscribe and be notified", () => {
@@ -23,9 +23,7 @@ describe("event bus behaviour", () => {
   test("throw error if callback is undefined", () => {
     expect.assertions(1);
     const bus = new EventBus();
-    expect(() => bus.on("event", {}, <any>undefined)).toThrow(
-      `Missing callback`
-    );
+    expect(() => bus.on("event", {}, <any>undefined)).toThrow(`Missing callback`);
   });
 
   test("can unsubscribe", () => {

tests/core/observer.test.ts

@@ -0,0 +1,432 @@
+import { Observer } from "../../src/core/observer";
+import { nextMicroTick } from "../helpers";
+
+describe("observer", () => {
+  test("properly observe objects", () => {
+    const observer = new Observer();
+    const obj: any = observer.observe({});
+
+    expect(typeof obj).toBe("object");
+    expect(observer.revNumber(obj)).toBe(1);
+    expect(observer.rev).toBe(1);
+
+    const obj2: any = observer.observe({ a: 1 });
+    expect(observer.revNumber(obj2)).toBe(1);
+    expect(observer.revNumber(obj)).toBe(1);
+    expect(observer.rev).toBe(1);
+
+    obj2.a = 2;
+
+    expect(observer.revNumber(obj)).toBe(1);
+    expect(observer.revNumber(obj2)).toBe(2);
+    expect(observer.rev).toBe(2);
+
+    expect(obj2).toEqual({
+      a: 2
+    });
+  });
+
+  test("properly handle null or undefined", () => {
+    const observer = new Observer();
+    const obj: any = observer.observe({ a: null, b: undefined });
+
+    expect(observer.revNumber(obj)).toBe(1);
+    expect(observer.rev).toBe(1);
+
+    obj.a = 3;
+    expect(observer.revNumber(obj)).toBe(2);
+    expect(observer.rev).toBe(2);
+
+    obj.b = 5;
+    expect(observer.revNumber(obj)).toBe(3);
+    expect(observer.rev).toBe(3);
+
+    obj.a = null;
+    obj.b = undefined;
+    expect(observer.revNumber(obj)).toBe(5);
+    expect(observer.rev).toBe(5);
+    expect(obj).toEqual({
+      a: null,
+      b: undefined
+    });
+  });
+
+  test("properly handle dates", () => {
+    const observer = new Observer();
+    const date = new Date();
+    const obj: any = observer.observe({ date });
+
+    expect(observer.revNumber(obj)).toBe(1);
+    expect(observer.rev).toBe(1);
+    expect(typeof obj.date.getFullYear()).toBe("number");
+    expect(obj.date).toBe(date);
+
+    obj.date = new Date();
+
+    expect(observer.revNumber(obj)).toBe(2);
+    expect(observer.rev).toBe(2);
+    expect(obj.date).not.toBe(date);
+  });
+
+  test("can change values in array", () => {
+    const observer = new Observer();
+    const obj: any = observer.observe({ arr: [1, 2] });
+
+    expect(Array.isArray(obj.arr)).toBe(true);
+    expect(observer.revNumber(obj.arr)).toBe(1);
+    expect(observer.rev).toBe(1);
+
+    obj.arr[0] = "nope";
+    expect(observer.revNumber(obj.arr)).toBe(2);
+    expect(observer.revNumber(obj)).toBe(2);
+    expect(observer.rev).toBe(2);
+  });
+
+  test("various object property changes", () => {
+    const observer = new Observer();
+    const obj: any = observer.observe({ a: 1 });
+
+    expect(observer.revNumber(obj)).toBe(1);
+    expect(observer.rev).toBe(1);
+
+    obj.a = 2;
+
+    expect(observer.revNumber(obj)).toBe(2);
+    expect(observer.rev).toBe(2);
+
+    // same value again
+    obj.a = 2;
+    expect(observer.revNumber(obj)).toBe(2);
+    expect(observer.rev).toBe(2);
+
+    obj.a = 3;
+    expect(observer.revNumber(obj)).toBe(3);
+    expect(observer.rev).toBe(3);
+  });
+
+  test("properly observe arrays", () => {
+    const observer = new Observer();
+    const arr: any = observer.observe([]);
+
+    expect(Array.isArray(arr)).toBe(true);
+    expect(arr.length).toBe(0);
+    expect(observer.revNumber(arr)).toBe(1);
+    expect(observer.rev).toBe(1);
+
+    arr.push(1);
+    expect(observer.revNumber(arr)).toBe(2);
+    expect(observer.rev).toBe(2);
+    expect(arr.length).toBe(1);
+    expect(arr).toEqual([1]);
+
+    arr.splice(1, 0, "hey");
+    expect(observer.revNumber(arr)).toBe(3);
+    expect(observer.rev).toBe(3);
+    expect(arr).toEqual([1, "hey"]);
+    expect(arr.length).toBe(2);
+
+    arr.unshift("lindemans");
+    //it generates 3 primitive operations
+    expect(observer.revNumber(arr)).toBe(6);
+    expect(observer.rev).toBe(6);
+    expect(arr).toEqual(["lindemans", 1, "hey"]);
+    expect(arr.length).toBe(3);
+
+    arr.reverse();
+    //it generates 2 primitive operations
+    expect(observer.revNumber(arr)).toBe(8);
+    expect(observer.rev).toBe(8);
+    expect(arr).toEqual(["hey", 1, "lindemans"]);
+    expect(arr.length).toBe(3);
+
+    arr.pop(); // one set, one delete
+    expect(observer.revNumber(arr)).toBe(10);
+    expect(observer.rev).toBe(10);
+    expect(arr).toEqual(["hey", 1]);
+    expect(arr.length).toBe(2);
+
+    arr.shift(); // 2 sets, 1 delete
+    expect(observer.revNumber(arr)).toBe(13);
+    expect(observer.rev).toBe(13);
+    expect(arr).toEqual([1]);
+    expect(arr.length).toBe(1);
+  });
+
+  test("object pushed into arrays are observed", () => {
+    const observer = new Observer();
+    const arr: any = observer.observe([]);
+    expect(observer.rev).toBe(1);
+
+    arr.push({ kriek: 5 });
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(arr)).toBe(2);
+    expect(observer.revNumber(arr[0])).toBe(2);
+
+    arr[0].kriek = 6;
+
+    expect(observer.rev).toBe(3);
+    expect(observer.revNumber(arr)).toBe(3);
+    expect(observer.revNumber(arr[0])).toBe(3);
+  });
+
+  test("set new property on observed object", async () => {
+    const observer = new Observer();
+    observer.notifyCB = jest.fn();
+    const state: any = observer.observe({ a: 1 });
+    expect(observer.notifyCB).toBeCalledTimes(0);
+    expect(observer.rev).toBe(1);
+    expect(observer.revNumber(state)).toBe(1);
+
+    state.b = 8;
+
+    await nextMicroTick();
+
+    expect(observer.notifyCB).toBeCalledTimes(1);
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(state)).toBe(2);
+
+    expect(state.b).toBe(8);
+  });
+
+  test("delete property from observed object", async () => {
+    const observer = new Observer();
+    observer.notifyCB = jest.fn();
+    const state: any = observer.observe({ a: 1, b: 8 });
+    observer.observe(state);
+
+    expect(observer.notifyCB).toBeCalledTimes(0);
+    expect(observer.rev).toBe(1);
+    expect(observer.revNumber(state)).toBe(1);
+
+    delete state.b;
+    await nextMicroTick();
+
+    expect(observer.notifyCB).toBeCalledTimes(1);
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(state)).toBe(2);
+
+    expect(state).toEqual({ a: 1 });
+  });
+
+  test("set element in observed array", async () => {
+    const observer = new Observer();
+    observer.notifyCB = jest.fn();
+    const state: any = observer.observe(["a"]);
+
+    expect(observer.rev).toBe(1);
+    expect(observer.revNumber(state)).toBe(1);
+    expect(observer.notifyCB).toBeCalledTimes(0);
+
+    state[1] = "b";
+
+    await nextMicroTick();
+
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(state)).toBe(2);
+    expect(observer.notifyCB).toBeCalledTimes(1);
+
+    expect(state).toEqual(["a", "b"]);
+  });
+
+  test("properly observe arrays in object", () => {
+    const observer = new Observer();
+    const state: any = observer.observe({ arr: [] });
+
+    expect(observer.rev).toBe(1);
+    expect(observer.revNumber(state.arr)).toBe(1);
+    expect(state.arr.length).toBe(0);
+
+    state.arr.push(1);
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(state.arr)).toBe(2);
+    expect(state.arr.length).toBe(1);
+  });
+
+  test("properly observe objects in array", () => {
+    const observer = new Observer();
+    const state: any = observer.observe({ arr: [{ something: 1 }] });
+    observer.observe(state);
+
+    expect(observer.rev).toBe(1);
+    expect(observer.revNumber(state.arr)).toBe(1);
+    expect(observer.revNumber(state.arr[0])).toBe(1);
+
+    state.arr[0].something = 2;
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(state.arr)).toBe(2);
+    expect(observer.revNumber(state.arr[0])).toBe(2);
+  });
+
+  test("properly observe objects in object", () => {
+    const observer = new Observer();
+    const state: any = observer.observe({ a: { b: 1 } });
+
+    expect(observer.rev).toBe(1);
+    expect(observer.revNumber(state)).toBe(1);
+    expect(observer.revNumber(state.a)).toBe(1);
+
+    state.a.b = 2;
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(state)).toBe(2);
+    expect(observer.revNumber(state.a)).toBe(2);
+  });
+
+  test("reobserve new object values", () => {
+    const observer = new Observer();
+    const obj: any = observer.observe({ a: 1 });
+
+    expect(observer.rev).toBe(1);
+    expect(observer.revNumber(obj)).toBe(1);
+
+    obj.a = { b: 2 };
+
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(obj)).toBe(2);
+    expect(observer.revNumber(obj.a)).toBe(2);
+    obj.a.b = 3;
+    expect(observer.rev).toBe(3);
+    expect(observer.revNumber(obj)).toBe(3);
+    expect(observer.revNumber(obj.a)).toBe(3);
+  });
+
+  test("deep observe misc changes", () => {
+    const observer = new Observer();
+    const state: any = observer.observe({ o: { a: 1 }, arr: [1], n: 13 });
+    expect(observer.revNumber(state)).toBe(1);
+
+    state.o.a = 2;
+    expect(observer.rev).toBe(2);
+    expect(observer.revNumber(state)).toBe(2);
+
+    state.arr.push(2);
+    expect(observer.rev).toBe(3);
+    expect(observer.revNumber(state)).toBe(3);
+
+    state.n = 155;
+    expect(observer.rev).toBe(4);
+    expect(observer.revNumber(state)).toBe(4);
+  });
+
+  test("properly handle already observed state", () => {
+    const observer = new Observer();
+    const obj1: any = observer.observe({ a: 1 });
+    const obj2: any = observer.observe({ b: 1 });
+
+    expect(observer.revNumber(obj1)).toBe(1);
+    expect(observer.revNumber(obj2)).toBe(1);
+
+    obj1.a = 2;
+    obj2.b = 3;
+    expect(observer.revNumber(obj1)).toBe(2);
+    expect(observer.revNumber(obj2)).toBe(2);
+
+    obj2.b = obj1;
+    expect(observer.revNumber(obj1)).toBe(2);
+    expect(observer.revNumber(obj2)).toBe(3);
+  });
+
+  test("can set a property more than once", () => {
+    const observer = new Observer();
+    const obj: any = observer.observe({});
+
+    expect(observer.revNumber(obj)).toBe(1);
+    expect(observer.rev).toBe(1);
+
+    obj.aku = "always finds annoying problems";
+    expect(observer.revNumber(obj)).toBe(2);
+    expect(observer.rev).toBe(2);
+
+    obj.aku = "always finds good problems";
+
+    expect(observer.revNumber(obj)).toBe(3);
+    expect(observer.rev).toBe(3);
+  });
+
+  test("properly handle swapping elements", () => {
+    const observer = new Observer();
+    const obj: any = observer.observe({ a: { arr: [] }, b: 1 });
+
+    // swap a and b
+    const b = obj.b;
+    obj.b = obj.a;
+    obj.a = b;
+    expect(observer.rev).toBe(3);
+
+    // push something into array to make sure it works
+    obj.b.arr.push("blanche");
+    expect(observer.rev).toBe(4);
+  });
+
+  test("properly handle assigning observed obj containing array", () => {
+    const observer = new Observer();
+    const obj: any = observer.observe({ a: { arr: [], val: "test" } });
+
+    expect(observer.rev).toBe(1);
+    obj.a = { ...obj.a, val: "test2" };
+    expect(observer.rev).toBe(2);
+
+    // push something into array to make sure it works
+    obj.a.arr.push("blanche");
+    expect(observer.rev).toBe(3);
+  });
+
+  test("accept cycles in observed state", () => {
+    const observer = new Observer();
+    let obj1: any = {};
+    let obj2: any = { b: obj1, key: 1 };
+    obj1.a = obj2;
+    obj1 = observer.observe(obj1);
+    obj2 = obj1.a;
+
+    expect(observer.revNumber(obj1)).toBe(1);
+    expect(observer.revNumber(obj2)).toBe(1);
+
+    obj2.key = 3;
+    expect(observer.revNumber(obj1)).toBe(2);
+    expect(observer.revNumber(obj2)).toBe(2);
+  });
+
+  test("call callback when state is changed", async () => {
+    const observer = new Observer();
+    observer.notifyCB = jest.fn();
+    const obj: any = observer.observe({ a: 1, b: { c: 2 }, d: [{ e: 3 }], f: 4 });
+
+    expect(observer.notifyCB).toBeCalledTimes(0);
+
+    obj.a = 2;
+    await nextMicroTick();
+    expect(observer.notifyCB).toBeCalledTimes(1);
+
+    obj.b.c = 3;
+    await nextMicroTick();
+    expect(observer.notifyCB).toBeCalledTimes(2);
+
+    obj.d[0].e = 5;
+    await nextMicroTick();
+    expect(observer.notifyCB).toBeCalledTimes(3);
+
+    obj.a = 111;
+    obj.f = 222;
+    await nextMicroTick();
+    expect(observer.notifyCB).toBeCalledTimes(5);
+  });
+
+  test("throw error when state is mutated in object if allowMutation=false", async () => {
+    const observer = new Observer();
+    observer.allowMutations = false;
+    const obj: any = observer.observe({ a: 1 });
+    expect(() => {
+      obj.a = 2;
+    }).toThrow('Observed state cannot be changed here! (key: "a", val: "2")');
+  });
+
+  test("throw error when state is mutated in array if allowMutation=false", async () => {
+    const observer = new Observer();
+    observer.allowMutations = false;
+    const obj: any = observer.observe({ a: [1] });
+
+    expect(() => {
+      obj.a.push(2);
+    }).toThrow('Observed state cannot be changed here! (key: "1", val: "2")');
+  });
+});

tests/helpers.ts

@@ -1,12 +1,50 @@
-import { Env } from "../src/component";
-import { QWeb } from "../src/qweb";
+import { Env, Component } from "../src/component/component";
+import { scheduler } from "../src/component/scheduler";
+import { EvalContext, QWeb } from "../src/qweb/qweb";
+import { CompilationContext } from "../src/qweb/compilation_context";
+import { patch } from "../src/vdom";
+import "../src/qweb/base_directives";
+import "../src/qweb/extensions";
+import "../src/component/directive";
 
+// 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;
+let nextId;
+let TEMPLATES;
+
+beforeEach(() => {
+  nextSlotId = QWeb.nextSlotId;
+  CompilationContext.nextID = 1;
+  slots = Object.assign({}, QWeb.slots);
+  nextId = QWeb.nextId;
+  TEMPLATES = Object.assign({}, QWeb.TEMPLATES);
+  Component.scheduler.tasks = [];
+});
+
+afterEach(() => {
+  QWeb.nextSlotId = nextSlotId;
+  QWeb.slots = slots;
+  QWeb.nextId = nextId;
+  QWeb.TEMPLATES = TEMPLATES;
+  Component.scheduler.tasks = [];
+});
+
+// helpers
 export function nextMicroTick(): Promise<void> {
   return Promise.resolve();
 }
 
-export function nextTick(): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve));
+export async function nextTick(): Promise<void> {
+  return new Promise(function(resolve) {
+    setTimeout(() => scheduler.requestAnimationFrame(() => resolve()));
+  });
 }
 
 export function makeTestFixture() {
@@ -35,8 +73,79 @@ export function makeDeferred(): Deferred {
   return <Deferred>def;
 }
 
-export function makeTestWEnv(): Env {
+export function makeTestEnv(): Env {
   return {
     qweb: new QWeb()
   };
 }
+
+export function trim(str: string): string {
+  return str.replace(/\s/g, "");
+}
+
+export function renderToDOM(
+  qweb: QWeb,
+  template: string,
+  context: EvalContext = {},
+  extra?: any
+): HTMLElement | Text {
+  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 };
+  }
+  const vnode = qweb.render(template, context, extra);
+
+  // we snapshot here the compiled code. This is useful to prevent unwanted code
+  // change.
+  expect(qweb.templates[template].fn.toString()).toMatchSnapshot();
+
+  if (vnode.sel === undefined) {
+    return document.createTextNode(vnode.text!);
+  }
+  const node = document.createElement(vnode.sel!);
+  const result = patch(node, vnode);
+  return result.elm as HTMLElement;
+}
+
+/**
+ * Render a template to an html string. The big difference with the
+ * renderToString method in QWeb is that we use the renderToDom method, which
+ * snapshots the resulting template function.  Doing so gives us a large body
+ * of reference to evaluate changes in the generated QWeb code.
+ *
+ * Note that the result of renderToString is guaranteed to be the same as the
+ * one from QWeb.
+ */
+export function renderToString(
+  qweb: QWeb,
+  t: string,
+  context: EvalContext = {},
+  extra?: any
+): string {
+  const result = qweb.renderToString(t, context, extra);
+  expect(qweb.templates[t].fn.toString()).toMatchSnapshot();
+  return result;
+}
+
+// hereafter, we define two helpers to patch/unpatch the nextFrame utils. This
+// 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;
+export function patchNextFrame(f: Function) {
+  QWeb.utils.nextFrame = (cb: () => void) => {
+    setTimeout(() => f(cb));
+  };
+}
+
+export function unpatchNextFrame() {
+  QWeb.utils.nextFrame = nextFrame;
+}
+
+export async function editInput(input: HTMLInputElement | HTMLTextAreaElement, value: string) {
+  input.value = value;
+  input.dispatchEvent(new Event("input"));
+  input.dispatchEvent(new Event("change"));
+  return nextTick();
+}

tests/hooks.test.ts

@@ -0,0 +1,631 @@
+import { makeTestEnv, makeTestFixture, nextTick } from "./helpers";
+import { Component, Env } from "../src/component/component";
+import {
+  useState,
+  onMounted,
+  onWillUnmount,
+  useRef,
+  onPatched,
+  onWillPatch,
+  onWillStart,
+  onWillUpdateProps,
+  useSubEnv,
+  useExternalListener
+} from "../src/hooks";
+import { xml } from "../src/tags";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - env: a WEnv, necessary to create new components
+
+let fixture: HTMLElement;
+let env: Env;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  env = makeTestEnv();
+  Component.env = env;
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+//------------------------------------------------------------------------------
+// Tests
+//------------------------------------------------------------------------------
+
+describe("hooks", () => {
+  test("can use a state hook", async () => {
+    class Counter extends Component<any, any> {
+      static template = xml`<div><t t-esc="counter.value"/></div>`;
+      counter = useState({ value: 42 });
+    }
+    const counter = new Counter();
+    await counter.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>42</div>");
+    counter.counter.value = 3;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div>3</div>");
+  });
+
+  test("can use onMounted, onWillUnmount", async () => {
+    const steps: string[] = [];
+    function useMyHook() {
+      onMounted(() => {
+        steps.push("mounted");
+      });
+      onWillUnmount(() => {
+        steps.push("willunmount");
+      });
+    }
+    class MyComponent extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      constructor() {
+        super();
+        useMyHook();
+      }
+    }
+    const component = new MyComponent();
+    await component.mount(fixture);
+    expect(component).not.toHaveProperty("mounted");
+    expect(component).not.toHaveProperty("willUnmount");
+    expect(fixture.innerHTML).toBe("<div>hey</div>");
+    expect(steps).toEqual(["mounted"]);
+    component.unmount();
+    expect(fixture.innerHTML).toBe("");
+    expect(steps).toEqual(["mounted", "willunmount"]);
+  });
+
+  test("can use onMounted, onWillUnmount, part 2", async () => {
+    const steps: string[] = [];
+    function useMyHook() {
+      onMounted(() => {
+        steps.push("mounted");
+      });
+      onWillUnmount(() => {
+        steps.push("willunmount");
+      });
+    }
+    class MyComponent extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      constructor(parent, props) {
+        super(parent, props);
+        useMyHook();
+      }
+    }
+
+    class Parent extends Component<any, any> {
+      static template = xml`<div><MyComponent t-if="state.flag"/></div>`;
+      static components = { MyComponent };
+      state = useState({ flag: true });
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>hey</div></div>");
+    expect(steps).toEqual(["mounted"]);
+
+    parent.state.flag = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div></div>");
+    expect(steps).toEqual(["mounted", "willunmount"]);
+  });
+
+  test("mounted, willUnmount, onMounted, onWillUnmount order", async () => {
+    const steps: string[] = [];
+    function useMyHook() {
+      onMounted(() => {
+        steps.push("hook:mounted");
+      });
+      onWillUnmount(() => {
+        steps.push("hook:willunmount");
+      });
+    }
+    class MyComponent extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      constructor() {
+        super();
+        useMyHook();
+      }
+      mounted() {
+        steps.push("comp:mounted");
+      }
+      willUnmount() {
+        steps.push("comp:willunmount");
+      }
+    }
+    const component = new MyComponent();
+    await component.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>hey</div>");
+    component.unmount();
+    expect(fixture.innerHTML).toBe("");
+    expect(steps).toEqual(["comp:mounted", "hook:mounted", "hook:willunmount", "comp:willunmount"]);
+  });
+
+  test("mounted, willUnmount, onMounted, onWillUnmount order, part 2", async () => {
+    const steps: string[] = [];
+    function useMyHook() {
+      onMounted(() => {
+        steps.push("hook:mounted");
+      });
+      onWillUnmount(() => {
+        steps.push("hook:willunmount");
+      });
+    }
+    class MyComponent extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      constructor(parent, props) {
+        super(parent, props);
+        useMyHook();
+      }
+      mounted() {
+        steps.push("comp:mounted");
+      }
+      willUnmount() {
+        steps.push("comp:willunmount");
+      }
+    }
+
+    class Parent extends Component<any, any> {
+      static template = xml`<div><MyComponent t-if="state.flag"/></div>`;
+      static components = { MyComponent };
+      state = useState({ flag: true });
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div>hey</div></div>");
+    parent.state.flag = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div></div>");
+
+    expect(steps).toEqual(["comp:mounted", "hook:mounted", "hook:willunmount", "comp:willunmount"]);
+  });
+
+  test("two different call to mounted/willunmount should work", async () => {
+    const steps: string[] = [];
+    function useMyHook(i) {
+      onMounted(() => {
+        steps.push("hook:mounted" + i);
+      });
+      onWillUnmount(() => {
+        steps.push("hook:willunmount" + i);
+      });
+    }
+    class MyComponent extends Component<any, any> {
+      static template = xml`<div>hey</div>`;
+      constructor() {
+        super();
+        useMyHook(1);
+        useMyHook(2);
+      }
+    }
+    const component = new MyComponent();
+    await component.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>hey</div>");
+    component.unmount();
+    expect(fixture.innerHTML).toBe("");
+    expect(steps).toEqual([
+      "hook:mounted1",
+      "hook:mounted2",
+      "hook:willunmount2",
+      "hook:willunmount1"
+    ]);
+  });
+
+  test("useRef hook", async () => {
+    class Counter extends Component<any, any> {
+      static template = xml`<div><button t-ref="button"><t t-esc="value"/></button></div>`;
+      button = useRef("button");
+      value = 0;
+      increment() {
+        this.value++;
+        (this.button.el as HTMLButtonElement).innerHTML = String(this.value);
+      }
+    }
+    const counter = new Counter();
+    expect(counter.button.el).toBe(null);
+    await counter.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><button>0</button></div>");
+    expect(counter.button.el).not.toBe(null);
+    expect(counter.button.el).toBe(fixture.querySelector("button"));
+    counter.increment();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><button>1</button></div>");
+  });
+
+  test("useRef hook is null if ref is removed ", async () => {
+    expect.assertions(4);
+    class TestRef extends Component<any, any> {
+      static template = xml`<div><span t-if="state.flag" t-ref="span">owl</span></div>`;
+      spanRef = useRef("span");
+      state = useState({ flag: true });
+      willPatch() {
+        expect(this.spanRef.el).not.toBeNull();
+      }
+      patched() {
+        expect(this.spanRef.el).toBeNull();
+      }
+    }
+    const component = new TestRef();
+    await component.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>owl</span></div>");
+    component.state.flag = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div></div>");
+  });
+
+  test("t-refs on widget are components", async () => {
+    class WidgetB extends Component<any, any> {
+      static template = xml`<div>b</div>`;
+    }
+    class WidgetC extends Component<any, any> {
+      static template = xml`<div class="outer-div">Hello<WidgetB t-ref="mywidgetb" /></div>`;
+      static components = { WidgetB };
+      ref = useRef("mywidgetb");
+    }
+
+    const widget = new WidgetC();
+    expect(widget.ref.comp).toBe(null);
+    expect(widget.ref.el).toBe(null);
+    await widget.mount(fixture);
+    expect(widget.ref.comp).toBeInstanceOf(WidgetB);
+    expect(widget.ref.el).toEqual(fixture.querySelector(".outer-div > div"));
+  });
+
+  test("t-refs are bound at proper timing", async () => {
+    expect.assertions(2);
+    class Widget extends Component<any, any> {
+      static template = xml`<div>widget</div>`;
+    }
+
+    class ParentWidget extends Component<any, any> {
+      static template = xml`
+        <div>
+          <t t-foreach="state.list" t-as="elem" t-ref="child" t-key="elem" t-component="Widget"/>
+        </div>
+      `;
+      static components = { Widget };
+      state = useState({ list: <any>[] });
+      child = useRef("child");
+      willPatch() {
+        expect(this.child.comp).toBeNull();
+      }
+      patched() {
+        expect(this.child.comp).not.toBeNull();
+      }
+    }
+
+    const parent = new ParentWidget();
+    await parent.mount(fixture);
+    parent.state.list.push(1);
+    await nextTick();
+  });
+
+  test("t-refs are bound at proper timing (2)", async () => {
+    expect.assertions(10);
+    class Widget extends Component<any, any> {
+      static template = xml`<div>widget</div>`;
+    }
+    class ParentWidget extends Component<any, any> {
+      static template = xml`
+        <div>
+          <t t-if="state.child1" t-ref="child1" t-component="Widget"/>
+          <t t-if="state.child2" t-ref="child2" t-component="Widget"/>
+        </div>`;
+      static components = { Widget };
+      state = useState({ child1: true, child2: false });
+      child1 = useRef("child1");
+      child2 = useRef("child2");
+      count = 0;
+      mounted() {
+        expect(this.child1.comp).toBeDefined();
+        expect(this.child2.comp).toBeNull();
+      }
+      willPatch() {
+        if (this.count === 0) {
+          expect(this.child1.comp).toBeDefined();
+          expect(this.child2.comp).toBeNull();
+        }
+        if (this.count === 1) {
+          expect(this.child1.comp).toBeDefined();
+          expect(this.child2.comp).toBeDefined();
+        }
+      }
+      patched() {
+        if (this.count === 0) {
+          expect(this.child1.comp).toBeDefined();
+          expect(this.child2.comp).toBeDefined();
+        }
+        if (this.count === 1) {
+          expect(this.child1.comp).toBeNull();
+          expect(this.child2.comp).toBeDefined();
+        }
+        this.count++;
+      }
+    }
+
+    const parent = new ParentWidget();
+    await parent.mount(fixture);
+    parent.state.child2 = true;
+    await nextTick();
+    parent.state.child1 = false;
+    await nextTick();
+  });
+
+  test("can use onPatched, onWillPatch", async () => {
+    const steps: string[] = [];
+    function useMyHook() {
+      onWillPatch(() => {
+        steps.push("willPatch");
+      });
+      onPatched(() => {
+        steps.push("patched");
+      });
+    }
+
+    class MyComponent extends Component<any, any> {
+      static template = xml`<div><t t-if="state.flag">hey</t></div>`;
+      state = useState({ flag: true });
+
+      constructor() {
+        super();
+        useMyHook();
+      }
+    }
+
+    const component = new MyComponent();
+    await component.mount(fixture);
+    expect(component).not.toHaveProperty("patched");
+    expect(component).not.toHaveProperty("willPatch");
+    expect(steps).toEqual([]);
+
+    expect(fixture.innerHTML).toBe("<div>hey</div>");
+    component.state.flag = false;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div></div>");
+
+    expect(steps).toEqual(["willPatch", "patched"]);
+  });
+
+  test("patched, willPatch, onPatched, onWillPatch order", async () => {
+    const steps: string[] = [];
+    function useMyHook() {
+      onPatched(() => {
+        steps.push("hook:patched");
+      });
+      onWillPatch(() => {
+        steps.push("hook:willPatch");
+      });
+    }
+    class MyComponent extends Component<any, any> {
+      static template = xml`<div><t t-if="state.flag">hey</t></div>`;
+      state = useState({ flag: true });
+
+      constructor() {
+        super();
+        useMyHook();
+      }
+      willPatch() {
+        steps.push("comp:willPatch");
+      }
+      patched() {
+        steps.push("comp:patched");
+      }
+    }
+    const component = new MyComponent();
+    await component.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>hey</div>");
+    component.state.flag = false;
+    await nextTick();
+
+    expect(steps).toEqual(["hook:willPatch", "comp:willPatch", "comp:patched", "hook:patched"]);
+  });
+
+  test("two different call to willPatch/patched should work", async () => {
+    const steps: string[] = [];
+    function useMyHook(i) {
+      onPatched(() => {
+        steps.push("hook:patched" + i);
+      });
+      onWillPatch(() => {
+        steps.push("hook:willPatch" + i);
+      });
+    }
+    class MyComponent extends Component<any, any> {
+      static template = xml`<div>hey<t t-esc="state.value"/></div>`;
+      state = useState({ value: 1 });
+      constructor() {
+        super();
+        useMyHook(1);
+        useMyHook(2);
+      }
+    }
+    const component = new MyComponent();
+    await component.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>hey1</div>");
+    component.state.value++;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div>hey2</div>");
+
+    expect(steps).toEqual(["hook:willPatch2", "hook:willPatch1", "hook:patched1", "hook:patched2"]);
+  });
+
+  describe("autofocus hook", () => {
+    function useAutofocus(name) {
+      let ref = useRef(name);
+      let isInDom = false;
+      function updateFocus() {
+        if (!isInDom && ref.el) {
+          isInDom = true;
+          ref.el.focus();
+        } else if (isInDom && !ref.el) {
+          isInDom = false;
+        }
+      }
+      onPatched(updateFocus);
+      onMounted(updateFocus);
+    }
+
+    test("simple input", async () => {
+      class SomeComponent extends Component<any, any> {
+        static template = xml`
+            <div>
+                <input t-ref="input1"/>
+                <input t-ref="input2"/>
+            </div>`;
+
+        constructor() {
+          super();
+          useAutofocus("input2");
+        }
+      }
+
+      const component = new SomeComponent();
+      await component.mount(fixture);
+      expect(fixture.innerHTML).toBe("<div><input><input></div>");
+      const input2 = fixture.querySelectorAll("input")[1];
+      expect(input2).toBe(document.activeElement);
+    });
+
+    test("input in a t-if", async () => {
+      class SomeComponent extends Component<any, any> {
+        static template = xml`
+            <div>
+                <input t-ref="input1"/>
+                <t t-if="state.flag"><input t-ref="input2"/></t>
+            </div>`;
+
+        state = useState({ flag: false });
+        constructor() {
+          super();
+          useAutofocus("input2");
+        }
+      }
+
+      const component = new SomeComponent();
+      await component.mount(fixture);
+      expect(fixture.innerHTML).toBe("<div><input></div>");
+      expect(document.activeElement).toBe(document.body);
+
+      component.state.flag = true;
+      await nextTick();
+      const input2 = fixture.querySelectorAll("input")[1];
+      expect(input2).toBe(document.activeElement);
+    });
+  });
+
+  test("can use sub env", async () => {
+    class TestComponent extends Component<any, any> {
+      static template = xml`<div><t t-esc="env.val"/></div>`;
+      constructor() {
+        super();
+        useSubEnv({ val: 3 });
+      }
+    }
+    const component = new TestComponent();
+    await component.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>3</div>");
+    expect(env).not.toHaveProperty("val");
+    expect(component.env).toHaveProperty("val");
+  });
+
+  test("parent and child env", async () => {
+    class Child extends Component<any, any> {
+      static template = xml`<div><t t-esc="env.val"/></div>`;
+      constructor(parent, props) {
+        super(parent, props);
+        useSubEnv({ val: 5 });
+      }
+    }
+
+    class Parent extends Component<any, any> {
+      static template = xml`<div><t t-esc="env.val"/><Child/></div>`;
+      static components = { Child };
+      constructor() {
+        super();
+        useSubEnv({ val: 3 });
+      }
+    }
+    const component = new Parent();
+    await component.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>3<div>5</div></div>");
+  });
+
+  test("can use onWillStart, onWillUpdateProps", async () => {
+    const steps: string[] = [];
+    function useMyHook() {
+      onWillStart(() => {
+        steps.push("onWillStart");
+      });
+      onWillUpdateProps(nextProps => {
+        expect(nextProps).toEqual({ value: 2 });
+        steps.push("onWillUpdateProps");
+      });
+    }
+    class MyComponent extends Component<any, any> {
+      static template = xml`<span><t t-esc="props.value"/></span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        useMyHook();
+      }
+    }
+    class App extends Component<any, any> {
+      static template = xml`<div><MyComponent value="state.value"/></div>`;
+      static components = { MyComponent };
+      state = useState({ value: 1 });
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+    expect(app).not.toHaveProperty("willStart");
+    expect(app).not.toHaveProperty("willUpdateProps");
+    expect(fixture.innerHTML).toBe("<div><span>1</span></div>");
+    expect(steps).toEqual(["onWillStart"]);
+
+    app.state.value = 2;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>2</span></div>");
+    expect(steps).toEqual(["onWillStart", "onWillUpdateProps"]);
+  });
+
+  test("useExternalListener", async () => {
+    let n = 0;
+
+    class MyComponent extends Component<any, any> {
+      static template = xml`<span><t t-esc="props.value"/></span>`;
+      constructor(parent, props) {
+        super(parent, props);
+        useExternalListener(window as any, "click", this.increment);
+      }
+      increment() {
+        n++;
+      }
+    }
+    class App extends Component<any, any> {
+      static template = xml`<div><MyComponent t-if="state.flag"/></div>`;
+      static components = { MyComponent };
+      state = useState({ flag: false });
+    }
+
+    const app = new App();
+    await app.mount(fixture);
+
+    expect(n).toBe(0);
+    window.dispatchEvent(new Event("click"));
+    expect(n).toBe(0);
+    app.state.flag = true;
+    await nextTick();
+    window.dispatchEvent(new Event("click"));
+    expect(n).toBe(1);
+    app.state.flag = false;
+    await nextTick();
+    window.dispatchEvent(new Event("click"));
+    expect(n).toBe(1);
+  });
+});

tests/misc/async_root.test.ts

@@ -0,0 +1,188 @@
+import { AsyncRoot } from "../../src/misc/async_root";
+import { useState } from "../../src/hooks";
+import { xml } from "../../src/tags";
+import { makeDeferred, makeTestFixture, makeTestEnv, nextTick } from "../helpers";
+import { Component } from "../../src/component/component";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - a test env, necessary to create components, that is set as env
+
+let fixture: HTMLElement;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  Component.env = makeTestEnv();
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+describe("Asyncroot", () => {
+  test("delayed component with AsyncRoot component", async () => {
+    let def;
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="props.val"/></span>`;
+    }
+    class AsyncChild extends Child {
+      willUpdateProps() {
+        return def;
+      }
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`
+          <div>
+            <button t-on-click="updateApp">Update App State</button>
+            <div class="children">
+              <Child val="state.val"/>
+              <AsyncRoot>
+                  <AsyncChild val="state.val"/>
+              </AsyncRoot>
+            </div>
+          </div>`;
+      static components = { Child, AsyncChild, AsyncRoot };
+      state = useState({ val: 0 });
+
+      updateApp() {
+        this.state.val++;
+      }
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>0</span><span>0</span>");
+
+    // click on button to increment Parent counter
+    def = makeDeferred();
+    fixture.querySelector("button")!.click();
+    await nextTick();
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>1</span><span>0</span>");
+
+    def.resolve();
+    await nextTick();
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>1</span><span>1</span>");
+  });
+
+  test("fast component with AsyncRoot", async () => {
+    let def;
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="props.val"/></span>`;
+    }
+    class AsyncChild extends Child {
+      willUpdateProps() {
+        return def;
+      }
+    }
+
+    class Parent extends Component<any, any> {
+      static template = xml`
+          <div>
+            <button t-on-click="updateApp">Update App State</button>
+            <div class="children">
+              <AsyncRoot>
+                <Child val="state.val"/>
+              </AsyncRoot>
+              <AsyncChild val="state.val"/>
+            </div>
+          </div>`;
+      static components = { Child, AsyncChild, AsyncRoot };
+      state = useState({ val: 0 });
+
+      updateApp() {
+        this.state.val++;
+      }
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>0</span><span>0</span>");
+
+    // click on button to increment Parent counter
+    def = makeDeferred();
+    fixture.querySelector("button")!.click();
+    await nextTick();
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>1</span><span>0</span>");
+
+    def.resolve();
+    await nextTick();
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>1</span><span>1</span>");
+  });
+
+  test("asyncroot component: mixed re-renderings", async () => {
+    let def;
+    class Child extends Component<any, any> {
+      static template = xml`
+        <span t-on-click="increment">
+          <t t-esc="state.val"/>/<t t-esc="props.val"/>
+        </span>`;
+      state = useState({ val: 0 });
+
+      increment() {
+        this.state.val++;
+      }
+    }
+    class AsyncChild extends Child {
+      willUpdateProps() {
+        return def;
+      }
+    }
+    class Parent extends Component<any, any> {
+      static template = xml`
+        <div>
+          <button t-on-click="updateApp">Update App State</button>
+          <div class="children">
+            <Child val="state.val"/>
+            <AsyncRoot>
+              <AsyncChild val="state.val"/>
+            </AsyncRoot>
+          </div>
+        </div>`;
+      static components = { Child, AsyncChild, AsyncRoot };
+      state = useState({ val: 0 });
+
+      updateApp() {
+        this.state.val++;
+      }
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>0/0</span><span>0/0</span>");
+
+    // click on button to increment Parent counter
+    def = makeDeferred();
+    fixture.querySelector("button")!.click();
+    await nextTick();
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>0/1</span><span>0/0</span>");
+
+    // click on each Child to increment their local counter
+    const children = parent.el!.querySelectorAll("span");
+    children[0]!.click();
+    await nextTick();
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>1/1</span><span>0/0</span>");
+
+    children[1]!.click();
+    await nextTick();
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>1/1</span><span>0/0</span>");
+
+    // finalize first re-rendering (coming from the props update)
+    def.resolve();
+    await nextTick();
+
+    expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>1/1</span><span>1/1</span>");
+  });
+});

tests/misc/portal.test.ts

@@ -0,0 +1,890 @@
+import { Portal } from "../../src/misc/portal";
+import { xml } from "../../src/tags";
+import { makeTestFixture, makeTestEnv, nextTick } from "../helpers";
+import { Component } from "../../src/component/component";
+import { useState } from "../../src/hooks";
+import { QWeb } from "../../src/qweb";
+
+//------------------------------------------------------------------------------
+// Setup and helpers
+//------------------------------------------------------------------------------
+
+// We create before each test:
+// - fixture: a div, appended to the DOM, intended to be the target of dom
+//   manipulations.  Note that it is removed after each test.
+// - outside: a div with id #outside appended into fixture, meant to be used as
+//   target by Portal component
+// - a test env, necessary to create components, that is set on Component
+
+let fixture: HTMLElement;
+let outside: HTMLElement;
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+  outside = document.createElement("div");
+  outside.setAttribute("id", "outside");
+  fixture.appendChild(outside);
+
+  Component.env = makeTestEnv();
+});
+
+afterEach(() => {
+  fixture.remove();
+});
+
+describe("Portal: Props validation", () => {
+  test("target is mandatory", async () => {
+    const dev = QWeb.dev;
+    QWeb.dev = true;
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal>
+            <div>2</div>
+          </Portal>
+        </div>`;
+    }
+    let error;
+    try {
+      const parent = new Parent();
+      await parent.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe(`Missing props 'target' (component 'Portal')`);
+
+    QWeb.dev = dev;
+  });
+
+  test("target is not list", async () => {
+    const dev = QWeb.dev;
+    QWeb.dev = true;
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="['body']">
+            <div>2</div>
+          </Portal>
+        </div>`;
+    }
+    let error;
+    try {
+      const parent = new Parent();
+      await parent.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe(`Invalid Prop 'target' in component 'Portal'`);
+
+    QWeb.dev = dev;
+  });
+});
+
+describe("Portal: Basic use and DOM placement", () => {
+  test("basic use of portal", async () => {
+    const dev = QWeb.dev;
+    QWeb.dev = true;
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <span>1</span>
+          <Portal target="'#outside'">
+            <div>2</div>
+          </Portal>
+        </div>`;
+    }
+    let error;
+    let parent;
+    try {
+      parent = new Parent();
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeUndefined();
+    await parent.mount(fixture);
+    expect(outside.innerHTML).toBe("<div>2</div>");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span><portal></portal></div>");
+    QWeb.dev = dev;
+  });
+
+  test("conditional use of Portal", async () => {
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <span>1</span>
+          <Portal target="'#outside'" t-if="state.hasPortal">
+            <div>2</div>
+          </Portal>
+        </div>`;
+
+      state = useState({ hasPortal: false });
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(outside.innerHTML).toBe("");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span></div>");
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(outside.innerHTML).toBe("<div>2</div>");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span><portal></portal></div>");
+
+    parent.state.hasPortal = false;
+    await nextTick();
+    expect(outside.innerHTML).toBe("");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span></div>");
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(outside.innerHTML).toBe("<div>2</div>");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span><portal></portal></div>");
+  });
+
+  test("conditional use of Portal (with sub Component)", async () => {
+    class Child extends Component<any, any> {
+      static template = xml`<div><t t-esc="props.val"/></div>`;
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div>
+          <span>1</span>
+          <Portal t-if="state.hasPortal" target="'#outside'">
+            <Child val="state.val"/>
+          </Portal>
+        </div>`;
+      state = useState({ hasPortal: false, val: 1 });
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(outside.innerHTML).toBe("");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span></div>");
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(outside.innerHTML).toBe("<div>1</div>");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span><portal></portal></div>");
+
+    parent.state.hasPortal = false;
+    await nextTick();
+    expect(outside.innerHTML).toBe("");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span></div>");
+
+    parent.state.val = 2;
+    await nextTick();
+    expect(outside.innerHTML).toBe("");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span></div>");
+
+    parent.state.hasPortal = true;
+    await nextTick();
+    expect(outside.innerHTML).toBe("<div>2</div>");
+    expect(parent.el!.outerHTML).toBe("<div><span>1</span><portal></portal></div>");
+  });
+
+  test("with target in template (before portal)", async () => {
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <div id="local-target"></div>
+          <span>1</span>
+          <Portal target="'#local-target'">
+            <p>2</p>
+          </Portal>
+        </div>`;
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(parent.el!.innerHTML).toBe(
+      '<div id="local-target"><p>2</p></div><span>1</span><portal></portal>'
+    );
+  });
+
+  test("with target in template (after portal)", async () => {
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <span>1</span>
+          <Portal target="'#local-target'">
+            <p>2</p>
+          </Portal>
+          <div id="local-target"></div>
+        </div>`;
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(parent.el!.innerHTML).toBe(
+      '<span>1</span><portal></portal><div id="local-target"><p>2</p></div>'
+    );
+  });
+
+  test("portal with target not in dom", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="'#does-not-exist'">
+            <div>2</div>
+          </Portal>
+        </div>`;
+    }
+
+    const parent = new Parent();
+    let error;
+    try {
+      await parent.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeDefined();
+    expect(error.message).toBe('Could not find any match for "#does-not-exist"');
+    expect(console.error).toBeCalledTimes(0);
+    expect(fixture.innerHTML).toBe(`<div id="outside"></div>`);
+    console.error = consoleError;
+  });
+
+  test("portal with child and props", async () => {
+    const steps: string[] = [];
+    class Child extends Component<any, any> {
+      static template = xml`<span><t t-esc="props.val"/></span>`;
+      mounted() {
+        steps.push("mounted");
+        expect(outside.innerHTML).toBe("<span>1</span>");
+      }
+      patched() {
+        steps.push("patched");
+        expect(outside.innerHTML).toBe("<span>2</span>");
+      }
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <Child val="state.val"/>
+          </Portal>
+        </div>`;
+      state = useState({ val: 1 });
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(outside.innerHTML).toBe("<span>1</span>");
+    expect(parent.el!.innerHTML).toBe("<portal></portal>");
+
+    parent.state.val = 2;
+    await nextTick();
+    expect(outside.innerHTML).toBe("<span>2</span>");
+    expect(parent.el!.innerHTML).toBe("<portal></portal>");
+    expect(steps).toEqual(["mounted", "patched"]);
+  });
+
+  test("portal with only text as content", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <t t-esc="'only text'"/>
+          </Portal>
+        </div>`;
+    }
+
+    const parent = new Parent();
+    let error;
+    try {
+      await parent.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Portal must have exactly one non-text child (has 0)");
+    expect(console.error).toBeCalledTimes(0);
+    expect(fixture.innerHTML).toBe(`<div id="outside"></div>`);
+    console.error = consoleError;
+  });
+
+  test("portal with no content", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <t t-if="false" t-esc="'ABC'"/>
+          </Portal>
+        </div>`;
+    }
+
+    const parent = new Parent();
+    let error;
+    try {
+      await parent.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Portal must have exactly one non-text child (has 0)");
+    expect(console.error).toBeCalledTimes(0);
+    expect(fixture.innerHTML).toBe(`<div id="outside"></div>`);
+    console.error = consoleError;
+  });
+
+  test("portal with many children", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <div>1</div>
+            <p>2</p>
+          </Portal>
+        </div>`;
+    }
+    const parent = new Parent();
+    let error;
+    try {
+      await parent.mount(fixture);
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Portal must have exactly one non-text child (has 2)");
+    expect(console.error).toBeCalledTimes(0);
+    expect(fixture.innerHTML).toBe(`<div id="outside"></div>`);
+    console.error = consoleError;
+  });
+
+  test("portal with dynamic body", async () => {
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <span t-if="state.val" t-esc="state.val"/>
+            <div t-else=""/>
+          </Portal>
+        </div>`;
+      state = useState({ val: "ab" });
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(outside.innerHTML).toBe(`<span>ab</span>`);
+
+    parent.state.val = "";
+    await nextTick();
+    expect(outside.innerHTML).toBe(`<div></div>`);
+  });
+
+  test("portal could have dynamically no content", async () => {
+    const consoleError = console.error;
+    console.error = jest.fn(() => {});
+
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <span t-if="state.val" t-esc="state.val"/>
+          </Portal>
+        </div>`;
+      state = { val: "ab" };
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(outside.innerHTML).toBe(`<span>ab</span>`);
+
+    let error;
+    try {
+      parent.state.val = "";
+      await parent.render();
+    } catch (e) {
+      error = e;
+    }
+    expect(outside.innerHTML).toBe(``);
+
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Portal must have exactly one non-text child (has 0)");
+
+    expect(console.error).toBeCalledTimes(0);
+    console.error = consoleError;
+  });
+
+  test("lifecycle hooks of portal sub component are properly called", async () => {
+    const steps: any[] = [];
+
+    class Child extends Component<any, any> {
+      static template = xml`<span t-esc="props.val"/>`;
+      mounted() {
+        steps.push("child:mounted");
+      }
+      willPatch() {
+        steps.push("child:willPatch");
+      }
+      patched() {
+        steps.push("child:patched");
+      }
+      willUnmount() {
+        steps.push("child:willUnmount");
+      }
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div>
+          <Portal t-if="state.hasChild" target="'#outside'">
+            <Child val="state.val"/>
+          </Portal>
+        </div>`;
+      state = useState({ hasChild: false, val: 1 });
+      mounted() {
+        steps.push("parent:mounted");
+      }
+      willPatch() {
+        steps.push("parent:willPatch");
+      }
+      patched() {
+        steps.push("parent:patched");
+      }
+      willUnmount() {
+        steps.push("parent:willUnmount");
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    expect(steps).toEqual(["parent:mounted"]);
+
+    parent.state.hasChild = true;
+    await nextTick();
+    expect(steps).toEqual([
+      "parent:mounted",
+      "parent:willPatch",
+      "child:mounted",
+      "parent:patched"
+    ]);
+
+    parent.state.val = 2;
+    await nextTick();
+    expect(steps).toEqual([
+      "parent:mounted",
+      "parent:willPatch",
+      "child:mounted",
+      "parent:patched",
+      "parent:willPatch",
+      "child:willPatch",
+      "child:patched",
+      "parent:patched"
+    ]);
+
+    parent.state.hasChild = false;
+    await nextTick();
+    expect(steps).toEqual([
+      "parent:mounted",
+      "parent:willPatch",
+      "child:mounted",
+      "parent:patched",
+      "parent:willPatch",
+      "child:willPatch",
+      "child:patched",
+      "parent:patched",
+      "parent:willPatch",
+      "child:willUnmount",
+      "parent:patched"
+    ]);
+  });
+
+  test("portal destroys on crash", async () => {
+    class Child extends Component<any, any> {
+      static template = xml`<span t-esc="props.error and this.will.crash" />`;
+      state = {};
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'" >
+            <Child error="state.error"/>
+          </Portal>
+        </div>`;
+      state = { error: false };
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    parent.state.error = true;
+
+    let error;
+    try {
+      await parent.render();
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toBe("Cannot read property 'crash' of undefined");
+  });
+
+  test("portal manual unmount", async () => {
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <span>gloria</span>
+          </Portal>
+        </div>`;
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(outside.innerHTML).toBe("<span>gloria</span>");
+    expect(parent.el!.innerHTML).toBe("<portal></portal>");
+
+    parent.unmount();
+    expect(outside.innerHTML).toBe("");
+    expect(parent.el!.innerHTML).toBe("<portal><span>gloria</span></portal>");
+
+    await parent.mount(fixture);
+    expect(outside.innerHTML).toBe("<span>gloria</span>");
+    expect(parent.el!.innerHTML).toBe("<portal></portal>");
+  });
+
+  test("portal manual unmount with subcomponent", async () => {
+    expect.assertions(9);
+    class Child extends Component<any, any> {
+      static template = xml`<span>gloria</span>`;
+      mounted() {
+        expect(outside.contains(this.el)).toBeTruthy();
+      }
+      willUnmount() {
+        expect(outside.contains(this.el)).toBeTruthy();
+      }
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <Child />
+          </Portal>
+        </div>`;
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(outside.innerHTML).toBe("<span>gloria</span>");
+    expect(parent.el!.innerHTML).toBe("<portal></portal>");
+
+    parent.unmount();
+    expect(outside.innerHTML).toBe("");
+    expect(parent.el!.innerHTML).toBe("<portal><span>gloria</span></portal>");
+
+    await parent.mount(fixture);
+    expect(outside.innerHTML).toBe("<span>gloria</span>");
+    expect(parent.el!.innerHTML).toBe("<portal></portal>");
+  });
+});
+
+describe("Portal: Events handling", () => {
+  test("events triggered on movable pure node are handled", async () => {
+    class Parent extends Component<any, any> {
+      static components = { Portal };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <span id="trigger-me" t-on-custom="_onCustom" t-esc="state.val"/>
+          </Portal>
+        </div>`;
+      state = useState({ val: "ab" });
+
+      _onCustom() {
+        this.state.val = "triggered";
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(outside.innerHTML).toBe(`<span id="trigger-me">ab</span>`);
+    outside.querySelector("#trigger-me")!.dispatchEvent(new Event("custom"));
+    await nextTick();
+    expect(outside.innerHTML).toBe(`<span id="trigger-me">triggered</span>`);
+  });
+
+  test("events triggered on movable owl components are redirected", async () => {
+    let childInst: Component<any, any> | null = null;
+    class Child extends Component<any, any> {
+      static template = xml`
+         <span t-on-custom="_onCustom" t-esc="props.val"/>`;
+
+      constructor(parent, props) {
+        super(parent, props);
+        childInst = this;
+      }
+
+      _onCustom() {
+        this.trigger("custom-portal");
+      }
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div t-on-custom-portal="_onCustomPortal">
+          <Portal target="'#outside'">
+            <Child val="state.val"/>
+          </Portal>
+        </div>`;
+      state = useState({ val: "ab" });
+
+      _onCustomPortal() {
+        this.state.val = "triggered";
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    expect(outside.innerHTML).toBe(`<span>ab</span>`);
+    childInst!.trigger("custom");
+    await nextTick();
+    expect(outside.innerHTML).toBe(`<span>triggered</span>`);
+  });
+
+  test("events triggered on contained movable owl components are redirected", async () => {
+    const steps: string[] = [];
+    let childInst: Component<any, any> | null = null;
+    class Child extends Component<any, any> {
+      static template = xml`
+         <span t-on-custom="_onCustom"/>`;
+
+      constructor(parent, props) {
+        super(parent, props);
+        childInst = this;
+      }
+
+      _onCustom() {
+        this.trigger("custom-portal");
+      }
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div t-on-custom="_handled" t-on-custom-portal="_handled">
+          <Portal target="'#outside'">
+            <div>
+              <Child/>
+            </div>
+          </Portal>
+        </div>`;
+
+      _handled(ev) {
+        steps.push(ev.type);
+      }
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    childInst!.trigger("custom");
+    await nextTick();
+
+    // This is expected because trigger is synchronous
+    expect(steps).toMatchObject(["custom-portal", "custom"]);
+  });
+
+  test("Dom events are not mapped", async () => {
+    let childInst: Component<any, any> | null = null;
+    const steps: string[] = [];
+    class Child extends Component<any, any> {
+      static template = xml`
+        <button>child</button>`;
+
+      constructor(parent, props) {
+        super(parent, props);
+        childInst = this;
+      }
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div t-on-click="_handled">
+          <Portal target="'#outside'">
+            <Child />
+          </Portal>
+        </div>`;
+
+      _handled(ev) {
+        steps.push(ev.type as string);
+      }
+    }
+    const bodyListener = ev => {
+      steps.push(`body: ${ev.type}`);
+    };
+    document.body.addEventListener("click", bodyListener);
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+    childInst!.el!.click();
+
+    expect(steps).toEqual(["body: click"]);
+    document.body.removeEventListener("click", bodyListener);
+  });
+
+  test("Nested portals event propagation", async () => {
+    const outside2 = document.createElement("div");
+    outside2.setAttribute("id", "outside2");
+    fixture.appendChild(outside2);
+
+    const steps: Array<string> = [];
+    let childInst: Component<any, any> | null = null;
+    class Child2 extends Component<any, any> {
+      static template = xml`<div>child2</div>`;
+      constructor(parent, props) {
+        super(parent, props);
+        childInst = this;
+      }
+    }
+    class Child extends Component<any, any> {
+      static components = { Portal, Child2 };
+      static template = xml`
+        <Portal target="'#outside2'">
+          <Child2 />
+        </Portal>`;
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div t-on-custom='_handled'>
+          <Portal target="'#outside'">
+            <Child/>
+          </Portal>
+        </div>`;
+
+      _handled(ev) {
+        steps.push(`${ev.type} from ${ev.originalComponent.constructor.name}`);
+      }
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    childInst!.trigger("custom");
+    expect(steps).toEqual(["custom from Child2"]);
+  });
+
+  test("portal's parent's env is not polluted", async () => {
+    class Child extends Component<any, any> {
+      static template = xml`
+        <button>child</button>`;
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <Child />
+          </Portal>
+        </div>`;
+    }
+    const parent = new Parent();
+    const parentEnv = Object.assign({}, parent.env);
+    await parent.mount(fixture);
+    expect(parentEnv).toStrictEqual(parent.env);
+  });
+
+  test("Portal composed with t-slot", async () => {
+    const steps: Array<string> = [];
+    let childInst: Component<any, any> | null = null;
+    class Child2 extends Component<any, any> {
+      static template = xml`<div>child2</div>`;
+      constructor(parent, props) {
+        super(parent, props);
+        childInst = this;
+      }
+    }
+    class Child extends Component<any, any> {
+      static components = { Portal, Child2 };
+      static template = xml`
+        <Portal target="'#outside'">
+          <t t-slot="default"/>
+        </Portal>`;
+    }
+    class Parent extends Component<any, any> {
+      static components = { Child, Child2 };
+      static template = xml`
+        <div t-on-custom='_handled'>
+          <Child>
+            <Child2/>
+          </Child>
+        </div>`;
+
+      _handled(ev) {
+        steps.push(ev.type as string);
+      }
+    }
+
+    const parent = new Parent();
+    await parent.mount(fixture);
+
+    childInst!.trigger("custom");
+    expect(steps).toEqual(["custom"]);
+  });
+});
+
+describe("Portal: UI/UX", () => {
+  test("focus is kept across re-renders", async () => {
+    class Child extends Component<any, any> {
+      static template = xml`
+        <input id="target-me" t-att-placeholder="props.val"/>`;
+    }
+    class Parent extends Component<any, any> {
+      static components = { Portal, Child };
+      static template = xml`
+        <div>
+          <Portal target="'#outside'">
+            <Child val="state.val"/>
+          </Portal>
+        </div>`;
+      state = useState({ val: "ab" });
+    }
+    const parent = new Parent();
+    await parent.mount(fixture);
+    const input = document.querySelector("#target-me");
+    expect(input!.nodeName).toBe("INPUT");
+    expect((input as HTMLInputElement).placeholder).toBe("ab");
+
+    (input as HTMLInputElement).focus();
+    expect(document.activeElement === input).toBeTruthy();
+
+    parent.state.val = "bc";
+    await nextTick();
+    const inputReRendered = document.querySelector("#target-me");
+    expect(inputReRendered!.nodeName).toBe("INPUT");
+    expect((inputReRendered as HTMLInputElement).placeholder).toBe("bc");
+    expect(document.activeElement === inputReRendered).toBeTruthy();
+  });
+});

tests/observer.test.ts

@@ -1,321 +0,0 @@
-import { Observer } from "../src/observer";
-import { nextMicroTick } from "./helpers";
-
-describe("observer", () => {
-  test("properly observe objects", () => {
-    const observer = new Observer();
-    const obj: any = {};
-
-    observer.observe(obj);
-    expect(obj.__owl__.rev).toBe(1);
-    expect(observer.rev).toBe(1);
-
-    const ob2: any = { a: 1 };
-    observer.observe(ob2);
-    expect(ob2.__owl__.rev).toBe(1);
-    ob2.a = 2;
-    expect(observer.rev).toBe(2);
-    expect(ob2.__owl__.rev).toBe(2);
-
-    ob2.b = 3;
-    expect(observer.rev).toBe(2);
-    expect(ob2.__owl__.rev).toBe(2);
-
-    observer.set(ob2, "b", 4);
-    expect(observer.rev).toBe(3);
-    expect(ob2.__owl__.rev).toBe(3);
-  });
-
-  test("properly handle null or undefined", () => {
-    const observer = new Observer();
-    const obj: any = { a: null, b: undefined };
-
-    observer.observe(obj);
-    expect(obj.__owl__.rev).toBe(1);
-    expect(observer.rev).toBe(1);
-
-    obj.a = 3;
-    expect(obj.__owl__.rev).toBe(2);
-
-    obj.b = 5;
-    expect(obj.__owl__.rev).toBe(3);
-
-    obj.a = null;
-    obj.b = undefined;
-    expect(obj.__owl__.rev).toBe(5);
-  });
-
-  test("can change values in array", () => {
-    const observer = new Observer();
-    const obj: any = { arr: [1, 2] };
-
-    observer.observe(obj);
-    expect(obj.arr.__owl__.rev).toBe(1);
-    expect(observer.rev).toBe(1);
-
-    obj.arr[0] = "nope";
-    expect(obj.arr.__owl__.rev).toBe(1);
-    expect(observer.rev).toBe(1);
-
-    observer.set(obj.arr, 0, "yep");
-    expect(obj.arr.__owl__.rev).toBe(2);
-    expect(observer.rev).toBe(2);
-  });
-
-  test("various object property changes", () => {
-    const observer = new Observer();
-    const obj: any = { a: 1 };
-    observer.observe(obj);
-    expect(obj.__owl__.rev).toBe(1);
-    obj.a = 2;
-    expect(observer.rev).toBe(2);
-    expect(obj.__owl__.rev).toBe(2);
-
-    // same value again
-    obj.a = 2;
-    expect(observer.rev).toBe(2);
-    expect(obj.__owl__.rev).toBe(2);
-
-    obj.a = 3;
-    expect(observer.rev).toBe(3);
-    expect(obj.__owl__.rev).toBe(3);
-  });
-
-  test("properly observe arrays", () => {
-    const observer = new Observer();
-    const arr: any = [];
-    observer.observe(arr);
-    expect(arr.__owl__.rev).toBe(1);
-    expect(observer.rev).toBe(1);
-    expect(arr.length).toBe(0);
-
-    arr.push(1);
-    expect(arr.__owl__.rev).toBe(2);
-    expect(observer.rev).toBe(2);
-    expect(arr.length).toBe(1);
-
-    arr.splice(1, 0, "hey");
-    expect(arr.__owl__.rev).toBe(3);
-    expect(observer.rev).toBe(3);
-    expect(arr.length).toBe(2);
-
-    arr.unshift("lindemans");
-    expect(arr.__owl__.rev).toBe(4);
-
-    arr.reverse();
-    expect(arr.__owl__.rev).toBe(5);
-
-    arr.pop();
-    expect(arr.__owl__.rev).toBe(6);
-
-    arr.shift();
-    expect(arr.__owl__.rev).toBe(7);
-
-    arr.sort();
-    expect(arr.__owl__.rev).toBe(8);
-
-    expect(arr).toEqual([1]);
-  });
-
-  test("object pushed into arrays are observed", () => {
-    const observer = new Observer();
-    const arr: any = [];
-    observer.observe(arr);
-    expect(observer.rev).toBe(1);
-
-    arr.push({ kriek: 5 });
-    expect(observer.rev).toBe(2);
-    expect(arr.__owl__.rev).toBe(2);
-    expect(arr[0].__owl__.rev).toBe(1);
-
-    arr[0].kriek = 6;
-    expect(observer.rev).toBe(3);
-    expect(arr.__owl__.rev).toBe(2);
-    expect(arr[0].__owl__.rev).toBe(2);
-  });
-
-  test("properly observe arrays in object", () => {
-    const observer = new Observer();
-    const state: any = { arr: [] };
-    observer.observe(state);
-    expect(state.arr.__owl__.rev).toBe(1);
-    expect(observer.rev).toBe(1);
-    expect(state.arr.length).toBe(0);
-
-    state.arr.push(1);
-    expect(state.arr.__owl__.rev).toBe(2);
-    expect(observer.rev).toBe(2);
-    expect(state.arr.length).toBe(1);
-  });
-
-  test("properly observe objects in array", () => {
-    const observer = new Observer();
-    const state: any = { arr: [{ something: 1 }] };
-    observer.observe(state);
-    expect(state.arr.__owl__.rev).toBe(1);
-    expect(state.arr[0].__owl__.rev).toBe(1);
-
-    state.arr[0].something = 2;
-    expect(state.arr.__owl__.rev).toBe(1);
-    expect(state.arr[0].__owl__.rev).toBe(2);
-  });
-
-  test("properly observe objects in object", () => {
-    const observer = new Observer();
-    const state: any = { a: { b: 1 } };
-    observer.observe(state);
-    expect(state.__owl__.rev).toBe(1);
-    expect(state.a.__owl__.rev).toBe(1);
-
-    state.a.b = 2;
-    expect(state.__owl__.rev).toBe(1);
-    expect(state.a.__owl__.rev).toBe(2);
-  });
-
-  test("reobserve new object values", () => {
-    const observer = new Observer();
-    const obj: any = { a: 1 };
-    observer.observe(obj);
-    expect(obj.__owl__.rev).toBe(1);
-    obj.a = { b: 2 };
-    expect(observer.rev).toBe(2);
-    expect(obj.__owl__.rev).toBe(2);
-    expect(obj.a.__owl__.rev).toBe(1);
-
-    obj.a.b = 3;
-    expect(observer.rev).toBe(3);
-    expect(obj.__owl__.rev).toBe(2);
-    expect(obj.a.__owl__.rev).toBe(2);
-  });
-
-  test("deep observe misc changes", () => {
-    const observer = new Observer();
-    const state: any = { o: { a: 1 }, arr: [1], n: 13 };
-    observer.observe(state);
-    expect(state.__owl__.rev).toBe(1);
-    expect(state.__owl__.deepRev).toBe(1);
-
-    state.o.a = 2;
-    expect(observer.rev).toBe(2);
-    expect(state.__owl__.rev).toBe(1);
-    expect(state.__owl__.deepRev).toBe(2);
-
-    state.arr.push(2);
-    expect(state.__owl__.rev).toBe(1);
-    expect(state.__owl__.deepRev).toBe(3);
-
-    state.n = 155;
-    expect(state.__owl__.rev).toBe(2);
-    expect(state.__owl__.deepRev).toBe(4);
-  });
-
-  test("properly handle already observed state", () => {
-    const observer = new Observer();
-    const obj1: any = { a: 1 };
-    const obj2: any = { b: 1 };
-    observer.observe(obj1);
-    observer.observe(obj2);
-    expect(obj1.__owl__.rev).toBe(1);
-    expect(obj2.__owl__.rev).toBe(1);
-
-    obj1.a = 2;
-    obj2.b = 3;
-    expect(obj1.__owl__.rev).toBe(2);
-    expect(obj2.__owl__.rev).toBe(2);
-
-    obj2.b = obj1;
-    expect(obj1.__owl__.rev).toBe(2);
-    expect(obj2.__owl__.rev).toBe(3);
-  });
-
-  test("properly handle swapping elements", () => {
-    const observer = new Observer();
-    const obj: any = { a: { arr: [] }, b: 1 };
-    observer.observe(obj);
-
-    // swap a and b
-    const b = obj.b;
-    obj.b = obj.a;
-    obj.a = b;
-    expect(observer.rev).toBe(3);
-
-    // push something into array to make sure it works
-    obj.b.arr.push("blanche");
-    expect(observer.rev).toBe(4);
-  });
-
-  test("properly handle assigning observed obj containing array", () => {
-    const observer = new Observer();
-    const obj: any = { a: { arr: [], val: "test" } };
-    observer.observe(obj);
-
-    obj.a = { ...obj.a, val: "test2" };
-    expect(observer.rev).toBe(2);
-
-    // push something into array to make sure it works
-    obj.a.arr.push("blanche");
-    expect(observer.rev).toBe(3);
-  });
-
-  test("accept cycles in observed state", () => {
-    const observer = new Observer();
-    const obj1: any = {};
-    const obj2: any = { b: obj1, key: 1 };
-    obj1.a = obj2;
-    observer.observe(obj1);
-    expect(obj1.__owl__.rev).toBe(1);
-    expect(obj2.__owl__.rev).toBe(1);
-
-    obj2.key = 3;
-    expect(obj1.__owl__.rev).toBe(1);
-    expect(obj2.__owl__.rev).toBe(2);
-  });
-
-  test("call callback when state is changed", async () => {
-    const observer = new Observer();
-    observer.notifyCB = jest.fn();
-    const obj: any = { a: 1, b: { c: 2 }, d: [{ e: 3 }], f: 4 };
-
-    observer.observe(obj);
-    expect(observer.notifyCB).toBeCalledTimes(0);
-
-    obj.a = 2;
-    await nextMicroTick();
-    expect(observer.notifyCB).toBeCalledTimes(1);
-
-    obj.b.c = 3;
-    await nextMicroTick();
-    expect(observer.notifyCB).toBeCalledTimes(2);
-
-    obj.d[0].e = 5;
-    await nextMicroTick();
-    expect(observer.notifyCB).toBeCalledTimes(3);
-
-    obj.a = 111;
-    obj.f = 222;
-    await nextMicroTick();
-    expect(observer.notifyCB).toBeCalledTimes(4);
-  });
-
-  test("throw error when state is mutated in object if allowMutation=false", async () => {
-    const observer = new Observer();
-    observer.allowMutations = false;
-    const obj: any = { a: 1 };
-    observer.observe(obj);
-
-    expect(() => {
-      obj.a = 2;
-    }).toThrow('Observed state cannot be changed here! (key: "a", val: "2")');
-  });
-
-  test("throw error when state is mutated in array if allowMutation=false", async () => {
-    const observer = new Observer();
-    observer.allowMutations = false;
-    const obj: any = { a: [1] };
-    observer.observe(obj);
-
-    expect(() => {
-      obj.a.push(2);
-    }).toThrow("Array cannot be changed here");
-  });
-});

tests/qweb/qweb_expressions.test.ts

@@ -0,0 +1,199 @@
+import { compileExpr, tokenize } from "../../src/qweb/expression_parser";
+
+describe("tokenizer", () => {
+  test("simple tokens", () => {
+    expect(tokenize("1.3")).toEqual([{ type: "VALUE", value: "1.3" }]);
+
+    expect(tokenize("{}")).toEqual([
+      { type: "LEFT_BRACE", value: "{" },
+      { type: "RIGHT_BRACE", value: "}" }
+    ]);
+    expect(tokenize("{ }}")).toEqual([
+      { type: "LEFT_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" }]);
+    expect(tokenize("abcde")).toEqual([{ type: "SYMBOL", value: "abcde" }]);
+    expect(tokenize("_ab2")).toEqual([{ type: "SYMBOL", value: "_ab2" }]);
+    expect(tokenize("$ab2")).toEqual([{ type: "SYMBOL", value: "$ab2" }]);
+    expect(tokenize("ABC")).toEqual([{ type: "SYMBOL", value: "ABC" }]);
+
+    expect(tokenize("{a: 2}")).toEqual([
+      { type: "LEFT_BRACE", value: "{" },
+      { type: "SYMBOL", value: "a" },
+      { type: "COLON", value: ":" },
+      { type: "VALUE", value: "2" },
+      { type: "RIGHT_BRACE", value: "}" }
+    ]);
+    expect(tokenize("a,")).toEqual([
+      { type: "SYMBOL", value: "a" },
+      { type: "COMMA", value: "," }
+    ]);
+    expect(tokenize("][")).toEqual([
+      { type: "RIGHT_BRACKET", value: "]" },
+      { type: "LEFT_BRACKET", value: "[" }
+    ]);
+  });
+
+  test("various operators", () => {
+    expect(tokenize(">= <= < > !== !=")).toEqual([
+      { type: "OPERATOR", value: ">=" },
+      { 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" }
+    ]);
+
+    expect(tokenize("a...1")).toEqual([
+      { type: "SYMBOL", value: "a" },
+      { type: "OPERATOR", value: "..." },
+      { type: "VALUE", value: "1" }
+    ]);
+
+    expect(tokenize("a in b")).toEqual([
+      { type: "SYMBOL", value: "a" },
+      { type: "OPERATOR", value: "in " },
+      { type: "SYMBOL", value: "b" }
+    ]);
+  });
+
+  test("strings", () => {
+    expect(() => tokenize("'")).toThrow("Invalid expression");
+    expect(() => tokenize("'\\")).toThrow("Invalid expression");
+    expect(() => tokenize("'\\'")).toThrow("Invalid expression");
+    expect(tokenize("'hello ged'")).toEqual([{ type: "VALUE", value: "'hello ged'" }]);
+    expect(tokenize("'hello \\'ged\\''")).toEqual([{ type: "VALUE", value: "'hello \\'ged\\''" }]);
+
+    expect(() => tokenize('"')).toThrow("Invalid expression");
+    expect(() => tokenize('"\\"')).toThrow("Invalid expression");
+    expect(tokenize('"hello ged"')).toEqual([{ type: "VALUE", value: '"hello ged"' }]);
+    expect(tokenize('"hello ged"}')).toEqual([
+      { type: "VALUE", value: '"hello ged"' },
+      { type: "RIGHT_BRACE", value: "}" }
+    ]);
+    expect(tokenize('"hello \\"ged\\""')).toEqual([{ type: "VALUE", value: '"hello \\"ged\\""' }]);
+  });
+});
+
+describe("expression evaluation", () => {
+  test("simple static values", () => {
+    expect(compileExpr("1", {})).toBe("1");
+    expect(compileExpr("1 ", {})).toBe("1");
+    expect(compileExpr("'some string#/, {' ", {})).toBe("'some string#/, {'");
+    expect(compileExpr("{ } ", {})).toBe("{}");
+    expect(compileExpr("{a: 1} ", {})).toBe("{a:1}");
+    expect(compileExpr("{a: 1, b: 2   } ", {})).toBe("{a:1,b:2}");
+    expect(compileExpr("[] ", {})).toBe("[]");
+    expect(compileExpr("[1] ", {})).toBe("[1]");
+    expect(compileExpr("['1', '2'] ", {})).toBe("['1','2']");
+    expect(compileExpr("['1', \"2\"] ", {})).toBe("['1',\"2\"]");
+  });
+
+  test("various types of 'words'", () => {
+    expect(compileExpr("true", {})).toBe("true");
+    expect(compileExpr("false", {})).toBe("false");
+    expect(compileExpr("debugger", {})).toBe("debugger");
+  });
+
+  test("parenthesis", () => {
+    expect(compileExpr("(1)", {})).toBe("(1)");
+    expect(compileExpr("a*(1 +3)", {})).toBe("scope['a']*(1+3)");
+  });
+
+  test("objects and sub objects", () => {
+    expect(compileExpr("{a:{b:1}} ", {})).toBe("{a:{b:1}}");
+  });
+
+  test("replacing variables", () => {
+    expect(compileExpr("a", {})).toBe("scope['a']");
+    expect(compileExpr("a", { a: { id: "_3", expr: "scope._3" } })).toBe("scope._3");
+  });
+
+  test("arrays and objects", () => {
+    expect(compileExpr("[{b:1}] ", {})).toBe("[{b:1}]");
+    expect(compileExpr("{a: []} ", {})).toBe("{a:[]}");
+    expect(compileExpr("[{b:1, c: [1, {d: {e: 3}} ]}] ", {})).toBe("[{b:1,c:[1,{d:{e:3}}]}]");
+  });
+
+  test("dot operator", () => {
+    expect(compileExpr("a.b", {})).toBe("scope['a'].b");
+    expect(compileExpr("a.b.c", {})).toBe("scope['a'].b.c");
+  });
+
+  test("various unary operators", () => {
+    expect(compileExpr("!flag", {})).toBe("!scope['flag']");
+    expect(compileExpr("-3", {})).toBe("-3");
+    expect(compileExpr("-a", {})).toBe("-scope['a']");
+    expect(compileExpr("typeof a", {})).toBe("typeof scope['a']");
+  });
+
+  test("various binary operators", () => {
+    expect(compileExpr("color == 'black'", {})).toBe("scope['color']=='black'");
+    expect(compileExpr("a || b", {})).toBe("scope['a']||scope['b']");
+    expect(compileExpr("color === 'black'", {})).toBe("scope['color']==='black'");
+    expect(compileExpr("'li_'+item", {})).toBe("'li_'+scope['item']");
+    expect(compileExpr("state.val > 1", {})).toBe("scope['state'].val>1");
+    expect(compileExpr("a in b", {})).toBe("scope['a']in scope['b']");
+  });
+
+  test("boolean operations", () => {
+    expect(compileExpr("a && b", {})).toBe("scope['a']&&scope['b']");
+  });
+
+  test("ternary operators", () => {
+    expect(compileExpr("a ? b: '2'", {})).toBe("scope['a']?scope['b']:'2'");
+    expect(compileExpr("a ? b: (c or '2') ", {})).toBe("scope['a']?scope['b']:(scope['c']||'2')");
+    expect(compileExpr("a ? {test:c}: [1,u]", {})).toBe(
+      "scope['a']?{test:scope['c']}:[1,scope['u']]"
+    );
+  });
+
+  test("word replacement", () => {
+    expect(compileExpr("a or b", {})).toBe("scope['a']||scope['b']");
+    expect(compileExpr("a and b", {})).toBe("scope['a']&&scope['b']");
+  });
+
+  test("function calls", () => {
+    expect(compileExpr("a()", {})).toBe("scope['a']()");
+    expect(compileExpr("a(1)", {})).toBe("scope['a'](1)");
+    expect(compileExpr("a(1,2)", {})).toBe("scope['a'](1,2)");
+    expect(compileExpr("a(1,2,{a:[a]})", {})).toBe("scope['a'](1,2,{a:[scope['a']]})");
+    expect(compileExpr("'x'.toUpperCase()", {})).toBe("'x'.toUpperCase()");
+    expect(compileExpr("'x'.toUpperCase({a: 3})", {})).toBe("'x'.toUpperCase({a:3})");
+    expect(compileExpr("'x'.toUpperCase(a)", { a: { id: "_v5", expr: "scope._v5" } })).toBe(
+      "'x'.toUpperCase(scope._v5)"
+    );
+    expect(compileExpr("'x'.toUpperCase({b: a})", { a: { id: "_v5", expr: "scope._v5" } })).toBe(
+      "'x'.toUpperCase({b:scope._v5})"
+    );
+  });
+
+  test("arrow functions", () => {
+    expect(compileExpr("list.map(e => e.val)", {})).toBe("scope['list'].map(e=>e.val)");
+    expect(compileExpr("list.map(e => a + e)", {})).toBe("scope['list'].map(e=>scope['a']+e)");
+    expect(compileExpr("list.map((e) => e)", {})).toBe("scope['list'].map((e)=>e)");
+    expect(compileExpr("list.map((elem, index) => elem + index)", {})).toBe(
+      "scope['list'].map((elem,index)=>elem+index)"
+    );
+  });
+
+  test("assignation", () => {
+    expect(compileExpr("a = b", {})).toBe("scope['a']=scope['b']");
+    expect(compileExpr("a += b", {})).toBe("scope['a']+=scope['b']");
+    expect(compileExpr("a -= b", {})).toBe("scope['a']-=scope['b']");
+    expect(compileExpr("a.b = !a.b", {})).toBe("scope['a'].b=!scope['a'].b");
+  });
+
+  test("spread operator", () => {
+    expect(compileExpr("[...state.list]", {})).toBe("[...scope['state'].list]");
+    expect(compileExpr("f(...state.list)", {})).toBe("scope['f'](...scope['state'].list)");
+    expect(compileExpr("f([...list])", {})).toBe("scope['f']([...scope['list']])");
+  });
+});

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

@@ -0,0 +1,22 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Link component can render simple cases 1`] = `
+"function anonymous(context, extra
+) {
+    // Template name: \\"__template__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}));
+    }
+    return vn6;
+}"
+`;