[REL] bump to v0.16.0

[REF] *: reformat with prettier and printWidth=100
closes #214
2025-10-06 19:59:41 +07:00 · 2019-06-28 11:20:29 +02:00 · 2019-06-28 10:33:13 +02:00 · 2019-06-28 10:12:56 +02:00 · 2019-06-28 09:49:41 +02:00 · 2019-06-28 09:45:43 +02:00
137 changed files with 23277 additions and 4191 deletions
@@ -1,5 +1,6 @@
 /node_modules
 /dist
+
 npm-debug.log

 # misc
@@ -14,8 +15,12 @@ yarn-debug.log*
 yarn-error.log*

 package-lock.json
+
+#ide's
 .vscode
+.idea
+
 node_modules

 # Extras temp file
-/extras/owl.js
+/tools/owl.js
@@ -10,7 +10,7 @@ other Odoo related projects. OWL's main feature is a _declarative component syst

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

-## OWL's design principles
+## OWL's Design Principles

 OWL is designed to be used in highly dynamic applications where changing
 requirements are common, code needs to be maintained by large teams.
@@ -30,12 +30,20 @@ Owl is not designed to be fast or small (even though it is quite good on those
 two topics). If you are interested in a comparison with React or Vue, you will
 find some more information [here](doc/comparison.md).

-# Example
+## Example

-Here is a short example to illustrate interactive widgets:
+Here is a short example to illustrate interactive components:
+
+```xml
+<templates>
+  <button t-name="Counter" t-on-click="increment">
+    Click Me! [<t t-esc="state.value"/>]
+  </button>
+</templates>
+```

 ```javascript
-class ClickCounter extends owl.Component {
+class Counter extends owl.Component {
  state = { value: 0 };

  increment() {
@@ -43,36 +51,33 @@ class ClickCounter extends owl.Component {
  }
 }

-const TEMPLATES = `
-    <button t-name="ClickCounter" t-on-click="increment">
-        Click Me! [<t t-esc="state.value"/>]
-    </button>`;
-
 const qweb = new owl.QWeb(TEMPLATES);
-const counter = new ClickCounter({ qweb });
+const counter = new Counter({ qweb });
 counter.mount(document.body);
 ```

-More interesting examples can be found on the [playground](https://odoo.github.io/owl/playground) application.
+Note that we assume here that the xml templates are available in the `TEMPLATES`
+string. More interesting examples can be found on the
+[playground](https://odoo.github.io/owl/playground) application.

 ## Installing/Building

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

- [owl-0.12.0.js](https://github.com/odoo/owl/releases/download/v0.12.0/owl.js)
- [owl-0.12.0.min.js](https://github.com/odoo/owl/releases/download/v0.12.0/owl.min.js)
+- [owl-0.16.0.js](https://github.com/odoo/owl/releases/download/v0.16.0/owl.js)
+- [owl-0.16.0.min.js](https://github.com/odoo/owl/releases/download/v0.16.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 tests                                                                   |
-| `npm run test:watch`   | run all tests, and keep a watcher                                               |
-| `npm run extras`       | build extras applications, start a static server (see [here](extras/readme.md)) |
-| `npm run extras:watch` | same as `extras`, but with a watcher to rebuild owl                             |
+| 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                                            |
+| `npm run tools`       | build tools applications, start a static server (see [here](doc/tooling.md)) |
+| `npm run tools:watch` | same as `tools`, but with a watcher to rebuild owl                           |

 ## Documentation

@@ -82,6 +87,9 @@ The complete documentation can be found [here](doc/readme.md). The most importan
 - [Component](doc/component.md)
 - [QWeb](doc/qweb.md)

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

 OWL is [GPL licensed](./LICENSE).
@@ -1,16 +1,14 @@
 # 🦉 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
+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>
 ```
@@ -19,7 +17,7 @@ with the following CSS:

 ```css
 btn {
-    background-color: gray;
+  background-color: gray;
 }

 .flash {
@@ -35,10 +33,64 @@ btn {
 will produce a nice flash effect whenever the user click (or activate with the
 keyboard) the button.

-## CSS Transitions (single element)
+## 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.
+of the page. For example, we may want a fade-in and fade-out effect.

-The `t-transition` directive is here to help us (see [QWeb documentation](qweb.md#t-transition-directive)).
+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
+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:
+
+- more information on animations are available [here](animations.md).
+- 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)
@@ -7,6 +7,8 @@ In this page, we try to highlight some of these differences. Obviously, some
 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)
 - [Tooling/Build Step](#toolingbuild-step)
 - [Templating](#templating)
@@ -14,7 +16,7 @@ discussed, feel free to open an issue/submit a PR to correct this text.
 - [Reactiveness](#reactiveness)
 - [State Management](#state-management)

-### 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.
@@ -26,7 +28,7 @@ than React and Vue. Also, jQuery is not the same kind of framework, but it is in
 | React + ReactDOM + Redux |                 | 40kb                     |
 | jQuery                   | 86kb            | 30kb                     |

-### Tooling/Build step
+## 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
@@ -84,22 +86,22 @@ 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
+## 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() {
@@ -115,7 +117,7 @@ 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.

-### 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.
@@ -129,7 +131,7 @@ 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.

-### 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
@@ -190,5 +192,5 @@ keeps track of who get data, and retrigger a render when it was changed.

 Owl store is a little bit like a mix of redux and vuex: it has 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
+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.
@@ -4,15 +4,23 @@

 - [Overview](#overview)
 - [Example](#example)
- [Composition](#composition)
 - [Reference](#reference)
  - [Properties](#properties)
  - [Static Properties](#static-properties)
  - [Methods](#methods)
  - [Lifecycle](#lifecycle)
+  - [Root Component](#root-component)
+  - [Environment](#environment)
+  - [Composition](#composition)
+  - [Event Handling](#event-handling)
+  - [Form Input Bindings](#form-input-bindings)
+  - [`t-key` Directive](#t-key-directive)
+  - [`t-mounted` Directive](#t-mounted-directive)
  - [Semantics](#semantics)
  - [Props Validation](#props-validation)
- [Asynchronous rendering](#asynchronous-rendering)
+  - [References](#references)
+  - [Slots](#slots)
+  - [Asynchronous Rendering](#asynchronous-rendering)

 ## Overview

@@ -21,11 +29,11 @@ OWL components are the building blocks for user interface. They are designed to
 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.
+2. **composable:** each component can seamlessly be created in a parent component by
+   a simple tag or 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
+   sub components 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
@@ -34,7 +42,7 @@ OWL components are the building blocks for user interface. They are designed to
 OWL components are defined as a subclass of Component. The rendering is
 exclusively done by a [QWeb](qweb.md) template (which needs to be preloaded in QWeb).
 Rendering a component generates a virtual dom representation
-of the widget, which is then patched to the DOM, in order to apply the changes in an efficient way.
+of the component, which is then patched to the DOM, in order to apply the changes in an efficient way.

 OWL components observe their states, and rerender themselves whenever it is
 changed. This is done by an [observer](observer.md).
@@ -69,58 +77,9 @@ a state object is defined. It is not mandatory to use the state object, but it
 is certainly encouraged. The state object is [observed](observer.md), and any
 change to it will cause a rerendering.

-## Composition
-
-The example above shows a QWeb template with a `t-on-click` directive. Widget
-templates are standard [QWeb](qweb.md) templates, but with an extra directive:
-`t-widget`. With the `t-widget` directive, widget templates can declare sub
-widgets:
-
-```xml
-<div t-name="ParentWidget">
-  <span>some text</span>
-  <t t-widget="MyWidget" t-props="{info: 13}"/>
-</div>
-```
-
-```js
-class ParentWidget extends owl.Component {
-    widgets = { MyWidget: MyWidget};
-    ...
-}
-```
-
-In this example, the `ParentWidget`'s template creates a widget `MyWidget` just
-after the span. See the [QWeb](qweb.md) documentation for more information on the
-`t-widget` directive.
-
-Note that the rendering context for the template is the widget itself. This means
-that the template can access `state`, `props`, `env`, or any methods defined in the widget.
-
-**CSS and style:** there is some specific support to allow the parent to declare
-additional css classes or style for the sub widget: css declared in `class`, `style`, `t-att-class` or `t-att-style` will be added to the
-root widget element.
-
-```xml
-<div t-name="ParentWidget">
-  <t t-widget="MyWidget" class="someClass" style="font-weight:bold;" t-props="{info: 13}"/>
-</div>
-```
-
-Warning: there is a small caveat with dynamic class attributes: since Owl needs
-to be able to add/remove proper classes whenever necessary, it needs to be aware
-of the possible classes. Otherwise, it will not be able to make the difference
-between a valid css class added by the component, or some custom code, and a
-class that need to be removed. This is why we only support the explicit syntax
-with a class object:
-
-```xml
-<t t-widget="MyWidget" t-att-class="{a: state.flagA, b: state.flagB}" />
-```
-
 ## Reference

-An Owl component is a small class which represent a widget or some UI element.
+An Owl component is a small class which represent a component or some UI element.
 It exists in the context of an environment (`env`), which is propagated from a
 parent to its children. The environment needs to have a QWeb instance, which
 will be used to render the component template.
@@ -141,7 +100,7 @@ find a template with the component name (or one of its ancestor).

 - **`state`** (Object): this is the location of the component's state, if there is
  any. After the willStart method, the `state` property is observed, and each
-  change will cause the widget to rerender itself.
+  change will cause the component to rerender itself.

 - **`props`** (Object): this is an object given (in the constructor) by the parent
  to configure the component. It can be dynamically changed later by the parent,
@@ -149,7 +108,7 @@ find a template with the component name (or one of its ancestor).
  As such, it should not ever be modified by the component!!

 - **`refs`** (Object): the `refs` object contains all references to sub DOM nodes
-  or sub widgets defined by a `t-ref` directive in the component's template.
+  or sub components defined by a `t-ref` directive in the component's template.

 ### Static Properties

@@ -164,6 +123,8 @@ find a template with the component name (or one of its ancestor).

 ### Methods

+We explain here all the public methods of the `Component` class.
+
 - **`mount(target)`** (async): this is the main way a component's hierarchy is added to the
  DOM: the root component is mounted to a target HTMLElement. Obviously, this
  is asynchronous, since each children need to be created as well. Most applications
@@ -181,7 +142,7 @@ find a template with the component name (or one of its ancestor).
  DOM in the same stack frame.

 - **`shouldUpdate(nextProps)`**: this method is called each time a component's props
-  are updated. It returns a boolean, which indicates if the widget should
+  are updated. It returns a boolean, which indicates if the component should
  ignore a props update. If it returns false, then `willUpdateProps` will not
  be called, and no rendering will occur. Its default implementation is to
  always return true. This is an optimization, similar to React's `shouldComponentUpdate`. Most of the time, this should not be used, but it
@@ -192,17 +153,17 @@ find a template with the component name (or one of its ancestor).
  if we have a `isMobile` key in the environment, to decide if we want a mobile
  interface or a destkop one.

- **`set(target, key, value)`**. This method is necessary in some cases when we
-  need to modify the state of the component in a way that is not visible to the
-  observer (see [observer's technical limitations](observer.md#technical-limitations)).
-  For example, if we need to add a key to the state.
-
 - **`destroy()`**. As its name suggests, this method will remove the component,
  and perform all necessary cleanup, such as unmounting the component, its children,
  removing the parent/children relationship. This method should almost never be
  called directly (except maybe on the root component), but should be done by the
  framework instead.

+Obviously, these methods are reserved for Owl, and should not be used by Owl
+users, unless they want to override them.  Also, Owl reserves all method names
+starting with `__`, in order to prevent possible future conflicts with user code
+whenever Owl needs to change.
+
 ### Lifecycle

 A solid and robust component system needs useful hooks/methods to help
@@ -211,13 +172,13 @@ a owl component:

 | Method                                           | Description                                           |
 | ------------------------------------------------ | ----------------------------------------------------- |
-| **[constructor](#constructor)**                  | constructor                                           |
-| **[willStart](#willStart)**                      | async, before first rendering                         |
+| **[constructor](#constructorparent-props)**      | constructor                                           |
+| **[willStart](#willstart)**                      | async, before first rendering                         |
 | **[mounted](#mounted)**                          | just after component is rendered and added to the DOM |
 | **[willUpdateProps](#willupdatepropsnextprops)** | async, before props update                            |
 | **[willPatch](#willpatch)**                      | just before the DOM is patched                        |
 | **[patched](#patchedsnapshot)**                  | just after the DOM is patched                         |
-| **[willUnmount](#willUnmount)**                  | just before removing component from DOM               |
+| **[willUnmount](#willunmount)**                  | just before removing component from DOM               |

 Notes:

@@ -262,7 +223,7 @@ 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.
+before the component is rendered. Another use case is to load data from a server.

 ```javascript
  async willStart() {
@@ -274,7 +235,7 @@ At this point, the component is not yet rendered. Note that a slow `willStart` m
 interface. Therefore, some care should be made to make this method as
 fast as possible.

-The widget rendering will take place after `willStart` is completed.
+The component rendering will take place after `willStart` is completed.

 #### `mounted()`

@@ -319,8 +280,8 @@ scrollbar.

 Note that modifying the state object is not allowed here. This method is called just
 before an actual DOM patch, and is only intended to be used to save some local
-DOM state. Also, it will not be called if the widget is not in the DOM (this can
-happen with widgets with `t-keepalive`).
+DOM state. Also, it will not be called if the component is not in the DOM (this can
+happen with components with `t-keepalive`).

 The return value of this method will be given as the first argument of the
 corresponding `patched` call.
@@ -332,12 +293,12 @@ likely via a change in its state/props or environment).

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

 The `snapshot` parameter is the result of the previous `willPatch` call.

-Updating the widget state in this hook is possible, but not encouraged.
+Updating the compoent 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.
@@ -358,6 +319,371 @@ the DOM. This is a good place to remove some listeners, for example.

 This is the opposite method of `mounted`.

+### Root Component
+
+Most of the time, an Owl component will be created automatically by a tag (or the `t-component`
+directive) in a template. There is however an obvious exception: the root component
+of an Owl application has to be created manually:
+
+```js
+class App extends owl.Component { ... }
+
+const qweb = new owl.QWeb(TEMPLATES);
+const env = { qweb: qweb };
+const app = new App(env);
+app.mount(document.body);
+```
+
+The root component needs an environment.
+
+### Environment
+
+In Owl, an environment is an object with a `qweb` key, which has to be a
+[QWeb](qweb.md) instance. This qweb instance will be used to render everything.
+
+The environment is meant to contain (mostly) static global information and
+methods for the whole application. For example, settings keys (`mode` to determine
+if we are in desktop or mobile mode, or `theme`: dark or light), `rpc` methods,
+session information, ...
+
+The environment will be given to each child, unchanged, in the `env` property.
+This can be very useful to share common information/methods. For example, all
+rpcs can be made through a `rpc` method in the environment. This makes it very
+easy to test a component.
+
+Updating the environment is not as simple as changing a component's state: its
+content is not observed, so updates will not be reflected immediately in the
+user interface.  There is however a mechanism to force root widgets to rerender
+themselves whenever the environment is modified: one only needs to trigger the
+`update` event on the QWeb instance.  For example, a responsive environment
+could be programmed like this:
+
+```js
+function setupResponsivePlugin(env) {
+    const isMobile = () => window.innerWidth <= 768;
+    env.isMobile = isMobile();
+    const updateEnv = owl.utils.debounce(() => {
+        if (env.isMobile !== isMobile()) {
+            env.isMobile = !env.isMobile;
+            env.qweb.trigger('update');
+        }
+    }, 15);
+    window.addEventListener("resize", updateEnv);
+}
+```
+
+### Composition
+
+The example above shows a QWeb template with a sub component. In a template,
+components are declared with a tagname corresponding to the class name. It has
+to be capitalized.
+
+```xml
+<div t-name="ParentComponent">
+  <span>some text</span>
+  <MyComponent info="13" />
+</div>
+```
+
+```js
+class ParentComponent extends owl.Component {
+    components = { MyComponent: MyComponent};
+    ...
+}
+```
+
+In this example, the `ParentComponent`'s template creates a component `MyComponent` just
+after the span. The `info` key will be added to the subcomponent's `props`. Each
+`props` is a string which represents a javascript (QWeb) expression, so it is
+dynamic. If it is necessary to give a string, this can be done by quoting it:
+`someString="'somevalue'"`.
+
+Note that the rendering context for the template is the component itself. This means
+that the template can access `state`, `props`, `env`, or any methods defined in the component.
+
+```xml
+<div t-name="ParentComponent">
+    <ChildComponent count="state.val" />
+</div>
+```
+
+```js
+class ParentComponent {
+  components = { ChildComponent };
+  state = { val: 4 };
+}
+```
+
+Whenever the template is rendered, it will automatically create the subcomponent
+`ChildComponent` at the correct place. It needs to find the reference to the
+actual component class in the special `components` key, or the class registered in
+QWeb's global registry (see `register` function of QWeb). It first looks inside
+the local `components` key, then fallbacks on the global registry.
+
+_Props_: In this example, the child component will receive the object `{count: 4}` in its
+constructor. This will be assigned to the `props` variable, which can be accessed
+on the component (and also, in the template). Whenever the state is updated, then
+the sub component will also be updated automatically.
+
+Note that there are some restrictions on prop names: `class`, `style` and any
+string which starts with `t-` are not allowed.
+
+The `t-component` directive can also be used to accept dynamic values with string interpolation (like the [`t-attf-`](qweb.md#dynamic-attributes) directive):
+
+```xml
+<div t-name="ParentComponent">
+    <t t-component="ChildComponent{{id}}" />
+</div>
+```
+
+```js
+class ParentComponent {
+  components = { ChildComponent1, ChildComponent2 };
+  state = { id: 1 };
+}
+```
+
+**CSS and style:** there is some specific support to allow the parent to declare
+additional css classes or style for the sub component: css declared in `class`, `style`, `t-att-class` or `t-att-style` will be added to the
+root component element.
+
+```xml
+<div t-name="ParentComponent">
+  <MyComponent class="someClass" style="font-weight:bold;" info="13" />
+</div>
+```
+
+Warning: there is a small caveat with dynamic class attributes: since Owl needs
+to be able to add/remove proper classes whenever necessary, it needs to be aware
+of the possible classes. Otherwise, it will not be able to make the difference
+between a valid css class added by the component, or some custom code, and a
+class that need to be removed. This is why we only support the explicit syntax
+with a class object:
+
+```xml
+<MyComponent t-att-class="{a: state.flagA, b: state.flagB}" />
+```
+
+### Event Handling
+
+In a component's template, it is useful to be able to register handlers on some
+elements to some specific events. This is what makes a template _alive_. There
+are four different use cases.
+
+1. Register an event handler on a DOM node (_pure_ DOM event)
+2. Register an event handler on a component (_pure_ DOM event)
+3. Register an event handler on a DOM node (_business_ DOM event)
+4. Register an event handler on a component (_business_ DOM event)
+
+A _pure_ DOM event is directly triggered by a user interaction (e.g. a `click`).
+
+```xml
+<button t-on-click="someMethod">Do something</button>
+```
+
+This will be roughly translated in javascript like this:
+
+```js
+button.addEventListener("click", component.someMethod.bind(component));
+```
+
+The suffix (`click` in this example) is simply the name of the actual DOM
+event.
+
+A _business_ DOM event is triggered by a call to `trigger` on a component.
+
+```xml
+<MyComponent t-on-menu-loaded="someMethod" />
+```
+
+```js
+ class MyComponent {
+     someWhere() {
+         const payload = ...;
+         this.trigger('menu-loaded', payload);
+     }
+ }
+```
+
+The call to `trigger` generates a [_CustomEvent_](https://developer.mozilla.org/docs/Web/Guide/Events/Creating_and_triggering_events)
+of type `menu-loaded` and dispatches it on the component's DOM element
+(`this.el`). The event bubbles and is cancelable. The parent component listening
+to event `menu-loaded` will receive the payload in its `someMethod` handler
+(in the `detail` property of the event), whenever the event is triggered.
+
+```js
+ class ParentComponent {
+     someMethod(ev) {
+         const payload = ev.detail;
+         ...
+     }
+ }
+```
+
+By convention, we use KebabCase for the name of _business_ events.
+
+In order to remove the DOM event details from the event handlers (like calls to
+`event.preventDefault`) and let them focus on data logic, _modifiers_ can be
+specified as additional suffixes of the `t-on` directive.
+
+| Modifier   | Description                                                       |
+| ---------- | ----------------------------------------------------------------- |
+| `.stop`    | calls `event.stopPropagation()` before calling the method         |
+| `.prevent` | calls `event.preventDefault()` before calling the method          |
+| `.self`    | calls the method only if the `event.target` is the element itself |
+
+```xml
+<button t-on-click.stop="someMethod">Do something</button>
+```
+
+Note that modifiers can be combined (ex: `t-on-click.stop.prevent`), and that
+the order may matter. For instance `t-on-click.prevent.self` will prevent all
+clicks while `t-on-click.self.prevent` will only prevent clicks on the element
+itself.
+
+The `t-on` directive also allows to prebind some arguments. For example,
+
+```xml
+<button t-on-click="someMethod(expr)">Do something</button>
+```
+
+Here, `expr` is a valid Owl expression, so it could be `true` or some variable
+from the rendering context.
+
+### Form Input Bindings
+
+It is very common to need to be able to read the value out of an html `input` (or
+`textarea`, or `select`) in order to use it (note: it does not need to be in a
+form!). A possible way to do this is to do it by hand:
+
+```js
+class Form extends owl.Component {
+  state = { text: "" };
+
+  _updateInputValue(event) {
+    this.state.text = event.target.value;
+  }
+}
+```
+
+```xml
+<div>
+  <input t-on-input="_updateInputValue" />
+  <span t-esc="state.text" />
+</div>
+```
+
+This works. However, this requires a little bit of _plumbing_ code. Also, the
+plumbing code is slightly different if you need to interact with a checkbox,
+or with radio buttons, or with select tags.
+
+To help with this situation, Owl has a builtin directive `t-model`: its value
+is the (top-level) name in the state object. With the `t-model` directive, we
+can write a shorter code, equivalent to the previous example:
+
+```js
+class Form extends owl.Component {
+  state = { text: "" };
+}
+```
+
+```xml
+<div>
+  <input t-model="text" />
+  <span t-esc="state.text" />
+</div>
+```
+
+The `t-model` directive works with `<input>`, `<input type="checkbox">`,
+`<input type="radio">`, `<textarea>` and `<select>`:
+
+```xml
+<div>
+    <div>Text in an input: <input t-model="someVal"/></div>
+    <div>Textarea: <textarea t-model="otherVal"/></div>
+    <div>Boolean value: <input type="checkbox" t-model="someFlag"/></div>
+    <div>Selection:
+        <select t-model="color">
+            <option value="">Select a color</option>
+            <option value="red">Red</option>
+            <option value="blue">Blue</option>
+        </select>
+    </div>
+    <div>
+        Selection with radio buttons:
+        <span>
+            <input type="radio" name="color" id="red" value="red" t-model="color"/>
+            <label for="red">Red</label>
+        </span>
+        <span>
+            <input type="radio" name="color" id="blue" value="blue" t-model="color" />
+            <label for="blue">Blue</label>
+        </span>
+    </div>
+</div>
+```
+
+Like event handling, the `t-model` directive accepts some modifiers:
+
+| Modifier  | Description                                                          |
+| --------- | -------------------------------------------------------------------- |
+| `.lazy`   | update the value on the `change` event (default is on `input` event) |
+| `.number` | tries to parse the value to a number (using `parseFloat`)            |
+| `.trim`   | trim the resulting value                                             |
+
+For example:
+
+```xml
+<input t-model.lazy="someVal" />
+```
+
+These modifiers can be combined. For instance, `t-model.lazy.number` will only
+update a number whenever the change is done.
+
+Note: the online playground has an example to show how it works.
+
+### `t-key` Directive
+
+Even though Owl tries to be as declarative as possible, some DOM state is still
+locked inside the DOM: for example, the scrolling state, the current user selection,
+the focused element or the state of an input. This is why we use a virtual dom
+algorithm to keep the actual DOM node as much as possible. However, this is
+sometimes not enough, and we need to help Owl decide if an element is actually
+the same, or is different. The `t-key` directive is used to give an identity to an element.
+
+There are three main use cases:
+
+- _elements in a list_:
+
+  ```xml
+    <span t-foreach="todos" t-as="todo" t-key="todo.id">
+        <t t-esc="todo.text" />
+    </span>
+  ```
+
+- _`t-if`/`t-else`_
+
+- _animations_: give a different identity to a component. Ex: thread id with
+  animations on add/remove message.
+
+### `t-mounted` Directive
+
+The `t-mounted` directive allows to register a callback to execute whenever the node
+is inserted into the DOM.
+
+```xml
+<div><input t-ref="someInput" t-mounted="focusMe"/></div>
+```
+
+```js
+class MyComponent extends owl.Component {
+    ...
+    focusMe() {
+        this.refs.someInput.focus();
+    }
+}
+```
+
 ### Semantics

 We give here an informal description of the way components are created/updated
@@ -381,27 +707,27 @@ component (with some code like `app.mount(document.body)`).

 2. when it is done, template `A` is rendered.

-   - widget `B` is created
+   - component `B` is created
     1. `willStart` is called on `B`
     2. template `B` is rendered
-   - widget `C` is created
+   - component `C` is created
     1. `willStart` is called on `C`
     2. template `C` is rendered
-        - widget `D` is created
+        - component `D` is created
          1. `willStart` is called on `D`
          2. template `D` is rendered
-        - widget `E` is created
+        - component `E` is created
          1. `willStart` is called on `E`
          2. template `E` is rendered

-3. widget `A` is patched into a detached DOM element. This will create the actual
-   widget `A` DOM structure. The patching process will cause recursively the
+3. component `A` is patched into a detached DOM element. This will create the actual
+   component `A` DOM structure. The patching process will cause recursively the
   patching of the `B`, `C`, `D` and `E` DOM trees. (so the actual full DOM tree is created
   in one pass)

-4. the widget `A` root element is actually appended to `document.body`
+4. the component `A` root element is actually appended to `document.body`

-5. The method `mounted` is called recursively on all widgets in the following
+5. The method `mounted` is called recursively on all components in the following
   order: `B`, `D`, `E`, `C`, `A`.

 **Scenario 2: rerendering a component**. Now, let's assume that the user clicked on some
@@ -409,7 +735,7 @@ button in `C`, and this results in a state update, which is supposed to:

 - update `D`,
 - remove `E`,
- add new widget `F`.
+- add new component `F`.

 So, the component tree should look like this:

@@ -426,17 +752,17 @@ 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

-   - widget `D` is updated:
+   - component `D` is updated:
     1. hook `willUpdateProps` is called on `D` (async)
     2. template `D` is rerendered
-   - widget `F` is created:
+   - component `F` is created:
     1. hook `willStart` is called on `E` (async)
     2. template `F` is rendered

-3. `willPatch` hooks are called recursively on widgets `C`, `D` (not on `F`,
+3. `willPatch` hooks are called recursively on components `C`, `D` (not on `F`,
   because it is not mounted yet)

-4. widget `C` is patched, which will cause recursively:
+4. component `C` is patched, which will cause recursively:

   2. `willUnmount` hook on `E`, then destruction of `E`,
   3. (initial) patching of `F`, then hook `mounted` is called on `F`
@@ -532,7 +858,103 @@ Examples:
  };
 ```

-## Asynchronous rendering
+### References
+
+The `t-ref` directive helps a component keep reference to some inside part of it.
+Like the `t-on` directive, it can work either on a DOM node, or on a component:
+
+```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
+inside the special `refs` variable:
+
+```js
+this.refs.someDiv;
+this.refs.someComponent;
+```
+
+This is useful for various usecases: for example, integrating with an external
+library that needs to render itself inside an actual DOM node. Or for calling
+some method on a sub component.
+
+Note: if used on a component, the reference will be set in the `refs`
+variable between `willPatch` and `patched`.
+
+The `t-ref` directive also accepts dynamic values with string interpolation
+(like the [`t-attf-`](qweb.md#dynamic-attributes) and
+`t-component` directives). For example, if we have
+`id` set to 44 in the rendering context,
+
+```xml
+<div t-ref="component_{{id}}"/>
+```
+
+```js
+this.refs.component_44;
+```
+
+### Slots
+
+To make generic components, it is useful to be able for a parent component to _inject_
+some sub template, but still be the owner. For example, a generic dialog component
+will need to render some content, some footer, but with the parent as the
+rendering context.
+
+This is what _slots_ are for.
+
+```xml
+<div t-name="Dialog" class="modal">
+  <div class="modal-title"><t t-esc="props.title"/></div>
+  <div class="modal-content">
+    <t t-slot="content"/>
+  </div>
+  <div class="modal-footer">
+    <t t-slot="footer"/>
+  </div>
+</div>
+```
+
+Slots are defined by the caller, with the `t-set` directive:
+
+```xml
+<div t-name="SomeComponent">
+  <div>some component</div>
+  <Dialog title="Some Dialog">
+    <t t-set="content">
+      <div>hey</div>
+    </t>
+    <t t-set="footer">
+      <button t-on-click="doSomething">ok</button>
+    </t>
+  </Dialog>
+</div>
+```
+
+In this example, the component `Dialog` will render the slots `content` and `footer`
+with its parent as rendering context. This means that clicking on the button
+will execute the `doSomething` method on the parent, not on the dialog.
+
+Default slot: the first element inside the component which is not a named slot will
+be considered the `default` slot. For example:
+
+```xml
+<div t-name="Parent">
+  <Child>
+    <span>some content</span>
+  </Child>
+</div>
+
+<div t-name="Child">
+  <t t-slot="default"/>
+</div>
+```
+
+### 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
@@ -541,18 +963,34 @@ components.

 There are two different common problems with Owl asynchronous rendering model:

- any widget can delay the rendering (initial and subsequent) of the whole
+- any component can delay the rendering (initial and subsequent) of the whole
  application
- for a given widget, there are two independant situations that will trigger an
+- 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 widgets:
+Here are a few tips on how to work with asynchronous components:

-1. minimize the use of asynchronous widgets!
+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`)
+4. For all the other cases, the `t-asyncroot` directive (to use alongside
+   `t-component`) is there to help you. When this directive 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 />
+     <AsyncChild t-asyncroot="1"/>
+   </div>
+   ```
@@ -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.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`.
@@ -20,35 +20,31 @@ obj.a.b = 2;
 ## Technical Limitations

 Since the observer uses getters and setters, it is actually unable to react to
-changes in two situations:
+changes in three situations:

- adding a key to an object:
+- adding a key to an object
+- deleting a key from an object
+- modifying an array by setting a new value at a given index

-  ```javascript
-  const observer = new owl.Observer();
-  const obj = { a: 1 };
-  observer.observe(obj);
-  obj.b = 2; // will do nothing
-  ```
+In those situations, we need a way to tell the observer that something happened.
+This can be done by using the `set` and `delete` (only for objects) static
+methods of the `Observer`.

-  In that case, we need a way to tell the observer that something happened.
-  This can be done by using the `set` method:
+```javascript
+const observer = new owl.Observer();
+const obj = { a: 1 };
+observer.observe(obj);
+obj.b = 2; // won't notify the change
+owl.Observer.set(obj, "b", 2); // will notify the change

-  ```javascript
-  observer.set(obj, "b", 2);
-  ```
+delete obj.b; // won't notify the change
+owl.Observer.delete(obj, "b"); // will notify the change
+```

- modifying an array by setting a new value at a given index:
-
-  ```javascript
-  const observer = new owl.Observer();
-  const obj = { todos: [{ id: 1, text: "todo" }] };
-  observer.observe(obj);
-  obj[0] = { id: 2, text: "othertodo" }; // will do nothing, and obj[0] is not observed
-  ```
-
-  In that case, the solution is the same, we can simply use the `set` method:
-
-  ```javascript
-  observer.set(obj, 0, { id: 2, text: "othertodo" });
-  ```
+```javascript
+const observer = new owl.Observer();
+const arr = ["a"];
+observer.observe(arr);
+arr[0] = "b"; // won't notify the change
+owl.Observer.set(arr, 0, "b"); // will notify the change
+```
@@ -1,6 +1,6 @@
 # 🦉 Quick Start 🦉

-## Static server
+## Static Server

 Let us assume that we have a static server running somewhere. We could then
 simply add an html page with a few extra files.
@@ -58,16 +58,16 @@ To build an application (or a sub-part of an application), we need two things:
  need. In practice, it could context 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 widget, which can
-  have sub widgets
+- 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 widget
- mount the root widget to a DOM element
+- 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`:

@@ -3,44 +3,78 @@
 ## Content

 - [Overview](#overview)
+- [Directives](#directives)
 - [QWeb Engine](#qweb-engine)
- [QWeb Specification](#qweb-specification)
-
-  - [Static html nodes](#static-html-nodes)
-  - [`t-esc` directive](#t-esc-directive)
-  - [`t-raw` directive](#t-raw-directive)
-  - [`t-set` directive](#t-set-directive)
-  - [`t-if` directive](#t-if-directive)
-  - [Expression evaluation](#expression-evaluation)
-  - [Dynamic attributes (`t-att` and `t-attf` directives)](#dynamic-attributes-t-att-and-t-attf-directives)
-  - [`t-call` directive (sub templates)](#t-call-directive-sub-templates)
-
- [JS/OWL Specific Extensions](#jsowl-specific-extensions)
-
-  - [`t-on` directive](#t-on-directive)
-  - [Component: `t-widget`, `t-props`](#component-t-widget-t-props)
-  - [`t-ref` directive](#t-ref-directive)
-  - [`t-key` directive](#t-key-directive)
-  - [`t-transition` directive](#t-transition-directive)
-  - [`t-mounted` directive](#t-mounted-directive)
-  - [Debugging (`t-debug` and `t-log`)](#debugging-t-debug-and-t-log)
-  - [White spaces](#white-spaces)
-  - [Root nodes](#root-nodes)
+- [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)
+  - [Debugging](#debugging)

 ## Overview

 [QWeb](https://www.odoo.com/documentation/12.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.
+mostly to generate HTML. In OWL, QWeb templates are compiled into functions that
+generate a virtual dom representation of the HTML.

 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.

-The QWeb implementation in the OWL project is slightly different. It compiles
-templates into functions that output a virtual DOM instead of a string. This is
-necessary for the component system. In addition, it has a few extra directives
-(see [OWL Specific Extensions](#owlspecificextensions))
+```xml
+<div>
+    <span t-if="somecondition">Some string</span>
+    <ul t-else="1">
+        <li t-foreach="messages" t-as="message">
+            <t t-esc="message">
+        </li>
+    </ul>
+</div>
+```
+
+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`, ...
+
+## Directives
+
+We present here 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-name`                       | [Defining a template (not really a directive)](#qweb-engine) |
+
+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-keepalive`, `t-asyncroot` | [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)](component.md#t-key-directive) |
+| `t-on-*`                                    | [Event handling](component.md#event-handling)                                       |
+| `t-transition`                              | [Defining an animation](animations.md#css-transitions)                              |
+| `t-mounted`                                 | [Callback when a node or component is mounted](component.md#t-mounted-directive)    |
+| `t-slot`                                    | [Rendering a slot](component.md#slots)                                              |
+| `t-model`                                   | [Form input bindings](component.md#form-input-bindings)                             |

 ## QWeb Engine

@@ -61,12 +95,14 @@ It's API is quite simple:
  const qweb = new owl.QWeb(TEMPLATES);
  ```

- **`addTemplate(name, xmlStr)`**: add a specific template.
+- **`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 return whenever a template is added for a second time.  Otherwise, `QWeb` will crash.
+
 - **`addTemplates(xmlStr)`**: add a list of templates (identified by `t-name`
  attribute).

@@ -74,7 +110,7 @@ It's API is quite simple:
  const TEMPLATES = `
    <templates>
      <div t-name="App" class="main">main</div>
-      <div t-name="OtherWidget">other widget</div>
+      <div t-name="OtherComponent">other component</div>
    </templates>`;
  qweb.addTemplates(TEMPLATES);
  ```
@@ -83,12 +119,12 @@ It's API is quite simple:
  which is a virtual representation of the DOM (see [vdom doc](vdom.md)).

  ```js
-  const vnode = qweb.render("App", widget);
+  const vnode = qweb.render("App", component);
  ```

 - **`register(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-widget` directive). This is useful for commonly used
+  templates (see the `t-component` directive). This is useful for commonly used
  components accross the application.

  ```js
@@ -97,16 +133,107 @@ It's API is quite simple:

  ...

-  class ParentWidget extends owl.Component { ... }
-  qweb.addTemplate("ParentWidget", "<div><t t-widget='Dialog'/></div>");
+  class ParentComponent extends owl.Component { ... }
+  qweb.addTemplate("ParentComponent", "<div><Dialog/></div>");
  ```

-## QWeb Specification
+In some way, a `QWeb` instance is the core of an Owl application. It is the only
+mandatory element of an [environment](component.md#environment). As such, it
+has an extra responsability: 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).
+
+## Reference

 We define in this section the specification of how `QWeb` templates should be
-rendered.
+rendered. Note that we only document here the standard QWeb specification. Owl
+specific extensions are documented in various other parts of the documentation.

-### Static html nodes
+### 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
+
+### 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="1">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 by 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 applies 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  | will be replaced by |
+   | ----- | ------------------- |
+   | `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:

@@ -114,7 +241,7 @@ Normal, regular html nodes are rendered into themselves:
  <div>hello</div> <!–– rendered as itself ––>
 ```

-### `t-esc` directive
+### 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.
@@ -129,14 +256,12 @@ rendered with the value `value` set to `42` in the rendering context yields:
 <p>42</p>
 ```

-### `t-raw` directive
-
 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-esc="value"/></p>
+<p><t t-raw="value"/></p>
 ```

 rendered with the value `value` set to `<span>foo</span>` in the rendering context yields:
@@ -145,7 +270,7 @@ rendered with the value `value` set to `<span>foo</span>` in the rendering conte
 <p><span>foo</span></p>
 ```

-### `t-set` directive
+### 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, ...

@@ -177,7 +302,7 @@ This is done via the `t-set` directive, which takes the name of the variable to
 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, ...

-### `t-if` directive
+### Conditionals

 The `t-if` directive is useful to conditionally render something. It evaluates
 the expression given as attribute value, and then acts accordingly.
@@ -227,52 +352,7 @@ Extra conditional branching directives `t-elif` and `t-else` are also available:
 </div>
 ```

-### Expression evaluation
-
-It is useful to explain the various rules that applies on QWeb expressions. These
-expressions are strings that will be converted to a javascript expression at
-compile time.
-
-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:
-
-   ```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  | will be replaced by |
-   | ----- | ------------------- |
-   | `and` | `&&`                |
-   | `or`  | `\|\|`              |
-   | `gt`  | `>`                 |
-   | `gte` | `>=`                |
-   | `lt`  | `<`                 |
-   | `lte` | `<=`                |
-
-   So, one can write this:
-
-   ```xml
-   <div><p t-if="10 + 2 gt 5">ok</p></div>
-   ```
-
-### Dynamic attributes (`t-att` and `t-attf` directives)
+### 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:
@@ -292,19 +372,77 @@ If an expression evaluates to a falsy value, it will not be set at all:
 There is another way to format a string attribute: the `t-attf-` directive. With
 it, you get string interpolation:

-```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> -->
-```
-
-For historical reason, there is an alternate form of string interpolation:
-
 ```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> -->
 ```

-### `t-call` directive (sub templates)
+### 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 by 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 -->
+```
+
+### 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
@@ -352,276 +490,7 @@ will result in :
 </div>
 ```

-## JS/OWL Specific Extensions
-
-### `t-on` directive
-
-In a component's template, it is useful to be able to register handlers on some
-elements to some specific events. This
-is what makes a template _alive_. There are two different use cases.
-
-1. Register an event handler on a DOM node
-
-   ```xml
-   <button t-on-click="someMethod">Do something</button>
-   ```
-
-   This will be roughly translated in javascript like this:
-
-   ```js
-   button.addEventListener("click", widget.someMethod.bind(widget));
-   ```
-
-   The suffix (`click` in this example) is simply the name of the actual DOM
-   event.
-
-   In order to remove the DOM event details from the event handlers (like calls
-   to `event.preventDefault`) and let them focus on data logic, _modifiers_ can
-   be specified as additional suffixes of the `t-on` directive.
-
-   | Modifier   | Description                                                       |
-   | ---------- | ----------------------------------------------------------------- |
-   | `.stop`    | calls `event.stopPropagation()` before calling the method         |
-   | `.prevent` | calls `event.preventDefault()` before calling the method          |
-   | `.self`    | calls the method only if the `event.target` is the element itself |
-
-   ```xml
-   <button t-on-click.stop="someMethod">Do something</button>
-   ```
-
-   Note that modifiers can be combined (ex: `t-on-click.stop.prevent`), and that
-   the order may matter. For instance `t-on-click.prevent.self` will prevent all
-   clicks while `t-on-click.self.prevent` will only prevent clicks on the
-   element itself.
-
-2. Register an event handler on a component. This will not capture a DOM event,
-   but rather a _business_ event:
-
-   ```xml
-   <t t-widget="MyWidget" t-on-menuLoaded="someMethod"/>
-   ```
-
-   ```js
-   class MyWidget {
-       someWhere() {
-           const payload = ...;
-           this.trigger('menuLoaded', payload);
-       }
-   }
-   ```
-
-   Here, the parent widget will receive the payload in its `someMethod` handler,
-   whenever the event is triggered.
-
-The `t-on` directive also allows to prebind some arguments. For example,
-
-```xml
-<button t-on-click="someMethod(expr)">Do something</button>
-```
-
-Here, `expr` is a valid Owl expression, so it could be `true` or some variable
-from the rendering context.
-
-### Component: `t-widget`, `t-props`
-
-The `t-widget` and the `t-props` directives are the key to a declarative component
-system. They allow a template to define where and how a sub widget is created
-and/or updated. For example:
-
-```xml
-<div t-name="ParentWidget">
-    <t t-widget="ChildWidget" t-props="{count: state.val}"/>
-</div>
-```
-
-```js
-class ParentWidget {
-  widgets = { ChildWidget };
-  state = { val: 4 };
-}
-```
-
-Whenever the template is rendered, it will automatically create the subwidget
-`ChildWidget` at the correct place. It needs to find the reference to the
-actual component class in the special `widgets` key, or the class registered in
-QWeb's global registry (see `register` function of QWeb). It first looks inside
-the local `widgets` key, then fallbacks on the global registry.
-
-In this example, the child widget will receive the object `{count: 4}` in its
-constructor. This will be assigned to the `props` variable, which can be accessed
-on the widget (and also, in the template). Whenever the state is updated, then
-the subwidget will also be updated automatically.
-
-The `t-widget` directive also accepts dynamic values with string interpolation
-(like the [`t-attf-`](#dynamic-attributes-t-att-and-t-attf-directives) directive):
-
-```xml
-<div t-name="ParentWidget">
-    <t t-widget="ChildWidget#{id}"/>
-</div>
-```
-
-```js
-class ParentWidget {
-  widgets = { ChildWidget1, ChildWidget2 };
-  state = { id: 1 };
-}
-```
-
-Similarly to `t-attf-`, there is an alternate form of string interpolation:
-
-```xml
-<div t-name="ParentWidget">
-    <t t-widget="ChildWidget{{id}}"/>
-</div>
-```
-
-### `t-ref` directive
-
-The `t-ref` directive helps a component keep reference to some inside part of it.
-Like the `t-on` directive, it can work either on a DOM node, or on a component:
-
-```xml
-<div>
-    <div t-ref="someDiv"/>
-    <t t-widget="SubWidget" t-ref="someWidget"/>
-</div>
-```
-
-In this example, the widget will be able to access the `div` and the component
-inside the special `refs` variable:
-
-```js
-this.refs.someDiv;
-this.refs.someWidget;
-```
-
-This is useful for various usecases: for example, integrating with an external
-library that needs to render itself inside an actual DOM node. Or for calling
-some method on a sub widget.
-
-Note: if used on a component, the reference will be set in the `refs`
-variable between `willPatch` and `patched`.
-
-The `t-ref` directive also accepts dynamic values with string interpolation
-(like the [`t-attf-`](#dynamic-attributes-t-att-and-t-attf-directives) and
-[`t-widget-`](#component-t-widget-t-props) directives). For example, if we have
-`id` set to 44 in the rendering context,
-
-```xml
-<div t-ref="widget_#{id}"/>
-```
-
-```js
-this.refs.widget_44;
-```
-
-Similarly to `t-attf-` and `t-widget`, there is an alternate form of string
-interpolation:
-
-```xml
-<div t-ref="widget_{{id}}"/>
-```
-
-### `t-key` directive
-
-Even though Owl tries to be as declarative as possible, some DOM state is still
-locked inside the DOM: for example, the scrolling state, the current user selection,
-the focused element or the state of an input. This is why we use a virtual dom
-algorithm to keep the actual DOM node as much as possible. However, this is
-sometimes not enough, and we need to help Owl decide if an element is actually
-the same, or is different. The `t-key` directive is used to give an identity to an element.
-
-There are three main use cases:
-
- _elements in a list_:
-
-  ```xml
-    <span t-foreach="todos" t-as="todo" t-key="todo.id">
-        <t t-esc="todo.text"/>
-    </span>
-  ```
-
- _`t-if`/`t-else`_
-
- _animations_: give a different identity to a component. Ex: thread id with
-  animations on add/remove message.
-
-### `t-transition` directive
-
-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
-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 combined with `t-widget`.
-
-Notes:
-
- more information on animations are available [here](animations.md).
- the value for `t-transition` must be a single class name. Owl does not support
-  more than one transition on a single node.
-
-### `t-mounted` directive
-
-The `t-mounted` directive allows to register a callback to execute whenever the node
-is inserted into the DOM.
-
-```xml
-<div><input t-ref="someInput" t-mounted="focusMe"/></div>
-```
-
-```js
-class MyWidget extends owl.Component {
-    ...
-    focusMe() {
-        this.refs.someInput.focus();
-    }
-}
-```
-
-### Debugging (`t-debug` and `t-log`)
+### Debugging

 The javascript QWeb implementation provides two useful debugging directives:

@@ -643,37 +512,3 @@ will stop execution if the browser dev tools are open.
 ```

 will print 42 to the console
-
-### 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
-
-### 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="1">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.
@@ -1,17 +1,21 @@
 # 🦉 OWL Documentation 🦉

-
 ## Reference

+- [Animations](animations.md)
 - [Component](component.md)
+- [Event Bus](event_bus.md)
+- [Observer](observer.md)
 - [QWeb](qweb.md)
 - [Store](store.md)
- [Observer](observer.md)
- [Virtual DOM](vdom.md)
 - [Utils](utils.md)
+- [Virtual DOM](vdom.md)
+
+## Learning Resources
+
+- [Quick Start](quick_start.md)

 ## Miscellaneous
- [Quick Start](quick_start.md)
- [Animations](animations.md)
- [Tooling](tooling.md)
+
 - [Comparison with React/Vue](comparison.md)
+- [Tooling](tooling.md)
@@ -9,7 +9,9 @@
  - [Mutations](#mutations)
  - [Actions](#actions)
  - [Getters](#getters)
-  - [Connecting a component](#connecting-a-component)
+  - [Connecting a Component](#connecting-a-component)
+  - [Semantics](#semantics)
+  - [Good Practices](#good-practices)

 ## Overview

@@ -28,50 +30,49 @@ Note: Owl's store is inspired by React Redux and VueX.

 ## Example

-Here is what a simple store look like:
+Here is what a simple store looks like:

 ```js
 const actions = {
-    addTodo({commit}, message) {
-        commit('addTodo', message);
-    }
+  addTodo({ commit }, message) {
+    commit("addTodo", message);
+  }
 };

 const mutations = {
-    addTodo({state}, message) {
-        const todo = {
-            id: state.nextId++,
-            message,
-            isCompleted: false,
-        };
-        state.todos.push(todo);
-    },
+  addTodo({ state }, message) {
+    const todo = {
+      id: state.nextId++,
+      message,
+      isCompleted: false
+    };
+    state.todos.push(todo);
+  }
 };

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

-const store = new owl.Store({state, actions, mutations});
-store.on('update', () => console.log(store.state));
+const store = new owl.Store({ state, actions, mutations });
+store.on("update", () => console.log(store.state));

 // updating the state
-store.dispatch('addTodo', 'fix all bugs');
+store.dispatch("addTodo", "fix all bugs");
 ```

-
 ## Reference

-The store is a simple `owl.EventBus` that triggers `update` events whenever its
-state is changed.  Note that these events are triggered only after a microtask
+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 a `owl.Observer`),
-which is the reason why it is able to know if it was changed.  This implies that
+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. This implies that
 state changes need to be done carefully in some cases (adding a new key to an
-object, or modifying an array with the `arr[i] = newValue` syntax).  See the
+object, or modifying an array with the `arr[i] = newValue` syntax). See the
 [Observer](observer.md)'s documentation for more details.

 ### Public API
@@ -82,29 +83,50 @@ object, or modifying an array with the `arr[i] = newValue` syntax).  See the

 ### Mutations

-Mutations are the only way to modify the state.  Changing the state outside a
-mutation is not allowed (and should throw an error).  Mutations are synchronous.
+Mutations are the only way to modify the state. Changing the state outside a
+mutation is not allowed (and should throw an error). Mutations are synchronous.
+
+```js
+const mutations = {
+  setLoginState({ state }, loginState) {
+      state.loginState = loginState;
+  }
+};
+```
+
+Mutations are called with the `commit` method on the store, and can receive an arbitrary number of arguments.
+
+```js
+store.commit("setLoginState", "error");
+```

 ### Actions

-Actions are used to coordinate state changes.  It is also useful whenever some
-asynchronous logic is necessary.  For example, fetching data should be done
+Actions are used to coordinate state changes. It is also useful whenever some
+asynchronous logic is necessary. For example, fetching data should be done
 in an action.

 ```js
 const actions = {
-    async login({commit}) {
-        commit('setLoginState', 'pending');
-        try {
-            const loginInfo = await doSomeRPC('/login/', 'someinfo');
-            commit('setLoginState', loginInfo);
-        } catch {
-            commit('setLoginState', 'error');
-        }
+  async login({ commit }, info) {
+    commit("setLoginState", "pending");
+    try {
+      const loginInfo = await doSomeRPC("/login/", info);
+      commit("setLoginState", loginInfo);
+    } catch {
+      commit("setLoginState", "error");
    }
+  }
 };
 ```

+Actions are called with the `dispatch` method on the store, and can receive an
+arbitrary number of arguments.
+
+```js
+store.dispatch("login", someInfo);
+```
+
 ### Getters

 Usually, data contained in the store will be stored in a normalized way. For
@@ -128,22 +150,109 @@ 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
-        };
-    },
+  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);
-
 ```

-### Connecting a component
+Getters take *at most* one argument.

-Todo
+
+Note that getters are cached if they don't take any argument, or their argument
+is a string or a number.
+
+### Connecting a Component
+
+By default, an Owl `Component` is not connected to any store. The `connect`
+function is there to create sub Components that are connected versions of
+Components.
+
+```javascript
+const actions = {
+  increment({ commit }) {
+    commit("increment", 1);
+  }
+};
+const mutations = {
+  increment({ state }, val) {
+    state.counter += val;
+  }
+};
+const state = {
+  counter: 0
+};
+const store = new owl.Store({ state, actions, mutations });
+
+class Counter extends owl.Component {
+  increment() {
+    this.env.store.dispatch("increment");
+  }
+}
+function mapStoreToProps(state) {
+  return {
+    value: state.counter
+  };
+}
+const ConnectedCounter = owl.connect(Counter, mapStoreToProps);
+
+const counter = new ConnectedCounter({ store, qweb });
+```
+
+```xml
+<button t-name="Counter" t-on-click="increment">
+  Click Me! [<t t-esc="props.value"/>]
+</button>
+```
+
+The arguments of `connect` are:
+
+- `Counter`: an owl `Component` to connect
+- `mapStoreToProps`: a function that extracts the `props` of the Component
+  from the `state` of the `Store` and returns them as a dict
+- `options`: dictionary of optional parameters that may contain
+  - `getStore`: a function that takes the `env` in arguments and returns an
+    instance of `Store` to connect to (if not given, connects to `env.store`)
+  - `hashFunction`: the function to use to detect changes in the state (if not
+    given, generates a function that uses revision numbers, incremented at
+    each state change)
+  - `deep`: [only useful if no hashFunction is given] if false, only watch
+    for top level state changes (true by default)
+
+The `connect` function returns a sub class of the given `Component` which is
+connected to the `store`.
+
+### Semantics
+
+The `Store` and the `connect` function 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 other parts 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 `mapStoreToProps` and a `Message` component could get the data of its own
+  message
+- since the `mapStoreToProps` 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.
@@ -1,18 +1,55 @@
 # 🦉 Tooling 🦉

-## Development mode
+## Content

-By default, Owl is in *production* mode, this means that it will try to do its
-job fast, and skip some expensive operations.  However, in some cases, it is
+- [Overview](#overview)
+- [Development Mode](#development-mode)
+- [Playground](#playground)
+- [Benchmarks](#benchmarks)
+
+## 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`).
+
+## Development 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, in some cases, it is
 convenient to have better information on what is going on, this is the purpose
 of the dev mode.

-Owl has a mode flag, in `owl.__info__.mode`.  Its default value is `prod`, but
+Owl has a mode flag, in `owl.__info__.mode`. Its default value is `prod`, but
 it can be set to `dev`:

 ```js
-owl.__info__.mode = 'dev';
+owl.__info__.mode = "dev";
 ```

 Note that templates compiled with the `prod` settings will not be recompiled.
-So, changing this setting is best done at startup.
+So, changing this setting is best done at startup.
+
+## 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.
@@ -5,35 +5,61 @@ functions are all available in the `owl.utils` namespace.

 ## Content

- [`whenReady`](#whenready)
- [`loadJS`](#loadjs)
- [`loadTemplates`](#loadtemplates)
- [`escape`](#escape)
- [`debounce`](#debounce)
+- [`whenReady`](#whenready): executing code when DOM is ready
+- [`loadJS`](#loadjs): loading script files
+- [`loadTemplates`](#loadtemplates): loading xml files
+- [`escape`](#escape): sanitizing strings
+- [`debounce`](#debounce): limiting rate of function calls

 ## `whenReady`

-The function `whenReady` is useful to register some code that need to be executed
-as soon as the document (page) is ready:
+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
-owl.utils.whenReady(function () {
-    const qweb = new owl.QWeb();
-    const app = new App({ qweb });
-    app.mount(document.body);
+Promise.all([loadTemplates(), owl.utils.whenReady()]).then(function([
+  templates
+]) {
+  const qweb = new owl.QWeb(templates);
+  const app = new App({ qweb });
+  app.mount(document.body);
+});
+```
+
+```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. It returns
+a promise, so the caller can properly react 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.
+
+```js
+class MyComponent extends owl.Component {
+  willStart() {
+    return owl.utils.loadJS("/static/libs/someLib.js");
+  }
+}
+```
+
 ## `loadTemplates`

+```js
+async function makeEnv() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const qweb = new owl.QWeb(templates);
+  return { qweb };
+}
+```
+
 ## `escape`

 ## `debounce`
-
-
-
-
-
-
@@ -1,3 +1,18 @@
 # 🦉 VDom 🦉

-Owl's virtual dom is a fork of [snabbdom](https://github.com/snabbdom/snabbdom).
+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).
@@ -1,30 +0,0 @@
-<templates>
-    <div class="main" t-name="root">
-        <div class="left-thing">
-            <div class="message_count">
-                Number of msg: 0
-            </div>
-            <button class="o_btn_msg 100">Add 100 messages</button>
-            <button class="o_btn_msg 1000">Add 1000 messages</button>
-            <button class="o_btn_msg 10000">Add 10000 messages</button>
-            <button class="o_btn_msg 50000">Add 50000 messages</button>
-            <button class="updateSomeMessages">Update every 10th message</button>
-            <button class="clear">Clear</button>
-        </div>
-        <div class="right-thing">
-            <div class="content">
-            </div>
-        </div>
-    </div>
-
-    <div t-name="message" class="message">
-        <span class="author"><t t-esc="widget.author"/></span>
-        <span class="msg"><t t-esc="widget.msg"/></span>
-        <button class="remove" >Remove</button>
-    </div>
-
-  <div t-name="counter">
-    <button class="o_increment"></button>
-  </div>
-
-</templates>
@@ -1,30 +0,0 @@
-<templates>
-    <div class="main" t-name="root">
-        <div class="left-thing">
-            <div class="message_count">
-                Number of msg: 0
-            </div>
-            <button class="o_btn_msg 100">Add 100 messages</button>
-            <button class="o_btn_msg 1000">Add 1000 messages</button>
-            <button class="o_btn_msg 10000">Add 10000 messages</button>
-            <button class="o_btn_msg 50000">Add 50000 messages</button>
-            <button class="updateSomeMessages">Update every 10th message</button>
-            <button class="clear">Clear</button>
-        </div>
-        <div class="right-thing">
-            <div class="content">
-            </div>
-        </div>
-    </div>
-
-    <div t-name="message" class="message">
-        <span class="author"><t t-esc="widget.author"/></span>
-        <span class="msg"><t t-esc="widget.msg"/></span>
-        <button class="remove" >Remove</button>
-    </div>
-
-  <div t-name="counter">
-    <button class="o_increment"></button>
-  </div>
-
-</templates>
@@ -1,84 +0,0 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
-
-//------------------------------------------------------------------------------
-// Likes Counter Widget
-//------------------------------------------------------------------------------
-class Counter extends owl.Component {
-  template = "counter";
-  state = { counter: 0 };
-
-  increment() {
-    this.state.counter++;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Message Widget
-//------------------------------------------------------------------------------
-class Message extends owl.Component {
-  template = "message";
-  widgets = { Counter };
-
-  shouldUpdate(nextProps) {
-    return nextProps !== this.props;
-  }
-  removeMessage() {
-    this.trigger("remove_message", {
-      id: this.props.id
-    });
-  }
-}
-
-//------------------------------------------------------------------------------
-// Root Widget
-//------------------------------------------------------------------------------
-class App extends owl.Component {
-  template = "root";
-  widgets = { Message };
-  state = { messages: [] };
-
-  addMessages(n) {
-    startMeasure("add " + n);
-    const newMessages = buildData(n);
-    this.state.messages.push.apply(this.state.messages, newMessages);
-    stopMeasure();
-  }
-
-  clear() {
-    startMeasure("clear");
-    this.state.messages = [];
-    stopMeasure();
-  }
-
-  updateSomeMessages() {
-    startMeasure("update every 10th");
-    const messages = this.state.messages;
-    for (let i = 0; i < this.state.messages.length; i += 10) {
-      const msg = Object.assign({}, messages[i]);
-      msg.author += '!!!';
-      this.set(messages, i, msg);
-    }
-    stopMeasure();
-  }
-
-  removeMessage(data) {
-    startMeasure("remove message");
-    const index = this.state.messages.findIndex(m => m.id === data.id);
-    this.state.messages.splice(index, 1);
-    stopMeasure();
-  }
-}
-
-//------------------------------------------------------------------------------
-// Application initialization
-//------------------------------------------------------------------------------
-async function start() {
-  const templates = await owl.utils.loadTemplates("templates.xml");
-  const env = {
-    qweb: new owl.QWeb(templates)
-  };
-  const app = new App(env);
-  app.mount(document.body);
-}
-
-start();
@@ -1,32 +0,0 @@
-<templates>
-  <div t-name="root" class="main">
-      <div class="left-thing">
-          <div>Number of msg: <t t-esc="state.messages.length"/></div>
-          <button t-on-click="addMessages(100)">Add 100 messages</button>
-          <button t-on-click="addMessages(1000)">Add 1000 messages</button>
-          <button t-on-click="addMessages(10000)">Add 10000 messages</button>
-          <button t-on-click="addMessages(50000)">Add 50000 messages</button>
-          <button t-on-click="updateSomeMessages">Update every 10th message</button>
-          <button t-on-click="clear">Clear</button>
-      </div>
-      <div class="right-thing">
-          <div class="content">
-              <t t-foreach="state.messages" t-as="message">
-                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
-              </t>
-          </div>
-      </div>
-  </div>
-
-  <div t-name="message" class="message">
-    <span class="author"><t t-esc="props.author"/></span>
-    <span class="msg"><t t-esc="props.msg"/></span>
-    <button class="remove" t-on-click="removeMessage">Remove</button>
-    <t t-widget="Counter"/>
-  </div>
-
-  <div t-name="counter">
-    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
-  </div>
-
-</templates>
@@ -1,84 +0,0 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
-
-//------------------------------------------------------------------------------
-// Likes Counter Widget
-//------------------------------------------------------------------------------
-class Counter extends owl.Component {
-  template = "counter";
-  state = { counter: 0 };
-
-  increment() {
-    this.state.counter++;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Message Widget
-//------------------------------------------------------------------------------
-class Message extends owl.Component {
-  template = "message";
-  widgets = { Counter };
-
-  shouldUpdate(nextProps) {
-    return nextProps !== this.props;
-  }
-  removeMessage() {
-    this.trigger("remove_message", {
-      id: this.props.id
-    });
-  }
-}
-
-//------------------------------------------------------------------------------
-// Root Widget
-//------------------------------------------------------------------------------
-class App extends owl.Component {
-  template = "root";
-  widgets = { Message };
-  state = { messages: [] };
-
-  addMessages(n) {
-    startMeasure("add " + n);
-    const newMessages = buildData(n);
-    this.state.messages.push.apply(this.state.messages, newMessages);
-    stopMeasure();
-  }
-
-  clear() {
-    startMeasure("clear");
-    this.state.messages = [];
-    stopMeasure();
-  }
-
-  updateSomeMessages() {
-    startMeasure("update every 10th");
-    const messages = this.state.messages;
-    for (let i = 0; i < this.state.messages.length; i += 10) {
-      const msg = Object.assign({}, messages[i]);
-      msg.author += '!!!';
-      this.set(messages, i, msg);
-    }
-    stopMeasure();
-  }
-
-  removeMessage(data) {
-    startMeasure("remove message");
-    const index = this.state.messages.findIndex(m => m.id === data.id);
-    this.state.messages.splice(index, 1);
-    stopMeasure();
-  }
-}
-
-//------------------------------------------------------------------------------
-// Application initialization
-//------------------------------------------------------------------------------
-async function start() {
-  const templates = await owl.utils.loadTemplates("templates.xml");
-  const env = {
-    qweb: new owl.QWeb(templates)
-  };
-  const app = new App(env);
-  app.mount(document.body);
-}
-
-start();
@@ -1,32 +0,0 @@
-<templates>
-  <div t-name="root" class="main">
-      <div class="left-thing">
-          <div>Number of msg: <t t-esc="state.messages.length"/></div>
-          <button t-on-click="addMessages(100)">Add 100 messages</button>
-          <button t-on-click="addMessages(1000)">Add 1000 messages</button>
-          <button t-on-click="addMessages(10000)">Add 10000 messages</button>
-          <button t-on-click="addMessages(50000)">Add 50000 messages</button>
-          <button t-on-click="updateSomeMessages">Update every 10th message</button>
-          <button t-on-click="clear">Clear</button>
-      </div>
-      <div class="right-thing">
-          <div class="content">
-              <t t-foreach="state.messages" t-as="message">
-                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
-              </t>
-          </div>
-      </div>
-  </div>
-
-  <div t-name="message" class="message">
-    <span class="author"><t t-esc="props.author"/></span>
-    <span class="msg"><t t-esc="props.msg"/></span>
-    <button class="remove" t-on-click="removeMessage">Remove</button>
-    <t t-widget="Counter"/>
-  </div>
-
-  <div t-name="counter">
-    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
-  </div>
-
-</templates>
@@ -1,85 +0,0 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
-
-//------------------------------------------------------------------------------
-// Likes Counter Widget
-//------------------------------------------------------------------------------
-class Counter extends owl.Component {
-  template = "counter";
-  state = { counter: 0 };
-
-  increment() {
-    this.state.counter++;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Message Widget
-//------------------------------------------------------------------------------
-class Message extends owl.Component {
-  template = "message";
-  widgets = { Counter };
-
-  shouldUpdate(nextProps) {
-    return nextProps !== this.props;
-  }
-
-  removeMessage() {
-    this.trigger("remove_message", {
-      id: this.props.id
-    });
-  }
-}
-
-//------------------------------------------------------------------------------
-// Root Widget
-//------------------------------------------------------------------------------
-class App extends owl.Component {
-  template = "root";
-  widgets = { Message };
-  state = { messages: [] };
-
-  addMessages(n) {
-    startMeasure("add " + n);
-    const newMessages = buildData(n);
-    this.state.messages.push.apply(this.state.messages, newMessages);
-    stopMeasure();
-  }
-
-  clear() {
-    startMeasure("clear");
-    this.state.messages = [];
-    stopMeasure();
-  }
-
-  updateSomeMessages() {
-    startMeasure("update every 10th");
-    const messages = this.state.messages;
-    for (let i = 0; i < this.state.messages.length; i += 10) {
-      const msg = Object.assign({}, messages[i]);
-      msg.author += '!!!';
-      this.set(messages, i, msg);
-    }
-    stopMeasure();
-  }
-
-  removeMessage(data) {
-    startMeasure('remove message');
-    const index = this.state.messages.findIndex(m => m.id === data.id);
-    this.state.messages.splice(index, 1);
-    stopMeasure();
-  }
-}
-
-//------------------------------------------------------------------------------
-// Application initialization
-//------------------------------------------------------------------------------
-async function start() {
-  const templates = await owl.utils.loadTemplates("templates.xml");
-  const env = {
-    qweb: new owl.QWeb(templates)
-  };
-  const app = new App(env);
-  app.mount(document.body);
-}
-
-start();
@@ -1,32 +0,0 @@
-<templates>
-  <div t-name="root" class="main">
-      <div class="left-thing">
-          <div>Number of msg: <t t-esc="state.messages.length"/></div>
-          <button t-on-click="addMessages(100)">Add 100 messages</button>
-          <button t-on-click="addMessages(1000)">Add 1000 messages</button>
-          <button t-on-click="addMessages(10000)">Add 10000 messages</button>
-          <button t-on-click="addMessages(50000)">Add 50000 messages</button>
-          <button t-on-click="updateSomeMessages">Update every 10th message</button>
-          <button t-on-click="clear">Clear</button>
-      </div>
-      <div class="right-thing">
-          <div class="content">
-              <t t-foreach="state.messages" t-as="message">
-                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
-              </t>
-          </div>
-      </div>
-  </div>
-
-  <div t-name="message" class="message">
-    <span class="author"><t t-esc="props.author"/></span>
-    <span class="msg"><t t-esc="props.msg"/></span>
-    <button class="remove" t-on-click="removeMessage">Remove</button>
-    <t t-widget="Counter"/>
-  </div>
-
-  <div t-name="counter">
-    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
-  </div>
-
-</templates>
@@ -1,84 +0,0 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
-
-//------------------------------------------------------------------------------
-// Likes Counter Widget
-//------------------------------------------------------------------------------
-class Counter extends owl.Component {
-  template = "counter";
-  state = { counter: 0 };
-
-  increment() {
-    this.state.counter++;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Message Widget
-//------------------------------------------------------------------------------
-class Message extends owl.Component {
-  template = "message";
-  widgets = { Counter };
-
-  shouldUpdate(nextProps) {
-    return nextProps !== this.props;
-  }
-  removeMessage() {
-    this.trigger("remove_message", {
-      id: this.props.id
-    });
-  }
-}
-
-//------------------------------------------------------------------------------
-// Root Widget
-//------------------------------------------------------------------------------
-class App extends owl.Component {
-  template = "root";
-  widgets = { Message };
-  state = { messages: [] };
-
-  addMessages(n) {
-    startMeasure("add " + n);
-    const newMessages = buildData(n);
-    this.state.messages.push.apply(this.state.messages, newMessages);
-    stopMeasure();
-  }
-
-  clear() {
-    startMeasure("clear");
-    this.state.messages = [];
-    stopMeasure();
-  }
-
-  updateSomeMessages() {
-    startMeasure("update every 10th");
-    const messages = this.state.messages;
-    for (let i = 0; i < this.state.messages.length; i += 10) {
-      const msg = Object.assign({}, messages[i]);
-      msg.author += '!!!';
-      this.set(messages, i, msg);
-    }
-    stopMeasure();
-  }
-
-  removeMessage(data) {
-    startMeasure("remove message");
-    const index = this.state.messages.findIndex(m => m.id === data.id);
-    this.state.messages.splice(index, 1);
-    stopMeasure();
-  }
-}
-
-//------------------------------------------------------------------------------
-// Application initialization
-//------------------------------------------------------------------------------
-async function start() {
-  const templates = await owl.utils.loadTemplates("templates.xml");
-  const env = {
-    qweb: new owl.QWeb(templates)
-  };
-  const app = new App(env);
-  app.mount(document.body);
-}
-
-start();
@@ -1,32 +0,0 @@
-<templates>
-  <div t-name="root" class="main">
-      <div class="left-thing">
-          <div>Number of msg: <t t-esc="state.messages.length"/></div>
-          <button t-on-click="addMessages(100)">Add 100 messages</button>
-          <button t-on-click="addMessages(1000)">Add 1000 messages</button>
-          <button t-on-click="addMessages(10000)">Add 10000 messages</button>
-          <button t-on-click="addMessages(50000)">Add 50000 messages</button>
-          <button t-on-click="updateSomeMessages">Update every 10th message</button>
-          <button t-on-click="clear">Clear</button>
-      </div>
-      <div class="right-thing">
-          <div class="content">
-              <t t-foreach="state.messages" t-as="message">
-                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
-              </t>
-          </div>
-      </div>
-  </div>
-
-  <div t-name="message" class="message">
-    <span class="author"><t t-esc="props.author"/></span>
-    <span class="msg"><t t-esc="props.msg"/></span>
-    <button class="remove" t-on-click="removeMessage">Remove</button>
-    <t t-widget="Counter"/>
-  </div>
-
-  <div t-name="counter">
-    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
-  </div>
-
-</templates>
@@ -1,84 +0,0 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
-
-//------------------------------------------------------------------------------
-// Likes Counter Widget
-//------------------------------------------------------------------------------
-class Counter extends owl.Component {
-  template = "counter";
-  state = { counter: 0 };
-
-  increment() {
-    this.state.counter++;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Message Widget
-//------------------------------------------------------------------------------
-class Message extends owl.Component {
-  template = "message";
-  widgets = { Counter };
-
-  shouldUpdate(nextProps) {
-    return nextProps !== this.props;
-  }
-  removeMessage() {
-    this.trigger("remove_message", {
-      id: this.props.id
-    });
-  }
-}
-
-//------------------------------------------------------------------------------
-// Root Widget
-//------------------------------------------------------------------------------
-class App extends owl.Component {
-  template = "root";
-  widgets = { Message };
-  state = { messages: [] };
-
-  addMessages(n) {
-    startMeasure("add " + n);
-    const newMessages = buildData(n);
-    this.state.messages.push.apply(this.state.messages, newMessages);
-    stopMeasure();
-  }
-
-  clear() {
-    startMeasure("clear");
-    this.state.messages = [];
-    stopMeasure();
-  }
-
-  updateSomeMessages() {
-    startMeasure("update every 10th");
-    const messages = this.state.messages;
-    for (let i = 0; i < this.state.messages.length; i += 10) {
-      const msg = Object.assign({}, messages[i]);
-      msg.author += '!!!';
-      this.set(messages, i, msg);
-    }
-    stopMeasure();
-  }
-
-  removeMessage(data) {
-    startMeasure("remove message");
-    const index = this.state.messages.findIndex(m => m.id === data.id);
-    this.state.messages.splice(index, 1);
-    stopMeasure();
-  }
-}
-
-//------------------------------------------------------------------------------
-// Application initialization
-//------------------------------------------------------------------------------
-async function start() {
-  const templates = await owl.utils.loadTemplates("templates.xml");
-  const env = {
-    qweb: new owl.QWeb(templates)
-  };
-  const app = new App(env);
-  app.mount(document.body);
-}
-
-start();
@@ -1,32 +0,0 @@
-<templates>
-  <div t-name="root" class="main">
-      <div class="left-thing">
-          <div>Number of msg: <t t-esc="state.messages.length"/></div>
-          <button t-on-click="addMessages(100)">Add 100 messages</button>
-          <button t-on-click="addMessages(1000)">Add 1000 messages</button>
-          <button t-on-click="addMessages(10000)">Add 10000 messages</button>
-          <button t-on-click="addMessages(50000)">Add 50000 messages</button>
-          <button t-on-click="updateSomeMessages">Update every 10th message</button>
-          <button t-on-click="clear">Clear</button>
-      </div>
-      <div class="right-thing">
-          <div class="content">
-              <t t-foreach="state.messages" t-as="message">
-                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
-              </t>
-          </div>
-      </div>
-  </div>
-
-  <div t-name="message" class="message">
-    <span class="author"><t t-esc="props.author"/></span>
-    <span class="msg"><t t-esc="props.msg"/></span>
-    <button class="remove" t-on-click="removeMessage">Remove</button>
-    <t t-widget="Counter"/>
-  </div>
-
-  <div t-name="counter">
-    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
-  </div>
-
-</templates>
@@ -1,81 +0,0 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
-
-//------------------------------------------------------------------------------
-// Likes Counter Widget
-//------------------------------------------------------------------------------
-class Counter extends owl.Component {
-  state = { counter: 0 };
-
-  increment() {
-    this.state.counter++;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Message Widget
-//------------------------------------------------------------------------------
-class Message extends owl.Component {
-  widgets = { Counter };
-
-  shouldUpdate(nextProps) {
-    return nextProps !== this.props;
-  }
-  removeMessage() {
-    this.trigger("remove_message", {
-      id: this.props.id
-    });
-  }
-}
-
-//------------------------------------------------------------------------------
-// Root Widget
-//------------------------------------------------------------------------------
-class App extends owl.Component {
-  widgets = { Message };
-  state = { messages: [] };
-
-  addMessages(n) {
-    startMeasure("add " + n);
-    const newMessages = buildData(n);
-    this.state.messages.push.apply(this.state.messages, newMessages);
-    stopMeasure();
-  }
-
-  clear() {
-    startMeasure("clear");
-    this.state.messages = [];
-    stopMeasure();
-  }
-
-  updateSomeMessages() {
-    startMeasure("update every 10th");
-    const messages = this.state.messages;
-    for (let i = 0; i < this.state.messages.length; i += 10) {
-      const msg = Object.assign({}, messages[i]);
-      msg.author += '!!!';
-      this.set(messages, i, msg);
-    }
-    stopMeasure();
-  }
-
-  removeMessage(data) {
-    startMeasure("remove message");
-    const index = this.state.messages.findIndex(m => m.id === data.id);
-    this.state.messages.splice(index, 1);
-    stopMeasure();
-  }
-}
-
-//------------------------------------------------------------------------------
-// Application initialization
-//------------------------------------------------------------------------------
-async function start() {
-  const templates = await owl.utils.loadTemplates("templates.xml");
-  const env = {
-    qweb: new owl.QWeb(templates)
-  };
-  const app = new App(env);
-  app.mount(document.body);
-}
-
-start();
@@ -1,32 +0,0 @@
-<templates>
-  <div t-name="App" class="main">
-      <div class="left-thing">
-          <div>Number of msg: <t t-esc="state.messages.length"/></div>
-          <button t-on-click="addMessages(100)">Add 100 messages</button>
-          <button t-on-click="addMessages(1000)">Add 1000 messages</button>
-          <button t-on-click="addMessages(10000)">Add 10000 messages</button>
-          <button t-on-click="addMessages(50000)">Add 50000 messages</button>
-          <button t-on-click="updateSomeMessages">Update every 10th message</button>
-          <button t-on-click="clear">Clear</button>
-      </div>
-      <div class="right-thing">
-          <div class="content">
-              <t t-foreach="state.messages" t-as="message">
-                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
-              </t>
-          </div>
-      </div>
-  </div>
-
-  <div t-name="Message" class="message">
-    <span class="author"><t t-esc="props.author"/></span>
-    <span class="msg"><t t-esc="props.msg"/></span>
-    <button class="remove" t-on-click="removeMessage">Remove</button>
-    <t t-widget="Counter"/>
-  </div>
-
-  <div t-name="Counter">
-    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
-  </div>
-
-</templates>
@@ -1,221 +0,0 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
-
-//------------------------------------------------------------------------------
-// Counter Widget
-//------------------------------------------------------------------------------
-class Counter extends React.Component {
-  constructor(props) {
-    super(props);
-    this.state = {
-      counter: 0
-    };
-    this.increment = this.increment.bind(this);
-  }
-
-  render() {
-    return React.createElement(
-      "div",
-      null,
-      React.createElement(
-        "button",
-        {
-          onClick: this.increment
-        },
-        "Value: ",
-        this.state.counter
-      )
-    );
-  }
-
-  increment() {
-    this.setState({
-      counter: this.state.counter + 1
-    });
-  }
-}
-//------------------------------------------------------------------------------
-// Message Widget
-//------------------------------------------------------------------------------
-class Message extends React.Component {
-  constructor(props) {
-    super(props);
-    this.removeMessage = this.removeMessage.bind(this);
-  }
-
-  render() {
-    return React.createElement(
-      "div",
-      {
-        className: "message"
-      },
-      React.createElement(
-        "span",
-        {
-          className: "author"
-        },
-        this.props.message.author
-      ),
-      React.createElement(
-        "span",
-        {
-          className: "msg"
-        },
-        this.props.message.msg
-      ),
-      React.createElement(
-        "button",
-        {
-          className: "remove",
-          onClick: this.removeMessage
-        },
-        "Remove"
-      ),
-      React.createElement(Counter, null)
-    );
-  }
-
-  removeMessage() {
-    this.props.removeCB(this.props.message.id);
-  }
-}
-
-//------------------------------------------------------------------------------
-// Root Widget
-//------------------------------------------------------------------------------
-class Main extends React.Component {
-  constructor(props) {
-    super(props);
-    this.state = {
-      messages: []
-    };
-    this.removeMessage = this.removeMessage.bind(this);
-  }
-
-  render() {
-    const msgList = this.state.messages.map(m =>
-      React.createElement(Message, {
-        key: m.id,
-        message: m,
-        removeCB: this.removeMessage
-      })
-    );
-    return React.createElement(
-      "div",
-      {
-        className: "main"
-      },
-      React.createElement(
-        "div",
-        {
-          className: "left-thing"
-        },
-        React.createElement(
-          "div",
-          null,
-          "Number of msg: ",
-          this.state.messages.length
-        ),
-        React.createElement(
-          "button",
-          {
-            onClick: _ => this.addMessages(100)
-          },
-          "Add 100 messages"
-        ),
-        React.createElement(
-          "button",
-          {
-            onClick: _ => this.addMessages(1000)
-          },
-          "Add 1000 messages"
-        ),
-        React.createElement(
-          "button",
-          {
-            onClick: _ => this.addMessages(10000)
-          },
-          "Add 10000 messages"
-        ),
-        React.createElement(
-          "button",
-          {
-            onClick: _ => this.addMessages(50000)
-          },
-          "Add 50000 messages"
-        ),
-        React.createElement(
-          "button",
-          {
-            onClick: _ => this.updateSomeMessages()
-          },
-          "Update every 10th messags"
-        ),
-        React.createElement(
-          "button",
-          {
-            onClick: _ => this.clear()
-          },
-          "Clear"
-        )
-      ),
-      React.createElement(
-        "div",
-        {
-          className: "right-thing"
-        },
-        React.createElement(
-          "div",
-          {
-            className: "content"
-          },
-          msgList
-        )
-      )
-    );
-  }
-
-  addMessages(n) {
-    startMeasure("add " + n);
-    const newMessages = this.state.messages.concat(buildData(n));
-    this.setState({
-      messages: newMessages
-    });
-    stopMeasure();
-  }
-
-  clear() {
-    startMeasure("clear");
-    this.setState({
-      messages: []
-    });
-    stopMeasure();
-  }
-
-  updateSomeMessages() {
-    startMeasure("update every 10th");
-    const messages = this.state.messages;
-    for (let i = 0; i < messages.length; i += 10) {
-      messages[i].author += "!!!";
-    }
-    this.forceUpdate();
-    stopMeasure();
-  }
-
-  removeMessage(id) {
-    startMeasure("remove message");
-    const index = this.state.messages.findIndex(m => m.id === id);
-    const messages = this.state.messages.slice();
-    messages.splice(index, 1);
-    this.setState({
-      messages
-    });
-    stopMeasure();
-  }
-} //-----------------------------
-// INIT
-//-----------------------------
-
-ReactDOM.render(
-  React.createElement(Main, null),
-  document.getElementById("main")
-);
@@ -1,42 +0,0 @@
-.main {
-  position: absolute;
-  left: 0;
-  right: 0;
-  top: 0;
-  bottom: 0;
-
-  display: grid;
-  grid-template-columns: 220px 1fr;
-}
-
-.left-thing {
-  background-color: gray;
-  padding: 20px;
-  color: white;
-}
-
-.left-thing button {
-  width: 100%;
-}
-
-.right-thing {
-  padding: 20px;
-  overflow: auto;
-}
-
-/* Message widget */
-.message .author {
-  font-weight: bold;
-}
-
-.message {
-  width: 400px;
-  background-color: lightblue;
-  margin: 10px 5px;
-  border-radius: 5px;
-  padding: 5px;
-}
-
-.remove {
-  float: right;
-}
@@ -1,106 +0,0 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
-
-//------------------------------------------------------------------------------
-// Counter Widget
-//------------------------------------------------------------------------------
-Vue.component("likes-counter", {
-  data: function() {
-    return {
-      counter: 0
-    };
-  },
-  methods: {
-    increment() {
-      this.counter++;
-    }
-  },
-  template: `
-    <div>
-      <button @click="increment">Value: {{counter}}</button>
-    </div>`
-});
-
-//------------------------------------------------------------------------------
-// Message Widget
-//------------------------------------------------------------------------------
-Vue.component("my-message", {
-  props: ["msg"],
-  methods: {
-    removeMessage() {
-      this.$emit("removeMessage", this.msg.id);
-    }
-  },
-  template: `
-    <div class="message">
-        <span class="author">{{msg.author}}</span>
-        <span class="msg">{{msg.msg}}</span>
-        <button class="remove" @click="removeMessage">Remove</button>
-        <likes-counter></likes-counter>
-    </div>`
-});
-
-//------------------------------------------------------------------------------
-// Root Widget
-//------------------------------------------------------------------------------
-const App = {
-  name: "App",
-  data() {
-    return { messages: [] };
-  },
-  methods: {
-    addMessages(n) {
-      startMeasure("add " + n);
-      const newMessages = buildData(n);
-      this.messages.push.apply(this.messages, newMessages);
-      stopMeasure();
-    },
-
-    clear() {
-      startMeasure("clear");
-      this.messages = [];
-      stopMeasure();
-    },
-
-    updateSomeMessages() {
-      startMeasure("update every 10th");
-      const messages = this.messages;
-      for (let i = 0; i < this.messages.length; i += 10) {
-        messages[i].author += "!!!";
-      }
-      stopMeasure();
-    },
-
-    removeMessage(id) {
-      startMeasure("remove message");
-      const index = this.messages.findIndex(m => m.id === id);
-      this.messages.splice(index, 1);
-      stopMeasure();
-    }
-  },
-  template: `
-    <div class="main">
-        <div class="left-thing">
-            <div>Number of msg: {{messages.length}}</div>
-            <button @click="addMessages(100)">Add 100 messages</button>
-            <button @click="addMessages(1000)">Add 1000 messages</button>
-            <button @click="addMessages(10000)">Add 10000 messages</button>
-            <button @click="addMessages(50000)">Add 50000 messages</button>
-            <button @click="updateSomeMessages">Update every 10th message</button>
-            <button @click="clear">Clear</button>
-        </div>
-        <div class="right-thing">
-            <div class="content">
-                <my-message v-for="msg in messages" v-bind:key="msg.id" v-bind:msg="msg" @removeMessage="removeMessage"></my-message>
-            </div>
-        </div>
-    </div>
-  `
-};
-
-//------------------------------------------------------------------------------
-// Application initialization
-//------------------------------------------------------------------------------
-
-new Vue({
-  render: h => h(App)
-}).$mount(`#main`);
@@ -1,43 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>OWL Extras</title>
-    <link rel="stylesheet" href="main.css">
-</head>
-<body>
-
-    <div class="title">
-        <h1>🦉 OWL Extra Stuff 🦉</h1>
-        <div>Mysterious OWL: A web framework for structured, dynamic and maintainable applications</div>
-    </div>
-
-    <div class="section misc">
-        <h2>Misc</h2>
-        <div class="links">
-            <a href="playground">Playground (local)</a>
-            <a href="https://github.com/odoo/owl">Github</a>
-            <a href="https://odoo.github.io/owl/">Owl main page</a>
-            <a href="https://github.com/odoo/owl/blob/master/doc/readme.md">Owl Documentation</a>
-        </div>
-    </div>
-
-    <div class="section benchmarks">
-        <h2>Benchmarks</h2>
-
-        <ul>
-            <li><a href="benchmarks/odoo-widgets-12.0">Odoo Widgets (12.0)</a></li>
-            <li><a href="benchmarks/odoo-widgets-12.3">Odoo Widgets (12.3)</a></li>
-            <li><a href="benchmarks/owl-0.7.0">OWL 0.7.0</a></li>
-            <li><a href="benchmarks/owl-0.8.0">OWL 0.8.0</a></li>
-            <li><a href="benchmarks/owl-0.9.0">OWL 0.9.0</a></li>
-            <li><a href="benchmarks/owl-0.10.0">OWL 0.10.0</a></li>
-            <li><a href="benchmarks/owl-0.11.0">OWL 0.11.0</a></li>
-            <li><a href="benchmarks/owl-master">OWL Master</a></li>
-            <li><a href="benchmarks/vue">Vue</a></li>
-            <li><a href="benchmarks/react">React</a></li>
-        </ul>
-    </div>
-
-</body>
-</html>
@@ -1,23 +0,0 @@
-body {
-    font-family: sans-serif;
-}
-
-.title, .section {
-    width: 768px;
-    margin: auto;
-}
-
-.title div {
-    color: #333333;
-    font-style: italic;
-}
-.section {
-    background-color: #d5d5d5;
-    padding: 16px;
-    margin-top: 10px;
-    margin-bottom: 10px;
-}
-
-.links a {
-    margin: 10px 5px;
-}
@@ -1,21 +0,0 @@
-# 🦉 Extra Stuff 🦉
-
-To help work/improve/learn with OWL, we have here:
-
- a benchmarks application
- a playground application
-
-Both of them 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 extras` (and its version with a watcher: `npm run extras:watch`).
-
-## Benchmarks
-
-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.
-
-## Playground
-
-The playground is an important application designed to help learning and
-experimenting with Owl.  It is available [online](https://odoo.github.io/owl/playground/).
@@ -1,38 +0,0 @@
-import sys
-import thread
-import webbrowser
-import time
-
-import BaseHTTPServer
-import SimpleHTTPServer
-
-HOST = '127.0.0.1'
-PORT = 8000
-URL = 'http://{0}:{1}/extras'.format(HOST, PORT)
-
-
-# We define our own handler here to remap owl.js GET requests to the Owl build
-# in dist/.  This is useful for the benchmarks and playground applications.
-# With this, we can simply copy the playground folder as is in the gh-page when
-# we want to update the playground.
-class OWLHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
-    def do_GET(self):
-        if self.path == '/extras/owl.js':
-            self.path = '/dist/owl.js'
-        return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
-
-
-def start_server():
-    httpd = BaseHTTPServer.HTTPServer((HOST, PORT), OWLHandler)
-    httpd.serve_forever()
-
-
-if __name__ == "__main__":
-    thread.start_new_thread(start_server, ())
-    webbrowser.open_new(URL)
-
-    while True:
-        try:
-            time.sleep(1)
-        except KeyboardInterrupt:
-            sys.exit(0)
@@ -1,18 +1,19 @@
 {
  "name": "owl",
-  "version": "0.12.0",
+  "version": "0.16.0",
  "description": "Odoo Web Library (OWL)",
  "main": "src/index.ts",
  "scripts": {
-    "build:js": "tsc --target esnext --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",
    "minify": "uglifyjs dist/owl.js -o dist/owl.min.js --compress --mangle",
    "test": "jest",
    "test:watch": "jest --watch",
-    "extras:serve": "python extras/server.py",
-    "extras": "npm run build && npm run extras:serve",
-    "extras:watch": "npm-run-all  --parallel extras:serve \"build:* -- --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\""
  },
  "repository": {
    "type": "git",
@@ -59,5 +60,8 @@
      "json",
      "node"
    ]
+  },
+  "prettier": {
+      "printWidth": 100
  }
 }
@@ -1,4 +1,3 @@
-import { EventBus } from "./event_bus";
 import { Observer } from "./observer";
 import { QWeb, CompiledTemplate } from "./qweb_core";
 import { h, patch, VNode } from "./vdom";
@@ -18,10 +17,24 @@ import { h, patch, VNode } from "./vdom";
 // 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;
 }

+/**
+ * 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.
+ */
 export interface Meta<T extends Env, Props> {
  readonly id: number;
  vnode: VNode | null;
@@ -29,8 +42,8 @@ export interface Meta<T extends Env, Props> {
  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?
+  // children mapping: from templateID to componentID
+  // should it be a map number => Component?
  cmap: { [key: number]: number };

  renderId: number;
@@ -40,6 +53,7 @@ export interface Meta<T extends Env, Props> {
  observer?: Observer;
  render?: CompiledTemplate;
  mountedHandlers: { [key: number]: Function };
+  classObj?: { [key: string]: boolean };
 }

 // If a component does not define explicitely a template
@@ -49,18 +63,18 @@ export interface Meta<T extends Env, Props> {
 const TEMPLATE_MAP: { [key: number]: { [name: string]: string } } = {};

 //------------------------------------------------------------------------------
-// Widget
+// Component
 //------------------------------------------------------------------------------
 let nextId = 1;

-export class Component<
-  T extends Env,
-  Props extends {},
-  State extends {}
-> extends EventBus {
+export class Component<T extends Env, Props extends {}, State extends {}> {
  readonly __owl__: Meta<Env, Props>;
  template?: string;

+  /**
+   * 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;
  }
@@ -84,36 +98,34 @@ export class Component<
  /**
   * Creates an instance of Component.
   *
-   * The root widget of a component tree needs an environment:
+   * The root component of a component tree needs an environment:
   *
   * ```javascript
-   *   const root = new RootWidget(env, props);
+   *   const root = new RootComponent(env, props);
   * ```
   *
-   * Every other widget simply needs a reference to its parent:
+   * Every other component simply needs a reference to its parent:
   *
   * ```javascript
-   *   const child = new SomeWidget(parent, props);
+   *   const child = new SomeComponent(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)
+   * 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, any> | T, props?: Props) {
-    super();
-
    const defaultProps = (<any>this.constructor).defaultProps;
    if (defaultProps) {
-      props = this._applyDefaultProps(props, defaultProps);
+      props = this.__applyDefaultProps(props, defaultProps);
    }
    if (QWeb.dev) {
-      this._validateProps(props || {});
+      this.__validateProps(props || {});
    }
    // is this a good idea?
-    //   Pro: if props is empty, we can create easily a widget
+    //   Pro: if props is empty, we can create easily a component
    //   Con: this is not really safe
-    //   Pro: but creating widget (by a template) is always unsafe anyway
+    //   Pro: but creating component (by a template) is always unsafe anyway
    this.props = <Props>props || <Props>{};
    let id: number = nextId++;
    let p: Component<T, any, any> | null = null;
@@ -123,6 +135,19 @@ export class Component<
      parent.__owl__.children[id] = this;
    } else {
      this.env = parent;
+      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);
+        }
+      });
    }
    this.__owl__ = {
      id: id,
@@ -146,7 +171,7 @@ export class 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.
+   * 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
@@ -196,7 +221,7 @@ export class Component<
   * 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.
+   * 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.
@@ -220,53 +245,29 @@ export class Component<
  // 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.
+   */
  async mount(target: HTMLElement): Promise<void> {
-    const vnode = await this._prepare();
+    const vnode = await this.__prepare();
    if (this.__owl__.isDestroyed) {
-      // widget was destroyed before we get here...
+      // component was destroyed before we get here...
      return;
    }
-    this._patch(vnode);
+    this.__patch(vnode);
    target.appendChild(this.el!);

    if (document.body.contains(target)) {
-      this._callMounted();
-    }
-  }
-
-  _callMounted() {
-    const __owl__ = this.__owl__;
-    const children = __owl__.children;
-    for (let id in children) {
-      const comp = children[id];
-      if (!comp.__owl__.isMounted && this.el!.contains(comp.el)) {
-        comp._callMounted();
-      }
-    }
-    __owl__.isMounted = true;
-    const handlers = __owl__.mountedHandlers;
-    for (let key in handlers) {
-      handlers[key]();
-    }
-    this.mounted();
-  }
-
-  _callWillUnmount() {
-    this.willUnmount();
-    const __owl__ = this.__owl__;
-    __owl__.isMounted = false;
-    const children = __owl__.children;
-    for (let id in children) {
-      const comp = children[id];
-      if (comp.__owl__.isMounted) {
-        comp._callWillUnmount();
-      }
+      this.__callMounted();
    }
  }

  unmount() {
    if (this.__owl__.isMounted) {
-      this._callWillUnmount();
+      this.__callWillUnmount();
      this.el!.remove();
    }
  }
@@ -280,69 +281,49 @@ export class Component<
    if (shouldPatch) {
      patchQueue = [];
    }
-    const renderVDom = this._render(force, patchQueue);
+    const renderVDom = this.__render(force, patchQueue);
    const renderId = __owl__.renderId;
    await renderVDom;

    if (shouldPatch && __owl__.isMounted && renderId === __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.
-      const patchLen = patchQueue!.length;
-      for (let i = 0; i < patchLen; i++) {
-        const patch = patchQueue![i];
-        patch.push(patch[0].willPatch());
-      }
-      for (let i = 0; i < patchLen; i++) {
-        const patch = patchQueue![i];
-        patch[0]._patch(patch[1]);
-      }
-
-      for (let i = patchLen - 1; i >= 0; i--) {
-        const patch = patchQueue![i];
-        patch[0].patched(patch[2]);
-      }
+      this.__applyPatchQueue(<any[]>patchQueue);
    }
  }

+  /**
+   * 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);
+      this.__destroy(__owl__.parent);
      if (el) {
        el.remove();
      }
    }
  }

-  _destroy(parent) {
-    const __owl__ = this.__owl__;
-    const isMounted = __owl__.isMounted;
-    if (isMounted) {
-      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;
-    }
-    this.clear();
-    __owl__.isDestroyed = true;
-    delete __owl__.vnode;
-  }
-
+  /**
+   * 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;
  }

  /**
-   * 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
+   * This method is the correct way to update the environment of a component. Doing
+   * this will cause a full rerender of the component 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
@@ -360,15 +341,78 @@ export class Component<
    }
  }

-  set(target: any, key: string | number, value: any) {
-    this.__owl__.observer!.set(target, key, value);
+  /**
+   * 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) {
+    if (this.el) {
+      const ev = new CustomEvent(eventType, {
+        bubbles: true,
+        cancelable: true,
+        detail: payload
+      });
+      this.el.dispatchEvent(ev);
+    }
  }

  //--------------------------------------------------------------------------
  // Private
  //--------------------------------------------------------------------------

-  async _updateProps(
+  __destroy(parent: Component<any, any, any> | null) {
+    const __owl__ = this.__owl__;
+    const isMounted = __owl__.isMounted;
+    if (isMounted) {
+      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;
+  }
+
+  __callMounted() {
+    const __owl__ = this.__owl__;
+    const children = __owl__.children;
+    for (let id in children) {
+      const comp = children[id];
+      if (!comp.__owl__.isMounted && this.el!.contains(comp.el)) {
+        comp.__callMounted();
+      }
+    }
+    __owl__.isMounted = true;
+    const handlers = __owl__.mountedHandlers;
+    for (let key in handlers) {
+      handlers[key]();
+    }
+    this.mounted();
+  }
+
+  __callWillUnmount() {
+    this.willUnmount();
+    const __owl__ = this.__owl__;
+    __owl__.isMounted = false;
+    const children = __owl__.children;
+    for (let id in children) {
+      const comp = children[id];
+      if (comp.__owl__.isMounted) {
+        comp.__callWillUnmount();
+      }
+    }
+  }
+
+  async __updateProps(
    nextProps: Props,
    forceUpdate: boolean = false,
    patchQueue?: any[]
@@ -377,10 +421,10 @@ export class Component<
    if (shouldUpdate) {
      const defaultProps = (<any>this.constructor).defaultProps;
      if (defaultProps) {
-        nextProps = this._applyDefaultProps(nextProps, defaultProps);
+        nextProps = this.__applyDefaultProps(nextProps, defaultProps);
      }
      if (QWeb.dev) {
-        this._validateProps(nextProps);
+        this.__validateProps(nextProps);
      }
      await this.willUpdateProps(nextProps);
      this.props = nextProps;
@@ -388,22 +432,26 @@ export class Component<
    }
  }

-  _patch(vnode) {
+  __patch(vnode) {
    const __owl__ = this.__owl__;
    __owl__.renderPromise = null;
    const target = __owl__.vnode || document.createElement(vnode.sel!);
+    if (this.__owl__.classObj) {
+      (<any>vnode).data.class = Object.assign((<any>vnode).data.class || {}, this.__owl__.classObj);
+    }
    __owl__.vnode = patch(target, vnode);
  }
-  _prepare(): Promise<VNode> {
+
+  __prepare(): Promise<VNode> {
    const __owl__ = this.__owl__;
    __owl__.renderProps = this.props;
-    __owl__.renderPromise = this._prepareAndRender();
+    __owl__.renderPromise = this.__prepareAndRender();
    return __owl__.renderPromise;
  }

-  async _prepareAndRender(): Promise<VNode> {
+  async __prepareAndRender(): Promise<VNode> {
    await this.willStart();
-      const __owl__ = this.__owl__;
+    const __owl__ = this.__owl__;
    if (__owl__.isDestroyed) {
      return Promise.resolve(h("div"));
    }
@@ -420,15 +468,11 @@ export class Component<
      if (template) {
        this.template = template;
      } else {
-        while (
-          (template = p.name) &&
-          !(template in qweb.templates) &&
-          p !== Component
-        ) {
+        while ((template = p.name) && !(template in qweb.templates) && p !== Component) {
          p = p.__proto__;
        }
        if (p === Component) {
-          this.template = "default";
+          throw new Error(`Could not find template for component "${this.constructor.name}"`);
        } else {
          tmap[name] = template;
          this.template = template;
@@ -436,14 +480,12 @@ export class Component<
      }
    }
    __owl__.render = qweb.render.bind(qweb, this.template);
-    this._observeState();
-    return this._render();
+    this.__observeState();
+    return this.__render();
  }
-  async _render(
-    force: boolean = false,
-    patchQueue: any[] = []
-  ): Promise<VNode> {
-      const __owl__ = this.__owl__;
+
+  async __render(force: boolean = false, patchQueue: any[] = []): Promise<VNode> {
+    const __owl__ = this.__owl__;
    __owl__.renderId++;
    const promises: Promise<void>[] = [];
    const patch: any[] = [this];
@@ -466,9 +508,9 @@ export class Component<
    }

    // 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
+    // tricky part is that a child component 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
+    // parent component.  With this, we make sure that the parent component will be
    // able to patch itself properly after
    vnode.key = __owl__.id;
    __owl__.renderProps = this.props;
@@ -477,29 +519,32 @@ export class Component<
  }

  /**
-   * Only called by qweb t-widget directive
+   * Only called by qweb t-component directive
   */
-  _mount(vnode: VNode, elm: HTMLElement): VNode {
-      const __owl__ = this.__owl__;
+  __mount(vnode: VNode, elm: HTMLElement): VNode {
+    const __owl__ = this.__owl__;
+    if (__owl__.classObj) {
+      (<any>vnode).data.class = Object.assign((<any>vnode).data.class || {}, __owl__.classObj);
+    }
    __owl__.vnode = patch(elm, vnode);
    if (__owl__.parent!.__owl__.isMounted && !__owl__.isMounted) {
-      this._callMounted();
+      this.__callMounted();
    }
    return __owl__.vnode;
  }

  /**
-   * Only called by qweb t-widget directive (when t-keepalive is set)
+   * Only called by qweb t-component directive (when t-keepalive is set)
   */
-  _remount() {
-      const __owl__ = this.__owl__;
+  __remount() {
+    const __owl__ = this.__owl__;
    if (!__owl__.isMounted) {
      __owl__.isMounted = true;
      this.mounted();
    }
  }

-  _observeState() {
+  __observeState() {
    if (this.state) {
      const __owl__ = this.__owl__;
      __owl__.observer = new Observer();
@@ -514,7 +559,7 @@ export class Component<
   * Note that this method does not modify in place the props, it returns a new
   * prop object
   */
-  _applyDefaultProps(props: Object | undefined, defaultProps: Object): Props {
+  __applyDefaultProps(props: Object | undefined, defaultProps: Object): Props {
    props = props ? Object.create(props) : {};
    for (let propName in defaultProps) {
      if (props![propName] === undefined) {
@@ -524,21 +569,42 @@ export class Component<
    return <Props>props;
  }

+  /**
+   * Apply the given patch queue. A patch is a pair [c, vn], where c is a
+   * Component instance and vn a VNode.
+   *   1) Call 'willPatch' on the component of each patch
+   *   2) Call '__patch' on the component of each patch
+   *   3) Call 'patched' on the component of each patch, in inverse order
+   */
+  __applyPatchQueue(patchQueue: any[]) {
+    const patchLen = patchQueue.length;
+    for (let i = 0; i < patchLen; i++) {
+      const patch = patchQueue[i];
+      patch.push(patch[0].willPatch());
+    }
+    for (let i = 0; i < patchLen; i++) {
+      const patch = patchQueue[i];
+      patch[0].__patch(patch[1]);
+    }
+    for (let i = patchLen - 1; i >= 0; i--) {
+      const patch = patchQueue[i];
+      patch[0].patched(patch[2]);
+    }
+  }
+
  /**
   * 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.
   */
-  _validateProps(props: Object) {
+  __validateProps(props: Object) {
    const propsDef = (<any>this.constructor).props;
    if (propsDef instanceof Array) {
      // list of strings (prop names)
      for (let i = 0, l = propsDef.length; i < l; i++) {
        if (!(propsDef[i] in props)) {
-          throw new Error(
-            `Missing props '${propsDef[i]}' (widget '${this.constructor.name}')`
-          );
+          throw new Error(`Missing props '${propsDef[i]}' (component '${this.constructor.name}')`);
        }
      }
    } else if (propsDef) {
@@ -546,9 +612,7 @@ export class Component<
      for (let propName in propsDef) {
        if (!(propName in props)) {
          if (propsDef[propName] && !propsDef[propName].optional) {
-            throw new Error(
-              `Missing props '${propName}' (widget '${this.constructor.name}')`
-            );
+            throw new Error(`Missing props '${propName}' (component '${this.constructor.name}')`);
          } else {
            break;
          }
@@ -556,9 +620,7 @@ export class Component<
        let isValid = isValidProp(props[propName], propsDef[propName]);
        if (!isValid) {
          throw new Error(
-            `Props '${propName}' of invalid type in widget '${
-              this.constructor.name
-            }'`
+            `Props '${propName}' of invalid type in component '${this.constructor.name}'`
          );
        }
      }
@@ -29,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
@@ -32,7 +32,7 @@ Object.defineProperty(__info__, "mode", {
        `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.`)
+      console.log(`Owl is now running in 'prod' mode.`);
    }
  }
 });
@@ -21,15 +21,7 @@

 // we define here a new modified Array prototype, which basically override all
 // Array methods that change some state to be able to track their changes
-const methodsToPatch = [
-  "push",
-  "pop",
-  "shift",
-  "unshift",
-  "splice",
-  "sort",
-  "reverse"
-];
+const methodsToPatch = ["push", "pop", "shift", "unshift", "splice", "sort", "reverse"];
 const methodLen = methodsToPatch.length;

 const ArrayProto = Array.prototype;
@@ -76,6 +68,20 @@ export class Observer {
  allowMutations: boolean = true;
  dirty: boolean = false;

+  static set(target: any, key: number | string, value: any) {
+    if (!target.__owl__) {
+      throw Error("`Observer.set()` can only be called with observed Objects or Arrays");
+    }
+    target.__owl__.observer.set(target, key, value);
+  }
+
+  static delete(target: any, key: number | string) {
+    if (!target.__owl__) {
+      throw Error("`Observer.delete()` can only be called with observed Objects");
+    }
+    target.__owl__.observer.delete(target, key);
+  }
+
  notifyCB() {}
  notifyChange() {
    this.dirty = true;
@@ -108,14 +114,30 @@ export class Observer {
  }

  set(target: any, key: number | string, value: any) {
-    this.rev++;
-    this._addProp(target, key, value);
-    target.__owl__.rev++;
+    let alreadyDefined =
+      key in target && Object.getOwnPropertyDescriptor(target, key)!.configurable === false;
+    if (alreadyDefined) {
+      target[key] = value;
+    } else {
+      this._addProp(target, key, value);
+      this._updateRevNumber(target);
+    }
+    this.notifyChange();
+  }
+
+  delete(target: any, key: number | string) {
+    delete target[key];
+    this._updateRevNumber(target);
    this.notifyChange();
  }

  _observeObj<T extends { __owl__?: any }>(obj: T, parent?: any) {
-    obj.__owl__ = { rev: this.rev, deepRev: this.rev, parent };
+    obj.__owl__ = {
+      rev: this.rev,
+      deepRev: this.rev,
+      parent,
+      observer: this
+    };
    Object.defineProperty(obj, "__owl__", { enumerable: false });
    for (let key in obj) {
      this._addProp(obj, key, obj[key]);
@@ -123,7 +145,12 @@ export class Observer {
  }

  _observeArr(arr: Array<any>, parent?: any) {
-    (<any>arr).__owl__ = { rev: this.rev, deepRev: this.rev, parent };
+    (<any>arr).__owl__ = {
+      rev: this.rev,
+      deepRev: this.rev,
+      parent,
+      observer: this
+    };
    Object.defineProperty(arr, "__owl__", { enumerable: false });
    (<any>arr).__proto__ = Object.create(ModifiedArrayProto);
    (<any>arr).__proto__.__observer__ = this;
@@ -132,36 +159,36 @@ export class Observer {
    }
  }

-  _addProp<T extends { __owl__?: any }>(
-    obj: T,
-    key: string | number,
-    value: any
-  ) {
+  _addProp<T extends { __owl__?: any }>(obj: T, key: string | number, value: any) {
    var self = this;
    Object.defineProperty(obj, key, {
+      configurable: true,
      enumerable: true,
      get() {
        return value;
      },
      set(newVal) {
        if (newVal !== value) {
-          self.rev++;
          if (!self.allowMutations) {
            throw new Error(
              `Observed state cannot be changed here! (key: "${key}", val: "${newVal}")`
            );
          }
+          self._updateRevNumber(obj);
          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);
  }
+  _updateRevNumber(target: any) {
+    this.rev++;
+    target.__owl__.rev!++;
+    let parent = target;
+    do {
+      parent.__owl__.deepRev++;
+    } while ((parent = parent.__owl__.parent) && parent !== target);
+  }
 }
@@ -1,4 +1,6 @@
 import { VNode, h } from "./vdom";
+import { QWebVar, compileExpr } from "./qweb_expressions";
+import { EventBus } from "./event_bus";

 /**
 * Owl QWeb Engine
@@ -56,27 +58,8 @@ export interface Directive {
 //------------------------------------------------------------------------------
 // Const/global stuff/helpers
 //------------------------------------------------------------------------------
-const RESERVED_WORDS = "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,this,typeof,eval,void,Math,RegExp,Array,Object,Date".split(
-  ","
-);

-const WORD_REPLACEMENT = {
-  and: "&&",
-  or: "||",
-  gt: ">",
-  gte: ">=",
-  lt: "<",
-  lte: "<="
-};
-
-const DISABLED_TAGS = [
-  "input",
-  "textarea",
-  "button",
-  "select",
-  "option",
-  "optgroup"
-];
+const DISABLED_TAGS = ["input", "textarea", "button", "select", "option", "optgroup"];

 const lineBreakRE = /[\r\n]/;
 const whitespaceRE = /\s+/g;
@@ -98,20 +81,35 @@ const NODE_HOOKS_PARAMS = {

 interface Utils {
  h: typeof h;
-  objectToAttrString(obj: Object): string;
+  toObj(expr: any): Object;
+  shallowEqual(p1: Object, p2: Object): boolean;
  [key: string]: any;
 }

 export const UTILS: Utils = {
  h: h,
-  objectToAttrString(obj: Object): string {
-    let classes: string[] = [];
-    for (let k in obj) {
-      if (obj[k]) {
-        classes.push(k);
+  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(p1, p2) {
+    for (let k in p1) {
+      if (p1[k] !== p2[k]) {
+        return false;
      }
    }
-    return classes.join(" ");
+    return true;
  }
 };

@@ -129,10 +127,10 @@ let nextID = 1;
 //------------------------------------------------------------------------------
 // QWeb rendering engine
 //------------------------------------------------------------------------------
-export class QWeb {
+export class QWeb extends EventBus {
  templates: { [name: string]: Template } = {};
  utils = UTILS;
-  static widgets = Object.create(null);
+  static components = Object.create(null);

  // dev mode enables better error messages or more costly validations
  static dev: boolean = false;
@@ -142,11 +140,16 @@ export class QWeb {
  // able to map a qweb instance to a template name.
  id = nextID++;

+  // slots contains sub templates defined with t-set inside t-component nodes, and
+  // are meant to be used by the t-slot directive.
+  slots = {};
+  nextSlotId = 1;
+
  constructor(data?: string) {
+    super();
    if (data) {
      this.addTemplates(data);
    }
-    this.addTemplate("default", "<div></div>");
  }

  static addDirective(directive: Directive) {
@@ -159,17 +162,20 @@ export class QWeb {
  }

  static register(name: string, Component: any) {
-    if (QWeb.widgets[name]) {
+    if (QWeb.components[name]) {
      throw new Error(`Component '${name}' has already been registered`);
    }
-    QWeb.widgets[name] = Component;
+    QWeb.components[name] = Component;
  }

  /**
   * Add a template to the internal template map.  Note that it is not
   * immediately compiled.
   */
-  addTemplate(name: string, xmlString: string) {
+  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)");
@@ -232,9 +238,7 @@ export class QWeb {
            return a + b;
          }) > 1
        ) {
-          throw new Error(
-            "Only one conditional branching directive is allowed per node"
-          );
+          throw new Error("Only one conditional branching directive is allowed per node");
        }
        // All text nodes between branch nodes are removed
        let textNode;
@@ -264,9 +268,15 @@ export class QWeb {
    return template.fn.call(this, context, extra);
  }

-  _compile(name: string, elem: Element): CompiledTemplate {
+  _compile(name: string, elem: Element, parentNode?: number): CompiledTemplate {
    const isDebug = elem.attributes.hasOwnProperty("t-debug");
    const ctx = new Context(name);
+    if (parentNode) {
+      ctx.nextID = parentNode + 1;
+      ctx.parentNode = parentNode;
+      ctx.allowMultipleRoots = true;
+      ctx.addLine(`let c${parentNode} = extra.parentNode;`);
+    }
    this._compileNode(elem, ctx);

    if (ctx.shouldProtectContext) {
@@ -284,30 +294,30 @@ export class QWeb {
      ctx.code.unshift("    let utils = this.utils;");
    }

-    if (!ctx.rootNode) {
-      throw new Error("A template should have one root node");
+    if (!parentNode) {
+      if (!ctx.rootNode) {
+        throw new Error("A template should have one root node");
+      }
+      ctx.addLine(`return vn${ctx.rootNode};`);
    }
-    ctx.addLine(`return vn${ctx.rootNode};`);
    let template;
    try {
-      template = new Function(
-        "context",
-        "extra",
-        ctx.code.join("\n")
-      ) as CompiledTemplate;
+      template = new Function("context", "extra", ctx.code.join("\n")) as CompiledTemplate;
    } catch (e) {
+      const templateName = ctx.templateName.replace(/`/g, "'");
+      console.groupCollapsed(`Invalid Code generated by ${templateName}`);
+      console.warn(ctx.code.join("\n"));
+      console.groupEnd();
      throw new Error(
-        `Invalid generated code while compiling template '${ctx.templateName.replace(
-          /`/g,
-          "'"
-        )}': ${e.message}`
+        `Invalid generated code while compiling template '${templateName}': ${e.message}`
      );
    }
    if (isDebug) {
-      console.log(
-        `Template: ${this.templates[name].elem.outerHTML}\nCompiled code:\n` +
-          template.toString()
-      );
+      const tpl = this.templates[name];
+      if (tpl) {
+        const msg = `Template: ${tpl.elem.outerHTML}\nCompiled code:\n${template.toString()}`;
+        console.log(msg);
+      }
    }
    return template;
  }
@@ -328,17 +338,25 @@ export class QWeb {
      }
      if (ctx.parentNode) {
        ctx.addLine(`c${ctx.parentNode}.push({text: \`${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(`var vn${nodeID} = {text: \`${text}\`};`);
        ctx.rootContext.rootNode = nodeID;
-        ctx.rootContext.parentNode = 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);
+    }
    const attributes = (<Element>node).attributes;

    const validDirectives: {
@@ -354,7 +372,7 @@ export class QWeb {
    for (let i = 0; i < attributes.length; i++) {
      let attrName = attributes[i].name;
      if (attrName.startsWith("t-")) {
-        let dName = attrName.slice(2).split("-")[0];
+        let dName = attrName.slice(2).split(/-|\./)[0];
        if (!(dName in DIRECTIVE_NAMES)) {
          throw new Error(`Unknown QWeb directive: '${attrName}'`);
        }
@@ -371,12 +389,13 @@ export class QWeb {
        const name = attributes[j].name;
        if (
          name === "t-" + directive.name ||
-          name.startsWith("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") {
+          if (directive.name === "on" || directive.name === "model") {
            withHandlers = true;
          }
        }
@@ -445,11 +464,7 @@ export class QWeb {
    }
  }

-  _compileGenericNode(
-    node: ChildNode,
-    ctx: Context,
-    withHandlers: boolean = true
-  ): number {
+  _compileGenericNode(node: ChildNode, ctx: Context, withHandlers: boolean = true): number {
    // nodeType 1 is generic tag
    if (node.nodeType !== 1) {
      throw new Error("unsupported node type");
@@ -473,66 +488,75 @@ export class QWeb {
      if (key === "disabled" && DISABLED_TAGS.indexOf(node.nodeName) > -1) {
        isProp = true;
      }
-      if (
-        (key === "readonly" && node.nodeName === "input") ||
-        node.nodeName === "textarea"
-      ) {
+      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;
      const value = attributes[i].textContent!;

      // regular attributes
-      if (
-        !name.startsWith("t-") &&
-        !(<Element>node).getAttribute("t-attf-" + name)
-      ) {
+      if (!name.startsWith("t-") && !(<Element>node).getAttribute("t-attf-" + name)) {
        const attID = ctx.generateID();
-        ctx.addLine(`var _${attID} = '${value}';`);
-        if (!name.match(/^[a-zA-Z]+$/)) {
-          // attribute contains 'non letters' => we want to quote it
-          name = '"' + name + '"';
+        if (name === "class") {
+          let classDef = value
+            .trim()
+            .split(/\s+/)
+            .map(a => `'${a}':true`)
+            .join(",");
+          classObj = `_${ctx.generateID()}`;
+          ctx.addLine(`let ${classObj} = {${classDef}};`);
+        } else {
+          ctx.addLine(`var _${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);
        }
-        attrs.push(`${name}: _${attID}`);
-        handleBooleanProps(name, attID);
      }

      // dynamic attributes
      if (name.startsWith("t-att-")) {
        let attName = name.slice(6);
-        let formattedValue = ctx.formatExpression(ctx.getValue(value!));
-        if (
-          formattedValue[0] === "{" &&
-          formattedValue[formattedValue.length - 1] === "}"
-        ) {
-          formattedValue = `this.utils.objectToAttrString(${formattedValue})`;
+        const v = ctx.getValue(value);
+        let formattedValue = v.id || ctx.formatExpression(v);
+
+        if (attName === "class") {
+          formattedValue = `this.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(`var _${attValueID} = ${formattedValue};`);
+            formattedValue = `'${attValue}' + (_${attValueID} ? ' ' + _${attValueID} : '')`;
+            const attrIndex = attrs.findIndex(att => att.startsWith(attName + ":"));
+            attrs.splice(attrIndex, 1);
+          }
+          ctx.addLine(`var _${attID} = ${formattedValue};`);
+          attrs.push(`${attName}: _${attID}`);
+          handleBooleanProps(attName, attID);
        }
-        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(`var _${attValueID} = ${formattedValue};`);
-          formattedValue = `'${attValue}' + (_${attValueID} ? ' ' + _${attValueID} : '')`;
-          const attrIndex = attrs.findIndex(att =>
-            att.startsWith(attName + ":")
-          );
-          attrs.splice(attrIndex, 1);
-        }
-        ctx.addLine(`var _${attID} = ${formattedValue};`);
-        attrs.push(`${attName}: _${attID}`);
-        handleBooleanProps(attName, attID);
      }

      if (name.startsWith("t-attf-")) {
@@ -573,6 +597,9 @@ export class QWeb {
    if (props.length > 0) {
      parts.push(`props:{${props.join(",")}}`);
    }
+    if (classObj) {
+      parts.push(`class:${classObj}`);
+    }
    if (withHandlers) {
      parts.push(`on:{}`);
    }
@@ -589,9 +616,7 @@ export class QWeb {
      ctx.addLine(`}`);
      ctx.closeIf();
    }
-    ctx.addLine(
-      `var vn${nodeID} = h('${node.nodeName}', p${nodeID}, c${nodeID});`
-    );
+    ctx.addLine(`var vn${nodeID} = h('${node.nodeName}', p${nodeID}, c${nodeID});`);
    if (ctx.parentNode) {
      ctx.addLine(`c${ctx.parentNode}.push(vn${nodeID});`);
    }
@@ -611,13 +636,14 @@ export class QWeb {
 //------------------------------------------------------------------------------
 // Compilation Context
 //------------------------------------------------------------------------------
+
 export class Context {
  nextID: number = 1;
  code: string[] = [];
-  variables: { [key: string]: any } = {};
-  definedVariables: { [key: string]: string } = {};
+  variables: { [key: string]: QWebVar } = {};
  escaping: boolean = false;
  parentNode: number | null = null;
+  parentTextNode: number | null = null;
  rootNode: number | null = null;
  indentLevel: number = 0;
  rootContext: Context;
@@ -629,6 +655,7 @@ export class Context {
  inLoop: boolean = false;
  inPreTag: boolean = false;
  templateName: string;
+  allowMultipleRoots: boolean = false;

  constructor(name?: string) {
    this.rootContext = this;
@@ -642,7 +669,11 @@ export class Context {
  }

  withParent(node: number): Context {
-    if (this === this.rootContext && this.parentNode) {
+    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) {
@@ -690,89 +721,31 @@ export class Context {
    return val in this.variables ? this.getValue(this.variables[val]) : val;
  }

-  formatExpression(e: string): string {
-    e = e.trim();
-    if (e[0] === "{" && e[e.length - 1] === "}") {
-      const innerExpr = e
-        .slice(1, -1)
-        .split(",")
-        .map(p => {
-          let [key, val] = p.trim().split(":");
-          if (key === "") {
-            return "";
-          }
-          if (!val) {
-            val = key;
-          }
-          return `${key}: ${this.formatExpression(val)}`;
-        })
-        .join(",");
-      return "{" + innerExpr + "}";
-    }
-
-    // Thanks CHM for this code...
-    const chars = e.split("");
-    let instring = "";
-    let invar = "";
-    let invarPos = 0;
-    let r = "";
-    chars.push(" ");
-    for (let i = 0, ilen = chars.length; i < ilen; i++) {
-      let c = chars[i];
-      if (instring.length) {
-        if (c === instring && chars[i - 1] !== "\\") {
-          instring = "";
-        }
-      } else if (c === '"' || c === "'") {
-        instring = c;
-      } else if (c.match(/[a-zA-Z_\$]/) && !invar.length) {
-        invar = c;
-        invarPos = i;
-        continue;
-      } else if (c.match(/\W/) && invar.length) {
-        // TODO: Should check for possible spaces before dot
-        if (chars[invarPos - 1] !== "." && RESERVED_WORDS.indexOf(invar) < 0) {
-          if (!(invar in this.definedVariables)) {
-            invar =
-              WORD_REPLACEMENT[invar] ||
-              (invar in this.variables &&
-                this.formatExpression(this.variables[invar])) ||
-              "context['" + invar + "']";
-          }
-        }
-        r += invar;
-        invar = "";
-      } else if (invar.length) {
-        invar += c;
-        continue;
-      }
-      r += c;
-    }
-    const result = r.slice(0, -1);
-    return result;
+  /**
+   * 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 {
+    return compileExpr(expr, this.variables);
  }

  /**
   * Perform string interpolation on the given string. Note that if the whole
-   * string is an expression, it simply returns it (formatted).
+   * string is an expression, it simply returns it (formatted and enclosed in
+   * parentheses).
   * For instance:
   *   'Hello {{x}}!' -> `Hello ${x}`
-   *   '{{x}}' -> x
+   *   '{{x ? 'a': 'b'}}' -> (x ? 'a' : 'b')
   */
  interpolate(s: string): string {
    let matches = s.match(/\{\{.*?\}\}/g);
    if (matches && matches[0].length === s.length) {
-      return this.formatExpression(s.slice(2, -2));
-    }
-    matches = s.match(/\#\{.*?\}/g);
-    if (matches && matches[0].length === s.length) {
-      return this.formatExpression(s.slice(2, -1));
+      return `(${this.formatExpression(s.slice(2, -2))})`;
    }

-    let formatter = expr => "${" + this.formatExpression(expr) + "}";
-    let r = s
-      .replace(/\{\{.*?\}\}/g, s => formatter(s.slice(2, -2)))
-      .replace(/\#\{.*?\}/g, s => formatter(s.slice(2, -1)));
+    let r = s.replace(/\{\{.*?\}\}/g, s => "${" + this.formatExpression(s.slice(2, -2)) + "}");
    return "`" + r + "`";
  }
 }
@@ -1,4 +1,5 @@
 import { Context, QWeb, UTILS } from "./qweb_core";
+import { QWebExprVar } from "./qweb_expressions";

 /**
 * Owl QWeb Directives
@@ -14,7 +15,6 @@ import { Context, QWeb, UTILS } from "./qweb_core";
 * - t-log
 */

-
 //------------------------------------------------------------------------------
 // t-esc and t-raw
 //------------------------------------------------------------------------------
@@ -30,42 +30,47 @@ function compileValueNode(value: any, node: Element, qweb: QWeb, ctx: Context) {
    return;
  }

-  if (typeof value === "string") {
-    let exprID = value;
-    if (!(value in ctx.definedVariables)) {
-      exprID = `_${ctx.generateID()}`;
-      ctx.addLine(`var ${exprID} = ${ctx.formatExpression(value)};`);
-    }
-    ctx.addIf(`${exprID} || ${exprID} === 0`);
-    if (!ctx.parentNode) {
-      throw new Error("Should not have a text node without a parent");
-    }
-    if (ctx.escaping) {
-      ctx.addLine(`c${ctx.parentNode}.push({text: ${exprID}});`);
-    } else {
-      let fragID = ctx.generateID();
-      ctx.addLine(`var frag${fragID} = this.utils.getFragment(${exprID})`);
-      let tempNodeID = ctx.generateID();
-      ctx.addLine(`var p${tempNodeID} = {hook: {`);
-      ctx.addLine(
-        `  insert: n => n.elm.parentNode.replaceChild(frag${fragID}, n.elm),`
-      );
-      ctx.addLine(`}};`);
-      ctx.addLine(`var vn${tempNodeID} = h('div', p${tempNodeID})`);
-      ctx.addLine(`c${ctx.parentNode}.push(vn${tempNodeID});`);
-    }
-    if (node.childNodes.length) {
-      ctx.addElse();
-      qweb._compileChildren(node, ctx);
-    }
-    ctx.closeIf();
-    return;
-  }
-  if (value instanceof NodeList) {
-    for (let node of Array.from(value)) {
+  if (value.xml instanceof NodeList) {
+    for (let node of Array.from(value.xml)) {
      qweb._compileNode(<ChildNode>node, ctx);
    }
+    return;
  }
+  let exprID: string;
+  if (typeof value === "string") {
+    exprID = `_${ctx.generateID()}`;
+    ctx.addLine(`var ${exprID} = ${ctx.formatExpression(value)};`);
+  } else {
+    exprID = value.id;
+  }
+  ctx.addIf(`${exprID} || ${exprID} === 0`);
+  if (ctx.escaping) {
+    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(`var vn${nodeID} = {text: ${exprID}};`);
+    }
+  } else {
+    let fragID = ctx.generateID();
+    ctx.addLine(`var frag${fragID} = this.utils.getFragment(${exprID})`);
+    let tempNodeID = ctx.generateID();
+    ctx.addLine(`var p${tempNodeID} = {hook: {`);
+    ctx.addLine(`  insert: n => n.elm.parentNode.replaceChild(frag${fragID}, n.elm),`);
+    ctx.addLine(`}};`);
+    ctx.addLine(`var vn${tempNodeID} = h('div', p${tempNodeID})`);
+    ctx.addLine(`c${ctx.parentNode}.push(vn${tempNodeID});`);
+  }
+  if (node.childNodes.length) {
+    ctx.addElse();
+    qweb._compileChildren(node, ctx);
+  }
+
+  ctx.closeIf();
 }

 QWeb.addDirective({
@@ -109,15 +114,19 @@ QWeb.addDirective({
    if (value) {
      const formattedValue = ctx.formatExpression(value);
      if (ctx.variables.hasOwnProperty(variable)) {
-        ctx.addLine(`${ctx.variables[variable]} = ${formattedValue}`);
+        ctx.addLine(`${(<QWebExprVar>ctx.variables[variable]).id} = ${formattedValue}`);
      } else {
        const varName = `_${ctx.generateID()}`;
        ctx.addLine(`var ${varName} = ${formattedValue};`);
-        ctx.definedVariables[varName] = formattedValue;
-        ctx.variables[variable] = varName;
+        ctx.variables[variable] = {
+          id: varName,
+          expr: formattedValue
+        };
      }
    } else {
-      ctx.variables[variable] = node.childNodes;
+      ctx.variables[variable] = {
+        xml: node.childNodes
+      };
    }
    return true;
  }
@@ -189,30 +198,25 @@ QWeb.addDirective({
    tempCtx.nextID = ctx.rootContext.nextID;
    qweb._compileNode(nodeCopy, tempCtx);
    const vars = Object.assign({}, ctx.variables, tempCtx.variables);
-    var definedVariables = Object.assign(
-      {},
-      ctx.definedVariables,
-      tempCtx.definedVariables
-    );
    ctx.rootContext.nextID = tempCtx.nextID;

    // open new scope, if necessary
-    const hasNewVariables = Object.keys(definedVariables).length > 0;
+    const hasNewVariables = Object.keys(tempCtx.variables).length > 0;
    if (hasNewVariables) {
      ctx.addLine("{");
      ctx.indent();
-    }
-
-    // add new variables, if any
-    for (let key in definedVariables) {
-      ctx.addLine(`let ${key} = ${definedVariables[key]}`);
+      // add new variables, if any
+      for (let key in tempCtx.variables) {
+        const v = tempCtx.variables[key];
+        if ((<QWebExprVar>v).expr) {
+          ctx.addLine(`let ${(<QWebExprVar>v).id} = ${(<QWebExprVar>v).expr};`);
+        }
+        // todo: handle XML variables...
+      }
    }

    // compile sub template
-    const subCtx = ctx
-      .subContext("caller", nodeCopy)
-      .subContext("variables", Object.create(vars))
-      .subContext("definedVariables", Object.create(definedVariables));
+    const subCtx = ctx.subContext("caller", nodeCopy).subContext("variables", Object.create(vars));

    qweb._compileNode(nodeTemplate.elem, subCtx);

@@ -240,34 +244,26 @@ QWeb.addDirective({
    const name = node.getAttribute("t-as")!;
    let arrayID = ctx.generateID();
    ctx.addLine(`var _${arrayID} = ${ctx.formatExpression(elems)};`);
-    ctx.addLine(
-      `if (!_${arrayID}) { throw new Error('QWeb error: Invalid loop expression')}`
-    );
-    ctx.addLine(
-      `if (typeof _${arrayID} === 'number') { _${arrayID} = Array.from(Array(_${arrayID}).keys())}`
-    );
+    ctx.addLine(`if (!_${arrayID}) { throw new Error('QWeb error: Invalid loop expression')}`);
    let keysID = ctx.generateID();
-    ctx.addLine(
-      `var _${keysID} = _${arrayID} instanceof Array ? _${arrayID} : Object.keys(_${arrayID});`
-    );
-    ctx.addLine(`var _length${keysID} = _${keysID}.length;`);
    let valuesID = ctx.generateID();
-    ctx.addLine(
-      `var _${valuesID} = _${arrayID} instanceof Array ? _${arrayID} : Object.values(_${arrayID});`
-    );
+    ctx.addLine(`var _${keysID} = _${valuesID} = _${arrayID};`);
+    ctx.addIf(`!(_${arrayID} instanceof Array)`);
+    ctx.addLine(`_${keysID} = Object.keys(_${arrayID});`);
+    ctx.addLine(`_${valuesID} = Object.values(_${arrayID});`);
+    ctx.closeIf();
+    ctx.addLine(`var _length${keysID} = _${keysID}.length;`);
    ctx.addLine(`for (let i = 0; i < _length${keysID}; i++) {`);
    ctx.indent();
    ctx.addLine(`context.${name}_first = i === 0;`);
    ctx.addLine(`context.${name}_last = i === _length${keysID} - 1;`);
-    ctx.addLine(`context.${name}_parity = i % 2 === 0 ? 'even' : 'odd';`);
    ctx.addLine(`context.${name}_index = i;`);
    ctx.addLine(`context.${name} = _${keysID}[i];`);
    ctx.addLine(`context.${name}_value = _${valuesID}[i];`);
    const nodeCopy = <Element>node.cloneNode(true);
-    let shouldWarn =
-      nodeCopy.tagName !== "t" && !nodeCopy.hasAttribute("t-key");
+    let shouldWarn = nodeCopy.tagName !== "t" && !nodeCopy.hasAttribute("t-key");
    if (!shouldWarn && node.tagName === "t") {
-      if (node.hasAttribute("t-widget") && !node.hasAttribute("t-key")) {
+      if (node.hasAttribute("t-component") && !node.hasAttribute("t-key")) {
        shouldWarn = true;
      }
      if (
@@ -299,7 +295,7 @@ QWeb.addDirective({
 //------------------------------------------------------------------------------
 QWeb.addDirective({
  name: "debug",
-  priority: 99,
+  priority: 1,
  atNodeEncounter({ ctx }) {
    ctx.addLine("debugger;");
  }
@@ -310,7 +306,7 @@ QWeb.addDirective({
 //------------------------------------------------------------------------------
 QWeb.addDirective({
  name: "log",
-  priority: 99,
+  priority: 1,
  atNodeEncounter({ ctx, value }) {
    const expr = ctx.formatExpression(value);
    ctx.addLine(`console.log(${expr})`);
@@ -0,0 +1,264 @@
+/**
+ * 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,typeof,eval,void,Math,RegExp,Array,Object,Date".split(
+  ","
+);
+
+const WORD_REPLACEMENT = {
+  and: "&&",
+  or: "||",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+
+export interface QWebExprVar {
+  id: string;
+  expr: string;
+}
+
+export interface QWebXMLVar {
+  xml: NodeList;
+}
+
+export type QWebVar = QWebExprVar | QWebXMLVar;
+
+//------------------------------------------------------------------------------
+// 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;
+  size?: number;
+}
+
+const STATIC_TOKEN_MAP: { [key: string]: TKind } = {
+  "{": "LEFT_BRACE",
+  "}": "RIGHT_BRACE",
+  "[": "LEFT_BRACKET",
+  "]": "RIGHT_BRACKET",
+  ":": "COLON",
+  ",": "COMMA",
+  "(": "LEFT_PAREN",
+  ")": "RIGHT_PAREN"
+};
+
+const OPERATORS = ".,===,==,+,!==,!=,!,||,&&,>=,>,<=,<,?,-,*,/,%".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,
+  tokenizeSymbol,
+  tokenizeStatic,
+  tokenizeOperator
+];
+
+/**
+ * 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}`)
+ */
+export function compileExpr(expr: string, vars: { [key: string]: QWebVar }): string {
+  const tokens = tokenize(expr);
+  let result = "";
+  for (let i = 0; i < tokens.length; i++) {
+    let token = tokens[i];
+    if (token.type === "SYMBOL" && !RESERVED_WORDS.includes(token.value)) {
+      // we need to find if it is a variable
+      let isVar = true;
+      let prevToken = tokens[i - 1];
+      if (prevToken) {
+        if (prevToken.type === "OPERATOR" && prevToken.value === ".") {
+          isVar = false;
+        } else if (prevToken.type === "LEFT_BRACE" || prevToken.type === "COMMA") {
+          let nextToken = tokens[i + 1];
+          if (nextToken && nextToken.type === "COLON") {
+            isVar = false;
+          }
+        }
+      }
+      if (isVar) {
+        if (token.value in vars && "id" in vars[token.value]) {
+          token.value = (<QWebExprVar>vars[token.value]).id;
+        } else {
+          token.value = `context['${token.value}']`;
+        }
+      }
+    }
+    result += token.value;
+  }
+  return result;
+}
@@ -1,4 +1,5 @@
 import { QWeb, UTILS } from "./qweb_core";
+import { VNode } from "./vdom";

 /**
 * Owl QWeb Extensions
@@ -9,8 +10,10 @@ import { QWeb, UTILS } from "./qweb_core";
 * - t-on
 * - t-ref
 * - t-transition
- * - t-widget/t-props/t-keepalive
+ * - t-component/t-keepalive
 * - t-mounted
+ * - t-slot
+ * - t-model
 */

 //------------------------------------------------------------------------------
@@ -46,9 +49,7 @@ QWeb.addDirective({
      )}'\`)`
    );
    ctx.closeIf();
-    let params = extraArgs
-      ? `owner, ${ctx.formatExpression(extraArgs)}`
-      : "owner";
+    let params = extraArgs ? `owner, ${ctx.formatExpression(extraArgs)}` : "owner";
    let handler;
    if (mods.length > 0) {
      handler = `function (e) {`;
@@ -67,9 +68,7 @@ QWeb.addDirective({
      ctx.addLine(
        `extra.handlers['${eventName}' + ${nodeID}] = extra.handlers['${eventName}' + ${nodeID}] || ${handler};`
      );
-      ctx.addLine(
-        `p${nodeID}.on['${eventName}'] = extra.handlers['${eventName}' + ${nodeID}];`
-      );
+      ctx.addLine(`p${nodeID}.on['${eventName}'] = extra.handlers['${eventName}' + ${nodeID}];`);
    }
  }
 });
@@ -94,7 +93,15 @@ UTILS.nextFrame = function(cb: () => void) {
  requestAnimationFrame(() => requestAnimationFrame(cb));
 };

-UTILS.transitionInsert = function(elm: HTMLElement, name: string) {
+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");
  const finalize = () => {
@@ -108,11 +115,10 @@ UTILS.transitionInsert = function(elm: HTMLElement, name: string) {
  });
 };

-UTILS.transitionRemove = function(
-  elm: HTMLElement,
-  name: string,
-  rm: () => void
-) {
+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 = () => {
@@ -152,9 +158,7 @@ function toMs(s: string): number {
 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 durations: Array<string> = (styles.transitionDuration || "").split(", ");
  const timeout: number = getTimeout(delays, durations);
  if (timeout > 0) {
    elm.addEventListener("transitionend", cb, { once: true });
@@ -169,8 +173,8 @@ QWeb.addDirective({
  atNodeCreation({ value, addNodeHook }) {
    let name = value;
    const hooks = {
-      insert: `this.utils.transitionInsert(vn.elm, '${name}');`,
-      remove: `this.utils.transitionRemove(vn.elm, '${name}', rm);`
+      insert: `this.utils.transitionInsert(vn, '${name}');`,
+      remove: `this.utils.transitionRemove(vn, '${name}', rm);`
    };
    for (let hookName in hooks) {
      addNodeHook(hookName, hooks[hookName]);
@@ -179,47 +183,48 @@ QWeb.addDirective({
 });

 //------------------------------------------------------------------------------
-// t-widget
+// t-component
 //------------------------------------------------------------------------------

+const T_COMPONENT_MODS_CODE = Object.assign({}, MODS_CODE, {
+  self: "if (e.target !== vn.elm) {return}"
+});
+
 /**
- * The t-widget directive is certainly a complicated and hard to maintain piece
+ * 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-widget directive for the following
+ * explanation of the code generated by the t-component directive for the following
 * situation:
 * ```xml
- *   <t t-widget="child"
+ *   <Child
 *      t-key="'somestring'"
- *      t-props="{flag:state.flag}"
+ *      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-widget directive: we start by evaluating the expression given by t-key:
+ * // t-component directive: we start by evaluating the expression given by t-key:
 * let key5 = "somestring";
 *
- * // We keep the index of the position of the widget in the closure.  We push
- * // null to reserve the slot, and will replace it later by the widget vnode,
- * // when it will be ready (do not forget that preparing/rendering a widget is
- * // asynchronous)
- * let _2_index = c1.length;
- * c1.push(null);
- *
- * // def3 is the deferred that will contain later either the new widget
+ * // 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 widget was already
+ * // 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 widget: it maps keys to widget ids,
+ * // `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 =
@@ -227,49 +232,57 @@ QWeb.addDirective({
 *   ? 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 widget, currently rendering, but not ready yet, and which was
- * // rendered with different props, we do not want to wait for it to be ready,
- * // then update it. We simply destroy it, and start anew.
- * if (
- *   w4 &&
- *   w4.__owl__.renderPromise &&
- *   !w4.__owl__.isStarted &&
- *   props4 !== w4.__owl__.renderProps
- * ) {
- *   w4.destroy();
- *   w4 = false;
+ * // 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 widget.  First step is
+ *   // 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.widgets["child"];
+ *   let W4 = context.component && context.components[componentKey4] || QWeb.component[componentKey4];
+
 *   if (!W4) {
- *     throw new Error("Cannot find the definition of widget 'child'");
+ *     throw new Error("Cannot find the definition of component 'child'");
 *   }
 *   w4 = new W4(owner, props4);
 *
- *   let utils = this.utils;
- *
- *   // Whenever we rerender the parent widget, we need to be sure that we
- *   // are able to find the widget instance. To do that, we register it to
+ *   // 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 widget from the template
+ *   // 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
- *   // widget
- *   def3 = w4._prepare();
+ *   // __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 widget). This
+ *     // 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
@@ -277,17 +290,17 @@ QWeb.addDirective({
 *     let pvnode = h(vnode.sel, { key: key5 });
 *
 *     // we add hooks to the parent vnode so we can interact with the new
- *     // widget at the proper time
+ *     // component at the proper time
 *     pvnode.data.hook = {
 *       insert(vn) {
- *         // the _mount method will patch the widget vdom into the elm vn.elm,
+ *         // 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);
+ *         let nvn = w4.__mount(vnode, vn.elm);
 *         pvnode.elm = nvn.elm;
- *         // what follows is only present if there are animations on the widget
- *         utils.transitionInsert(vn.elm, "fade");
+ *         // 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
@@ -296,28 +309,30 @@ QWeb.addDirective({
 *       },
 *       destroy() {
 *         // if there are animations, we delay the call to destroy on the
- *         // widget, if not, we call it directly.
+ *         // component, if not, we call it directly.
 *         let finalize = () => {
 *           w4.destroy();
 *         };
- *         utils.transitionRemove(vn.elm, "fade", finalize);
+ *         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
- *     // widget, so we can reuse it later whenever we update the widget
+ *     // 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 widget update
- *   def3 = w4._updateProps(props4, extra.forceUpdate, extra.patchQueue);
+ *   // 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 widget was destroyed in the meantime, we do nothing (so, this
+ *     // 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 widget's position, which will cause the pvnode to be removed
+ *     // the component's position, which will cause the pvnode to be removed
 *     // when it is patched.
 *     if (w4.__owl__.isDestroyed) {
 *       return;
@@ -337,27 +352,40 @@ QWeb.addDirective({
 */

 QWeb.addDirective({
-  name: "widget",
-  extraNames: ["props", "keepalive"],
+  name: "component",
+  extraNames: ["props", "keepalive", "asyncroot"],
  priority: 100,
-  atNodeEncounter({ ctx, value, node }): boolean {
-    ctx.addLine("//WIDGET");
+  atNodeEncounter({ ctx, value, node, qweb }): boolean {
+    ctx.addLine("//COMPONENT");
    ctx.rootContext.shouldDefineOwner = true;
    ctx.rootContext.shouldDefineQWeb = true;
    ctx.rootContext.shouldDefineUtils = true;
-    let props = node.getAttribute("t-props");
    let keepAlive = node.getAttribute("t-keepalive") ? true : false;
+    let async = node.getAttribute("t-asyncroot") ? true : false;

    // t-on- events and t-transition
-    const events: [string, string][] = [];
+    const events: [string, string[], 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.slice(5), attributes[i].textContent!]);
+        const [eventName, ...mods] = name.slice(5).split(".");
+        let extraArgs;
+        let handlerName = value.replace(/\(.*\)/, function(args) {
+          extraArgs = args.slice(1, -1);
+          return "";
+        });
+        events.push([eventName, mods, handlerName, extraArgs]);
      } else if (name === "t-transition") {
-        transition = attributes[i].textContent!;
+        transition = value;
+      } else if (!name.startsWith("t-")) {
+        if (name !== "class" && name !== "style") {
+          // this is a prop!
+          props[name] = ctx.formatExpression(value);
+        }
      }
    }

@@ -365,26 +393,36 @@ QWeb.addDirective({
    if (key) {
      key = ctx.formatExpression(key);
    }
-    if (props) {
-      props = ctx.formatExpression(props);
-    }
+
+    // computing the props string representing the props object
+    let propStr = Object.keys(props)
+      .map(k => k + ":" + props[k])
+      .join(",");
    let dummyID = ctx.generateID();
    let defID = ctx.generateID();
-    let widgetID = ctx.generateID();
+    let componentID = ctx.generateID();
    let keyID = key && ctx.generateID();
    if (key) {
      // we bind a variable to the key (could be a complex expression, so we
      // want to evaluate it only once)
      ctx.addLine(`let key${keyID} = ${key};`);
    }
-    ctx.addLine(`let _${dummyID}_index = c${ctx.parentNode}.length;`);
-    ctx.addLine(`c${ctx.parentNode}.push(null);`);
    ctx.addLine(`let def${defID};`);
    let templateID = key
      ? `key${keyID}`
      : ctx.inLoop
-      ? `String(-${widgetID} - i)`
-      : String(widgetID);
+      ? `String(-${componentID} - i)`
+      : String(componentID);
+    if (ctx.allowMultipleRoots) {
+      // necessary to prevent collisions
+      if (!key && ctx.inLoop) {
+        let id = ctx.generateID();
+        ctx.addLine(`let template${id} = "_slot_" + String(-${componentID} - i)`);
+        templateID = `template${id}`;
+      } else {
+        templateID = `"_slot_${templateID}"`;
+      }
+    }

    let ref = node.getAttribute("t-ref");
    let refExpr = "";
@@ -392,23 +430,21 @@ QWeb.addDirective({
    if (ref) {
      refKey = `ref${ctx.generateID()}`;
      ctx.addLine(`const ${refKey} = ${ctx.interpolate(ref)};`);
-      refExpr = `context.refs[${refKey}] = w${widgetID};`;
+      refExpr = `context.refs[${refKey}] = w${componentID};`;
    }
    let transitionsInsertCode = "";
    if (transition) {
-      transitionsInsertCode = `utils.transitionInsert(vn.elm, '${transition}');`;
+      transitionsInsertCode = `utils.transitionInsert(vn, '${transition}');`;
    }
-    let finalizeWidgetCode = `w${widgetID}.${
-      keepAlive ? "unmount" : "destroy"
-    }();`;
-    if (ref) {
-      finalizeWidgetCode += `delete context.refs[${refKey}];`; // FIXME: shouldn't we keep ref if keepAlive is true?
+    let finalizeComponentCode = `w${componentID}.${keepAlive ? "unmount" : "destroy"}();`;
+    if (ref && !keepAlive) {
+      finalizeComponentCode += `delete context.refs[${refKey}];`;
    }
    if (transition) {
-      finalizeWidgetCode = `let finalize = () => {
-          ${finalizeWidgetCode}
+      finalizeComponentCode = `let finalize = () => {
+          ${finalizeComponentCode}
        };
-        utils.transitionRemove(vn.elm, '${transition}', finalize);`;
+        utils.transitionRemove(vn, '${transition}', finalize);`;
    }

    let createHook = "";
@@ -421,94 +457,168 @@ QWeb.addDirective({
      ctx.addLine(`const ${attVar} = ${ctx.formatExpression(tattStyle)};`);
      tattStyle = attVar;
    }
-    let updateClassCode = "";
-    if (classAttr || tattClass || styleAttr || tattStyle) {
-      let classCode = "";
+    let classObj = "";
+    if (classAttr || tattClass || styleAttr || tattStyle || events.length) {
      if (classAttr) {
-        classCode =
-          classAttr
-            .split(" ")
-            .map(c => `vn.elm.classList.add('${c}')`)
-            .join(";") + ";";
+        let classDef = classAttr
+          .trim()
+          .split(/\s+/)
+          .map(a => `'${a}':true`)
+          .join(",");
+        classObj = `_${ctx.generateID()}`;
+        ctx.addLine(`let ${classObj} = {${classDef}};`);
      }
      if (tattClass) {
-        const attVar = `_${ctx.generateID()}`;
-        ctx.addLine(`const ${attVar} = ${ctx.formatExpression(tattClass)};`);
-        classCode = `for (let k in ${attVar}) {
-              if (${attVar}[k]) {
-                  vn.elm.classList.add(k);
-              }
-          }`;
-        updateClassCode = `let cl=w${widgetID}.el.classList;for (let k in ${attVar}) {if (${attVar}[k]) {cl.add(k)} else {cl.remove(k)}}`;
+        let tattExpr = ctx.formatExpression(tattClass);
+        if (tattExpr[0] !== "{" || tattExpr[tattExpr.length - 1] !== "}") {
+          tattExpr = `this.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([eventName, mods, handlerName, extraArgs]) {
+          let params = "owner";
+          if (extraArgs) {
+            if (ctx.inLoop) {
+              let argId = ctx.generateID();
+              // we need to evaluate the arguments now, because the handler will
+              // be set asynchronously later when the widget is ready, and the
+              // context might be different.
+              ctx.addLine(`let arg${argId} = ${ctx.formatExpression(extraArgs)};`);
+              params = `owner, arg${argId}`;
+            } else {
+              params = `owner, ${ctx.formatExpression(extraArgs)}`;
+            }
+          }
+          let handler;
+          if (mods.length > 0) {
+            handler = `function (e) {`;
+            handler += mods
+              .map(function(mod) {
+                return T_COMPONENT_MODS_CODE[mod];
+              })
+              .join("");
+            handler += `owner['${handlerName}'].call(${params}, e);}`;
+          } else {
+            handler = `owner['${handlerName}'].bind(${params})`;
+          }
+          return `vn.elm.addEventListener('${eventName}', ${handler});`;
+        })
+        .join("");
      const styleExpr = tattStyle || (styleAttr ? `'${styleAttr}'` : false);
-      const styleCode = styleExpr ? `vn.elm.style = ${styleExpr}` : "";
-      createHook = `vnode.data.hook = {create(_, vn){${classCode}${styleCode}}};`;
+      const styleCode = styleExpr ? `vn.elm.style = ${styleExpr};` : "";
+      createHook = `vnode.data.hook = {create(_, vn){${styleCode}${eventsCode}}};`;
    }

    ctx.addLine(
-      `let w${widgetID} = ${templateID} in context.__owl__.cmap ? context.__owl__.children[context.__owl__.cmap[${templateID}]] : false;`
+      `let w${componentID} = ${templateID} in context.__owl__.cmap ? context.__owl__.children[context.__owl__.cmap[${templateID}]] : false;`
    );
-    ctx.addLine(`let props${widgetID} = ${props || "{}"};`);
+    ctx.addLine(`let _${dummyID}_index = c${ctx.parentNode}.length;`);
+    if (async) {
+      ctx.addLine(`const patchQueue${componentID} = [];`);
+      ctx.addLine(
+        `c${ctx.parentNode}.push(w${componentID} && w${componentID}.__owl__.pvnode || null);`
+      );
+    } else {
+      ctx.addLine(`c${ctx.parentNode}.push(null);`);
+    }
+    ctx.addLine(`let props${componentID} = {${propStr}};`);
    ctx.addIf(
-      `w${widgetID} && w${widgetID}.__owl__.renderPromise && !w${widgetID}.__owl__.vnode && props${widgetID} !== w${widgetID}.__owl__.renderProps`
+      `w${componentID} && w${componentID}.__owl__.renderPromise && !w${componentID}.__owl__.vnode`
    );
-    ctx.addLine(`w${widgetID}.destroy();`);
-    ctx.addLine(`w${widgetID} = false`);
+    ctx.addIf(`utils.shallowEqual(props${componentID}, w${componentID}.__owl__.renderProps)`);
+    ctx.addLine(`def${defID} = w${componentID}.__owl__.renderPromise;`);
+    ctx.addElse();
+    ctx.addLine(`w${componentID}.destroy();`);
+    ctx.addLine(`w${componentID} = false;`);
+    ctx.closeIf();
    ctx.closeIf();

-    ctx.addIf(`!w${widgetID}`);
-    // new widget
-    ctx.addLine(`let widgetKey${widgetID} = ${ctx.interpolate(value)};`);
+    ctx.addIf(`!w${componentID}`);
+    // new component
+    ctx.addLine(`let componentKey${componentID} = ${ctx.interpolate(value)};`);
    ctx.addLine(
-      `let W${widgetID} = context.widgets && context.widgets[widgetKey${widgetID}] || QWeb.widgets[widgetKey${widgetID}];`
+      `let W${componentID} = context.components && context.components[componentKey${componentID}] || QWeb.components[componentKey${componentID}];`
    );

    // maybe only do this in dev mode...
    ctx.addLine(
-      `if (!W${widgetID}) {throw new Error('Cannot find the definition of widget "' + widgetKey${widgetID} + '"')}`
+      `if (!W${componentID}) {throw new Error('Cannot find the definition of component "' + componentKey${componentID} + '"')}`
    );
-    ctx.addLine(`w${widgetID} = new W${widgetID}(owner, props${widgetID});`);
-    ctx.addLine(
-      `context.__owl__.cmap[${templateID}] = w${widgetID}.__owl__.id;`
-    );
-    for (let [event, method] of events) {
-      ctx.addLine(`w${widgetID}.on('${event}', owner, owner['${method}'])`);
+    ctx.addLine(`w${componentID} = new W${componentID}(owner, props${componentID});`);
+    ctx.addLine(`context.__owl__.cmap[${templateID}] = w${componentID}.__owl__.id;`);
+
+    // SLOTS
+    if (node.childNodes.length) {
+      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.parentNode!);
+          qweb.slots[`${slotId}_${key}`] = slotFn.bind(qweb);
+        }
+      }
+      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.parentNode!);
+        qweb.slots[`${slotId}_default`] = slotFn.bind(qweb);
+      }
    }
-    ctx.addLine(`def${defID} = w${widgetID}._prepare();`);
+
+    ctx.addLine(`def${defID} = w${componentID}.__prepare();`);
    // hack: specify empty remove hook to prevent the node from being removed from the DOM
-    // FIXME: click to re-add widget during remove transition -> leak
    ctx.addLine(
-      `def${defID} = def${defID}.then(vnode=>{${createHook}let pvnode=h(vnode.sel, {key: ${templateID}, hook: {insert(vn) {let nvn=w${widgetID}._mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;${refExpr}${transitionsInsertCode}},remove() {},destroy(vn) {${finalizeWidgetCode}}}});c${
+      `def${defID} = def${defID}.then(vnode=>{${createHook}let pvnode=h(vnode.sel, {key: ${templateID}, hook: {insert(vn) {let nvn=w${componentID}.__mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;${refExpr}${transitionsInsertCode}},remove() {},destroy(vn) {${finalizeComponentCode}}}});c${
        ctx.parentNode
-      }[_${dummyID}_index]=pvnode;w${widgetID}.__owl__.pvnode = pvnode;});`
+      }[_${dummyID}_index]=pvnode;w${componentID}.__owl__.pvnode = pvnode;});`
    );

    ctx.addElse();
-    // need to update widget
+    // need to update component
+    const patchQueueCode = async ? `patchQueue${componentID}` : "extra.patchQueue";
    ctx.addLine(
-      `def${defID} = w${widgetID}._updateProps(props${widgetID}, extra.forceUpdate, extra.patchQueue);`
+      `def${defID} = def${defID} || w${componentID}.__updateProps(props${componentID}, extra.forceUpdate, ${patchQueueCode});`
    );
    let keepAliveCode = "";
    if (keepAlive) {
-      keepAliveCode = `pvnode.data.hook.insert = vn => {vn.elm.parentNode.replaceChild(w${widgetID}.el,vn.elm);vn.elm=w${widgetID}.el;w${widgetID}._remount();};`;
+      keepAliveCode = `pvnode.data.hook.insert = vn => {vn.elm.parentNode.replaceChild(w${componentID}.el,vn.elm);vn.elm=w${componentID}.el;w${componentID}.__remount();};`;
    }
    ctx.addLine(
-      `def${defID} = def${defID}.then(()=>{if (w${widgetID}.__owl__.isDestroyed) {return};${
-        tattStyle ? `w${widgetID}.el.style=${tattStyle};` : ""
-      }${updateClassCode}let pvnode=w${widgetID}.__owl__.pvnode;${keepAliveCode}c${
+      `def${defID} = def${defID}.then(()=>{if (w${componentID}.__owl__.isDestroyed) {return};${
+        tattStyle ? `w${componentID}.el.style=${tattStyle};` : ""
+      }let pvnode=w${componentID}.__owl__.pvnode;${keepAliveCode}c${
        ctx.parentNode
      }[_${dummyID}_index]=pvnode;});`
    );
    ctx.closeIf();

-    ctx.addLine(`extra.promises.push(def${defID});`);
+    if (classObj) {
+      ctx.addLine(`w${componentID}.__owl__.classObj=${classObj};`);
+    }

-    if (
-      node.hasAttribute("t-if") ||
-      node.hasAttribute("t-else") ||
-      node.hasAttribute("t-elif")
-    ) {
+    if (async) {
+      ctx.addLine(
+        `def${defID}.then(w${componentID}.__applyPatchQueue.bind(w${componentID}, patchQueue${componentID}));`
+      );
+    } else {
+      ctx.addLine(`extra.promises.push(def${defID});`);
+    }
+
+    if (node.hasAttribute("t-if") || node.hasAttribute("t-else") || node.hasAttribute("t-elif")) {
      ctx.closeIf();
    }

@@ -548,9 +658,70 @@ QWeb.addDirective({
        `extra.mountedHandlers[${nodeID}] = extra.mountedHandlers[${nodeID}] || (context['${handler}'] || ${error}).bind(owner);`
      );
    }
-    addNodeHook(
-      "insert",
-      `if (context.__owl__.isMounted) { extra.mountedHandlers[${nodeID}](); }`
-    );
+    addNodeHook("insert", `if (context.__owl__.isMounted) { extra.mountedHandlers[${nodeID}](); }`);
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-slot
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "slot",
+  priority: 80,
+  atNodeEncounter({ ctx, value }): boolean {
+    const slotKey = ctx.generateID();
+    ctx.addLine(`const slot${slotKey} = this.slots[context.__owl__.slotId + '_' + '${value}'];`);
+    ctx.addIf(`slot${slotKey}`);
+    ctx.addLine(
+      `slot${slotKey}(context.__owl__.parent, Object.assign({}, extra, {parentNode: c${
+        ctx.parentNode
+      }}));`
+    );
+    ctx.closeIf();
+    return true;
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-model
+//------------------------------------------------------------------------------
+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 }) {
+    const type = node.getAttribute("type");
+    let handler;
+    let event = fullName.includes(".lazy") ? "change" : "input";
+    if (node.tagName === "select") {
+      ctx.addLine(`p${nodeID}.props = {value: context.state['${value}']};`);
+      event = "change";
+      handler = `(ev) => {context.state['${value}'] = ev.target.value}`;
+    } else if (type === "checkbox") {
+      ctx.addLine(`p${nodeID}.props = {checked: context.state['${value}']};`);
+      handler = `(ev) => {context.state['${value}'] = ev.target.checked}`;
+    } else if (type === "radio") {
+      const nodeValue = node.getAttribute("value")!;
+      ctx.addLine(`p${nodeID}.props = {checked:context.state['${value}'] === '${nodeValue}'};`);
+      handler = `(ev) => {context.state['${value}'] = ev.target.value}`;
+      event = "click";
+    } else {
+      ctx.addLine(`p${nodeID}.props = {value: context.state['${value}']};`);
+      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) => {context.state['${value}'] = ${valueCode}}`;
+    }
+    ctx.addLine(
+      `extra.handlers['${event}' + ${nodeID}] = extra.handlers['${event}' + ${nodeID}] || (${handler});`
+    );
+    ctx.addLine(`p${nodeID}.on['${event}'] = extra.handlers['${event}' + ${nodeID}];`);
  }
 });
@@ -21,8 +21,8 @@ import { Observer } from "./observer";
 // Store Definition
 //------------------------------------------------------------------------------

-type Mutation = ({ state, commit, set, getters }, payload: any) => void;
-type Action = ({ commit, state, dispatch, env, getters }, payload: any) => void;
+type Mutation = ({ state, commit, getters }, ...payload: any) => void;
+type Action = ({ commit, state, dispatch, env, getters }, ...payload: any) => void;
 type Getter = ({ state, getters }, payload) => any;

 interface StoreConfig {
@@ -46,8 +46,9 @@ export class Store extends EventBus {
  debug: boolean;
  env: any;
  observer: Observer;
-  set: any;
  getters: { [name: string]: (payload?) => any };
+  _gettersCache: { [name: string]: {} };
+  _updateId: number = 1;

  constructor(config: StoreConfig, options: StoreOption = {}) {
    super();
@@ -57,26 +58,34 @@ export class Store extends EventBus {
    this.mutations = config.mutations;
    this.env = config.env;
    this.observer = new Observer();
-    this.observer.notifyCB = this.trigger.bind(this, "update");
+    this.observer.notifyCB = this.__notifyComponents.bind(this);
    this.observer.allowMutations = false;
    this.observer.observe(this.state);
    this.getters = {};
+    this._gettersCache = {};

    if (this.debug) {
      this.history.push({ state: this.state });
    }
-    this.set = this.observer.set.bind(this.observer);

+    const cTypes = ["undefined", "number", "string"];
    for (let entry of Object.entries(config.getters || {})) {
      const name: string = entry[0];
      const func: (...any) => any = entry[1];
      this.getters[name] = payload => {
+        if (this._commitLevel === 0 && cTypes.indexOf(typeof payload) >= 0) {
+          this._gettersCache[name] = this._gettersCache[name] || {};
+          this._gettersCache[name][payload] =
+            this._gettersCache[name][payload] ||
+            func({ state: this.state, getters: this.getters }, payload);
+          return this._gettersCache[name][payload];
+        }
        return func({ state: this.state, getters: this.getters }, payload);
      };
    }
  }

-  dispatch(action: string, 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`);
    }
@@ -88,7 +97,7 @@ export class Store extends EventBus {
        state: this.state,
        getters: this.getters
      },
-      payload
+      ...payload
    );
    if (result instanceof Promise) {
      return new Promise((resolve, reject) => {
@@ -98,7 +107,7 @@ export class Store extends EventBus {
    }
  }

-  commit(type: string, payload?: any): any {
+  commit(type: string, ...payload: any): any {
    if (!this.mutations[type]) {
      throw new Error(`[Error] mutation ${type} is undefined`);
    }
@@ -110,10 +119,9 @@ export class Store extends EventBus {
      {
        commit: this.commit.bind(this),
        state: this.state,
-        set: this.set,
        getters: this.getters
      },
-      payload
+      ...payload
    );

    if (this._commitLevel === 1) {
@@ -122,13 +130,41 @@ export class Store extends EventBus {
        this.history.push({
          state: this.state,
          mutation: type,
-          payload: payload
+          payload: [...payload]
        });
      }
    }
    this._commitLevel--;
    return res;
  }
+
+  /**
+   * 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.  The reason is that if an update
+   * as an effect of destroying a children, we do not want to call the
+   * mapStoreToProps function of the child, nor rendering it.
+   *
+   * This method is not optimal if we have a bunch of asynchronous components:
+   * we wait sequentially for each component to be completed before updating the
+   * next.  However, the only things that matters is that children are updated
+   * after their parents.  So, this could be optimized by being smarter, and
+   * updating all widgets concurrently, except for parents/children.
+   */
+  async __notifyComponents() {
+    this._updateId++;
+    const current = this._updateId;
+    this._gettersCache = {};
+    const subs = this.subscriptions.update || [];
+    for (let i = 0, iLen = subs.length; i < iLen; i++) {
+      const sub = subs[i];
+      const shouldCallback = sub.owner ? sub.owner.__owl__.isMounted : true;
+      if (shouldCallback) {
+        await sub.callback.call(sub.owner, current);
+      }
+    }
+  }
 }

 //------------------------------------------------------------------------------
@@ -153,11 +189,20 @@ type Constructor<T> = new (...args: any[]) => T;
 interface EnvWithStore extends Env {
  store: Store;
 }
+type HashFunction = (a: any, b: any) => number;
+interface StoreOptions {
+  getStore?(Env): Store;
+  hashFunction?: HashFunction;
+  deep?: boolean;
+}

-let nextID = 1;
-
-export function connect(mapStateToProps, options: any = {}) {
+export function connect<E extends EnvWithStore, P, S>(
+  Comp: Constructor<Component<E, P, S>>,
+  mapStoreToProps,
+  options: StoreOptions = <StoreOptions>{}
+) {
  let hashFunction = options.hashFunction || null;
+  const getStore = options.getStore || (env => env.store);

  if (!hashFunction) {
    let deep = "deep" in options ? options.deep : true;
@@ -183,101 +228,96 @@ export function connect(mapStateToProps, options: any = {}) {
    };
  }

-  return function<E extends EnvWithStore, P, S>(
-    Comp: Constructor<Component<E, P, S>>
-  ) {
-    const Result = 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,
-          env.store.getters
-        );
-        const mergedProps = Object.assign({}, props || {}, storeProps);
-        super(parent, mergedProps);
-        (<any>this.__owl__).ownProps = ownProps;
+  const Result = class extends Comp {
+    constructor(parent, props?: any) {
+      const env = parent instanceof Component ? parent.env : parent;
+      const store = getStore(env);
+      const ownProps = Object.assign({}, props || {});
+      const storeProps = mapStoreToProps(store.state, ownProps, store.getters);
+      const mergedProps = Object.assign({}, props || {}, storeProps);
+      super(parent, mergedProps);
+      (<any>this.__owl__).ownProps = ownProps;
+      (<any>this.__owl__).currentStoreProps = storeProps;
+      (<any>this.__owl__).store = store;
+      (<any>this.__owl__).storeHash = (<HashFunction>hashFunction)(
+        {
+          state: store.state,
+          storeProps: storeProps,
+          revNumber,
+          deepRevNumber
+        },
+        {
+          currentStoreProps: storeProps
+        }
+      );
+    }
+    /**
+     * We do not use the mounted hook here for a subtle reason: we want the
+     * updates to be called for the parents before the children.  However,
+     * if we use the mounted hook, this will be done in the reverse order.
+     */
+    __callMounted() {
+      (<any>this.__owl__).store.on("update", this, this.__checkUpdate);
+      super.__callMounted();
+    }
+    willUnmount() {
+      (<any>this.__owl__).store.off("update", this);
+      super.willUnmount();
+    }
+
+    async __checkUpdate(updateId) {
+      if (updateId === (<any>this.__owl__).currentUpdateId) {
+        return;
+      }
+      const ownProps = (<any>this.__owl__).ownProps;
+      const storeProps = mapStoreToProps(
+        (<any>this.__owl__).store.state,
+        ownProps,
+        (<any>this.__owl__).store.getters
+      );
+      const options: any = {
+        currentStoreProps: (<any>this.__owl__).currentStoreProps
+      };
+      const storeHash = (<HashFunction>hashFunction)(
+        {
+          state: (<any>this.__owl__).store.state,
+          storeProps: storeProps,
+          revNumber,
+          deepRevNumber
+        },
+        options
+      );
+      let didChange = options.didChange;
+      if (storeHash !== (<any>this.__owl__).storeHash) {
+        didChange = true;
+        (<any>this.__owl__).storeHash = storeHash;
+      }
+      if (didChange) {
        (<any>this.__owl__).currentStoreProps = storeProps;
-        (<any>this.__owl__).storeHash = hashFunction(
-          {
-            state: env.store.state,
-            storeProps: storeProps,
-            revNumber,
-            deepRevNumber
-          },
-          {
-            currentStoreProps: storeProps
-          }
-        );
+        await this.__updateProps(ownProps, false);
      }
-      /**
-       * We do not use the mounted hook here for a subtle reason: we want the
-       * updates to be called for the parents before the children.  However,
-       * if we use the mounted hook, this will be done in the reverse order.
-       */
-      _callMounted() {
-        this.env.store.on("update", this, this._checkUpdate);
-        super._callMounted();
-      }
-      willUnmount() {
-        this.env.store.off("update", this);
-        super.willUnmount();
-      }
-
-      _checkUpdate() {
-        const ownProps = (<any>this.__owl__).ownProps;
-        const storeProps = mapStateToProps(
-          this.env.store.state,
-          ownProps,
-          this.env.store.getters
-        );
-        const options: any = {
-          currentStoreProps: (<any>this.__owl__).currentStoreProps
-        };
-        const storeHash = hashFunction(
-          {
-            state: this.env.store.state,
-            storeProps: storeProps,
-            revNumber,
-            deepRevNumber
-          },
-          options
-        );
-        let didChange = options.didChange;
-        if (storeHash !== (<any>this.__owl__).storeHash) {
-          didChange = true;
-          (<any>this.__owl__).storeHash = storeHash;
-        }
-        if (didChange) {
-          (<any>this.__owl__).currentStoreProps = storeProps;
-          this._updateProps(ownProps, false);
-        }
-      }
-      _updateProps(nextProps, forceUpdate, patchQueue?: any[]) {
-        if ((<any>this.__owl__).ownProps !== nextProps) {
-          (<any>this.__owl__).currentStoreProps = mapStateToProps(
-            this.env.store.state,
-            nextProps,
-            this.env.store.getters
-          );
-        }
-        (<any>this.__owl__).ownProps = nextProps;
-        const mergedProps = Object.assign(
-          {},
+    }
+    __updateProps(nextProps, forceUpdate, patchQueue?: any[]) {
+      const __owl__ = <any>this.__owl__;
+      __owl__.currentUpdateId = __owl__.store._updateId;
+      if (__owl__.ownProps !== nextProps) {
+        __owl__.currentStoreProps = mapStoreToProps(
+          __owl__.store.state,
          nextProps,
-          (<any>this.__owl__).currentStoreProps
+          __owl__.store.getters
        );
-        return super._updateProps(mergedProps, forceUpdate, patchQueue);
      }
-    };
-
-    // we assign here a unique name to the resulting anonymous class.
-    // this is necessary for Owl to be able to properly deduce templates.
-    // Otherwise, all connected components would have the same name, and then
-    // each component after the first will necessarily have the same template.
-    let name = `ConnectedComponent${nextID++}`;
-    Object.defineProperty(Result, "name", { value: name });
-    return Result;
+      __owl__.ownProps = nextProps;
+      const mergedProps = Object.assign({}, nextProps, __owl__.currentStoreProps);
+      return super.__updateProps(mergedProps, forceUpdate, patchQueue);
+    }
  };
+
+  // we assign here a unique name to the resulting anonymous class.
+  // this is necessary for Owl to be able to properly deduce templates.
+  // Otherwise, all connected components would have the same name, and then
+  // each component after the first will necessarily have the same template.
+  let name = `Connected${Comp.name}`;
+  Object.defineProperty(Result, "name", { value: name });
+  return Result;
 }
@@ -11,11 +11,13 @@
 */

 export function whenReady(fn) {
-  if (document.readyState === "complete") {
-    fn();
-  } else {
-    document.addEventListener("DOMContentLoaded", fn, false);
-  }
+  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> } = {};
@@ -74,11 +76,7 @@ export function escape(str: string | number | undefined): string {
 *
 * 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;
@@ -59,14 +59,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 };
 }

 //------------------------------------------------------------------------------
@@ -116,14 +109,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,
@@ -145,13 +131,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) {
@@ -186,19 +166,14 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
      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 tag = hashIdx !== -1 || dotIdx !== -1 ? sel.slice(0, Math.min(hash, dot)) : sel;
      const 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, iLen = cbs.create.length; i < iLen; ++i)
-        cbs.create[i](emptyNode, vnode);
+      if (dotIdx > 0) elm.setAttribute("class", sel.slice(dot + 1).replace(/\./g, " "));
+      for (i = 0, iLen = cbs.create.length; i < iLen; ++i) cbs.create[i](emptyNode, vnode);
      if (array(children)) {
        for (i = 0, iLen = children.length; i < iLen; ++i) {
          const ch = children[i];
@@ -244,8 +219,7 @@ export function init(modules: Array<Partial<Module>>, domApi?: DOMAPI) {
      data = vnode.data;
    if (data !== undefined) {
      if (isDef((i = data.hook)) && isDef((i = i.destroy))) i(vnode);
-      for (i = 0, iLen = cbs.destroy.length; i < iLen; ++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, jLen = vnode.children.length; j < jLen; ++j) {
          i = vnode.children[j];
@@ -274,13 +248,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, 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))
-          ) {
+          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();
@@ -342,11 +311,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 {
@@ -373,11 +338,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];
        }
@@ -386,31 +347,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
-  ) {
+  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))
-    ) {
+    if (isDef((i = vnode.data)) && isDef((hook = i.hook)) && isDef((i = hook.prepatch))) {
      i(oldVnode, vnode);
    }
    const elm = (vnode.elm = oldVnode.elm as Node);
@@ -418,20 +364,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, iLen = cbs.update.length; i < iLen; ++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(
@@ -443,23 +383,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);
    }
@@ -517,11 +447,7 @@ 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;
@@ -550,11 +476,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);
 }

@@ -651,21 +573,13 @@ 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 {
+function addNS(data: any, children: VNodes | undefined, sel: string | undefined): void {
  data.ns = "http://www.w3.org/2000/svg";
  if (sel !== "foreignObject" && children !== undefined) {
    for (let i = 0, iLen = children.length; i < iLen; ++i) {
      let childData = children[i].data;
      if (childData !== undefined) {
-        addNS(
-          childData,
-          (children[i] as VNode).children as VNodes,
-          children[i].sel
-        );
+        addNS(childData, (children[i] as VNode).children as VNodes, children[i].sel);
      }
    }
  }
@@ -704,13 +618,7 @@ export function h(sel: any, b?: any, c?: any): VNode {
  if (children !== undefined) {
    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 (
@@ -776,9 +684,7 @@ interface Module {
 //------------------------------------------------------------------------------
 // module/eventlisteners.ts
 //------------------------------------------------------------------------------
-type On = {
-  [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void
-} & {
+type On = { [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void } & {
  [event: string]: EventListener;
 };

@@ -857,8 +763,7 @@ function updateEventListeners(oldVnode: VNode, vnode?: VNode): void {
  // 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());
+    var listener = ((vnode as any).listener = (oldVnode as any).listener || createListener());
    // update vnode for listener
    listener.vnode = vnode;

@@ -945,4 +850,39 @@ export const attrsModule = {
  update: updateAttrs
 } as Module;

-export const patch = init([eventListenersModule, attrsModule, propsModule]);
+//------------------------------------------------------------------------------
+// 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 (!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);
+    }
+  }
+}
+
+const classModule = { create: updateClass, update: updateClass } as Module;
+
+//------------------------------------------------------------------------------
+// patch
+//------------------------------------------------------------------------------
+export const patch = init([eventListenersModule, attrsModule, propsModule, classModule]);
@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP

-exports[`animations t-transition combined with t-widget 1`] = `
+exports[`animations t-transition combined with component 1`] = `
 "function anonymous(context,extra
 ) {
    let utils = this.utils;
@@ -9,29 +9,33 @@ exports[`animations t-transition combined with t-widget 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    //WIDGET
-    let _2_index = c1.length;
-    c1.push(null);
+    //COMPONENT
    let def3;
    let w4 = 4 in context.__owl__.cmap ? context.__owl__.children[context.__owl__.cmap[4]] : false;
+    let _2_index = c1.length;
+    c1.push(null);
    let props4 = {};
-    if (w4 && w4.__owl__.renderPromise && !w4.__owl__.vnode && props4 !== w4.__owl__.renderProps) {
-        w4.destroy();
-        w4 = false
+    if (w4 && w4.__owl__.renderPromise && !w4.__owl__.vnode) {
+        if (utils.shallowEqual(props4, w4.__owl__.renderProps)) {
+            def3 = w4.__owl__.renderPromise;
+        } else {
+            w4.destroy();
+            w4 = false;
+        }
    }
    if (!w4) {
-        let widgetKey4 = \`Child\`;
-        let W4 = context.widgets && context.widgets[widgetKey4] || QWeb.widgets[widgetKey4];
-        if (!W4) {throw new Error('Cannot find the definition of widget \\"' + widgetKey4 + '\\"')}
+        let componentKey4 = \`Child\`;
+        let W4 = context.components && context.components[componentKey4] || QWeb.components[componentKey4];
+        if (!W4) {throw new Error('Cannot find the definition of component \\"' + componentKey4 + '\\"')}
        w4 = new W4(owner, props4);
        context.__owl__.cmap[4] = w4.__owl__.id;
-        def3 = w4._prepare();
-        def3 = def3.then(vnode=>{let pvnode=h(vnode.sel, {key: 4, hook: {insert(vn) {let nvn=w4._mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;utils.transitionInsert(vn.elm, 'chimay');},remove() {},destroy(vn) {let finalize = () => {
+        def3 = w4.__prepare();
+        def3 = def3.then(vnode=>{let pvnode=h(vnode.sel, {key: 4, hook: {insert(vn) {let nvn=w4.__mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;utils.transitionInsert(vn, 'chimay');},remove() {},destroy(vn) {let finalize = () => {
          w4.destroy();
        };
-        utils.transitionRemove(vn.elm, 'chimay', finalize);}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
+        utils.transitionRemove(vn, 'chimay', finalize);}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
    } else {
-        def3 = w4._updateProps(props4, extra.forceUpdate, extra.patchQueue);
+        def3 = def3 || w4.__updateProps(props4, extra.forceUpdate, extra.patchQueue);
        def3 = def3.then(()=>{if (w4.__owl__.isDestroyed) {return};let pvnode=w4.__owl__.pvnode;c1[_2_index]=pvnode;});
    }
    extra.promises.push(def3);
@@ -39,7 +43,7 @@ exports[`animations t-transition combined with t-widget 1`] = `
 }"
 `;

-exports[`animations t-transition combined with t-widget and t-if 1`] = `
+exports[`animations t-transition combined with t-component and t-if 1`] = `
 "function anonymous(context,extra
 ) {
    let utils = this.utils;
@@ -49,29 +53,33 @@ exports[`animations t-transition combined with t-widget and t-if 1`] = `
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
    if (context['state'].display) {
-        //WIDGET
-        let _2_index = c1.length;
-        c1.push(null);
+        //COMPONENT
        let def3;
        let w4 = 4 in context.__owl__.cmap ? context.__owl__.children[context.__owl__.cmap[4]] : false;
+        let _2_index = c1.length;
+        c1.push(null);
        let props4 = {};
-        if (w4 && w4.__owl__.renderPromise && !w4.__owl__.vnode && props4 !== w4.__owl__.renderProps) {
-            w4.destroy();
-            w4 = false
+        if (w4 && w4.__owl__.renderPromise && !w4.__owl__.vnode) {
+            if (utils.shallowEqual(props4, w4.__owl__.renderProps)) {
+                def3 = w4.__owl__.renderPromise;
+            } else {
+                w4.destroy();
+                w4 = false;
+            }
        }
        if (!w4) {
-            let widgetKey4 = \`Child\`;
-            let W4 = context.widgets && context.widgets[widgetKey4] || QWeb.widgets[widgetKey4];
-            if (!W4) {throw new Error('Cannot find the definition of widget \\"' + widgetKey4 + '\\"')}
+            let componentKey4 = \`Child\`;
+            let W4 = context.components && context.components[componentKey4] || QWeb.components[componentKey4];
+            if (!W4) {throw new Error('Cannot find the definition of component \\"' + componentKey4 + '\\"')}
            w4 = new W4(owner, props4);
            context.__owl__.cmap[4] = w4.__owl__.id;
-            def3 = w4._prepare();
-            def3 = def3.then(vnode=>{let pvnode=h(vnode.sel, {key: 4, hook: {insert(vn) {let nvn=w4._mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;utils.transitionInsert(vn.elm, 'chimay');},remove() {},destroy(vn) {let finalize = () => {
+            def3 = w4.__prepare();
+            def3 = def3.then(vnode=>{let pvnode=h(vnode.sel, {key: 4, hook: {insert(vn) {let nvn=w4.__mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;utils.transitionInsert(vn, 'chimay');},remove() {},destroy(vn) {let finalize = () => {
          w4.destroy();
        };
-        utils.transitionRemove(vn.elm, 'chimay', finalize);}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
+        utils.transitionRemove(vn, 'chimay', finalize);}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
        } else {
-            def3 = w4._updateProps(props4, extra.forceUpdate, extra.patchQueue);
+            def3 = def3 || w4.__updateProps(props4, extra.forceUpdate, extra.patchQueue);
            def3 = def3.then(()=>{if (w4.__owl__.isDestroyed) {return};let pvnode=w4.__owl__.pvnode;c1[_2_index]=pvnode;});
        }
        extra.promises.push(def3);
@@ -88,10 +96,10 @@ exports[`animations t-transition with no delay/duration 1`] = `
    var vn1 = h('span', p1, c1);
    p1.hook = {
      insert: vn => {
-        this.utils.transitionInsert(vn.elm, 'jupiler');
+        this.utils.transitionInsert(vn, 'jupiler');
      },
      remove: (vn, rm) => {
-        this.utils.transitionRemove(vn.elm, 'jupiler', rm);
+        this.utils.transitionRemove(vn, 'jupiler', rm);
      },
    };
    c1.push({text: \`blue\`});
@@ -107,10 +115,10 @@ exports[`animations t-transition, on a simple node (insert) 1`] = `
    var vn1 = h('span', p1, c1);
    p1.hook = {
      insert: vn => {
-        this.utils.transitionInsert(vn.elm, 'chimay');
+        this.utils.transitionInsert(vn, 'chimay');
      },
      remove: (vn, rm) => {
-        this.utils.transitionRemove(vn.elm, 'chimay', rm);
+        this.utils.transitionRemove(vn, 'chimay', rm);
      },
    };
    c1.push({text: \`blue\`});
@@ -1,5 +1,16 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP

+exports[`attributes class and t-attf-class with ternary operation 1`] = `
+"function anonymous(context,extra
+) {
+    var h = this.utils.h;
+    var _1 = 'hello ' + (context['value']?'world':'');
+    let c2 = [], p2 = {key:2,attrs:{class: _1}};
+    var vn2 = h('div', p2, c2);
+    return vn2;
+}"
+`;
+
 exports[`attributes dynamic attribute falsy variable  1`] = `
 "function anonymous(context,extra
 ) {
@@ -59,7 +70,7 @@ exports[`attributes format expression 1`] = `
 "function anonymous(context,extra
 ) {
    var h = this.utils.h;
-    var _1 = context['value'] + 37;
+    var _1 = (context['value']+37);
    let c2 = [], p2 = {key:2,attrs:{foo: _1}};
    var vn2 = h('div', p2, c2);
    return vn2;
@@ -70,7 +81,7 @@ exports[`attributes format expression, other format 1`] = `
 "function anonymous(context,extra
 ) {
    var h = this.utils.h;
-    var _1 = context['value'] + 37;
+    var _1 = (context['value']+37);
    let c2 = [], p2 = {key:2,attrs:{foo: _1}};
    var vn2 = h('div', p2, c2);
    return vn2;
@@ -116,9 +127,9 @@ exports[`attributes from object variables set previously 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    var _2 = {a: 'b'};
-    var _3 = _2.a;
-    let c4 = [], p4 = {key:4,attrs:{class: _3}};
+    var _2 = {a:'b'};
+    let _3 = this.utils.toObj(_2.a);
+    let c4 = [], p4 = {key:4,class:_3};
    var vn4 = h('span', p4, c4);
    c1.push(vn4);
    return vn1;
@@ -132,8 +143,8 @@ exports[`attributes from variables set previously 1`] = `
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
    var _2 = 'def';
-    var _3 = _2;
-    let c4 = [], p4 = {key:4,attrs:{class: _3}};
+    let _3 = this.utils.toObj(_2);
+    let c4 = [], p4 = {key:4,class:_3};
    var vn4 = h('span', p4, c4);
    c1.push(vn4);
    return vn1;
@@ -198,12 +209,11 @@ exports[`attributes t-att-class and class should combine together 1`] = `
 "function anonymous(context,extra
 ) {
    var h = this.utils.h;
-    var _1 = 'hello';
-    var _3 = context['value'];
-    var _2 = 'hello' + (_3 ? ' ' + _3 : '');
-    let c4 = [], p4 = {key:4,attrs:{class: _2}};
-    var vn4 = h('div', p4, c4);
-    return vn4;
+    let _2 = {'hello':true};
+    Object.assign(_2, this.utils.toObj(context['value']))
+    let c3 = [], p3 = {key:3,class:_2};
+    var vn3 = h('div', p3, c3);
+    return vn3;
 }"
 `;

@@ -211,12 +221,11 @@ exports[`attributes t-att-class with object 1`] = `
 "function anonymous(context,extra
 ) {
    var h = this.utils.h;
-    var _1 = 'static';
-    var _3 = this.utils.objectToAttrString({a: context['b'],c: context['d'],e: context['f']});
-    var _2 = 'static' + (_3 ? ' ' + _3 : '');
-    let c4 = [], p4 = {key:4,attrs:{class: _2}};
-    var vn4 = h('div', p4, c4);
-    return vn4;
+    let _2 = {'static':true};
+    Object.assign(_2, this.utils.toObj({a:context['b'],c:context['d'],e:context['f']}))
+    let c3 = [], p3 = {key:3,class:_2};
+    var vn3 = h('div', p3, c3);
+    return vn3;
 }"
 `;

@@ -235,7 +244,7 @@ exports[`attributes tuple literal 1`] = `
 "function anonymous(context,extra
 ) {
    var h = this.utils.h;
-    var _1 = ['foo', 'bar'];
+    var _1 = ['foo','bar'];
    let c2 = [], p2 = {key:2,attrs:{}};
    if (_1 instanceof Array) {
        p2.attrs[_1[0]] = _1[1];
@@ -292,7 +301,7 @@ exports[`debugging t-log 1`] = `
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
    var _2 = 42;
-    console.log(_2 + 3)
+    console.log(_2+3)
    return vn1;
 }"
 `;
@@ -306,14 +315,15 @@ exports[`foreach does not pollute the rendering context 1`] = `
    var vn1 = h('div', p1, c1);
    var _2 = [1];
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.item_first = i === 0;
        context.item_last = i === _length3 - 1;
-        context.item_parity = i % 2 === 0 ? 'even' : 'odd';
        context.item_index = i;
        context.item = _3[i];
        context.item_value = _4[i];
@@ -333,16 +343,17 @@ exports[`foreach iterate on items (on a element node) 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    var _2 = [1, 2];
+    var _2 = [1,2];
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.item_first = i === 0;
        context.item_last = i === _length3 - 1;
-        context.item_parity = i % 2 === 0 ? 'even' : 'odd';
        context.item_index = i;
        context.item = _3[i];
        context.item_value = _4[i];
@@ -365,16 +376,17 @@ exports[`foreach iterate on items 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    var _2 = [3, 2, 1];
+    var _2 = [3,2,1];
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.item_first = i === 0;
        context.item_last = i === _length3 - 1;
-        context.item_parity = i % 2 === 0 ? 'even' : 'odd';
        context.item_index = i;
        context.item = _3[i];
        context.item_value = _4[i];
@@ -408,60 +420,15 @@ exports[`foreach iterate, dict param 1`] = `
    var vn1 = h('div', p1, c1);
    var _2 = context['value'];
    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 _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
-    for (let i = 0; i < _length3; i++) {
-        context.item_first = i === 0;
-        context.item_last = i === _length3 - 1;
-        context.item_parity = i % 2 === 0 ? 'even' : 'odd';
-        context.item_index = i;
-        context.item = _3[i];
-        context.item_value = _4[i];
-        c1.push({text: \` [\`});
-        var _5 = context['item_index'];
-        if (_5 || _5 === 0) {
-            c1.push({text: _5});
-        }
-        c1.push({text: \`: \`});
-        var _6 = context['item'];
-        if (_6 || _6 === 0) {
-            c1.push({text: _6});
-        }
-        c1.push({text: \` \`});
-        var _7 = context['item_value'];
-        if (_7 || _7 === 0) {
-            c1.push({text: _7});
-        }
-        c1.push({text: \` - \`});
-        var _8 = context['item_parity'];
-        if (_8 || _8 === 0) {
-            c1.push({text: _8});
-        }
-        c1.push({text: \`] \`});
+    var _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
    }
-    return vn1;
-}"
-`;
-
-exports[`foreach iterate, integer param 1`] = `
-"function anonymous(context,extra
-) {
-    context = Object.create(context);
-    var h = this.utils.h;
-    let c1 = [], p1 = {key:1};
-    var vn1 = h('div', p1, c1);
-    var _2 = 3;
-    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 _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.item_first = i === 0;
        context.item_last = i === _length3 - 1;
-        context.item_parity = i % 2 === 0 ? 'even' : 'odd';
        context.item_index = i;
        context.item = _3[i];
        context.item_value = _4[i];
@@ -493,16 +460,17 @@ exports[`foreach iterate, position 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    var _2 = 5;
+    var _2 = Array(5);
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.elem_first = i === 0;
        context.elem_last = i === _length3 - 1;
-        context.elem_parity = i % 2 === 0 ? 'even' : 'odd';
        context.elem_index = i;
        context.elem = _3[i];
        context.elem_value = _4[i];
@@ -514,7 +482,7 @@ exports[`foreach iterate, position 1`] = `
            c1.push({text: \` last\`});
        }
        c1.push({text: \` (\`});
-        var _5 = context['elem_parity'];
+        var _5 = context['elem_index'];
        if (_5 || _5 === 0) {
            c1.push({text: _5});
        }
@@ -531,16 +499,17 @@ exports[`foreach warn if no key in some case 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    var _2 = [1, 2];
+    var _2 = [1,2];
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.item_first = i === 0;
        context.item_last = i === _length3 - 1;
-        context.item_parity = i % 2 === 0 ? 'even' : 'odd';
        context.item_index = i;
        context.item = _3[i];
        context.item_value = _4[i];
@@ -594,14 +563,15 @@ exports[`misc global 1`] = `
    var vn1 = h('div', p1, c1);
    var _2 = [4,5,6];
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.value_first = i === 0;
        context.value_last = i === _length3 - 1;
-        context.value_parity = i % 2 === 0 ? 'even' : 'odd';
        context.value_index = i;
        context.value = _3[i];
        context.value_value = _4[i];
@@ -613,13 +583,13 @@ exports[`misc global 1`] = `
            c5.push({text: _6});
        }
        {
-            let _11 = 'bbb'
+            let _11 = 'bbb';
            var _13 = 'agüero';
            let c14 = [], p14 = {key:14,attrs:{\\"falló\\": _13},on:{}};
            var vn14 = h('Año', p14, c14);
            c1.push(vn14);
            {
-                let _15 = 'aaa'
+                let _15 = 'aaa';
                let c16 = [], p16 = {key:16,on:{}};
                var vn16 = h('span', p16, c16);
                c14.push(vn16);
@@ -639,16 +609,13 @@ exports[`misc global 1`] = `
                c17.push({text: \`foo default\`});
            }
            var _19 = 'bbb';
-            {
-                let _19 = 'bbb'
-                let c20 = [], p20 = {key:20,on:{}};
-                var vn20 = h('span', p20, c20);
-                c14.push(vn20);
-                if (_19 || _19 === 0) {
-                    c20.push({text: _19});
-                } else {
-                    c20.push({text: \`foo default\`});
-                }
+            let c20 = [], p20 = {key:20,on:{}};
+            var vn20 = h('span', p20, c20);
+            c14.push(vn20);
+            if (_19 || _19 === 0) {
+                c20.push({text: _19});
+            } else {
+                c20.push({text: \`foo default\`});
            }
        }
    }
@@ -757,6 +724,18 @@ exports[`static templates empty div 1`] = `
 }"
 `;

+exports[`static templates simple dynamic value 1`] = `
+"function anonymous(context,extra
+) {
+    var h = this.utils.h;
+    var _1 = context['text'];
+    if (_1 || _1 === 0) {
+        var vn2 = {text: _1};
+    }
+    return vn2;
+}"
+`;
+
 exports[`static templates simple string 1`] = `
 "function anonymous(context,extra
 ) {
@@ -766,6 +745,19 @@ exports[`static templates simple string 1`] = `
 }"
 `;

+exports[`static templates simple string, with some dynamic value 1`] = `
+"function anonymous(context,extra
+) {
+    var h = this.utils.h;
+    var vn1 = {text: \`hello \`};
+    var _2 = context['text'];
+    if (_2 || _2 === 0) {
+        vn1.text += _2;
+    }
+    return vn1;
+}"
+`;
+
 exports[`t-call (template calling basic caller 1`] = `
 "function anonymous(context,extra
 ) {
@@ -784,11 +776,8 @@ exports[`t-call (template calling inherit context 1`] = `
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
    var _2 = 1;
-    {
-        let _2 = 1
-        if (_2 || _2 === 0) {
-            c1.push({text: _2});
-        }
+    if (_2 || _2 === 0) {
+        c1.push({text: _2});
    }
    return vn1;
 }"
@@ -801,7 +790,7 @@ exports[`t-call (template calling scoped parameters 1`] = `
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
    {
-        let _2 = 42
+        let _2 = 42;
        c1.push({text: \`ok\`});
    }
    var _3 = context['foo'];
@@ -828,7 +817,7 @@ exports[`t-call (template calling with unused setbody 1`] = `
 ) {
    var h = this.utils.h;
    {
-        let _1 = 3
+        let _1 = 3;
        let c2 = [], p2 = {key:2};
        var vn2 = h('div', p2, c2);
        c2.push({text: \`ok\`});
@@ -855,7 +844,7 @@ exports[`t-call (template calling with used set body 1`] = `
    let c1 = [], p1 = {key:1};
    var vn1 = h('span', p1, c1);
    {
-        let _2 = 'ok'
+        let _2 = 'ok';
        if (_2 || _2 === 0) {
            c1.push({text: _2});
        }
@@ -944,13 +933,13 @@ exports[`t-if boolean value condition elif 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    if (context['color'] == 'black') {
+    if (context['color']=='black') {
        c1.push({text: \`black pearl\`});
    }
-    else if (context['color'] == 'yellow') {
+    else if (context['color']=='yellow') {
        c1.push({text: \`yellow submarine\`});
    }
-    else if (context['color'] == 'red') {
+    else if (context['color']=='red') {
        c1.push({text: \`red is dead\`});
    }
    else {
@@ -1053,28 +1042,28 @@ exports[`t-if can use some boolean operators in expressions 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    if (context['cond1'] && context['cond2']) {
+    if (context['cond1']&&context['cond2']) {
        c1.push({text: \`and\`});
    }
-    if (context['cond1'] && context['cond3']) {
+    if (context['cond1']&&context['cond3']) {
        c1.push({text: \`nope\`});
    }
-    if (context['cond1'] || context['cond3']) {
+    if (context['cond1']||context['cond3']) {
        c1.push({text: \`or\`});
    }
-    if (context['cond3'] || context['cond4']) {
+    if (context['cond3']||context['cond4']) {
        c1.push({text: \`nope\`});
    }
-    if (context['m'] > 3) {
+    if (context['m']>3) {
        c1.push({text: \`mgt\`});
    }
-    if (context['n'] > 3) {
+    if (context['n']>3) {
        c1.push({text: \`ngt\`});
    }
-    if (context['m'] < 3) {
+    if (context['m']<3) {
        c1.push({text: \`mlt\`});
    }
-    if (context['n'] < 3) {
+    if (context['n']<3) {
        c1.push({text: \`nlt\`});
    }
    return vn1;
@@ -1104,14 +1093,15 @@ exports[`t-key t-key directive in a list 1`] = `
    var vn1 = h('ul', p1, c1);
    var _2 = context['beers'];
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.beer_first = i === 0;
        context.beer_last = i === _length3 - 1;
-        context.beer_parity = i % 2 === 0 ? 'even' : 'odd';
        context.beer_index = i;
        context.beer = _3[i];
        context.beer_value = _4[i];
@@ -1162,7 +1152,7 @@ exports[`t-on can bind handlers with arguments 1`] = `
 }"
 `;

-exports[`t-on can bind handlers with empty object (with non empty inner string 1`] = `
+exports[`t-on can bind handlers with empty object (with non empty inner string) 1`] = `
 "function anonymous(context,extra
 ) {
    let owner = context;
@@ -1204,14 +1194,15 @@ exports[`t-on can bind handlers with loop variable as argument 1`] = `
    var vn1 = h('ul', p1, c1);
    var _2 = ['someval'];
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.action_first = i === 0;
        context.action_last = i === _length3 - 1;
-        context.action_parity = i % 2 === 0 ? 'even' : 'odd';
        context.action_index = i;
        context.action = _3[i];
        context.action_value = _4[i];
@@ -1241,7 +1232,7 @@ exports[`t-on can bind handlers with object arguments 1`] = `
    if (!context['add']) {
        throw new Error('Missing handler \\\\'' + 'add' + \`\\\\' when evaluating template 'test'\`)
    }
-    p1.on['click'] = context['add'].bind(owner, {val: 5});
+    p1.on['click'] = context['add'].bind(owner, {val:5});
    c1.push({text: \`Click\`});
    return vn1;
 }"
@@ -1532,21 +1523,22 @@ exports[`t-ref refs in a loop 1`] = `
    var vn1 = h('div', p1, c1);
    var _2 = context['items'];
    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 _3 = _4 = _2;
+    if (!(_2 instanceof Array)) {
+        _3 = Object.keys(_2);
+        _4 = Object.values(_2);
+    }
    var _length3 = _3.length;
-    var _4 = _2 instanceof Array ? _2 : Object.values(_2);
    for (let i = 0; i < _length3; i++) {
        context.item_first = i === 0;
        context.item_last = i === _length3 - 1;
-        context.item_parity = i % 2 === 0 ? 'even' : 'odd';
        context.item_index = i;
        context.item = _3[i];
        context.item_value = _4[i];
        let c5 = [], p5 = {key:context['item']};
        var vn5 = h('div', p5, c5);
        c1.push(vn5);
-        const ref6 = context['item'];
+        const ref6 = (context['item']);
        p5.hook = {
          create: (_, n) => {
            context.refs[ref6] = n.elm;
@@ -1567,7 +1559,7 @@ exports[`t-set evaluate value expression 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    var _2 = 1 + 2;
+    var _2 = 1+2;
    if (_2 || _2 === 0) {
        c1.push({text: _2});
    }
@@ -1581,7 +1573,7 @@ exports[`t-set evaluate value expression, part 2 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    var _2 = context['somevariable'] + 2;
+    var _2 = context['somevariable']+2;
    if (_2 || _2 === 0) {
        c1.push({text: _2});
    }
@@ -1657,7 +1649,7 @@ exports[`t-set t-set and t-if 1`] = `
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
    var _2 = context['value'];
-    if (_2 === 'ok') {
+    if (_2==='ok') {
        c1.push({text: \`grimbergen\`});
    }
    return vn1;
@@ -1670,7 +1662,7 @@ exports[`t-set t-set evaluates an expression only once 1`] = `
    var h = this.utils.h;
    let c1 = [], p1 = {key:1};
    var vn1 = h('div', p1, c1);
-    var _2 = context['value'] + ' artois';
+    var _2 = context['value']+' artois';
    if (_2 || _2 === 0) {
        c1.push({text: _2});
    }
@@ -1691,14 +1683,15 @@ exports[`t-set t-set should reuse variable if possible 1`] = `
    var _2 = 1;
    var _3 = context['list'];
    if (!_3) { throw new Error('QWeb error: Invalid loop expression')}
-    if (typeof _3 === 'number') { _3 = Array.from(Array(_3).keys())}
-    var _4 = _3 instanceof Array ? _3 : Object.keys(_3);
+    var _4 = _5 = _3;
+    if (!(_3 instanceof Array)) {
+        _4 = Object.keys(_3);
+        _5 = Object.values(_3);
+    }
    var _length4 = _4.length;
-    var _5 = _3 instanceof Array ? _3 : Object.values(_3);
    for (let i = 0; i < _length4; i++) {
        context.elem_first = i === 0;
        context.elem_last = i === _length4 - 1;
-        context.elem_parity = i % 2 === 0 ? 'even' : 'odd';
        context.elem_index = i;
        context.elem = _4[i];
        context.elem_value = _5[i];
@@ -1,5 +1,9 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP

+exports[`connecting a component to store connecting a component to a local store 1`] = `"<div></div>"`;
+
+exports[`connecting a component to store connecting a component to a local store 2`] = `"<div><span>hello</span></div>"`;
+
 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>"`;
@@ -1,33 +0,0 @@
-function anonymous(context, extra) {
- var h = this.utils.h;
-          let c1 = [], p1 = {key:1};
-          var vn1 = h('div', p1, c1);
-          if (context['state'].display) {
-              //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 = {};
-              if (w4 && w4.__owl__.renderPromise && !w4.__owl__.vnode && props4 !== w4.__owl__.renderProps) {
-                  w4.destroy();
-                  w4 = false
-              }
-              if (!w4) {
-                  let W4 = context.widgets['Child'];
-                  if (!W4) {throw new Error(`Cannot find the definition of widget "Child"`)}
-                  w4 = new W4(owner, props4);
-                  context.__owl__.cmap[4] = w4.__owl__.id;
-                  def3 = w4._prepare();
-                  def3 = def3.then(vnode=>{let pvnode=h(vnode.sel, {key: 4, hook: {insert: (vn) => {let nvn=w4._mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;this.utils.transitionInsert(vn.elm, 'chimay');},remove: () => {},destroy: (vn) => {let finalize = () => {
-                w4.destroy();
-              };
-              this.utils.transitionRemove(vn.elm, 'chimay', finalize);}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
-              } else {
-                  def3 = w4._updateProps(props4, extra.forceUpdate, extra.patchQueue);
-                  def3 = def3.then(()=>{if (w4.__owl__.isDestroyed) {return};let pvnode=w4.__owl__.pvnode;c1[_2_index]=pvnode;});
-              }
-              extra.promises.push(def3);
-          }
-
-}
@@ -18,7 +18,7 @@ import {
 // - 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 widgets
+// - env: a WEnv, necessary to create new components
 // - cssEl: a stylesheet injected into the dom

 let fixture: HTMLElement;
@@ -170,16 +170,13 @@ describe("animations", () => {
    expect(spanNode.className).toBe("");
  });

-  test("t-transition combined with t-widget", async () => {
+  test("t-transition combined with component", async () => {
    expect.assertions(5);

-    env.qweb.addTemplate(
-      "Parent",
-      `<div><t t-widget="Child" t-transition="chimay"/></div>`
-    );
+    env.qweb.addTemplate("Parent", `<div><Child t-transition="chimay"/></div>`);
    env.qweb.addTemplate("Child", `<span>blue</span>`);
    class Parent extends Widget {
-      widgets = { Child: Child };
+      components = { Child: Child };
    }
    class Child extends Widget {}
    const widget = new Parent(env);
@@ -209,16 +206,16 @@ describe("animations", () => {
    expect(fixture.innerHTML).toBe('<div><span class="">blue</span></div>');
  });

-  test("t-transition combined with t-widget and t-if", async () => {
+  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-widget="Child" t-transition="chimay"/></div>`
+      `<div><t t-if="state.display" t-component="Child" t-transition="chimay"/></div>`
    );
    env.qweb.addTemplate("Child", `<span>blue</span>`);
    class Parent extends Widget {
-      widgets = { Child: Child };
+      components = { Child: Child };
      state = { display: true };
    }
    class Child extends Widget {}
@@ -253,11 +250,11 @@ describe("animations", () => {
    widget.state.display = false;
    patchNextFrame(cb => {
      expect(fixture.innerHTML).toBe(
-        '<div><span class="chimay-leave chimay-leave-active">blue</span></div>'
+        '<div><span class="chimay-leave chimay-leave-active" data-owl-key="4">blue</span></div>'
      );
      cb();
      expect(fixture.innerHTML).toBe(
-        '<div><span class="chimay-leave-active chimay-leave-to">blue</span></div>'
+        '<div><span class="chimay-leave-active chimay-leave-to" data-owl-key="4">blue</span></div>'
      );
      def.resolve();
    });
@@ -287,4 +284,121 @@ describe("animations", () => {
    expect(widget.f).toHaveBeenCalledTimes(1);
    unpatchNextFrame();
  });
+
+  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 {
+      constructor(parent) {
+        super(parent);
+        this.state = { flag: false };
+      }
+      toggle() {
+        this.state.flag = !this.state.flag;
+      }
+    }
+
+    const widget = new Parent(env);
+    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(11);
+
+    env.qweb.addTemplates(
+      `<templates>
+        <div t-name="Parent">
+          <button t-on-click="toggle">Toggle</button>
+          <t t-if="state.flag" t-component="Child" t-transition="chimay"/>
+        </div>
+        <span t-name="Child">blue</span>
+      </templates>`
+    );
+    class Child extends Widget {}
+    class Parent extends Widget {
+      components = { Child };
+      constructor(parent) {
+        super(parent);
+        this.state = { flag: false };
+      }
+      toggle() {
+        this.state.flag = !this.state.flag;
+      }
+    }
+
+    const widget = new Parent(env);
+    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>');
+  });
 });
@@ -0,0 +1,126 @@
+/**
+ * Doc Link Checker
+ *
+ * We define here a test to make sure that there are no dead link in the Owl
+ * documentation.
+ */
+import * as fs from "fs";
+
+const LINK_REGEXP = /\[([^\[]+)\]\(([^\)]+)\)/g;
+const HEADING_REGEXP = /\n(#+\s*)(.*)/g;
+
+// files to be checked
+function getFiles(): string[] {
+  const DOCFILES = fs.readdirSync("doc").map(f => `doc/${f}`);
+  const MAINREADME = "README.md";
+  return DOCFILES.concat(MAINREADME);
+}
+
+test("All markdown links work", () => {
+  let linkNumber = 0;
+  let invalidLinkNumber = 0;
+  const files = getFiles();
+  const data = readDocData(files);
+  for (let file of data) {
+    for (let link of file.links) {
+      // DEBUG: uncomment next line
+      // console.warn(`Checking "${link.name}" in "${file.name}"`);
+      linkNumber++;
+      if (!isLinkValid(link, file, data)) {
+        console.warn(`Invalid Link: "${link.name}" in "${file.name}"`);
+        invalidLinkNumber++;
+      }
+    }
+  }
+  expect(invalidLinkNumber).toBe(0);
+  expect(linkNumber).toBeGreaterThan(10);
+});
+
+interface MarkDownLink {
+  name: string;
+  link: string;
+}
+
+interface MarkDownSection {
+  name: string;
+  slug: string;
+}
+
+interface FileData {
+  name: string;
+  links: MarkDownLink[];
+  sections: MarkDownSection[];
+}
+
+function isLinkValid(link: MarkDownLink, current: FileData, files: FileData[]): boolean {
+  const parts = link.link.split("#");
+  const currentParts = current.name.split("/");
+  const path = currentParts.length > 1 ? currentParts[0] + "/" : "";
+  const fullName = path + parts[0];
+  if (parts.length === 1) {
+    // no # in url
+    if (parts[0].endsWith(".md")) {
+      // it is a local md file
+      if (!files.find(f => f.name === fullName)) {
+        return false;
+      }
+    }
+  } else {
+    const file = parts[0] === "" ? current : files.find(f => f.name === fullName);
+    if (!file) {
+      return false;
+    }
+    if (!file.sections.find(s => s.slug === parts[1])) {
+      return false;
+    }
+  }
+  return true;
+}
+// adapted from https://medium.com/@mhagemann/the-ultimate-way-to-slugify-a-url-string-in-javascript-b8e4a0d849e1
+function slugify(str) {
+  const a = "àáäâãåăæçèéëêǵḧìíïîḿńǹñòóöôœøṕŕßśșțùúüûǘẃẍÿź·_,:;";
+  const b = "aaaaaaaaceeeeghiiiimnnnooooooprssstuuuuuwxyz-----";
+  const p = new RegExp(a.split("").join("|"), "g");
+  return str
+    .toString()
+    .toLowerCase()
+    .replace(/\//g, "") // remove /
+    .replace(/\s+/g, "-") // Replace spaces with -
+    .replace(p, c => b.charAt(a.indexOf(c))) // Replace special characters
+    .replace(/&/g, "-and-") // Replace & with ‘and’
+    .replace(/[^\w\-]+/g, "") // Remove all non-word characters
+    .replace(/\-\-+/g, "-") // Replace multiple - with single -
+    .replace(/^-+/, "") // Trim - from start of text
+    .replace(/-+$/, ""); // Trim - from end of text
+}
+
+function readDocData(files: string[]): FileData[] {
+  const result: FileData[] = [];
+
+  for (let file of files) {
+    const fileData: FileData = {
+      name: file,
+      links: [],
+      sections: []
+    };
+    const content = fs.readFileSync(file, { encoding: "utf8" });
+    let m;
+    // get links info
+    do {
+      m = LINK_REGEXP.exec(content);
+      if (m) {
+        fileData.links.push({ name: m[0], link: m[2] });
+      }
+    } while (m);
+    // get sections info
+    do {
+      m = HEADING_REGEXP.exec(content);
+      if (m) {
+        fileData.sections.push({ name: m[0], slug: slugify(m[2]) });
+      }
+    } while (m);
+
+    result.push(fileData);
+  }
+  return result;
+}
@@ -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", () => {
@@ -68,11 +68,7 @@ export function renderToDOM(
  return result.elm as HTMLElement;
 }

-export function renderToString(
-  qweb: QWeb,
-  t: string,
-  context: EvalContext = {}
-): string {
+export function renderToString(qweb: QWeb, t: string, context: EvalContext = {}): string {
  const node = renderToDOM(qweb, t, context);
  return node instanceof Text ? node.textContent! : node.outerHTML;
 }
@@ -91,3 +87,10 @@ export function patchNextFrame(f: Function) {
 export function unpatchNextFrame() {
  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();
+}
@@ -134,6 +134,57 @@ describe("observer", () => {
    expect(arr[0].__owl__.rev).toBe(3);
  });

+  test("set new property on observed object", async () => {
+    const observer = new Observer();
+    observer.notifyCB = jest.fn();
+    const state: any = { a: 1 };
+    observer.observe(state);
+    expect(state.__owl__.rev).toBe(1);
+    expect(observer.rev).toBe(1);
+    expect(observer.notifyCB).toBeCalledTimes(0);
+
+    Observer.set(state, "b", 8);
+    await nextMicroTick();
+    expect(state.__owl__.rev).toBe(2);
+    expect(observer.rev).toBe(2);
+    expect(observer.notifyCB).toBeCalledTimes(1);
+    expect(state.b).toBe(8);
+  });
+
+  test("delete property from observed object", async () => {
+    const observer = new Observer();
+    observer.notifyCB = jest.fn();
+    const state: any = { a: 1, b: 8 };
+    observer.observe(state);
+    expect(state.__owl__.rev).toBe(1);
+    expect(observer.rev).toBe(1);
+    expect(observer.notifyCB).toBeCalledTimes(0);
+
+    Observer.delete(state, "b");
+    await nextMicroTick();
+    expect(state.__owl__.rev).toBe(2);
+    expect(observer.rev).toBe(2);
+    expect(observer.notifyCB).toBeCalledTimes(1);
+    expect(state).toEqual({ a: 1 });
+  });
+
+  test("set element in observed array", async () => {
+    const observer = new Observer();
+    observer.notifyCB = jest.fn();
+    const state: any = ["a"];
+    observer.observe(state);
+    expect(state.__owl__.rev).toBe(1);
+    expect(observer.rev).toBe(1);
+    expect(observer.notifyCB).toBeCalledTimes(0);
+
+    Observer.set(state, 1, "b");
+    await nextMicroTick();
+    expect(state.__owl__.rev).toBe(2);
+    expect(observer.rev).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 = { arr: [] };
@@ -230,6 +281,26 @@ describe("observer", () => {
    expect(obj2.__owl__.rev).toBe(3);
  });

+  test("can set a property more than once", () => {
+    const observer = new Observer();
+    const obj: any = {};
+
+    observer.observe(obj);
+    expect(obj.__owl__.rev).toBe(1);
+    expect(observer.rev).toBe(1);
+    expect(obj.__owl__.deepRev).toBe(1);
+
+    observer.set(obj, "aku", "always finds annoying problems");
+    expect(observer.rev).toBe(2);
+    expect(obj.__owl__.rev).toBe(2);
+    expect(obj.__owl__.deepRev).toBe(2);
+
+    observer.set(obj, "aku", "always finds good problems");
+    expect(observer.rev).toBe(3);
+    expect(obj.__owl__.rev).toBe(3);
+    expect(obj.__owl__.deepRev).toBe(3);
+  });
+
  test("properly handle swapping elements", () => {
    const observer = new Observer();
    const obj: any = { a: { arr: [] }, b: 1 };
@@ -52,9 +52,9 @@ describe("props validation", () => {
    }
    const w = new TestWidget(env, { message: "bottle" });
    try {
-      await w._updateProps({});
+      await w.__updateProps({});
    } catch (e) {
-      expect(e.message).toBe("Missing props 'message' (widget 'TestWidget')");
+      expect(e.message).toBe("Missing props 'message' (component 'TestWidget')");
    }
  });

@@ -65,7 +65,7 @@ describe("props validation", () => {

    expect(() => {
      new TestWidget(env);
-    }).toThrow("Missing props 'message' (widget 'TestWidget')");
+    }).toThrow("Missing props 'message' (component 'TestWidget')");
  });

  test("validate simple types", async () => {
@@ -93,7 +93,7 @@ describe("props validation", () => {

      expect(() => {
        new TestWidget(env, { p: test.ko });
-      }).toThrow("Props 'p' of invalid type in widget");
+      }).toThrow("Props 'p' of invalid type in component");
    }
  });

@@ -122,11 +122,10 @@ describe("props validation", () => {

      expect(() => {
        new TestWidget(env, { p: test.ko });
-      }).toThrow("Props 'p' of invalid type in widget");
+      }).toThrow("Props 'p' of invalid type in component");
    }
  });

-
  test("can validate a prop with multiple types", async () => {
    let TestWidget = class extends Widget {
      static props = { p: [String, Boolean] };
@@ -139,7 +138,7 @@ describe("props validation", () => {

    expect(() => {
      new TestWidget(env, { p: 1 });
-    }).toThrow("Props 'p' of invalid type in widget");
+    }).toThrow("Props 'p' of invalid type in component");
  });

  test("can validate an optional props", async () => {
@@ -149,16 +148,14 @@ describe("props validation", () => {

    expect(() => {
      new TestWidget(env, { p: "hey" });
-      new TestWidget(env, { });
+      new TestWidget(env, {});
    }).not.toThrow();

    expect(() => {
      new TestWidget(env, { p: 1 });
    }).toThrow();
-
  });

-
  test("can validate an array with given primitive type", async () => {
    let TestWidget = class extends Widget {
      static props = { p: { type: Array, element: String } };
@@ -222,7 +219,7 @@ describe("props validation", () => {
          type: Object,
          shape: {
            id: Number,
-            url: [Boolean, {type: Array, element: Number}],
+            url: [Boolean, { type: Array, element: Number }]
          }
        }
      };
@@ -230,21 +227,19 @@ describe("props validation", () => {

    expect(() => {
      new TestWidget(env, { p: { id: 1, url: true } });
-      new TestWidget(env, { p: { id: 1, url: [12]} });
+      new TestWidget(env, { p: { id: 1, url: [12] } });
    }).not.toThrow();

    expect(() => {
-      new TestWidget(env, { p: { id: 1, url: [12, true]} });
+      new TestWidget(env, { p: { id: 1, url: [12, true] } });
    }).toThrow();
-
  });
 });

-
 describe("default props", () => {
  test("can set default values", async () => {
    class TestWidget extends Widget {
-      static defaultProps = {p: 4}
+      static defaultProps = { p: 4 };
    }

    const w = new TestWidget(env, {});
@@ -253,11 +248,11 @@ describe("default props", () => {

  test("default values are also set whenever component is updated", async () => {
    class TestWidget extends Widget {
-      static defaultProps = {p: 4}
+      static defaultProps = { p: 4 };
    }

-    const w = new TestWidget(env, {p: 1});
-    await w._updateProps({});
+    const w = new TestWidget(env, { p: 1 });
+    await w.__updateProps({});
    expect(w.props.p).toBe(4);
  });
 });
@@ -24,6 +24,16 @@ describe("static templates", () => {
    expect(renderToString(qweb, "test")).toBe("hello vdom");
  });

+  test("simple dynamic value", () => {
+    qweb.addTemplate("test", '<t><t t-esc="text"/></t>');
+    expect(renderToString(qweb, "test", { text: "hello vdom" })).toBe("hello vdom");
+  });
+
+  test("simple string, with some dynamic value", () => {
+    qweb.addTemplate("test", '<t>hello <t t-esc="text"/></t>');
+    expect(renderToString(qweb, "test", { text: "vdom" })).toBe("hello vdom");
+  });
+
  test("empty div", () => {
    qweb.addTemplate("test", "<div></div>");
    expect(renderToString(qweb, "test")).toBe("<div></div>");
@@ -42,9 +52,7 @@ describe("static templates", () => {

 describe("error handling", () => {
  test("invalid xml", () => {
-    expect(() => qweb.addTemplate("test", "<div>")).toThrow(
-      "Invalid XML in template"
-    );
+    expect(() => qweb.addTemplate("test", "<div>")).toThrow("Invalid XML in template");
  });

  test("template with text node and tag", () => {
@@ -61,6 +69,7 @@ describe("error handling", () => {

  test("cannot add twice the same template", () => {
    qweb.addTemplate("test", `<t></t>`);
+    expect(() => qweb.addTemplate("test", "<div/>", true)).not.toThrow("already defined");
    expect(() => qweb.addTemplate("test", "<div/>")).toThrow("already defined");
  });

@@ -79,29 +88,14 @@ describe("error handling", () => {

  test("nice error when t-on is evaluated with a missing event", () => {
    qweb.addTemplate("templatename", `<div t-on="somemethod"></div>`);
-    expect(() =>
-      qweb.render("templatename", { someMethod() {} }, { handlers: [] })
-    ).toThrow("Missing event name with t-on directive");
-  });
-
-  test("error when compiled code is invalid", () => {
-    qweb.addTemplate(
-      "templatename",
-      `<div t-att-hey="}/^function invalid{{>'"></div>`
-    );
-    expect(() => qweb.render("templatename")).toThrow(
-      "Invalid generated code while compiling template 'templatename': Unexpected token }"
+    expect(() => qweb.render("templatename", { someMethod() {} }, { handlers: [] })).toThrow(
+      "Missing event name with t-on directive"
    );
  });

  test("error when unknown directive", () => {
-    qweb.addTemplate(
-      "templatename",
-      `<div t-best-beer="rochefort 10">test</div>`
-    );
-    expect(() => qweb.render("templatename")).toThrow(
-      "Unknown QWeb directive: 't-best-beer'"
-    );
+    qweb.addTemplate("templatename", `<div t-best-beer="rochefort 10">test</div>`);
+    expect(() => qweb.render("templatename")).toThrow("Unknown QWeb directive: 't-best-beer'");
  });
 });

@@ -118,9 +112,7 @@ describe("t-esc", () => {

  test.skip("escaping", () => {
    qweb.addTemplate("test", `<span><t t-esc="var"/></span>`);
-    expect(renderToString(qweb, "test", { var: "<ok>" })).toBe(
-      "<span>&lt;ok&gt;</span>"
-    );
+    expect(renderToString(qweb, "test", { var: "<ok>" })).toBe("<span>&lt;ok&gt;</span>");
  });

  test("escaping on a node", () => {
@@ -152,9 +144,7 @@ describe("t-raw", () => {

  test("not escaping", () => {
    qweb.addTemplate("test", `<div><t t-raw="var"/></div>`);
-    expect(renderToString(qweb, "test", { var: "<ok></ok>" })).toBe(
-      "<div><ok></ok></div>"
-    );
+    expect(renderToString(qweb, "test", { var: "<ok></ok>" })).toBe("<div><ok></ok></div>");
  });

  test("t-raw and another sibling node", () => {
@@ -167,39 +157,28 @@ describe("t-raw", () => {

 describe("t-set", () => {
  test("set from attribute literal", () => {
-    qweb.addTemplate(
-      "test",
-      `<div><t t-set="value" t-value="'ok'"/><t t-esc="value"/></div>`
-    );
+    qweb.addTemplate("test", `<div><t t-set="value" t-value="'ok'"/><t t-esc="value"/></div>`);
    expect(renderToString(qweb, "test")).toBe("<div>ok</div>");
  });

  test("t-set and t-if", () => {
    qweb.addTemplate(
      "test",
-      `<div >
+      `<div>
        <t t-set="v" t-value="value"/>
        <t t-if="v === 'ok'">grimbergen</t>
        </div>`
    );
-    expect(renderToString(qweb, "test", { value: "ok" })).toBe(
-      "<div>grimbergen</div>"
-    );
+    expect(renderToString(qweb, "test", { value: "ok" })).toBe("<div>grimbergen</div>");
  });

  test("set from body literal", () => {
-    qweb.addTemplate(
-      "test",
-      `<t><t t-set="value">ok</t><t t-esc="value"/></t>`
-    );
+    qweb.addTemplate("test", `<t><t t-set="value">ok</t><t t-esc="value"/></t>`);
    expect(renderToString(qweb, "test")).toBe("ok");
  });

  test("set from attribute lookup", () => {
-    qweb.addTemplate(
-      "test",
-      `<div><t t-set="stuff" t-value="value"/><t t-esc="stuff"/></div>`
-    );
+    qweb.addTemplate("test", `<div><t t-set="stuff" t-value="value"/><t t-esc="stuff"/></div>`);
    expect(renderToString(qweb, "test", { value: "ok" })).toBe("<div>ok</div>");
  });

@@ -231,18 +210,12 @@ describe("t-set", () => {
  });

  test("value priority", () => {
-    qweb.addTemplate(
-      "test",
-      `<div><t t-set="value" t-value="1">2</t><t t-esc="value"/></div>`
-    );
+    qweb.addTemplate("test", `<div><t t-set="value" t-value="1">2</t><t t-esc="value"/></div>`);
    expect(renderToString(qweb, "test")).toBe("<div>1</div>");
  });

  test("evaluate value expression", () => {
-    qweb.addTemplate(
-      "test",
-      `<div><t t-set="value" t-value="1 + 2"/><t t-esc="value"/></div>`
-    );
+    qweb.addTemplate("test", `<div><t t-set="value" t-value="1 + 2"/><t t-esc="value"/></div>`);
    expect(renderToString(qweb, "test")).toBe("<div>3</div>");
  });

@@ -267,25 +240,19 @@ describe("t-set", () => {
      "test",
      `<div><t t-set="value" t-value="somevariable + 2"/><t t-esc="value"/></div>`
    );
-    expect(renderToString(qweb, "test", { somevariable: 43 })).toBe(
-      "<div>45</div>"
-    );
+    expect(renderToString(qweb, "test", { somevariable: 43 })).toBe("<div>45</div>");
  });
 });

 describe("t-if", () => {
  test("boolean value true condition", () => {
    qweb.addTemplate("test", `<div><t t-if="condition">ok</t></div>`);
-    expect(renderToString(qweb, "test", { condition: true })).toBe(
-      "<div>ok</div>"
-    );
+    expect(renderToString(qweb, "test", { condition: true })).toBe("<div>ok</div>");
  });

  test("boolean value false condition", () => {
    qweb.addTemplate("test", `<div><t t-if="condition">ok</t></div>`);
-    expect(renderToString(qweb, "test", { condition: false })).toBe(
-      "<div></div>"
-    );
+    expect(renderToString(qweb, "test", { condition: false })).toBe("<div></div>");
  });

  test("boolean value condition missing", () => {
@@ -302,9 +269,7 @@ describe("t-if", () => {
        <t t-else="">beer</t></div>
    `
    );
-    expect(renderToString(qweb, "test", { color: "red" })).toBe(
-      "<div>red is dead</div>"
-    );
+    expect(renderToString(qweb, "test", { color: "red" })).toBe("<div>red is dead</div>");
  });

  test("boolean value condition else", () => {
@@ -330,9 +295,7 @@ describe("t-if", () => {
        `
    );
    const result = trim(renderToString(qweb, "test", { condition: false }));
-    expect(result).toBe(
-      "<div><span>begin</span>fail-else<span>end</span></div>"
-    );
+    expect(result).toBe("<div><span>begin</span>fail-else<span>end</span></div>");
  });

  test("can use some boolean operators in expressions", () => {
@@ -357,9 +320,7 @@ describe("t-if", () => {
      m: 5,
      n: 2
    };
-    expect(normalize(renderToString(qweb, "test", context))).toBe(
-      "<div>andormgtnlt</div>"
-    );
+    expect(normalize(renderToString(qweb, "test", context))).toBe("<div>andormgtnlt</div>");
  });
 });

@@ -478,16 +439,13 @@ describe("attributes", () => {
  });

  test("format expression, other format", () => {
-    qweb.addTemplate("test", `<div t-attf-foo="#{value + 37}"/>`);
+    qweb.addTemplate("test", `<div t-attf-foo="{{value + 37}}"/>`);
    const result = renderToString(qweb, "test", { value: 5 });
    expect(result).toBe(`<div foo="42"></div>`);
  });

  test("format multiple", () => {
-    qweb.addTemplate(
-      "test",
-      `<div t-attf-foo="a {{value1}} is {{value2}} of {{value3}} ]"/>`
-    );
+    qweb.addTemplate("test", `<div t-attf-foo="a {{value1}} is {{value2}} of {{value3}} ]"/>`);
    const result = renderToString(qweb, "test", {
      value1: 0,
      value2: 1,
@@ -522,11 +480,14 @@ describe("attributes", () => {
    expect(result).toBe(`<div class="hello world"></div>`);
  });

+  test("class and t-attf-class with ternary operation", () => {
+    qweb.addTemplate("test", `<div class="hello" t-attf-class="{{value ? 'world' : ''}}"/>`);
+    const result = renderToString(qweb, "test", { value: true });
+    expect(result).toBe(`<div class="hello world"></div>`);
+  });
+
  test("t-att-class with object", () => {
-    qweb.addTemplate(
-      "test",
-      `<div class="static" t-att-class="{a: b, c: d, e: f}"/>`
-    );
+    qweb.addTemplate("test", `<div class="static" t-att-class="{a: b, c: d, e: f}"/>`);
    const result = renderToString(qweb, "test", { b: true, d: false, f: true });
    expect(result).toBe(`<div class="static a e"></div>`);
  });
@@ -555,10 +516,7 @@ describe("t-call (template calling", () => {

  test("with unused setbody", () => {
    qweb.addTemplate("_basic-callee", "<div>ok</div>");
-    qweb.addTemplate(
-      "caller",
-      '<t t-call="_basic-callee"><t t-set="qux" t-value="3"/></t>'
-    );
+    qweb.addTemplate("caller", '<t t-call="_basic-callee"><t t-set="qux" t-value="3"/></t>');
    const expected = "<div>ok</div>";
    expect(renderToString(qweb, "caller")).toBe(expected);
  });
@@ -644,25 +602,13 @@ describe("foreach", () => {
      "test",
      `
      <div>
-        <t t-foreach="5" t-as="elem">
-          -<t t-if="elem_first"> first</t><t t-if="elem_last"> last</t> (<t t-esc="elem_parity"/>)
+        <t t-foreach="Array(5)" t-as="elem">
+          -<t t-if="elem_first"> first</t><t t-if="elem_last"> last</t> (<t t-esc="elem_index"/>)
        </t>
      </div>`
    );
    const result = trim(renderToString(qweb, "test"));
-    const expected = `<div>-first(even)-(odd)-(even)-(odd)-last(even)</div>`;
-    expect(result).toBe(expected);
-  });
-
-  test("iterate, integer param", () => {
-    qweb.addTemplate(
-      "test",
-      `<div><t t-foreach="3" t-as="item">
-        [<t t-esc="item_index"/>: <t t-esc="item"/> <t t-esc="item_value"/>]
-      </t></div>`
-    );
-    const result = trim(renderToString(qweb, "test"));
-    const expected = `<div>[0:00][1:11][2:22]</div>`;
+    const expected = `<div>-first(0)-(1)-(2)-(3)-last(4)</div>`;
    expect(result).toBe(expected);
  });

@@ -672,14 +618,12 @@ describe("foreach", () => {
      `
      <div>
        <t t-foreach="value" t-as="item">
-          [<t t-esc="item_index"/>: <t t-esc="item"/> <t t-esc="item_value"/> - <t t-esc="item_parity"/>]
+          [<t t-esc="item_index"/>: <t t-esc="item"/> <t t-esc="item_value"/>]
        </t>
      </div>`
    );
-    const result = trim(
-      renderToString(qweb, "test", { value: { a: 1, b: 2, c: 3 } })
-    );
-    const expected = `<div>[0:a1-even][1:b2-odd][2:c3-even]</div>`;
+    const result = trim(renderToString(qweb, "test", { value: { a: 1, b: 2, c: 3 } }));
+    const expected = `<div>[0:a1][1:b2][2:c3]</div>`;
    expect(result).toBe(expected);
  });

@@ -725,14 +669,8 @@ describe("foreach", () => {
 describe("misc", () => {
  test("global", () => {
    qweb.addTemplate("_callee-asc", `<Año t-att-falló="'agüero'" t-raw="0"/>`);
-    qweb.addTemplate(
-      "_callee-uses-foo",
-      `<span t-esc="foo">foo default</span>`
-    );
-    qweb.addTemplate(
-      "_callee-asc-toto",
-      `<div t-raw="toto">toto default</div>`
-    );
+    qweb.addTemplate("_callee-uses-foo", `<span t-esc="foo">foo default</span>`);
+    qweb.addTemplate("_callee-asc-toto", `<div t-raw="toto">toto default</div>`);
    qweb.addTemplate(
      "caller",
      `
@@ -845,10 +783,7 @@ describe("t-on", () => {
  });

  test("can bind handlers with object arguments", () => {
-    qweb.addTemplate(
-      "test",
-      `<button t-on-click="add({val: 5})">Click</button>`
-    );
+    qweb.addTemplate("test", `<button t-on-click="add({val: 5})">Click</button>`);
    let a = 1;
    const node = renderToDOM(
      qweb,
@@ -866,10 +801,7 @@ describe("t-on", () => {

  test("can bind handlers with empty object", () => {
    expect.assertions(2);
-    qweb.addTemplate(
-      "test",
-      `<button t-on-click="doSomething({})">Click</button>`
-    );
+    qweb.addTemplate("test", `<button t-on-click="doSomething({})">Click</button>`);
    const node = renderToDOM(
      qweb,
      "test",
@@ -883,12 +815,9 @@ describe("t-on", () => {
    (<HTMLElement>node).click();
  });

-  test("can bind handlers with empty object (with non empty inner string", () => {
+  test("can bind handlers with empty object (with non empty inner string)", () => {
    expect.assertions(2);
-    qweb.addTemplate(
-      "test",
-      `<button t-on-click="doSomething({ })">Click</button>`
-    );
+    qweb.addTemplate("test", `<button t-on-click="doSomething({ })">Click</button>`);
    const node = renderToDOM(
      qweb,
      "test",
@@ -1108,7 +1037,7 @@ describe("loading templates", () => {
  test("does not crash if string does not have templates", () => {
    const data = "";
    qweb.addTemplates(data);
-    expect(Object.keys(qweb.templates)).toEqual(["default"]);
+    expect(Object.keys(qweb.templates)).toEqual([]);
  });
 });

@@ -1188,13 +1117,10 @@ describe("whitespace handling", () => {

 describe("t-key", () => {
  test("can use t-key directive on a node", () => {
-    qweb.addTemplate(
-      "test",
-      `<div t-key="beer.id"><t t-esc="beer.name"/></div>`
+    qweb.addTemplate("test", `<div t-key="beer.id"><t t-esc="beer.name"/></div>`);
+    expect(renderToString(qweb, "test", { beer: { id: 12, name: "Chimay Rouge" } })).toBe(
+      "<div>Chimay Rouge</div>"
    );
-    expect(
-      renderToString(qweb, "test", { beer: { id: 12, name: "Chimay Rouge" } })
-    ).toBe("<div>Chimay Rouge</div>");
  });

  test("t-key directive in a list", () => {
@@ -0,0 +1,158 @@
+import { compileExpr, tokenize } from "../src/qweb_expressions";
+
+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: "!=" }
+    ]);
+  });
+
+  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("context['a']*(1+3)");
+  });
+
+  test("objects and sub objects", () => {
+    expect(compileExpr("{a:{b:1}} ", {})).toBe("{a:{b:1}}");
+  });
+
+  test("replacing variables", () => {
+    expect(compileExpr("a", {})).toBe("context['a']");
+    expect(compileExpr("a", { a: { id: "_3", expr: "" } })).toBe("_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("context['a'].b");
+    expect(compileExpr("a.b.c", {})).toBe("context['a'].b.c");
+  });
+
+  test("various unary operators", () => {
+    expect(compileExpr("!flag", {})).toBe("!context['flag']");
+    expect(compileExpr("-3", {})).toBe("-3");
+    expect(compileExpr("-a", {})).toBe("-context['a']");
+  });
+
+  test("various binary operators", () => {
+    expect(compileExpr("color == 'black'", {})).toBe("context['color']=='black'");
+    expect(compileExpr("a || b", {})).toBe("context['a']||context['b']");
+    expect(compileExpr("color === 'black'", {})).toBe("context['color']==='black'");
+    expect(compileExpr("'li_'+item", {})).toBe("'li_'+context['item']");
+    expect(compileExpr("state.val > 1", {})).toBe("context['state'].val>1");
+  });
+
+  test("boolean operations", () => {
+    expect(compileExpr("a && b", {})).toBe("context['a']&&context['b']");
+  });
+
+  test("ternary operators", () => {
+    expect(compileExpr("a ? b: '2'", {})).toBe("context['a']?context['b']:'2'");
+    expect(compileExpr("a ? b: (c or '2') ", {})).toBe(
+      "context['a']?context['b']:(context['c']||'2')"
+    );
+    expect(compileExpr("a ? {test:c}: [1,u]", {})).toBe(
+      "context['a']?{test:context['c']}:[1,context['u']]"
+    );
+  });
+
+  test("word replacement", () => {
+    expect(compileExpr("a or b", {})).toBe("context['a']||context['b']");
+    expect(compileExpr("a and b", {})).toBe("context['a']&&context['b']");
+  });
+
+  test("function calls", () => {
+    expect(compileExpr("a()", {})).toBe("context['a']()");
+    expect(compileExpr("a(1)", {})).toBe("context['a'](1)");
+    expect(compileExpr("a(1,2)", {})).toBe("context['a'](1,2)");
+    expect(compileExpr("a(1,2,{a:[a]})", {})).toBe("context['a'](1,2,{a:[context['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: "" } })).toBe(
+      "'x'.toUpperCase(_v5)"
+    );
+    expect(compileExpr("'x'.toUpperCase({b: a})", { a: { id: "_v5", expr: "" } })).toBe(
+      "'x'.toUpperCase({b:_v5})"
+    );
+  });
+});
@@ -1,11 +1,7 @@
 import { Component, Env } from "../src/component";
 import { connect, Store } from "../src/store";
-import {
-  makeTestFixture,
-  makeTestEnv,
-  nextMicroTick,
-  nextTick
-} from "./helpers";
+import { makeTestFixture, makeTestEnv, nextMicroTick, nextTick } from "./helpers";
+import { Observer } from "../src";

 describe("basic use", () => {
  test("commit a mutation", () => {
@@ -41,6 +37,31 @@ describe("basic use", () => {
    expect(store.state.n).toBe(15);
  });

+  test("dispatch an action + commit a mutation with positional arguments", () => {
+    const state = { n1: 1, n2: 1, n3: 1 };
+    const mutations = {
+      batchInc({ state }, delta1, delta2, delta3) {
+        state.n1 += delta1;
+        state.n2 += delta2;
+        state.n3 += delta3;
+      }
+    };
+    const actions = {
+      batchInc({ commit }, delta1, delta2, delta3) {
+        commit("batchInc", delta1, delta2, delta3);
+      }
+    };
+    const store = new Store({ state, mutations, actions });
+
+    expect(store.state.n1).toBe(1);
+    expect(store.state.n2).toBe(1);
+    expect(store.state.n3).toBe(1);
+    store.dispatch("batchInc", 14, 30, 88);
+    expect(store.state.n1).toBe(15);
+    expect(store.state.n2).toBe(31);
+    expect(store.state.n3).toBe(89);
+  });
+
  test("modifying state outside of mutations trigger error", () => {
    const state = { n: 1 };
    const actions = {
@@ -152,24 +173,6 @@ describe("basic use", () => {
    store.dispatch("someaction");
  });

-  test("set function is given to mutations", async () => {
-    let updateCounter = 0;
-    const state = { bertinchamps: "brune" };
-    const mutations = {
-      addInfo({ state, set }) {
-        set(state, "chouffe", "blonde");
-      }
-    };
-    const store = new Store({ state, mutations, actions: {} });
-    store.on("update", null, () => updateCounter++);
-
-    expect(updateCounter).toBe(0);
-    store.commit("addInfo");
-    await nextMicroTick();
-    expect(updateCounter).toBe(1);
-    expect(store.state).toEqual({ bertinchamps: "brune", chouffe: "blonde" });
-  });
-
  test("can have getters from store", async () => {
    const state = {
      beers: {
@@ -200,6 +203,155 @@ describe("basic use", () => {
    expect((<any>store.getters).beerTasterName(1)).toBe("aaron");
  });

+  test("getters are memoized", async () => {
+    const state = {
+      beers: {
+        1: {
+          id: 1,
+          name: "bertinchamps",
+          tasterID: 1
+        }
+      },
+      tasters: {
+        1: {
+          id: 1,
+          name: "aaron"
+        }
+      }
+    };
+    let n = 0;
+    const getters = {
+      beerTasterName({ state }, beerID) {
+        n++;
+        return state.tasters[state.beers[beerID].tasterID].name;
+      },
+      bestBeerName({ state }) {
+        n++;
+        return state.beers[1].name;
+      }
+    };
+    const store = new Store({ state, mutations: {}, actions: {}, getters });
+    expect((<any>store.getters).bestBeerName()).toBe("bertinchamps");
+    expect((<any>store.getters).beerTasterName(1)).toBe("aaron");
+    expect(n).toBe(2);
+    expect((<any>store.getters).bestBeerName()).toBe("bertinchamps");
+    expect((<any>store.getters).beerTasterName(1)).toBe("aaron");
+    expect(n).toBe(2);
+  });
+
+  test("getters taking Array as argument aren't memoized", async () => {
+    const state = {
+      beers: {
+        1: {
+          id: 1,
+          name: "bertinchamps",
+          tasterID: 1
+        }
+      }
+    };
+    let n = 0;
+    const getters = {
+      getBeerNames({ state }, beerIDs) {
+        n++;
+        return beerIDs.map(beerID => {
+          return state.beers[beerID].name;
+        });
+      }
+    };
+    const store = new Store({ state, mutations: {}, actions: {}, getters });
+    expect((<any>store.getters).getBeerNames([1])).toEqual(["bertinchamps"]);
+    expect(n).toBe(1);
+    expect((<any>store.getters).getBeerNames([1])).toEqual(["bertinchamps"]);
+    expect(n).toBe(2);
+  });
+
+  test("getters cache is nuked on store changes", async () => {
+    const state = {
+      beers: {
+        1: {
+          id: 1,
+          name: "bertinchamps",
+          tasterID: 1
+        }
+      },
+      tasters: {
+        1: {
+          id: 1,
+          name: "aaron"
+        },
+        2: {
+          id: 2,
+          name: "gery"
+        }
+      }
+    };
+    const mutations = {
+      changeTaster({ state }, { beerID, tasterID }) {
+        state.beers[beerID].tasterID = tasterID;
+      }
+    };
+    let n = 0;
+    const getters = {
+      beerTasterName({ state }, beerID) {
+        n++;
+        return state.tasters[state.beers[beerID].tasterID].name;
+      }
+    };
+    const store = new Store({
+      state,
+      mutations: mutations,
+      actions: {},
+      getters
+    });
+    expect((<any>store.getters).beerTasterName(1)).toBe("aaron");
+    expect(n).toBe(1);
+    expect((<any>store.getters).beerTasterName(1)).toBe("aaron");
+    expect(n).toBe(1);
+
+    store.commit("changeTaster", { beerID: 1, tasterID: 2 });
+    await nextTick();
+
+    expect((<any>store.getters).beerTasterName(1)).toBe("gery");
+    expect(n).toBe(2);
+  });
+
+  test("getters cache is disabled during a mutation", async () => {
+    const state = {
+      beers: {
+        1: {
+          id: 1,
+          name: "bertinchamps"
+        }
+      }
+    };
+    const mutations = {
+      renameBeer({ state, getters }, beerID) {
+        expect(getters.beerName(beerID)).toBe("bertinchamps");
+        state.beers[1].name = "chouffe";
+        expect(getters.beerName(beerID)).toBe("chouffe");
+      }
+    };
+    let n = 0;
+    const getters = {
+      beerName({ state }, beerID) {
+        n++;
+        return state.beers[beerID].name;
+      }
+    };
+    const store = new Store({
+      state,
+      mutations: mutations,
+      actions: {},
+      getters
+    });
+
+    store.commit("renameBeer", 1);
+    expect((<any>store.getters).beerName(1)).toBe("chouffe");
+    await nextTick();
+
+    expect(n).toBe(3);
+  });
+
  test("getters given to actions", async () => {
    expect.assertions(3);
    const state = {
@@ -413,14 +565,14 @@ describe("connecting a component to store", () => {
      "App",
      `
            <div>
-                <t t-foreach="props.todos" t-as="todo" t-key="todo">
-                    <t t-widget="Todo" t-props="todo"/>
+                <t t-foreach="props.todos" t-as="todo" >
+                    <Todo msg="todo.msg" t-key="todo"/>
                </t>
            </div>`
    );
    env.qweb.addTemplate("Todo", `<span><t t-esc="props.msg"/></span>`);
    class App extends Component<any, any, any> {
-      widgets = { Todo };
+      components = { Todo };
    }
    class Todo extends Component<any, any, any> {}
    const state = { todos: [] };
@@ -429,10 +581,13 @@ describe("connecting a component to store", () => {
        state.todos.push({ msg });
      }
    };
-    function mapStateToProps(s) {
+    function mapStoreToProps(s) {
      return { todos: s.todos };
    }
-    const TodoApp = connect(mapStateToProps)(App);
+    const TodoApp = connect(
+      App,
+      mapStoreToProps
+    );
    const store = new Store({ state, mutations });
    (<any>env).store = store;
    const app = new TodoApp(env);
@@ -452,7 +607,7 @@ describe("connecting a component to store", () => {
        state.todos[0].title = title;
      }
    };
-    function mapStateToProps(s) {
+    function mapStoreToProps(s) {
      return { todos: s.todos };
    }
    const store = new Store({ state, mutations });
@@ -469,13 +624,15 @@ describe("connecting a component to store", () => {
    class App extends Component<any, any, any> {}

    const DeepTodoApp = connect(
-      mapStateToProps,
+      App,
+      mapStoreToProps,
      { deep: true }
-    )(App);
+    );
    const ShallowTodoApp = connect(
-      mapStateToProps,
+      App,
+      mapStoreToProps,
      { deep: false }
-    )(App);
+    );
    (<any>env).store = store;
    const deepTodoApp = new DeepTodoApp(env);
    const shallowTodoApp = new ShallowTodoApp(env);
@@ -494,6 +651,51 @@ describe("connecting a component to store", () => {
    expect(shallowFix.innerHTML).toMatchSnapshot();
  });

+  test("connecting a component to a local store", async () => {
+    env.qweb.addTemplates(`
+      <templates>
+        <div t-name="App">
+          <t t-foreach="props.todos" t-as="todo">
+            <Todo msg="todo.msg" t-key="todo" />
+          </t>
+        </div>
+        <span t-name="Todo"><t t-esc="props.msg"/></span>
+      </templates>
+      `);
+    class App extends Component<any, any, any> {
+      components = { Todo };
+    }
+    class Todo extends Component<any, any, any> {}
+
+    (<any>env).store = new Store({});
+    const store = new Store({
+      state: { todos: [] },
+      mutations: {
+        addTodo({ state }, msg) {
+          state.todos.push({ msg });
+        }
+      }
+    });
+    function mapStoreToProps(s) {
+      return { todos: s.todos };
+    }
+    const TodoApp = connect(
+      App,
+      mapStoreToProps,
+      {
+        getStore: () => store
+      }
+    );
+    const app = new TodoApp(env);
+
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toMatchSnapshot();
+
+    (<any>app.__owl__).store.commit("addTodo", "hello");
+    await nextTick();
+    expect(fixture.innerHTML).toMatchSnapshot();
+  });
+
  test("connected child components with custom hooks", async () => {
    let steps: any = [];
    env.qweb.addTemplate("Child", `<div/>`);
@@ -506,17 +708,20 @@ describe("connecting a component to store", () => {
      }
    }

-    const ConnectedChild = connect(s => s)(Child);
+    const ConnectedChild = connect(
+      Child,
+      s => s
+    );

    env.qweb.addTemplate(
      "Parent",
      `
          <div>
-              <t t-if="state.child" t-widget="ConnectedChild"/>
+              <t t-if="state.child" t-component="ConnectedChild"/>
          </div>`
    );
    class Parent extends Component<any, any, any> {
-      widgets = { ConnectedChild };
+      components = { ConnectedChild };

      constructor(env: Env) {
        super(env);
@@ -548,27 +753,33 @@ describe("connecting a component to store", () => {

    env.qweb.addTemplate("TodoItem", `<span><t t-esc="props.text"/></span>`);
    class TodoItem extends Component<any, any, any> {}
-    const ConnectedTodo = connect((state, props) => {
-      const todo = state.todos.find(t => t.id === props.id);
-      return todo;
-    })(TodoItem);
+    const ConnectedTodo = connect(
+      TodoItem,
+      (state, props) => {
+        const todo = state.todos.find(t => t.id === props.id);
+        return todo;
+      }
+    );

    env.qweb.addTemplate(
      "TodoList",
      `<div>
            <t t-foreach="props.todos" t-as="todo">
-              <t t-widget="ConnectedTodo" t-props="todo"/>
+              <ConnectedTodo id="todo.id" t-key="todo.id"/>
            </t>
          </div>`
    );
    class TodoList extends Component<any, any, any> {
-      widgets = { ConnectedTodo };
+      components = { ConnectedTodo };
    }

-    function mapStateToProps(state) {
+    function mapStoreToProps(state) {
      return { todos: state.todos };
    }
-    const ConnectedTodoList = connect(mapStateToProps)(TodoList);
+    const ConnectedTodoList = connect(
+      TodoList,
+      mapStoreToProps
+    );

    (<any>env).store = store;
    const app = new ConnectedTodoList(env);
@@ -578,9 +789,7 @@ describe("connecting a component to store", () => {

    store.commit("addTodo", "hoegaarden");
    await nextTick();
-    expect(fixture.innerHTML).toBe(
-      "<div><span>jupiler</span><span>hoegaarden</span></div>"
-    );
+    expect(fixture.innerHTML).toBe("<div><span>jupiler</span><span>hoegaarden</span></div>");
  });

  test("connect receives store getters as third argument", async () => {
@@ -606,30 +815,36 @@ describe("connecting a component to store", () => {
      </div>`
    );
    class TodoItem extends Component<any, any, any> {}
-    const ConnectedTodo = connect((state, props, getters) => {
-      const todo = state.todos.find(t => t.id === props.id);
-      return {
-        activeTodoText: getters.text(todo.id),
-        importantTodoText: getters.importantTodoText()
-      };
-    })(TodoItem);
+    const ConnectedTodo = connect(
+      TodoItem,
+      (state, props, getters) => {
+        const todo = state.todos.find(t => t.id === props.id);
+        return {
+          activeTodoText: getters.text(todo.id),
+          importantTodoText: getters.importantTodoText()
+        };
+      }
+    );

    env.qweb.addTemplate(
      "TodoList",
      `<div>
            <t t-foreach="props.todos" t-as="todo">
-              <t t-widget="ConnectedTodo" t-props="todo"/>
+              <ConnectedTodo id="todo.id" t-key="todo.id"/>
            </t>
          </div>`
    );
    class TodoList extends Component<any, any, any> {
-      widgets = { ConnectedTodo };
+      components = { ConnectedTodo };
    }

-    function mapStateToProps(state) {
+    function mapStoreToProps(state) {
      return { todos: state.todos };
    }
-    const ConnectedTodoList = connect(mapStateToProps)(TodoList);
+    const ConnectedTodoList = connect(
+      TodoList,
+      mapStoreToProps
+    );

    (<any>env).store = store;
    const app = new ConnectedTodoList(env);
@@ -643,18 +858,21 @@ describe("connecting a component to store", () => {
  test("connected component is updated when props are updated", async () => {
    env.qweb.addTemplate("Beer", `<span><t t-esc="props.name"/></span>`);
    class Beer extends Component<any, any, any> {}
-    const ConnectedBeer = connect((state, props) => {
-      return state.beers[props.id];
-    })(Beer);
+    const ConnectedBeer = connect(
+      Beer,
+      (state, props) => {
+        return state.beers[props.id];
+      }
+    );

    env.qweb.addTemplate(
      "App",
      `<div>
-            <t t-widget="ConnectedBeer" t-props="{id: state.beerId}"/>
+            <ConnectedBeer id="state.beerId"/>
        </div>`
    );
    class App extends Component<any, any, any> {
-      widgets = { ConnectedBeer };
+      components = { ConnectedBeer };
      state = { beerId: 1 };
    }

@@ -691,10 +909,13 @@ describe("connecting a component to store", () => {
    const store = new Store({ state, mutations });
    (<any>env).store = store;

-    function mapStateToProps(state) {
+    function mapStoreToProps(state) {
      return { beers: state.beers, otherKey: 1 };
    }
-    const ConnectedApp = connect(mapStateToProps)(App);
+    const ConnectedApp = connect(
+      App,
+      mapStoreToProps
+    );
    const app = new ConnectedApp(env);

    await app.mount(fixture);
@@ -702,9 +923,7 @@ describe("connecting a component to store", () => {

    store.commit("addBeer", "kwak");
    await nextTick();
-    expect(fixture.innerHTML).toBe(
-      "<div><span>jupiler</span><span>kwak</span></div>"
-    );
+    expect(fixture.innerHTML).toBe("<div><span>jupiler</span><span>kwak</span></div>");
  });

  test("connected component with undefined, null and string props", async () => {
@@ -717,22 +936,25 @@ describe("connecting a component to store", () => {
        </div>`
    );
    class Beer extends Component<any, any, any> {}
-    const ConnectedBeer = connect((state, props) => {
-      return {
-        selected: state.beers[props.id],
-        consumed: state.beers[state.consumedID] || null,
-        taster: state.taster
-      };
-    })(Beer);
+    const ConnectedBeer = connect(
+      Beer,
+      (state, props) => {
+        return {
+          selected: state.beers[props.id],
+          consumed: state.beers[state.consumedID] || null,
+          taster: state.taster
+        };
+      }
+    );

    env.qweb.addTemplate(
      "App",
      `<div>
-              <t t-widget="ConnectedBeer" t-props="{id: state.beerId}"/>
-          </div>`
+            <ConnectedBeer id="state.beerId"/>
+        </div>`
    );
    class App extends Component<any, any, any> {
-      widgets = { ConnectedBeer };
+      components = { ConnectedBeer };
      state = { beerId: 0 };
    }

@@ -753,9 +975,7 @@ describe("connecting a component to store", () => {
    const app = new App(env);

    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe(
-      "<div><div><span>taster:aaron</span></div></div>"
-    );
+    expect(fixture.innerHTML).toBe("<div><div><span>taster:aaron</span></div></div>");

    app.state.beerId = 1;
    await nextTick();
@@ -786,22 +1006,25 @@ describe("connecting a component to store", () => {
        </div>`
    );
    class Beer extends Component<any, any, any> {}
-    const ConnectedBeer = connect((state, props) => {
-      return {
-        selected: state.beers[props.id],
-        consumed: state.beers[state.consumedID] || null,
-        taster: state.taster
-      };
-    })(Beer);
+    const ConnectedBeer = connect(
+      Beer,
+      (state, props) => {
+        return {
+          selected: state.beers[props.id],
+          consumed: state.beers[state.consumedID] || null,
+          taster: state.taster
+        };
+      }
+    );

    env.qweb.addTemplate(
      "App",
      `<div>
-              <t t-widget="ConnectedBeer" t-props="{id: state.beerId}"/>
+              <ConnectedBeer id="state.beerId"/>
          </div>`
    );
    class App extends Component<any, any, any> {
-      widgets = { ConnectedBeer };
+      components = { ConnectedBeer };
      state = { beerId: 0 };
    }

@@ -828,9 +1051,7 @@ describe("connecting a component to store", () => {
    const app = new App(env);

    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe(
-      "<div><div><span>taster:aaron</span></div></div>"
-    );
+    expect(fixture.innerHTML).toBe("<div><div><span>taster:aaron</span></div></div>");

    app.state.beerId = 1;
    await nextTick();
@@ -876,25 +1097,31 @@ describe("connecting a component to store", () => {
      "Parent",
      `
        <div>
-            <t t-widget="Child" t-props="{key: props.current}"/>
+            <Child key="props.current"/>
        </div>
      `
    );
    class Parent extends Component<any, any, any> {
-      widgets = { Child: ConnectedChild };
+      components = { Child: ConnectedChild };
    }
-    const ConnectedParent = connect(function(s) {
-      steps.push("parent");
-      return { current: s.current, isvisible: s.isvisible };
-    })(Parent);
+    const ConnectedParent = connect(
+      Parent,
+      function(s) {
+        steps.push("parent");
+        return { current: s.current, isvisible: s.isvisible };
+      }
+    );

    env.qweb.addTemplate("Child", `<span><t t-esc="props.msg"/></span>`);
    class Child extends Component<any, any, any> {}

-    const ConnectedChild = connect(function(s, props) {
-      steps.push("child");
-      return { msg: s.msg[props.key] };
-    })(Child);
+    const ConnectedChild = connect(
+      Child,
+      function(s, props) {
+        steps.push("child");
+        return { msg: s.msg[props.key] };
+      }
+    );

    const state = { current: "a", msg: { a: "a", b: "b" } };
    const mutations = {
@@ -913,7 +1140,188 @@ describe("connecting a component to store", () => {

    store.commit("setCurrent", "b");
    await nextTick();
-    expect(steps).toEqual(["parent", "child", "parent", "child", "child"]);
+    expect(fixture.innerHTML).toBe("<div><span>b</span></div>");
+    expect(steps).toEqual(["parent", "child", "parent", "child"]);
+  });
+
+  test("connected parent/children: no double rendering", async () => {
+    const mutations = {
+      editTodo({ state }) {
+        state.todos[1].title = "abc";
+      }
+    };
+    const todos = { 1: { id: 1, title: "kikoou" } };
+    const state = {
+      todos
+    };
+    const store = new Store({
+      state,
+      mutations
+    });
+
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="TodoApp" class="todoapp">
+                <t t-foreach="Object.values(props.todos)" t-as="todo">
+                    <ConnectedTodoItem t-key="todo.id" id="todo.id"/>
+                </t>
+            </div>
+
+            <div t-name="TodoItem" class="todo">
+                <t t-esc="props.todo.title"/>
+                <button class="destroy" t-on-click="editTodo">x</button>
+            </div>
+        </templates>
+    `);
+
+    function mapStoreToPropsTodoApp(state) {
+      return {
+        todos: state.todos
+      };
+    }
+
+    class TodoApp extends Component<any, any, any> {
+      components = { ConnectedTodoItem };
+    }
+
+    const ConnectedTodoApp = connect(
+      TodoApp,
+      mapStoreToPropsTodoApp
+    );
+
+    let renderCount = 0;
+    let fCount = 0;
+
+    function mapStoreToPropsTodoItem(state, ownProps) {
+      fCount++;
+      return {
+        todo: state.todos[ownProps.id]
+      };
+    }
+
+    class TodoItem extends Component<any, any, any> {
+      state = { isEditing: false };
+
+      editTodo() {
+        this.env.store.commit("editTodo");
+      }
+      __render(...args) {
+        renderCount++;
+        return super.__render(...args);
+      }
+    }
+
+    const ConnectedTodoItem = connect(
+      TodoItem,
+      mapStoreToPropsTodoItem
+    );
+
+    (<any>env).store = store;
+    const app = new ConnectedTodoApp(env);
+
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe(
+      '<div class="todoapp"><div class="todo">kikoou<button class="destroy">x</button></div></div>'
+    );
+
+    expect(renderCount).toBe(1);
+    expect(fCount).toBe(1);
+    fixture.querySelector("button")!.click();
+    await nextTick();
+    expect(renderCount).toBe(2);
+    expect(fCount).toBe(2);
+    expect(fixture.innerHTML).toBe(
+      '<div class="todoapp"><div class="todo">abc<button class="destroy">x</button></div></div>'
+    );
+  });
+
+  test("connected parent/children: no rendering if child is destroyed", async () => {
+    const mutations = {
+      removeTodo({ state }) {
+        Observer.delete(state.todos, 1);
+      }
+    };
+    const todos = { 1: { id: 1, title: "kikoou" } };
+    const state = {
+      todos
+    };
+    const store = new Store({
+      state,
+      mutations
+    });
+
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="TodoApp" class="todoapp">
+                <t t-foreach="Object.values(props.todos)" t-as="todo">
+                    <ConnectedTodoItem t-key="todo.id" id="todo.id"/>
+                </t>
+            </div>
+
+            <div t-name="TodoItem" class="todo">
+                <t t-esc="props.todo.title"/>
+                <button class="destroy" t-on-click="removeTodo">x</button>
+            </div>
+        </templates>
+    `);
+
+    function mapStoreToPropsTodoApp(state) {
+      return {
+        todos: state.todos
+      };
+    }
+
+    class TodoApp extends Component<any, any, any> {
+      components = { ConnectedTodoItem };
+    }
+
+    const ConnectedTodoApp = connect(
+      TodoApp,
+      mapStoreToPropsTodoApp
+    );
+
+    let renderCount = 0;
+    let fCount = 0;
+
+    function mapStoreToPropsTodoItem(state, ownProps) {
+      fCount++;
+      return {
+        todo: state.todos[ownProps.id]
+      };
+    }
+
+    class TodoItem extends Component<any, any, any> {
+      state = { isEditing: false };
+
+      removeTodo() {
+        this.env.store.commit("removeTodo");
+      }
+      __render(...args) {
+        renderCount++;
+        return super.__render(...args);
+      }
+    }
+
+    const ConnectedTodoItem = connect(
+      TodoItem,
+      mapStoreToPropsTodoItem
+    );
+
+    (<any>env).store = store;
+    const app = new ConnectedTodoApp(env);
+
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe(
+      '<div class="todoapp"><div class="todo">kikoou<button class="destroy">x</button></div></div>'
+    );
+
+    expect(renderCount).toBe(1);
+    expect(fCount).toBe(1);
+    fixture.querySelector("button")!.click();
+    await nextTick();
+    expect(renderCount).toBe(1);
+    expect(fCount).toBe(1);
+    expect(fixture.innerHTML).toBe('<div class="todoapp"></div>');
  });

  test("connected component willpatch/patch hooks are called on store updates", async () => {
@@ -927,9 +1335,12 @@ describe("connecting a component to store", () => {
        steps.push("patched");
      }
    }
-    const ConnectedApp = connect(function(s) {
-      return { msg: s.msg };
-    })(App);
+    const ConnectedApp = connect(
+      App,
+      function(s) {
+        return { msg: s.msg };
+      }
+    );

    const state = { msg: "a" };
    const mutations = {
@@ -950,4 +1361,30 @@ describe("connecting a component to store", () => {
    expect(fixture.innerHTML).toBe("<div>b</div>");
    expect(steps).toEqual(["willpatch", "patched"]);
  });
+
+  test("connected component has its own name", () => {
+    function mapStoreToProps() {}
+
+    class Named extends Component<any, any, any> {}
+    const namedConnected = connect(
+      Named,
+      mapStoreToProps
+    );
+    expect(namedConnected.name).toMatch("ConnectedNamed");
+
+    class ParentNamed extends Component<any, any, any> {}
+    class ChildNamed extends ParentNamed {}
+    const childConnected = connect(
+      ChildNamed,
+      mapStoreToProps
+    );
+    expect(childConnected.name).toMatch("ConnectedChildNamed");
+
+    const Anonymous = class extends Component<any, any, any> {};
+    const anonymousConnected = connect(
+      Anonymous,
+      mapStoreToProps
+    );
+    expect(anonymousConnected.name).toMatch(/^Connectedclass_\d+/);
+  });
 });
@@ -59,9 +59,7 @@ describe("attributes", function() {
  test("are set correctly when namespaced", function() {
    const vnode1 = h("div", { attrs: { "xlink:href": "#foo" } });
    elm = patch(vnode0, vnode1).elm;
-    expect(elm.getAttributeNS("http://www.w3.org/1999/xlink", "href")).toBe(
-      "#foo"
-    );
+    expect(elm.getAttributeNS("http://www.w3.org/1999/xlink", "href")).toBe("#foo");
  });

  test("should not touch class nor id fields", function() {
@@ -207,12 +205,8 @@ describe("snabbdom", function() {
      expect(elm.firstChild.namespaceURI).toBe(SVGNamespace);

      // verify that svg tag automatically gets svg namespace
-      elm = patch(
-        vnode0,
-        h("svg", [
-          h("foreignObject", [h("div", ["I am HTML embedded in SVG"])])
-        ])
-      ).elm;
+      elm = patch(vnode0, h("svg", [h("foreignObject", [h("div", ["I am HTML embedded in SVG"])])]))
+        .elm;
      expect(elm.namespaceURI).toBe(SVGNamespace);
      expect(elm.firstChild.namespaceURI).toBe(SVGNamespace);
      expect(elm.firstChild.firstChild.namespaceURI).toBe(XHTMLNamespace);
@@ -352,13 +346,7 @@ describe("snabbdom", function() {
        elm = patch(vnode0, vnode1).elm;
        expect(elm.children.length).toBe(2);
        elm = patch(vnode1, vnode2).elm;
-        expect(map(elm.children, c => c.innerHTML)).toEqual([
-          "1",
-          "2",
-          "3",
-          "4",
-          "5"
-        ]);
+        expect(map(elm.children, c => c.innerHTML)).toEqual(["1", "2", "3", "4", "5"]);
      });

      test("add elements in the middle", function() {
@@ -368,13 +356,7 @@ describe("snabbdom", function() {
        expect(elm.children.length).toBe(4);
        expect(elm.children.length).toBe(4);
        elm = patch(vnode1, vnode2).elm;
-        expect(map(elm.children, c => c.innerHTML)).toEqual([
-          "1",
-          "2",
-          "3",
-          "4",
-          "5"
-        ]);
+        expect(map(elm.children, c => c.innerHTML)).toEqual(["1", "2", "3", "4", "5"]);
      });

      test("add elements at beginning and end", function() {
@@ -383,13 +365,7 @@ describe("snabbdom", function() {
        elm = patch(vnode0, vnode1).elm;
        expect(elm.children.length).toBe(3);
        elm = patch(vnode1, vnode2).elm;
-        expect(map(elm.children, c => c.innerHTML)).toEqual([
-          "1",
-          "2",
-          "3",
-          "4",
-          "5"
-        ]);
+        expect(map(elm.children, c => c.innerHTML)).toEqual(["1", "2", "3", "4", "5"]);
      });

      test("adds children to parent with no children", function() {
@@ -588,35 +564,19 @@ describe("snabbdom", function() {
        elm = patch(vnode0, vnode1).elm;
        expect(elm.children.length).toBe(6);
        elm = patch(vnode1, vnode2).elm;
-        expect(map(elm.children, c => c.innerHTML)).toEqual([
-          "4",
-          "3",
-          "2",
-          "1",
-          "5",
-          "0"
-        ]);
+        expect(map(elm.children, c => c.innerHTML)).toEqual(["4", "3", "2", "1", "5", "0"]);
      });

      test("supports null/undefined children", function() {
        const vnode1 = h("i", [0, 1, 2, 3, 4, 5].map(spanNum));
        const vnode2 = h(
          "i",
-          [null, 2, undefined, null, 1, 0, null, 5, 4, null, 3, undefined].map(
-            spanNum
-          )
+          [null, 2, undefined, null, 1, 0, null, 5, 4, null, 3, undefined].map(spanNum)
        );
        elm = patch(vnode0, vnode1).elm;
        expect(elm.children.length).toBe(6);
        elm = patch(vnode1, vnode2).elm;
-        expect(map(elm.children, c => c.innerHTML)).toEqual([
-          "2",
-          "1",
-          "0",
-          "5",
-          "4",
-          "3"
-        ]);
+        expect(map(elm.children, c => c.innerHTML)).toEqual(["2", "1", "0", "5", "4", "3"]);
      });

      test("supports all null/undefined children", function() {
@@ -627,14 +587,7 @@ describe("snabbdom", function() {
        elm = patch(vnode1, vnode2).elm;
        expect(elm.children.length).toBe(0);
        elm = patch(vnode2, vnode3).elm;
-        expect(map(elm.children, c => c.innerHTML)).toEqual([
-          "5",
-          "4",
-          "3",
-          "2",
-          "1",
-          "0"
-        ]);
+        expect(map(elm.children, c => c.innerHTML)).toEqual(["5", "4", "3", "2", "1", "0"]);
      });
    });
  });
@@ -714,18 +667,10 @@ describe("snabbdom", function() {
    });

    test("removes elements", function() {
-      const vnode1 = h("div", [
-        h("span", "One"),
-        h("span", "Two"),
-        h("span", "Three")
-      ]);
+      const vnode1 = h("div", [h("span", "One"), h("span", "Two"), h("span", "Three")]);
      const vnode2 = h("div", [h("span", "One"), h("span", "Three")]);
      elm = patch(vnode0, vnode1).elm;
-      expect(map(elm.children, c => c.innerHTML)).toEqual([
-        "One",
-        "Two",
-        "Three"
-      ]);
+      expect(map(elm.children, c => c.innerHTML)).toEqual(["One", "Two", "Three"]);
      elm = patch(vnode1, vnode2).elm;
      expect(map(elm.children, c => c.innerHTML)).toEqual(["One", "Three"]);
    });
@@ -760,49 +705,19 @@ describe("snabbdom", function() {
    });

    test("reorders elements", function() {
-      const vnode1 = h("div", [
-        h("span", "One"),
-        h("div", "Two"),
-        h("b", "Three")
-      ]);
-      const vnode2 = h("div", [
-        h("b", "Three"),
-        h("span", "One"),
-        h("div", "Two")
-      ]);
+      const vnode1 = h("div", [h("span", "One"), h("div", "Two"), h("b", "Three")]);
+      const vnode2 = h("div", [h("b", "Three"), h("span", "One"), h("div", "Two")]);
      elm = patch(vnode0, vnode1).elm;
-      expect(map(elm.children, c => c.innerHTML)).toEqual([
-        "One",
-        "Two",
-        "Three"
-      ]);
+      expect(map(elm.children, c => c.innerHTML)).toEqual(["One", "Two", "Three"]);
      elm = patch(vnode1, vnode2).elm;
      expect(map(elm.children, c => c.tagName)).toEqual(["B", "SPAN", "DIV"]);
-      expect(map(elm.children, c => c.innerHTML)).toEqual([
-        "Three",
-        "One",
-        "Two"
-      ]);
+      expect(map(elm.children, c => c.innerHTML)).toEqual(["Three", "One", "Two"]);
    });

    test("supports null/undefined children", function() {
      const vnode1 = h("i", [null, h("i", "1"), h("i", "2"), null]);
-      const vnode2 = h("i", [
-        h("i", "2"),
-        undefined,
-        undefined,
-        h("i", "1"),
-        undefined
-      ]);
-      const vnode3 = h("i", [
-        null,
-        h("i", "1"),
-        undefined,
-        null,
-        h("i", "2"),
-        undefined,
-        null
-      ]);
+      const vnode2 = h("i", [h("i", "2"), undefined, undefined, h("i", "1"), undefined]);
+      const vnode3 = h("i", [null, h("i", "1"), undefined, null, h("i", "2"), undefined, null]);
      elm = patch(vnode0, vnode1).elm;
      expect(map(elm.children, c => c.innerHTML)).toEqual(["1", "2"]);
      elm = patch(vnode1, vnode2).elm;
@@ -835,10 +750,7 @@ describe("snabbdom", function() {
        }
        const vnode1 = h("div", [
          h("span", "First sibling"),
-          h("div", { hook: { create: cb } }, [
-            h("span", "Child 1"),
-            h("span", "Child 2")
-          ]),
+          h("div", { hook: { create: cb } }, [h("span", "Child 1"), h("span", "Child 2")]),
          h("span", "Can't touch me")
        ]);
        patch(vnode0, vnode1);
@@ -855,10 +767,7 @@ describe("snabbdom", function() {
        }
        const vnode1 = h("div", [
          h("span", "First sibling"),
-          h("div", { hook: { insert: cb } }, [
-            h("span", "Child 1"),
-            h("span", "Child 2")
-          ]),
+          h("div", { hook: { insert: cb } }, [h("span", "Child 1"), h("span", "Child 2")]),
          h("span", "Can touch me")
        ]);
        patch(vnode0, vnode1);
@@ -874,17 +783,11 @@ describe("snabbdom", function() {
        }
        const vnode1 = h("div", [
          h("span", "First sibling"),
-          h("div", { hook: { prepatch: cb } }, [
-            h("span", "Child 1"),
-            h("span", "Child 2")
-          ])
+          h("div", { hook: { prepatch: cb } }, [h("span", "Child 1"), h("span", "Child 2")])
        ]);
        const vnode2 = h("div", [
          h("span", "First sibling"),
-          h("div", { hook: { prepatch: cb } }, [
-            h("span", "Child 1"),
-            h("span", "Child 2")
-          ])
+          h("div", { hook: { prepatch: cb } }, [h("span", "Child 1"), h("span", "Child 2")])
        ]);
        patch(vnode0, vnode1);
        patch(vnode1, vnode2);
@@ -965,10 +868,7 @@ describe("snabbdom", function() {
        }
        const vnode1 = h("div", [
          h("span", "First sibling"),
-          h("div", { hook: { remove: cb } }, [
-            h("span", "Child 1"),
-            h("span", "Child 2")
-          ])
+          h("div", { hook: { remove: cb } }, [h("span", "Child 1"), h("span", "Child 2")])
        ]);
        const vnode2 = h("div", [h("span", "First sibling")]);
        patch(vnode0, vnode1);
@@ -981,9 +881,7 @@ describe("snabbdom", function() {
        function cb(vnode) {
          calls++;
        }
-        const vnode1 = h("div", [
-          h("div", { hook: { destroy: cb } }, [h("span", "Child 1")])
-        ]);
+        const vnode1 = h("div", [h("div", { hook: { destroy: cb } }, [h("span", "Child 1")])]);
        const vnode2 = h("div", "Text node");
        patch(vnode0, vnode1);
        patch(vnode1, vnode2);
@@ -1053,10 +951,7 @@ describe("snabbdom", function() {
          result.push(vnode);
          rm();
        }
-        const vnode1 = h("div", { hook: { remove: cb } }, [
-          h("b", "Child 1"),
-          h("i", "Child 2")
-        ]);
+        const vnode1 = h("div", { hook: { remove: cb } }, [h("b", "Child 1"), h("i", "Child 2")]);
        const vnode2 = h("span", [h("b", "Child 1"), h("i", "Child 2")]);
        patch(vnode0, vnode1);
        patch(vnode1, vnode2);
@@ -1091,10 +986,7 @@ describe("snabbdom", function() {
        }
        const vnode1 = h("div", [
          h("span", "First sibling"),
-          h("div", [
-            h("span", { hook: { destroy: cb } }, "Child 1"),
-            h("span", "Child 2")
-          ])
+          h("div", [h("span", { hook: { destroy: cb } }, "Child 1"), h("span", "Child 2")])
        ]);
        const vnode2 = h("div");
        patch(vnode0, vnode1);
@@ -1150,11 +1042,7 @@ describe("snabbdom", function() {
            }
          }
        ]);
-        const vnode1 = h("div", [
-          h("span", "First child"),
-          "",
-          h("span", "Third child")
-        ]);
+        const vnode1 = h("div", [h("span", "First child"), "", h("span", "Third child")]);
        const vnode2 = h("div");
        patch(vnode0, vnode1);
        patch(vnode1, vnode2);
@@ -1196,10 +1084,7 @@ describe("snabbdom", function() {
      function cb(vnode) {
        result.push(vnode);
      }
-      const vnode1 = h("div", [
-        h("span", { hook: { update: cb } }, "Hello"),
-        h("span", "there")
-      ]);
+      const vnode1 = h("div", [h("span", { hook: { update: cb } }, "Hello"), h("span", "there")]);
      patch(vnode0, vnode1);
      patch(vnode1, vnode1);
      expect(result).toHaveLength(0);
@@ -1,4 +1,9 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
+import {
+  buildData,
+  startMeasure,
+  stopMeasure,
+  formatNumber
+} from "../shared/utils.js";

 odoo.define("app", function(require) {
  const Widget = require("web.Widget");
@@ -97,14 +102,23 @@ odoo.define("app", function(require) {
      "click .o_btn_msg.10000": function() {
        this.addMessages(10000);
      },
-      "click .o_btn_msg.50000": function() {
-        this.addMessages(50000);
+      "click .o_btn_msg.30000": function() {
+        this.addMessages(30000);
      },
      "click .updateSomeMessages": function() {
        this.updateSomeMessages();
      },
      "click .clear": function() {
        this.clear();
+      },
+      "click .o_multiple": function() {
+        this.multipleFlag = !this.multipleFlag;
+      },
+      "click .o_clear": function() {
+        this.clearFlag = !this.clearFlag;
+      },
+      "click .clear-log": function() {
+        this.$log[0].innerHTML = "";
      }
    },
    custom_events: {
@@ -116,11 +130,15 @@ odoo.define("app", function(require) {
      this.widgets = {};
      this.isInDom = false;
      this.messageCount = 0;
+      this.multipleFlag = false;
+      this.clearFlag = false;
    },

    start: function() {
      this.$content = this.$(".content");
      this.$msgCount = this.$(".message_count");
+      this.$log = this.$(".log-content");
+      this.log("Benchmarking odoo widgets, 12.0");
    },
    on_attach_callback: function() {
      this.isInDom = true;
@@ -144,34 +162,41 @@ odoo.define("app", function(require) {
    },

    addMessages: function(n) {
-      var self = this;
-      startMeasure("add " + n);
-      const defs = [];
-      const messages = buildData(n);
-      for (let message of messages) {
-        const widget = new Message(this, message);
-        this.widgets[message.id] = widget;
-        defs.push(widget.appendTo("<div>"));
-      }
-      $.when
-        .apply($, defs)
-        .then(function() {
-          for (let message of messages) {
-            let widget = self.widgets[message.id];
-            dom.append(self.$content, widget.$el, {
-              in_DOM: this.isInDom,
-              callbacks: [{ widget: widget }]
-            });
-          }
-        })
-        .then(function() {
-          self.messageCount += n;
-          self.updateMessageCount();
-          stopMeasure();
-        });
+      const self = this;
+      this.benchmark("add " + n, () => {
+        const defs = [];
+        const messages = buildData(n);
+        for (let message of messages) {
+          const widget = new Message(this, message);
+          this.widgets[message.id] = widget;
+          defs.push(widget.appendTo("<div>"));
+        }
+        return $.when
+          .apply($, defs)
+          .then(function() {
+            for (let message of messages) {
+              let widget = self.widgets[message.id];
+              dom.append(self.$content, widget.$el, {
+                in_DOM: this.isInDom,
+                callbacks: [{ widget: widget }]
+              });
+            }
+          })
+          .then(function() {
+            self.messageCount += n;
+            self.updateMessageCount();
+          });
+      });
    },
    clear: function() {
      startMeasure("clear");
+      this._clear();
+      stopMeasure(info => {
+        this.log(info.msg);
+      });
+    },
+
+    _clear: function() {
      this.$content.empty();
      for (let key in this.widgets) {
        this.widgets[key].destroy();
@@ -179,15 +204,14 @@ odoo.define("app", function(require) {
      }
      this.messageCount = 0;
      this.updateMessageCount();
-      stopMeasure();
    },
    updateSomeMessages: function() {
-      startMeasure("update every 10th");
-      const widgets = Object.values(this.widgets);
-      for (let i = 0; i < widgets.length; i += 10) {
-        widgets[i].update();
-      }
-      stopMeasure();
+      this.benchmark("update every 10th", () => {
+        const widgets = Object.values(this.widgets);
+        for (let i = 0; i < widgets.length; i += 10) {
+          widgets[i].update();
+        }
+      });
    },
    _onRemoveMessage: function(ev) {
      startMeasure("remove message");
@@ -196,6 +220,65 @@ odoo.define("app", function(require) {
      this.messageCount--;
      this.updateMessageCount();
      stopMeasure();
+    },
+
+    benchmark: function(message, fn, callback) {
+      if (this.multipleFlag) {
+        const N = 20;
+        let n = N;
+        let total = 0;
+        let cb = info => {
+          let finalize = () => {
+            n--;
+            total += info.delta;
+            if (n === 0) {
+              const avg = total / N;
+              this.log(`Average: ${formatNumber(avg)}ms`, true);
+              if (callback) {
+                callback();
+              }
+            } else {
+              this._benchmark(message, fn, cb);
+            }
+          };
+
+          if (this.clearFlag) {
+            this._benchmark("clear", this._clear.bind(this), finalize, false);
+          } else {
+            finalize();
+          }
+        };
+        this._benchmark(message, fn, cb);
+      } else {
+        this._benchmark(message, fn, callback);
+      }
+    },
+
+    _benchmark: function(message, fn, cb, log = true) {
+      setTimeout(() => {
+        startMeasure(message);
+        const benchmark = fn();
+        (benchmark && benchmark.then ? benchmark : $.when()).then(() => {
+          stopMeasure(info => {
+            if (log) {
+              this.log(info.msg);
+            }
+            if (cb) {
+              cb(info);
+            }
+          });
+        }, 10);
+      });
+    },
+
+    log: function(str, isBold) {
+      const div = document.createElement("div");
+      if (isBold) {
+        div.classList.add("bold");
+      }
+      div.textContent = `> ${str}`;
+      this.$log[0].appendChild(div);
+      this.$log[0].scrollTop = this.$log[0].scrollHeight;
    }
  });

@@ -0,0 +1,47 @@
+<templates>
+    <div class="main" t-name="root">
+        <div class="left-thing">
+            <div class="title">Actions</div>
+            <div class="panel">
+                <button class="o_btn_msg 100">Add 100 messages</button>
+                <button class="o_btn_msg 1000">Add 1k messages</button>
+                <button class="o_btn_msg 10000">Add 10k messages</button>
+                <button class="o_btn_msg 30000">Add 30k messages</button>
+                <button class="updateSomeMessages">Update every 10th message</button>
+                <button class="clear">Clear</button>
+            </div>
+            <div class="flags">
+                <div>
+                    <input type="checkbox" class="o_multiple" id="multipleflag" />
+                    <label for="multipleflag">Do it 20x</label>
+                </div>
+                <div>
+                    <input type="checkbox" class="o_clear" id="clearFlag" />
+                    <label for="clearFlag">Clear after</label>
+                </div>
+            </div>
+            <div class="info message_count">
+                Number of messages: 0
+            </div>
+            <div class="title">Log <span class="clear-log">(clear)</span></div>
+            <div class="log">
+                <div class="log-content"/>
+            </div>
+        </div>
+        <div class="right-thing">
+            <div class="content">
+            </div>
+        </div>
+    </div>
+
+    <div t-name="message" class="message">
+        <span class="author"><t t-esc="widget.author"/></span>
+        <span class="msg"><t t-esc="widget.msg"/></span>
+        <button class="remove">Remove</button>
+    </div>
+
+  <div t-name="counter">
+    <button class="o_increment"></button>
+  </div>
+
+</templates>
@@ -1,4 +1,9 @@
-import { buildData, startMeasure, stopMeasure } from "../shared/utils.js";
+import {
+  buildData,
+  startMeasure,
+  stopMeasure,
+  formatNumber
+} from "../shared/utils.js";

 odoo.define("app", function(require) {
  const Widget = require("web.Widget");
@@ -97,14 +102,23 @@ odoo.define("app", function(require) {
      "click .o_btn_msg.10000": function() {
        this.addMessages(10000);
      },
-      "click .o_btn_msg.50000": function() {
-        this.addMessages(50000);
+      "click .o_btn_msg.30000": function() {
+        this.addMessages(30000);
      },
      "click .updateSomeMessages": function() {
        this.updateSomeMessages();
      },
      "click .clear": function() {
        this.clear();
+      },
+      "click .o_multiple": function() {
+        this.multipleFlag = !this.multipleFlag;
+      },
+      "click .o_clear": function() {
+        this.clearFlag = !this.clearFlag;
+      },
+      "click .clear-log": function() {
+        this.$log[0].innerHTML = "";
      }
    },
    custom_events: {
@@ -116,11 +130,15 @@ odoo.define("app", function(require) {
      this.widgets = {};
      this.isInDom = false;
      this.messageCount = 0;
+      this.multipleFlag = false;
+      this.clearFlag = false;
    },

    start: function() {
      this.$content = this.$(".content");
      this.$msgCount = this.$(".message_count");
+      this.$log = this.$(".log-content");
+      this.log("Benchmarking odoo widgets, 12.3");
    },
    on_attach_callback: function() {
      this.isInDom = true;
@@ -144,34 +162,41 @@ odoo.define("app", function(require) {
    },

    addMessages: function(n) {
-      var self = this;
-      startMeasure("add " + n);
-      const defs = [];
-      const messages = buildData(n);
-      for (let message of messages) {
-        const widget = new Message(this, message);
-        this.widgets[message.id] = widget;
-        defs.push(widget.appendTo("<div>"));
-      }
-      $.when
-        .apply($, defs)
-        .then(function() {
-          for (let message of messages) {
-            let widget = self.widgets[message.id];
-            dom.append(self.$content, widget.$el, {
-              in_DOM: this.isInDom,
-              callbacks: [{ widget: widget }]
-            });
-          }
-        })
-        .then(function() {
-          self.messageCount += n;
-          self.updateMessageCount();
-          stopMeasure();
-        });
+      const self = this;
+      this.benchmark("add " + n, () => {
+        const defs = [];
+        const messages = buildData(n);
+        for (let message of messages) {
+          const widget = new Message(this, message);
+          this.widgets[message.id] = widget;
+          defs.push(widget.appendTo("<div>"));
+        }
+        return $.when
+          .apply($, defs)
+          .then(function() {
+            for (let message of messages) {
+              let widget = self.widgets[message.id];
+              dom.append(self.$content, widget.$el, {
+                in_DOM: this.isInDom,
+                callbacks: [{ widget: widget }]
+              });
+            }
+          })
+          .then(function() {
+            self.messageCount += n;
+            self.updateMessageCount();
+          });
+      });
    },
    clear: function() {
      startMeasure("clear");
+      this._clear();
+      stopMeasure(info => {
+        this.log(info.msg);
+      });
+    },
+
+    _clear: function() {
      this.$content.empty();
      for (let key in this.widgets) {
        this.widgets[key].destroy();
@@ -179,15 +204,14 @@ odoo.define("app", function(require) {
      }
      this.messageCount = 0;
      this.updateMessageCount();
-      stopMeasure();
    },
    updateSomeMessages: function() {
-      startMeasure("update every 10th");
-      const widgets = Object.values(this.widgets);
-      for (let i = 0; i < widgets.length; i += 10) {
-        widgets[i].update();
-      }
-      stopMeasure();
+      this.benchmark("update every 10th", () => {
+        const widgets = Object.values(this.widgets);
+        for (let i = 0; i < widgets.length; i += 10) {
+          widgets[i].update();
+        }
+      });
    },
    _onRemoveMessage: function(ev) {
      startMeasure("remove message");
@@ -196,6 +220,65 @@ odoo.define("app", function(require) {
      this.messageCount--;
      this.updateMessageCount();
      stopMeasure();
+    },
+
+    benchmark: function(message, fn, callback) {
+      if (this.multipleFlag) {
+        const N = 20;
+        let n = N;
+        let total = 0;
+        let cb = info => {
+          let finalize = () => {
+            n--;
+            total += info.delta;
+            if (n === 0) {
+              const avg = total / N;
+              this.log(`Average: ${formatNumber(avg)}ms`, true);
+              if (callback) {
+                callback();
+              }
+            } else {
+              this._benchmark(message, fn, cb);
+            }
+          };
+
+          if (this.clearFlag) {
+            this._benchmark("clear", this._clear.bind(this), finalize, false);
+          } else {
+            finalize();
+          }
+        };
+        this._benchmark(message, fn, cb);
+      } else {
+        this._benchmark(message, fn, callback);
+      }
+    },
+
+    _benchmark: function(message, fn, cb, log = true) {
+      setTimeout(() => {
+        startMeasure(message);
+        const benchmark = fn();
+        (benchmark && benchmark.then ? benchmark : $.when()).then(() => {
+          stopMeasure(info => {
+            if (log) {
+              this.log(info.msg);
+            }
+            if (cb) {
+              cb(info);
+            }
+          });
+        }, 10);
+      });
+    },
+
+    log: function(str, isBold) {
+      const div = document.createElement("div");
+      if (isBold) {
+        div.classList.add("bold");
+      }
+      div.textContent = `> ${str}`;
+      this.$log[0].appendChild(div);
+      this.$log[0].scrollTop = this.$log[0].scrollHeight;
    }
  });

@@ -0,0 +1,47 @@
+<templates>
+    <div class="main" t-name="root">
+        <div class="left-thing">
+            <div class="title">Actions</div>
+            <div class="panel">
+                <button class="o_btn_msg 100">Add 100 messages</button>
+                <button class="o_btn_msg 1000">Add 1k messages</button>
+                <button class="o_btn_msg 10000">Add 10k messages</button>
+                <button class="o_btn_msg 30000">Add 30k messages</button>
+                <button class="updateSomeMessages">Update every 10th message</button>
+                <button class="clear">Clear</button>
+            </div>
+            <div class="flags">
+                <div>
+                    <input type="checkbox" class="o_multiple" id="multipleflag" />
+                    <label for="multipleflag">Do it 20x</label>
+                </div>
+                <div>
+                    <input type="checkbox" class="o_clear" id="clearFlag" />
+                    <label for="clearFlag">Clear after</label>
+                </div>
+            </div>
+            <div class="info message_count">
+                Number of messages: 0
+            </div>
+            <div class="title">Log <span class="clear-log">(clear)</span></div>
+            <div class="log">
+                <div class="log-content"/>
+            </div>
+        </div>
+        <div class="right-thing">
+            <div class="content">
+            </div>
+        </div>
+    </div>
+
+    <div t-name="message" class="message">
+        <span class="author"><t t-esc="widget.author"/></span>
+        <span class="msg"><t t-esc="widget.msg"/></span>
+        <button class="remove">Remove</button>
+    </div>
+
+  <div t-name="counter">
+    <button class="o_increment"></button>
+  </div>
+
+</templates>
@@ -0,0 +1,173 @@
+import {
+  buildData,
+  startMeasure,
+  stopMeasure,
+  formatNumber
+} from "../shared/utils.js";
+
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = { counter: 0 };
+  template = "Counter";
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  widgets = { Counter };
+  template = "Message";
+
+  shouldUpdate(nextProps) {
+    return nextProps !== this.props;
+  }
+  removeMessage() {
+    this.trigger("remove_message", {
+      id: this.props.id
+    });
+  }
+}
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  widgets = { Message };
+  state = { messages: [], multipleFlag: false, clearAfterFlag: false };
+  template = "App";
+
+  mounted() {
+    this.log(
+      `Benchmarking Owl v${owl._version} (build date: ${
+        owl._date
+      })`
+    );
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this._benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < this.state.messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        this.set(messages, i, msg);
+      }
+    });
+  }
+
+  removeMessage(data) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === data.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.refs.log.appendChild(div);
+    this.refs.log.scrollTop = this.refs.log.scrollHeight;
+  }
+
+  clearLog() {
+    this.refs.log.innerHTML = "";
+  }
+
+  toggleMultiple() {
+    this.state.multipleFlag = !this.state.multipleFlag;
+  }
+
+  toggleClear() {
+    this.state.clearAfterFlag = !this.state.clearAfterFlag;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const env = {
+    qweb: new owl.QWeb(templates)
+  };
+  const app = new App(env);
+  app.mount(document.body);
+}
+
+start();
@@ -0,0 +1,50 @@
+<templates>
+  <div t-name="App" class="main">
+      <div class="left-thing">
+        <div class="title">Actions</div>
+        <div class="panel">
+          <button t-on-click="addMessages(100)">Add 100 messages</button>
+          <button t-on-click="addMessages(1000)">Add 1k messages</button>
+          <button t-on-click="addMessages(10000)">Add 10k messages</button>
+          <button t-on-click="addMessages(30000)">Add 30k messages</button>
+          <button t-on-click="updateSomeMessages">Update every 10th messages</button>
+          <button t-on-click="clear">Clear</button>
+        </div>
+        <div class="flags">
+            <div>
+                <input type="checkbox" id="multipleflag" t-on-change="toggleMultiple" t-att-checked="state.multipleFlag"/>
+                <label for="multipleflag">Do it 20x</label>
+            </div>
+            <div>
+                <input type="checkbox" id="clearFlag" t-on-change="toggleClear"  t-att-checked="state.clearAfterFlag"/>
+                <label for="clearFlag">Clear after</label>
+            </div>
+        </div>
+        <div class="info">Number of messages: <t t-esc="state.messages.length"/></div>
+        <hr/>
+        <div class="title">Log <span class="clear-log" t-on-click="clearLog">(clear)</span></div>
+        <div class="log">
+            <div class="log-content" t-ref="'log'"/>
+        </div>
+      </div>
+      <div class="right-thing">
+          <div class="content" t-on-remove-message="removeMessage">
+              <t t-foreach="state.messages" t-as="message">
+                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
+              </t>
+          </div>
+      </div>
+  </div>
+
+  <div t-name="Message" class="message">
+    <span class="author"><t t-esc="props.author"/></span>
+    <span class="msg"><t t-esc="props.msg"/></span>
+    <button class="remove" t-on-click="removeMessage">Remove</button>
+    <t t-widget="Counter"/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>
@@ -0,0 +1,170 @@
+import {
+  buildData,
+  startMeasure,
+  stopMeasure,
+  formatNumber
+} from "../shared/utils.js";
+
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = { counter: 0 };
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  widgets = { Counter };
+
+  shouldUpdate(nextProps) {
+    return nextProps !== this.props;
+  }
+  removeMessage() {
+    this.trigger("remove_message", {
+      id: this.props.id
+    });
+  }
+}
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  widgets = { Message };
+  state = { messages: [], multipleFlag: false, clearAfterFlag: false };
+
+  mounted() {
+    this.log(
+      `Benchmarking Owl v${owl._version} (build date: ${
+        owl._date
+      })`
+    );
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this._benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < this.state.messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        this.set(messages, i, msg);
+      }
+    });
+  }
+
+  removeMessage(data) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === data.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.refs.log.appendChild(div);
+    this.refs.log.scrollTop = this.refs.log.scrollHeight;
+  }
+
+  clearLog() {
+    this.refs.log.innerHTML = "";
+  }
+
+  toggleMultiple() {
+    this.state.multipleFlag = !this.state.multipleFlag;
+  }
+
+  toggleClear() {
+    this.state.clearAfterFlag = !this.state.clearAfterFlag;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const env = {
+    qweb: new owl.QWeb(templates)
+  };
+  const app = new App(env);
+  app.mount(document.body);
+}
+
+start();
@@ -0,0 +1,50 @@
+<templates>
+  <div t-name="App" class="main">
+      <div class="left-thing">
+        <div class="title">Actions</div>
+        <div class="panel">
+          <button t-on-click="addMessages(100)">Add 100 messages</button>
+          <button t-on-click="addMessages(1000)">Add 1k messages</button>
+          <button t-on-click="addMessages(10000)">Add 10k messages</button>
+          <button t-on-click="addMessages(30000)">Add 30k messages</button>
+          <button t-on-click="updateSomeMessages">Update every 10th messages</button>
+          <button t-on-click="clear">Clear</button>
+        </div>
+        <div class="flags">
+            <div>
+                <input type="checkbox" id="multipleflag" t-on-change="toggleMultiple" t-att-checked="state.multipleFlag"/>
+                <label for="multipleflag">Do it 20x</label>
+            </div>
+            <div>
+                <input type="checkbox" id="clearFlag" t-on-change="toggleClear"  t-att-checked="state.clearAfterFlag"/>
+                <label for="clearFlag">Clear after</label>
+            </div>
+        </div>
+        <div class="info">Number of messages: <t t-esc="state.messages.length"/></div>
+        <hr/>
+        <div class="title">Log <span class="clear-log" t-on-click="clearLog">(clear)</span></div>
+        <div class="log">
+            <div class="log-content" t-ref="'log'"/>
+        </div>
+      </div>
+      <div class="right-thing">
+          <div class="content" t-on-remove-message="removeMessage">
+              <t t-foreach="state.messages" t-as="message">
+                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
+              </t>
+          </div>
+      </div>
+  </div>
+
+  <div t-name="Message" class="message">
+    <span class="author"><t t-esc="props.author"/></span>
+    <span class="msg"><t t-esc="props.msg"/></span>
+    <button class="remove" t-on-click="removeMessage">Remove</button>
+    <t t-widget="Counter"/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>
@@ -0,0 +1,170 @@
+import {
+  buildData,
+  startMeasure,
+  stopMeasure,
+  formatNumber
+} from "../shared/utils.js";
+
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = { counter: 0 };
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  widgets = { Counter };
+
+  shouldUpdate(nextProps) {
+    return nextProps !== this.props;
+  }
+  removeMessage() {
+    this.trigger("remove_message", {
+      id: this.props.id
+    });
+  }
+}
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  widgets = { Message };
+  state = { messages: [], multipleFlag: false, clearAfterFlag: false };
+
+  mounted() {
+    this.log(
+      `Benchmarking Owl v${owl.__info__.version} (build date: ${
+        owl.__info__.date
+      })`
+    );
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this.benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < this.state.messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        this.set(messages, i, msg);
+      }
+    });
+  }
+
+  removeMessage(data) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === data.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.refs.log.appendChild(div);
+    this.refs.log.scrollTop = this.refs.log.scrollHeight;
+  }
+
+  clearLog() {
+    this.refs.log.innerHTML = "";
+  }
+
+  toggleMultiple() {
+    this.state.multipleFlag = !this.state.multipleFlag;
+  }
+
+  toggleClear() {
+    this.state.clearAfterFlag = !this.state.clearAfterFlag;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const env = {
+    qweb: new owl.QWeb(templates)
+  };
+  const app = new App(env);
+  app.mount(document.body);
+}
+
+start();
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OWL 0.12.0 Benchmark</title>
+  <link href="../shared/main.css" rel="stylesheet"/>
+  <script src='owl.js'></script>
+</head>
+<body>
+  <div id='main'></div>
+  <script src='app.js' type="module"></script>
+</body>
+</html>
@@ -0,0 +1,50 @@
+<templates>
+  <div t-name="App" class="main">
+      <div class="left-thing">
+        <div class="title">Actions</div>
+        <div class="panel">
+          <button t-on-click="addMessages(100)">Add 100 messages</button>
+          <button t-on-click="addMessages(1000)">Add 1k messages</button>
+          <button t-on-click="addMessages(10000)">Add 10k messages</button>
+          <button t-on-click="addMessages(30000)">Add 30k messages</button>
+          <button t-on-click="updateSomeMessages">Update every 10th messages</button>
+          <button t-on-click="clear">Clear</button>
+        </div>
+        <div class="flags">
+            <div>
+                <input type="checkbox" id="multipleflag" t-on-change="toggleMultiple" t-att-checked="state.multipleFlag"/>
+                <label for="multipleflag">Do it 20x</label>
+            </div>
+            <div>
+                <input type="checkbox" id="clearFlag" t-on-change="toggleClear"  t-att-checked="state.clearAfterFlag"/>
+                <label for="clearFlag">Clear after</label>
+            </div>
+        </div>
+        <div class="info">Number of messages: <t t-esc="state.messages.length"/></div>
+        <hr/>
+        <div class="title">Log <span class="clear-log" t-on-click="clearLog">(clear)</span></div>
+        <div class="log">
+            <div class="log-content" t-ref="log"/>
+        </div>
+      </div>
+      <div class="right-thing">
+          <div class="content" t-on-remove-message="removeMessage">
+              <t t-foreach="state.messages" t-as="message">
+                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
+              </t>
+          </div>
+      </div>
+  </div>
+
+  <div t-name="Message" class="message">
+    <span class="author"><t t-esc="props.author"/></span>
+    <span class="msg"><t t-esc="props.msg"/></span>
+    <button class="remove" t-on-click="removeMessage">Remove</button>
+    <t t-widget="Counter"/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>
@@ -0,0 +1,161 @@
+import { buildData, startMeasure, stopMeasure, formatNumber } from "../shared/utils.js";
+
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = { counter: 0 };
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  widgets = { Counter };
+
+  shouldUpdate(nextProps) {
+    return nextProps.message !== this.props.message;
+  }
+  removeMessage() {
+    this.trigger("remove-message", {
+      id: this.props.message.id
+    });
+  }
+}
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  widgets = { Message };
+  state = { messages: [], multipleFlag: false, clearAfterFlag: false };
+
+  mounted() {
+    this.log(`Benchmarking Owl v${owl.__info__.version} (build date: ${owl.__info__.date})`);
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this._benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < this.state.messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        this.set(messages, i, msg);
+      }
+    });
+  }
+
+  removeMessage(event) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === event.detail.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.refs.log.appendChild(div);
+    this.refs.log.scrollTop = this.refs.log.scrollHeight;
+  }
+
+  clearLog() {
+    this.refs.log.innerHTML = "";
+  }
+
+  toggleMultiple() {
+    this.state.multipleFlag = !this.state.multipleFlag;
+  }
+
+  toggleClear() {
+    this.state.clearAfterFlag = !this.state.clearAfterFlag;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const env = {
+    qweb: new owl.QWeb(templates)
+  };
+  const app = new App(env);
+  app.mount(document.body);
+}
+
+start();
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OWL 0.13.0 Benchmark</title>
+  <link href="../shared/main.css" rel="stylesheet"/>
+  <script src='owl.js'></script>
+</head>
+<body>
+  <div id='main'></div>
+  <script src='app.js' type="module"></script>
+</body>
+</html>
@@ -0,0 +1,50 @@
+<templates>
+  <div t-name="App" class="main">
+      <div class="left-thing">
+        <div class="title">Actions</div>
+        <div class="panel">
+          <button t-on-click="addMessages(100)">Add 100 messages</button>
+          <button t-on-click="addMessages(1000)">Add 1k messages</button>
+          <button t-on-click="addMessages(10000)">Add 10k messages</button>
+          <button t-on-click="addMessages(30000)">Add 30k messages</button>
+          <button t-on-click="updateSomeMessages">Update every 10th messages</button>
+          <button t-on-click="clear">Clear</button>
+        </div>
+        <div class="flags">
+            <div>
+                <input type="checkbox" id="multipleflag" t-on-change="toggleMultiple" t-att-checked="state.multipleFlag"/>
+                <label for="multipleflag">Do it 20x</label>
+            </div>
+            <div>
+                <input type="checkbox" id="clearFlag" t-on-change="toggleClear"  t-att-checked="state.clearAfterFlag"/>
+                <label for="clearFlag">Clear after</label>
+            </div>
+        </div>
+        <div class="info">Number of messages: <t t-esc="state.messages.length"/></div>
+        <hr/>
+        <div class="title">Log <span class="clear-log" t-on-click="clearLog">(clear)</span></div>
+        <div class="log">
+            <div class="log-content" t-ref="log"/>
+        </div>
+      </div>
+      <div class="right-thing">
+          <div class="content" t-on-remove-message="removeMessage">
+              <t t-foreach="state.messages" t-as="message">
+                  <t t-widget="Message" t-key="message.id" message="message"/>
+              </t>
+          </div>
+      </div>
+  </div>
+
+  <div t-name="Message" class="message">
+    <span class="author"><t t-esc="props.message.author"/></span>
+    <span class="msg"><t t-esc="props.message.msg"/></span>
+    <button class="remove" t-on-click="removeMessage">Remove</button>
+    <t t-widget="Counter"/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>
@@ -0,0 +1,161 @@
+import { buildData, startMeasure, stopMeasure, formatNumber } from "../shared/utils.js";
+
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = { counter: 0 };
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  widgets = { Counter };
+
+  shouldUpdate(nextProps) {
+    return nextProps.message !== this.props.message;
+  }
+  removeMessage() {
+    this.trigger("remove-message", {
+      id: this.props.message.id
+    });
+  }
+}
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  widgets = { Message };
+  state = { messages: [], multipleFlag: false, clearAfterFlag: false };
+
+  mounted() {
+    this.log(`Benchmarking Owl v${owl.__info__.version} (build date: ${owl.__info__.date})`);
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this._benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < this.state.messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        this.set(messages, i, msg);
+      }
+    });
+  }
+
+  removeMessage(event) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === event.detail.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.refs.log.appendChild(div);
+    this.refs.log.scrollTop = this.refs.log.scrollHeight;
+  }
+
+  clearLog() {
+    this.refs.log.innerHTML = "";
+  }
+
+  toggleMultiple() {
+    this.state.multipleFlag = !this.state.multipleFlag;
+  }
+
+  toggleClear() {
+    this.state.clearAfterFlag = !this.state.clearAfterFlag;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const env = {
+    qweb: new owl.QWeb(templates)
+  };
+  const app = new App(env);
+  app.mount(document.body);
+}
+
+start();
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OWL 0.14.0 Benchmark</title>
+  <link href="../shared/main.css" rel="stylesheet"/>
+  <script src='owl.js'></script>
+</head>
+<body>
+  <div id='main'></div>
+  <script src='app.js' type="module"></script>
+</body>
+</html>
@@ -0,0 +1,50 @@
+<templates>
+  <div t-name="App" class="main">
+      <div class="left-thing">
+        <div class="title">Actions</div>
+        <div class="panel">
+          <button t-on-click="addMessages(100)">Add 100 messages</button>
+          <button t-on-click="addMessages(1000)">Add 1k messages</button>
+          <button t-on-click="addMessages(10000)">Add 10k messages</button>
+          <button t-on-click="addMessages(30000)">Add 30k messages</button>
+          <button t-on-click="updateSomeMessages">Update every 10th messages</button>
+          <button t-on-click="clear">Clear</button>
+        </div>
+        <div class="flags">
+            <div>
+                <input type="checkbox" id="multipleflag" t-on-change="toggleMultiple" t-att-checked="state.multipleFlag"/>
+                <label for="multipleflag">Do it 20x</label>
+            </div>
+            <div>
+                <input type="checkbox" id="clearFlag" t-on-change="toggleClear"  t-att-checked="state.clearAfterFlag"/>
+                <label for="clearFlag">Clear after</label>
+            </div>
+        </div>
+        <div class="info">Number of messages: <t t-esc="state.messages.length"/></div>
+        <hr/>
+        <div class="title">Log <span class="clear-log" t-on-click="clearLog">(clear)</span></div>
+        <div class="log">
+            <div class="log-content" t-ref="log"/>
+        </div>
+      </div>
+      <div class="right-thing">
+          <div class="content" t-on-remove-message="removeMessage">
+              <t t-foreach="state.messages" t-as="message">
+                  <t t-widget="Message" t-key="message.id" message="message"/>
+              </t>
+          </div>
+      </div>
+  </div>
+
+  <div t-name="Message" class="message">
+    <span class="author"><t t-esc="props.message.author"/></span>
+    <span class="msg"><t t-esc="props.message.msg"/></span>
+    <button class="remove" t-on-click="removeMessage">Remove</button>
+    <t t-widget="Counter"/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>
@@ -0,0 +1,161 @@
+import { buildData, startMeasure, stopMeasure, formatNumber } from "../shared/utils.js";
+
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = { counter: 0 };
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  widgets = { Counter };
+
+  shouldUpdate(nextProps) {
+    return nextProps.message !== this.props.message;
+  }
+  removeMessage() {
+    this.trigger("remove-message", {
+      id: this.props.message.id
+    });
+  }
+}
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  widgets = { Message };
+  state = { messages: [], multipleFlag: false, clearAfterFlag: false };
+
+  mounted() {
+    this.log(`Benchmarking Owl v${owl.__info__.version} (build date: ${owl.__info__.date})`);
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this._benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < this.state.messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        this.set(messages, i, msg);
+      }
+    });
+  }
+
+  removeMessage(event) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === event.detail.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.refs.log.appendChild(div);
+    this.refs.log.scrollTop = this.refs.log.scrollHeight;
+  }
+
+  clearLog() {
+    this.refs.log.innerHTML = "";
+  }
+
+  toggleMultiple() {
+    this.state.multipleFlag = !this.state.multipleFlag;
+  }
+
+  toggleClear() {
+    this.state.clearAfterFlag = !this.state.clearAfterFlag;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const env = {
+    qweb: new owl.QWeb(templates)
+  };
+  const app = new App(env);
+  app.mount(document.body);
+}
+
+start();
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OWL 0.15.0 Benchmark</title>
+  <link href="../shared/main.css" rel="stylesheet"/>
+  <script src='owl.js'></script>
+</head>
+<body>
+  <div id='main'></div>
+  <script src='app.js' type="module"></script>
+</body>
+</html>
@@ -0,0 +1,50 @@
+<templates>
+  <div t-name="App" class="main">
+      <div class="left-thing">
+        <div class="title">Actions</div>
+        <div class="panel">
+          <button t-on-click="addMessages(100)">Add 100 messages</button>
+          <button t-on-click="addMessages(1000)">Add 1k messages</button>
+          <button t-on-click="addMessages(10000)">Add 10k messages</button>
+          <button t-on-click="addMessages(30000)">Add 30k messages</button>
+          <button t-on-click="updateSomeMessages">Update every 10th messages</button>
+          <button t-on-click="clear">Clear</button>
+        </div>
+        <div class="flags">
+            <div>
+                <input type="checkbox" id="multipleflag" t-on-change="toggleMultiple" t-att-checked="state.multipleFlag"/>
+                <label for="multipleflag">Do it 20x</label>
+            </div>
+            <div>
+                <input type="checkbox" id="clearFlag" t-on-change="toggleClear"  t-att-checked="state.clearAfterFlag"/>
+                <label for="clearFlag">Clear after</label>
+            </div>
+        </div>
+        <div class="info">Number of messages: <t t-esc="state.messages.length"/></div>
+        <hr/>
+        <div class="title">Log <span class="clear-log" t-on-click="clearLog">(clear)</span></div>
+        <div class="log">
+            <div class="log-content" t-ref="log"/>
+        </div>
+      </div>
+      <div class="right-thing">
+          <div class="content" t-on-remove-message="removeMessage">
+              <t t-foreach="state.messages" t-as="message">
+                  <t t-widget="Message" t-key="message.id" message="message"/>
+              </t>
+          </div>
+      </div>
+  </div>
+
+  <div t-name="Message" class="message">
+    <span class="author"><t t-esc="props.message.author"/></span>
+    <span class="msg"><t t-esc="props.message.msg"/></span>
+    <button class="remove" t-on-click="removeMessage">Remove</button>
+    <t t-widget="Counter"/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>
@@ -0,0 +1,173 @@
+import {
+  buildData,
+  startMeasure,
+  stopMeasure,
+  formatNumber
+} from "../shared/utils.js";
+
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = { counter: 0 };
+  template = "Counter";
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  widgets = { Counter };
+  template = "Message";
+
+  shouldUpdate(nextProps) {
+    return nextProps !== this.props;
+  }
+  removeMessage() {
+    this.trigger("remove_message", {
+      id: this.props.id
+    });
+  }
+}
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  widgets = { Message };
+  state = { messages: [], multipleFlag: false, clearAfterFlag: false };
+  template = "App";
+
+  mounted() {
+    this.log(
+      `Benchmarking Owl v${owl._version} (build date: ${
+        owl._date
+      })`
+    );
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this._benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < this.state.messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        this.set(messages, i, msg);
+      }
+    });
+  }
+
+  removeMessage(data) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === data.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.refs.log.appendChild(div);
+    this.refs.log.scrollTop = this.refs.log.scrollHeight;
+  }
+
+  clearLog() {
+    this.refs.log.innerHTML = "";
+  }
+
+  toggleMultiple() {
+    this.state.multipleFlag = !this.state.multipleFlag;
+  }
+
+  toggleClear() {
+    this.state.clearAfterFlag = !this.state.clearAfterFlag;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const env = {
+    qweb: new owl.QWeb(templates)
+  };
+  const app = new App(env);
+  app.mount(document.body);
+}
+
+start();
@@ -0,0 +1,50 @@
+<templates>
+  <div t-name="App" class="main">
+      <div class="left-thing">
+        <div class="title">Actions</div>
+        <div class="panel">
+          <button t-on-click="addMessages(100)">Add 100 messages</button>
+          <button t-on-click="addMessages(1000)">Add 1k messages</button>
+          <button t-on-click="addMessages(10000)">Add 10k messages</button>
+          <button t-on-click="addMessages(30000)">Add 30k messages</button>
+          <button t-on-click="updateSomeMessages">Update every 10th messages</button>
+          <button t-on-click="clear">Clear</button>
+        </div>
+        <div class="flags">
+            <div>
+                <input type="checkbox" id="multipleflag" t-on-change="toggleMultiple" t-att-checked="state.multipleFlag"/>
+                <label for="multipleflag">Do it 20x</label>
+            </div>
+            <div>
+                <input type="checkbox" id="clearFlag" t-on-change="toggleClear"  t-att-checked="state.clearAfterFlag"/>
+                <label for="clearFlag">Clear after</label>
+            </div>
+        </div>
+        <div class="info">Number of messages: <t t-esc="state.messages.length"/></div>
+        <hr/>
+        <div class="title">Log <span class="clear-log" t-on-click="clearLog">(clear)</span></div>
+        <div class="log">
+            <div class="log-content" t-ref="'log'"/>
+        </div>
+      </div>
+      <div class="right-thing">
+          <div class="content" t-on-remove-message="removeMessage">
+              <t t-foreach="state.messages" t-as="message">
+                  <t t-widget="Message" t-key="message.id" t-props="message" t-on-remove_message="removeMessage"/>
+              </t>
+          </div>
+      </div>
+  </div>
+
+  <div t-name="Message" class="message">
+    <span class="author"><t t-esc="props.author"/></span>
+    <span class="msg"><t t-esc="props.msg"/></span>
+    <button class="remove" t-on-click="removeMessage">Remove</button>
+    <t t-widget="Counter"/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>
@@ -0,0 +1,173 @@
+import {
+  buildData,
+  startMeasure,
+  stopMeasure,
+  formatNumber
+} from "../shared/utils.js";
+
+//------------------------------------------------------------------------------
+// Likes Counter Widget
+//------------------------------------------------------------------------------
+class Counter extends owl.Component {
+  state = { counter: 0 };
+  template = "Counter";
+
+  increment() {
+    this.state.counter++;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Message Widget
+//------------------------------------------------------------------------------
+class Message extends owl.Component {
+  widgets = { Counter };
+  template = "Message";
+
+  shouldUpdate(nextProps) {
+    return nextProps !== this.props;
+  }
+  removeMessage() {
+    this.trigger("remove_message", {
+      id: this.props.id
+    });
+  }
+}
+
+//------------------------------------------------------------------------------
+// Root Widget
+//------------------------------------------------------------------------------
+class App extends owl.Component {
+  widgets = { Message };
+  state = { messages: [], multipleFlag: false, clearAfterFlag: false };
+  template = "App";
+
+  mounted() {
+    this.log(
+      `Benchmarking Owl v${owl._version} (build date: ${
+        owl._date
+      })`
+    );
+  }
+
+  benchmark(message, fn, callback) {
+    if (this.state.multipleFlag) {
+      const N = 20;
+      let n = N;
+      let total = 0;
+      let cb = info => {
+        let finalize = () => {
+          n--;
+          total += info.delta;
+          if (n === 0) {
+            const avg = total / N;
+            this.log(`Average: ${formatNumber(avg)}ms`, true);
+            if (callback) {
+              callback();
+            }
+          } else {
+            this._benchmark(message, fn, cb);
+          }
+        };
+
+        if (this.state.clearAfterFlag) {
+          this._benchmark(
+            "clear",
+            () => {
+              this.state.messages = [];
+            },
+            finalize,
+            false
+          );
+        } else {
+          finalize();
+        }
+      };
+      this._benchmark(message, fn, cb);
+    } else {
+      this._benchmark(message, fn, callback);
+    }
+  }
+
+  _benchmark(message, fn, cb, log = true) {
+    setTimeout(() => {
+      startMeasure(message);
+      fn();
+      stopMeasure(info => {
+        if (log) {
+          this.log(info.msg);
+        }
+        if (cb) {
+          cb(info);
+        }
+      });
+    }, 10);
+  }
+
+  addMessages(n) {
+    this.benchmark("add " + n, () => {
+      const newMessages = buildData(n);
+      this.state.messages.push.apply(this.state.messages, newMessages);
+    });
+  }
+
+  clear() {
+    this._benchmark("clear", () => {
+      this.state.messages = [];
+    });
+  }
+
+  updateSomeMessages() {
+    this.benchmark("update every 10th", () => {
+      const messages = this.state.messages;
+      for (let i = 0; i < this.state.messages.length; i += 10) {
+        const msg = Object.assign({}, messages[i]);
+        msg.author += "!!!";
+        this.set(messages, i, msg);
+      }
+    });
+  }
+
+  removeMessage(data) {
+    this.benchmark("remove message", () => {
+      const index = this.state.messages.findIndex(m => m.id === data.id);
+      this.state.messages.splice(index, 1);
+    });
+  }
+
+  log(str, isBold) {
+    const div = document.createElement("div");
+    if (isBold) {
+      div.classList.add("bold");
+    }
+    div.textContent = `> ${str}`;
+    this.refs.log.appendChild(div);
+    this.refs.log.scrollTop = this.refs.log.scrollHeight;
+  }
+
+  clearLog() {
+    this.refs.log.innerHTML = "";
+  }
+
+  toggleMultiple() {
+    this.state.multipleFlag = !this.state.multipleFlag;
+  }
+
+  toggleClear() {
+    this.state.clearAfterFlag = !this.state.clearAfterFlag;
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  const templates = await owl.utils.loadTemplates("templates.xml");
+  const env = {
+    qweb: new owl.QWeb(templates)
+  };
+  const app = new App(env);
+  app.mount(document.body);
+}
+
+start();
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Géry Debongnie	d381e85d94	[REL] bump to v0.16.0	2019-06-28 11:20:29 +02:00
Géry Debongnie	af7520d869	[REF] *: reformat with prettier and printWidth=100 closes #214	2019-06-28 10:33:13 +02:00
Alexandre Kühn	0095bfa61f	[IMP] store: positional arguments with dispatch/commit	2019-06-28 10:12:56 +02:00
Géry Debongnie	1b12cf9b91	[FIX] qweb/component: better handling of class attribute This changes requires using the class module of vdom. closes #192	2019-06-28 09:49:41 +02:00
Géry Debongnie	dbfc7e4acd	[FIX] store/connect: fix bugs with parent/child connected There were big issues when we use parent/child connected widgets. - children was rendered twice (and mapStoreToProps was called twice) - if children was supposed to be destroyed, it was rendered once. We solve them in this commit by waiting for parent widgets to be ready before updating children. closes #216	2019-06-28 09:45:43 +02:00
Pierre Paridans	e838e879c0	[FIX] qweb: add missing not equals operators Implement "!=" and "!==" operator support in QWeb.	2019-06-26 16:14:32 +02:00
Géry Debongnie	ee63f6bb0f	[IMP] playground: log error in console	2019-06-26 15:50:10 +02:00
Géry Debongnie	16bbb8bc9f	[FIX] qweb/component: better handling for t-debug - fix issue with t-debug on a t-set (defining a slot) - put t-debug and t-log at a very low (high) priority to make sure they are executed before other directives closes #201	2019-06-25 14:03:05 +02:00
Alexandre Kühn	4a5db0c283	[FIX] qweb: t-component + class with extra whitespaces Crashed due to `DOMTokenList.add(string)` requiring non-empty string.	2019-06-25 13:08:14 +02:00
Géry Debongnie	cc50a2e3bb	[FIX] playground: fix some issues with tab handling closes #200	2019-06-25 09:38:00 +02:00
Géry Debongnie	1e2b204fdd	[FIX] component: default slot now works with textnodes closes #209	2019-06-25 09:37:26 +02:00
Géry Debongnie	4a889b7b6b	[IMP] qweb: add option to allow duplicate templates	2019-06-24 22:41:02 +02:00
Géry Debongnie	34695883c2	[REF] component: use __ for private methods closes #202	2019-06-24 13:42:20 +02:00
Géry Debongnie	3d2e2a1873	[FIX] components: ignore slot if no definition is given closes #203	2019-06-24 13:38:32 +02:00
Géry Debongnie	af6aca83a2	[IMP] components: allow multiple roots in slots closes #199	2019-06-24 13:36:11 +02:00
Géry Debongnie	8c8ffb6a6b	[IMP] qweb,component: make QWeb an event bus closes #197	2019-06-24 09:47:11 +02:00
Géry Debongnie	63a8fcd7e2	[FIX] component: scoping issue with t-on and t-foreach closes #193	2019-06-21 16:31:24 +02:00
Géry Debongnie	e6a5934162	[REF] component: use 'component' instead of 'widget'	2019-06-20 12:31:00 +02:00
Pierre Paridans	5524c2e323	[IMP] store: connected component reuse base component name Connected component should have a unique name. To achieve this the connected component currently have an id based generated name (like `ConnectedComponent1`). To make it clearer and ease debugging this commit reuse the extended component's name to include it in the generated name in the form of `Connected<ComponentName>`.	2019-06-20 12:26:13 +02:00
Géry Debongnie	35c1de26b8	[IMP] component: allow component name in templates closes #186	2019-06-18 15:02:35 +02:00
Géry Debongnie	d1cf6b1b8d	[FIX] playground: sample was using old t-foreach syntax	2019-06-17 16:14:49 +02:00
Géry Debongnie	bfa2c681cd	[ADD] tools: add v0.15.0 benchmark	2019-06-17 16:07:06 +02:00
Géry Debongnie	609c108607	[REL] bump to v0.15.0	2019-06-17 15:59:15 +02:00
Aaron Bohy	a56939f13a	[IMP] store: memoize getters Closes #95	2019-06-17 15:46:48 +02:00
Géry Debongnie	5ff501f8b8	[IMP] component: add support for default slot closes #180	2019-06-17 09:26:37 +02:00
Géry Debongnie	60917bb102	[DOC] improve main readme.md	2019-06-15 10:38:29 +02:00
Géry Debongnie	b201ef8162	[FIX] component: crashes if no template can be found closes #178	2019-06-14 23:33:45 +02:00
Géry Debongnie	9cacc78ad7	[DOC] component: add section on root widget	2019-06-14 23:11:23 +02:00
Géry Debongnie	0d933b8570	[IMP] tools: improve playground samples closes #177	2019-06-14 21:44:12 +02:00
Aaron Bohy	72f6daa695	[FIX] playground: t-async leftover in sample	2019-06-14 21:03:21 +02:00
Géry Debongnie	567d78a9ac	[DOC] component: put input bindings section higher	2019-06-14 15:46:14 +02:00
Géry Debongnie	f013c57050	[REF] component: rename t-async into t-asyncroot	2019-06-14 15:40:32 +02:00
Géry Debongnie	b9fae87273	[DOC] doc: miscellaneous formatting updates	2019-06-14 15:33:43 +02:00
Géry Debongnie	1f0457f69b	[REF] tools: use t-model in benchmarks	2019-06-14 15:01:29 +02:00
Géry Debongnie	c481a73a76	[ADD] component: implement t-model directive closes #170	2019-06-14 15:01:29 +02:00
Aaron Bohy	e64e415b3b	[IMP] qweb: add t-async directive on t-widget Closes #98	2019-06-14 14:58:24 +02:00
Géry Debongnie	aa406b53e2	[FIX] tools: react benchmarks did not look like the others	2019-06-14 09:36:29 +02:00
Géry Debongnie	57027bd0fa	[FIX] doc: add missing link	2019-06-13 16:02:35 +02:00
Aaron Bohy	671c662fee	[FIX] playground: don't remove empty tabs Fixes #169	2019-06-13 14:04:59 +02:00
Géry Debongnie	0ae70b1d63	[ADD] tools: add v0.14.0 benchmark	2019-06-13 12:22:38 +02:00
Géry Debongnie	2701a7d861	[REL] bump to v0.14.0	2019-06-13 12:10:52 +02:00
Aaron Bohy	3ebe985c3c	[FIX] qweb: no more duplicated nodes during transitions If a node was re-added while being removed (i.e. during the remove transition), the node was duplicated in the DOM for the delay of the remove transition. This rev. removes the old occurence directly in that case. Fixes #121	2019-06-13 11:55:10 +02:00
Aaron Bohy	1c0d4b5832	[FIX] tests: update snapshots	2019-06-13 11:55:10 +02:00
Géry Debongnie	2840794fa2	[IMP] tools: rework benchmarks application closes #130	2019-06-13 11:41:49 +02:00
Géry Debongnie	710f42d4e4	[IMP] qweb: add t-slot directive Closes #67	2019-06-12 14:54:24 +02:00
Géry Debongnie	45a2b0122d	[FIX] qweb: add better support for template with only strings	2019-06-12 14:54:24 +02:00
Géry Debongnie	4c41f62364	[FIX] owl: remove inline source maps They are wrong anyway. Simpler to work with the raw javascript.	2019-06-12 14:54:24 +02:00
Aaron Bohy	c2ab9774fb	[IMP] utils: whenReady now returns a Promise Closes #160	2019-06-11 14:45:56 +02:00
Aaron Bohy	22e48e3be0	[REF] store: simplify connect API Closes #158	2019-06-11 11:41:29 +02:00
Aaron Bohy	1ff3c32fe4	[IMP] store: allow connecting to another store Closes #58	2019-06-11 11:41:29 +02:00
Géry Debongnie	9a3e1ed99e	[FIX] benchmarks: two small fixes	2019-06-11 11:29:31 +02:00
Géry Debongnie	438e2fbc2e	[FIX] qweb: add some missing operators closes #162	2019-06-11 10:45:20 +02:00
Géry Debongnie	b3db085745	[REF] vdom: simplify vnode function This is a snabbdom commit	2019-06-11 10:23:57 +02:00
Géry Debongnie	b948c59c6d	[DOC] *: improve some parts of the doc	2019-06-11 10:23:46 +02:00
Géry Debongnie	6426fe98f9	[DOC] tooling: improve doc	2019-06-10 09:31:06 +02:00
Géry Debongnie	4dd9de349e	[FIX] tests: check links for main README.md as well	2019-06-10 09:31:06 +02:00
Géry Debongnie	e1bcea77b5	[REF] tools: rename extras into tools	2019-06-10 09:31:06 +02:00
Géry Debongnie	2a19aeb6a3	[REF] extras: start loading templates earlier	2019-06-08 16:29:01 +02:00
Géry Debongnie	b53a34b7d1	[FIX] utils: whenReady should work for all document states Document readyState can be either 'loading', 'interactive' or 'complete'. We can access the DOM whenever we are no longer in 'loading' state.	2019-06-08 16:20:44 +02:00
Géry Debongnie	f881640d3d	[DOC] event_bus: add initial doc closes #157	2019-06-07 16:07:41 +02:00
Géry Debongnie	54c3dd76e4	[FIX] doc: fix all dead links closes #149	2019-06-07 15:40:03 +02:00
Géry Debongnie	7b887447da	[IMP] qweb: implements an expression evaluator closes #5	2019-06-07 15:37:45 +02:00
Géry Debongnie	438b21df3f	[REF] qweb: improve variable handling	2019-06-07 15:37:45 +02:00
Aaron Bohy	d1094f647a	[IMP] observer: add set and delete static functions This rev. add a 'set' and 'delete' static functions to the Observer. They allow to set or delete (only for objects) properties on observed objects or arrays. With this, the 'set' functions in Store and Component are no longer necessary, so they have been removed. Closes #138	2019-06-07 14:55:12 +02:00
Aaron Bohy	49baf0de6e	[REF] qweb: t-foreach: remove integer support for t-value Handling it complexifies the compiled code, and it is not really useful (the same result can be achieved with t-foreach="Array(n)") Part of #128	2019-06-07 14:52:12 +02:00
Aaron Bohy	b14d069ee7	[REF] qweb: drop support of #{.} string interpolation We only support the {{.}} syntax. Part of #128	2019-06-07 14:52:12 +02:00
Aaron Bohy	e14a4fe338	[REF] qweb: t-foreach: remove x_parity Part of #128	2019-06-07 14:52:12 +02:00
Aaron Bohy	1f9ec46236	[FIX] qweb: keep ref of unmounted (kept alive) widget Fixes #120	2019-06-06 09:11:52 +02:00
Géry Debongnie	1464a3631b	[ADD] benchmarks: add 0.13.0 to the list	2019-06-05 11:24:27 +02:00
Géry Debongnie	7d3c374b78	[REL] bump to v0.13.0	2019-06-05 10:47:39 +02:00
Géry Debongnie	1dd257f33c	[DOC] owl: add comment on updating the doc	2019-06-05 10:44:58 +02:00
Vincent Schippefilt	1206afe6be	[FIX] base: compile correctly on windows Fix package.json and tsconfig.json to build correctly on windows: the extention scr/* doesn't expand on windows, so I removed it. Added a precompilation step on npm run extras:watch	2019-06-05 10:31:18 +02:00
Vincent Schippefilt	5842ed51b0	[IMP] extras: update server to python3, disable cache	2019-06-05 10:31:18 +02:00
Géry Debongnie	d22219f084	[DOC] reorganize qweb/component doc Also, document t-foreach closes #146	2019-06-05 10:28:30 +02:00
Aaron Bohy	0be1a54e03	[IMP] playground: use custom events bubbling	2019-06-04 11:59:21 +02:00
Aaron Bohy	32921ecc20	[IMP] qweb: t-on with t-widget: allow to bind args	2019-06-04 11:59:21 +02:00
Aaron Bohy	1c290c1172	[IMP] qweb: handle t-on modifiers with t-widget	2019-06-04 11:59:21 +02:00
Aaron Bohy	2f9d7ea58f	[REF] qweb: revamp event management Closes #111	2019-06-04 11:59:21 +02:00
Géry Debongnie	fe23e76341	[FIX] observer: allow reobserving values twice closes #139	2019-06-04 11:18:12 +02:00
Géry Debongnie	73023d4869	[IMP] extras: add url in log when starting server	2019-06-04 10:25:50 +02:00
Géry Debongnie	ff51443b8e	[FIX] playground: keep ace editor alive between mounting/remounting closes #136	2019-06-04 09:43:58 +02:00
Géry Debongnie	f8e07f6d30	[DOC] *: remove all remaining references to t-props closes #135	2019-06-03 13:34:01 +02:00
Vincent Schippefilt	00da778753	[FIX] extras remove references to t-props	2019-06-03 13:34:01 +02:00
Géry Debongnie	187eb922c0	[IMP] component: define props as attribute (remove t-props)	2019-06-03 13:34:01 +02:00
Géry Debongnie	466c12a0e6	[FIX] component: reuse widget if possible Previous code always destroy and recreate widgets.	2019-06-03 13:34:01 +02:00
Géry Debongnie	8dc3ec94bf	[IMP] qweb: log invalid code generated by template	2019-05-31 13:56:45 +02:00
Géry Debongnie	a554436d03	[FIX] playground: properly resize editors when resizing panels	2019-05-31 13:11:08 +02:00
Géry Debongnie	34b5049dee	[DOC] doc: small misc fixes	2019-05-31 12:40:02 +02:00
Géry Debongnie	0eccfd08fe	[REF] component: add some docstrings	2019-05-31 10:26:37 +02:00
Vincent Schippefilt	98b063fd70	[FIX] owl: ignore idea ide configuration	2019-05-31 09:51:37 +02:00
Géry Debongnie	e9ba94ae55	[IMP] playground: add some padding in error window closes #134	2019-05-29 16:13:29 +02:00
Aaron Bohy	4d72a4f240	[FIX] qweb: enclose interpolated expr in parentheses Since rev `53e53e9b`, <div class="o_app" t-attf-class="{{ true ? 'o_extra' : '' }}"/> produced <div class="o_extra"/> whereas it should have produced <div class="o_app o_extra"/> This is because there were missing parentheses around the string returned by `interpolate`, which produced instructions like var _1 = 'o_app ' + true ? 'o_extra' : ''; Fixes #132	2019-05-29 13:31:48 +02:00
Géry Debongnie	a08deb895d	[ADD] benchmarks: add 0.12.0 to the list	2019-05-29 13:24:58 +02:00
Géry Debongnie	60cea14b01	[IMP] extras: improve landing page	2019-05-29 13:16:35 +02:00