[REL] bump to v0.20.0

closes #267

README.md

@@ -4,32 +4,16 @@ _A web framework for structured, dynamic and maintainable applications_
 
 ## Project Overview
 
-The Odoo Web Library (OWL) is a small
-UI framework intended to be the basis for the [Odoo](https://www.odoo.com/) Web Client, and hopefully many
-other Odoo related projects. OWL's main feature is a _declarative component system_, with QWeb as a template engine, asynchronous rendering, and an underlying virtual dom.
+The Odoo Web Library (OWL) is a small (~16kb gzipped) UI framework intended to be the basis for
+the [Odoo](https://www.odoo.com/) Web Client, and hopefully many other Odoo
+related projects. OWL's main features are:
+
+- a _declarative component system_, (template based, with asynchronous rendering and a virtual dom)
+- a store implementation (for state management)
+- a small frontend router
 
 **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 is designed to be used in highly dynamic applications where changing
-requirements are common, code needs to be maintained by large teams.
-
-- **XML based**: templates are based on the XML format, which allows interesting
-  applications. For example, they could be stored in a database and modified
-  dynamically with `xpaths`.
-- **templates compilation in the browser**: this may not be a good fit for all
-  applications, but if you need to generate dynamically user interfaces in the
-  browser, this is very powerful. For example, a generic form view component
-  could generate a specific form user interface for each various models, from a XML view.
-- **no toolchain required**: this is extremely useful for some applications, if,
-  for various reasons (security/deployment/dynamic modules/specific assets tools),
-  it is not ok to use standard web tools based on `npm`.
-
-Owl is not designed to be fast 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
 
 Here is a short example to illustrate interactive components:
@@ -39,6 +23,10 @@ Here is a short example to illustrate interactive components:
   <button t-name="Counter" t-on-click="increment">
     Click Me! [<t t-esc="state.value"/>]
   </button>
+  <div t-name="App">
+    <span>Hello Owl</span>
+    <Counter />
+  </div>
 </templates>
 ```
 
@@ -51,21 +39,59 @@ class Counter extends owl.Component {
   }
 }
 
+class App extends owl.Component {
+    components = { Counter };
+}
+
 const qweb = new owl.QWeb(TEMPLATES);
-const counter = new Counter({ qweb });
-counter.mount(document.body);
+const app = new App({ qweb });
+app.mount(document.body);
 ```
 
 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.
 
+## OWL's Design Principles
+
+OWL is designed to be used in highly dynamic applications where changing
+requirements are common and code needs to be maintained by large teams.
+
+- **XML based**: templates are based on the XML format, which allows interesting
+  applications. For example, they could be stored in a database and modified
+  dynamically with `xpaths`.
+- **templates compilation in the browser**: this may not be a good fit for all
+  applications, but if you need to generate dynamically user interfaces in the
+  browser, this is very powerful. For example, a generic form view component
+  could generate a specific form user interface for each various models, from a XML view.
+- **no toolchain required**: this is extremely useful for some applications, if,
+  for various reasons (security/deployment/dynamic modules/specific assets tools),
+  it is not ok to use standard web tools based on `npm`.
+
+Owl is not designed to be fast nor small (even though it is quite good on those
+two topics). It is a no nonsense framework to build applications.  There is only
+one way to define components (with classes).
+
+If you are interested in a comparison with React or Vue, you will
+find some more information [here](doc/comparison.md).
+
+## Documentation
+
+The complete documentation can be found [here](doc/readme.md). The most important sections are:
+
+- [Quick Start](doc/quick_start.md)
+- [Component](doc/component.md)
+- [QWeb](doc/qweb.md)
+
+Found an issue in the documentation? A broken link? Some outdated information?
+Submit a PR!
+
 ## Installing/Building
 
 If you want to use a simple `<script>` tag, the last release can be downloaded here:
 
-- [owl-0.17.0.js](https://github.com/odoo/owl/releases/download/v0.17.0/owl.js)
-- [owl-0.17.0.min.js](https://github.com/odoo/owl/releases/download/v0.17.0/owl.min.js)
+- [owl-0.20.0.js](https://github.com/odoo/owl/releases/download/v0.20.0/owl.js)
+- [owl-0.20.0.min.js](https://github.com/odoo/owl/releases/download/v0.20.0/owl.min.js)
 
 Some npm scripts are available:
 
@@ -79,17 +105,6 @@ Some npm scripts are available:
 | `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
-
-The complete documentation can be found [here](doc/readme.md). The most important sections are:
-
-- [Quick Start](doc/quick_start.md)
-- [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).
+OWL is [LGPL licensed](./LICENSE).

doc/comparison.md

@@ -10,6 +10,7 @@ discussed, feel free to open an issue/submit a PR to correct this text.
 ## Content
 
 - [Size](#size)
+- [Class Based](#class-based)
 - [Tooling/Build Step](#toolingbuild-step)
 - [Templating](#templating)
 - [Asynchronous rendering](#asynchronous-rendering)
@@ -21,12 +22,23 @@ discussed, feel free to open an issue/submit a PR to correct this text.
 OWL is intended to be small and to work at a slightly lower level of abstraction
 than React and Vue. Also, jQuery is not the same kind of framework, but it is interesting to compare.
 
-| Framework                | Size (minified) | Size (minified, gzipped) |
-| ------------------------ | --------------- | ------------------------ |
-| OWL                      | 32kb            | 11kb                     |
-| Vue + VueX               |                 | 30kb                     |
-| React + ReactDOM + Redux |                 | 40kb                     |
-| jQuery                   | 86kb            | 30kb                     |
+| Framework                | Size (minified, gzipped) |
+| ------------------------ | ------------------------ |
+| OWL                      | 16kb                     |
+| Vue + VueX               | 30kb                     |
+| React + ReactDOM + Redux | 40kb                     |
+| jQuery                   | 30kb                     |
+
+## Class Based
+
+Both React and Vue moved away from defining components with classes.  They prefer
+a more functional approach, in particular, with the new `hooks` mechanisms.
+
+This has some advantages and disadvantages.  But the end result is that React
+and Vue both offers multiple different ways of defining new components.  In
+contrast, Owl has only one mechanism: class-based components. We believe that Owl
+components are fast enough for all our usecases, and making it as simple as
+possible for developers is more valuable (for us).
 
 ## Tooling/Build step
 
@@ -45,7 +57,7 @@ components, which also necessitate a build step.
 On the flipside, external tooling may make it harder to use in some case, but it
 also brings a lot of benefits. And React/Vue have both a large ecosystem.
 
-### Templating
+## Templating
 
 OWL uses its own QWeb engine, which compiles templates on the
 frontend, as they are needed. This is extremely convenient for our use case, in
@@ -128,8 +140,10 @@ by getters/setters. With that, it can notify components whenever the state that
 they read was changed.
 
 Owl is closer to vue: it also tracks magically the state properties, but it does
-only increment a counter whenever it changes (and a _deep_ counter for each of
-its parents). This assumes that the state is actually a tree.
+only increment an internal counter whenever it changes. Note that it is done
+with a `Proxy`, which means that it is totally transparent to the developers.
+Adding new keys is supported. Once any part of the state has been changed, a
+rendering is scheduled in the next microtask tick (promise queue).
 
 ## State Management
 
@@ -190,7 +204,33 @@ keeps track of who get data, and retrigger a render when it was changed.
 
 **Owl**
 
-Owl store is a little bit like a mix of redux and vuex: it has mutations and
-actions, like VueX, it keeps track of the state changes, but it does not notify
-a component when the state changes. Instead, components need to connect to the
-store like in redux, with a function that will listen to the relevant state.
+Owl store is a little bit like a mix of redux and vuex: it has actions (but not
+mutations), and like VueX, it keeps track of the state changes. However, it does
+not notify a component when the state changes. Instead, components need to connect
+to the store like in redux, by inheriting the `ConnectedComponent` class.
+
+```javascript
+const actions = {
+  increment({ state }, val) {
+    state.counter += val;
+  }
+};
+
+const state = {
+  counter: 0
+};
+const store = new owl.Store({ state, actions });
+
+class Counter extends owl.ConnectedComponent {
+  static mapStoreToProps(state) {
+    return {
+      value: state.counter
+    };
+  }
+  increment() {
+    this.env.store.dispatch("increment");
+  }
+}
+
+const counter = new Counter({ store, qweb });
+```

doc/component.md

@@ -144,10 +144,16 @@ find a template with the component name (or one of its ancestor).
 
 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
-  will need to call `mount` exactly once, on the root component.
+- **`mount(target, renderBeforeRemount=false)`** (async): this is the main way a
+  component 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 will need to call `mount` exactly once, on
+  the root component.
+
+  The `renderBeforeRemount` argument is useful when a component is unmounted and remounted.
+  In that case, we may want to rerender the component _before_ it is remounted, if
+  we know that its state (or something in the environment, or ...) has changed.
+  In that case, it should simply set to `true`.
 
 - **`unmount()`**: in case a component need to be detached/removed from the DOM, this
   method can be used. Most applications should not call `unmount`, this is more
@@ -255,7 +261,8 @@ 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 component rendering will take place after `willStart` is completed.
+After the `willStart` method is completed, the state will be observed with a
+new `Observer`. Then, the component will be rendered by `QWeb`.
 
 #### `mounted()`
 

doc/readme.md

@@ -1,5 +1,31 @@
 # 🦉 OWL Documentation 🦉
 
+## Owl Content
+
+Owl is a javascript library that contains some core classes and function to help
+build applications.  Here is a complete representation of its content:
+
+```
+owl
+    Component
+    QWeb
+    core
+        EventBus
+        Observer
+    router
+        Link
+        Router
+    store
+        Store
+        ConnectedComponent
+    utils
+        debounce
+        escape
+        loadJS
+        loadTemplates
+        whenReady
+```
+
 ## Reference
 
 - [Animations](animations.md)
@@ -7,6 +33,7 @@
 - [Event Bus](event_bus.md)
 - [Observer](observer.md)
 - [QWeb](qweb.md)
+- [Router](router.md)
 - [Store](store.md)
 - [Utils](utils.md)
 - [Virtual DOM](vdom.md)
@@ -19,3 +46,4 @@
 
 - [Comparison with React/Vue](comparison.md)
 - [Tooling](tooling.md)
+- [Templates to start Owl applications (external link)](https://github.com/ged-odoo/owl-templates)

doc/router.md

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

doc/store.md

@@ -5,8 +5,7 @@
 - [Overview](#overview)
 - [Example](#example)
 - [Reference](#reference)
-  - [Public API](#public-api)
-  - [Mutations](#mutations)
+  - [Store](#store)
   - [Actions](#actions)
   - [Getters](#getters)
   - [Connecting a Component](#connecting-a-component)
@@ -22,11 +21,10 @@ in various parts of the user interface, and then, it is not obvious which
 component should own which part of the state.
 
 Owl's solution to this issue is a centralized store. It is a class that owns
-some state, and let the developer update it in a structured way (through
-mutations and actions). Owl components can then connect to the store, and will
-be updated if necessary.
+some state, and let the developer update it in a structured way, with `actions`.
+Owl components can then connect to the store, and will be updated if necessary.
 
-Note: Owl's store is inspired by React Redux and VueX.
+Note: Owl store is inspired by React Redux and VueX.
 
 ## Example
 
@@ -34,19 +32,12 @@ Here is what a simple store looks like:
 
 ```js
 const actions = {
-  addTodo({ commit }, message) {
-    commit("addTodo", message);
-  }
-};
-
-const mutations = {
   addTodo({ state }, message) {
-    const todo = {
+    state.todos.push({
       id: state.nextId++,
       message,
       isCompleted: false
-    };
-    state.todos.push(todo);
+    });
   }
 };
 
@@ -55,66 +46,65 @@ const state = {
   nextId: 1
 };
 
-const store = new owl.Store({ state, actions, mutations });
+const store = new owl.Store({ state, actions });
 store.on("update", () => console.log(store.state));
 
 // updating the state
 store.dispatch("addTodo", "fix all bugs");
 ```
 
+This example shows how a store can be defined and used. Note that in most cases,
+actions will be dispatched by connected components.
+
 ## Reference
 
-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
+### `Store`
+
+The store is a simple [`owl.EventBus`](event_bus.md) that triggers `update` events
+whenever its state is changed. Note that these events are triggered only after a
+microtask tick, so only one event will be triggered for any number of state changes in a
 call stack.
 
 Also, it is important to mention that the state is observed (with an `owl.Observer`),
-which is the reason why it is able to know if it was changed. 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
+which is the reason why it is able to know if it was changed. See the
 [Observer](observer.md)'s documentation for more details.
 
-### Public API
+The `Store` class is quite small. It has two public methods:
 
-1. `constructor`
-2. `commit`
-3. `dispatch`
+- its constructor
+- `dispatch`
 
-### Mutations
+The constructor takes a configuration object with four (optional) keys:
 
-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.
+- the initial state
+- the actions
+- the getters
+- the environment
 
-```js
-const mutations = {
-  setLoginState({ state }, loginState) {
-    state.loginState = loginState;
-  }
+```javascript
+const config = {
+  state,
+  actions,
+  getters,
+  env
 };
-```
-
-Mutations are called with the `commit` method on the store, and can receive an arbitrary number of arguments.
-
-```js
-store.commit("setLoginState", "error");
+const store = new Store(config);
 ```
 
 ### 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
-in an action.
+Actions are used to coordinate state changes. It can be used for both synchronous
+and asynchronous logic.
 
 ```js
 const actions = {
-  async login({ commit }, info) {
-    commit("setLoginState", "pending");
+  async login({ state }, info) {
+    state.loginState = "pending";
     try {
       const loginInfo = await doSomeRPC("/login/", info);
-      commit("setLoginState", loginInfo);
-    } catch {
-      commit("setLoginState", "error");
+      state.loginState = loginInfo;
+    } catch (e) {
+      state.loginState = "error";
     }
   }
 };
@@ -127,6 +117,39 @@ arbitrary number of arguments.
 store.dispatch("login", someInfo);
 ```
 
+Note that anything returned by an action will also be returned by the `dispatch`
+call.
+
+Also, it is important to be aware that we need to be careful with asynchronous
+logic. Each state change will potentially trigger a rerendering, so we need to
+make sure that we do not have a partial corrupted state. Here is an example that
+is likely not a good idea:
+
+```javascript
+const actions = {
+  async fetchSomeData({ state }, recordId) {
+    state.recordId = recordId;
+    const data = await doSomeRPC("/read/", recordId);
+    state.recordData = data;
+  }
+};
+```
+
+In the previous example, there is a period of time in which the state has a
+`recordId` which does not correspond to the `recordData`. It is more likely that
+we want an atomic update: updating the `recordId` at the same time as the `recordData`
+values:
+
+```javascript
+const actions = {
+  async fetchSomeData({ state }, recordId) {
+    const data = await doSomeRPC("/read/", recordId);
+    state.recordId = recordId;
+    state.recordData = data;
+  }
+};
+```
+
 ### Getters
 
 Usually, data contained in the store will be stored in a normalized way. For
@@ -178,19 +201,15 @@ need to create a component inheriting from `OwlComponent`:
 
 ```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 });
+const store = new owl.Store({ state, actions });
 
 class Counter extends owl.ConnectedComponent {
   static mapStoreToProps(state) {
@@ -224,6 +243,25 @@ The `ConnectedComponent` class can be configured with the following fields:
 - `deep` (boolean): [only useful if no hashFunction is given] if `false`, only watch
   for top level state changes (`true` by default)
 
+Note that the class `ConnectedComponent` has a `dispatch` method. This means
+that the previous example could be simplified like this:
+
+```javascript
+class Counter extends owl.ConnectedComponent {
+  static mapStoreToProps(state) {
+    return {
+      value: state.counter
+    };
+  }
+}
+```
+
+```xml
+<button t-name="Counter" t-on-click="dispatch('increment')">
+  Click Me! [<t t-esc="props.value"/>]
+</button>
+```
+
 ### Semantics
 
 The `Store` and the `ConnectedComponent` try to be smart and to optimize as much

package.json

@@ -1,12 +1,13 @@
 {
   "name": "owl",
-  "version": "0.17.0",
+  "version": "0.20.0",
   "description": "Odoo Web Library (OWL)",
   "main": "src/index.ts",
   "scripts": {
     "build:js": "tsc --target esnext --module es6 --outDir dist/owl",
     "build:bundle": "rollup -c",
     "build": "npm run build:js && npm run build:bundle",
+    "buildcommonjs": "npm run build:js && npm run build:bundle -- -f cjs",
     "minify": "uglifyjs dist/owl.js -o dist/owl.min.js --compress --mangle",
     "test": "jest",
     "test:watch": "jest --watch",
@@ -30,6 +31,7 @@
     "cpx": "^1.5.0",
     "git-rev-sync": "^1.12.0",
     "jest": "^23.6.0",
+    "jest-environment-jsdom": "^24.7.1",
     "live-server": "^1.2.1",
     "npm-run-all": "^4.1.5",
     "rollup": "^1.6.0",
@@ -38,8 +40,7 @@
     "source-map-support": "^0.5.10",
     "ts-jest": "^23.10.5",
     "typescript": "^3.2.2",
-    "uglify-es": "^3.3.9",
-    "jest-environment-jsdom": "^24.7.1"
+    "uglify-es": "^3.3.9"
   },
   "dependencies": {},
   "jest": {
@@ -62,6 +63,6 @@
     ]
   },
   "prettier": {
-      "printWidth": 100
+    "printWidth": 100
   }
 }

src/component/component.ts

@@ -1,6 +1,8 @@
-import { Observer } from "./observer";
-import { QWeb, CompiledTemplate, UTILS } from "./qweb_core";
-import { h, patch, VNode } from "./vdom";
+import { Observer } from "../core/observer";
+import { CompiledTemplate, QWeb } from "../qweb/index";
+import { h, patch, VNode } from "../vdom/index";
+import "./directive";
+import "./props_validation";
 
 /**
  * Owl Component System
@@ -28,6 +30,7 @@ import { h, patch, VNode } from "./vdom";
  */
 export interface Env {
   qweb: QWeb;
+  [key: string]: any;
 }
 
 /**
@@ -35,25 +38,36 @@ export interface Env {
  * useful to typecheck and describe the internal keys used by Owl to manage the
  * component tree.
  */
-export interface Meta<T extends Env, Props> {
+interface Internal<T extends Env, Props> {
+  // each component has a unique id, useful mostly to handle parent/child
+  // relationships
   readonly id: number;
   vnode: VNode | null;
   isMounted: boolean;
   isDestroyed: boolean;
+
+  // parent and children keys are obviously useful to setup the parent-children
+  // relationship.
   parent: Component<T, any, any> | null;
   children: { [key: number]: Component<T, any, any> };
-  // children mapping: from templateID to componentID
-  // should it be a map number => Component?
+  // children mapping: from templateID to componentID. templateID identifies a
+  // place in a template. The t-component directive needs it to be able to get
+  // the component instance back whenever the template is rerendered.
   cmap: { [key: number]: number };
 
   renderId: number;
+
+  // the renderProps and renderPromise keys are only useful for the "prepare"
+  // step of the lifecycle of a component.  Once a component has been rendered
+  // and patched, it is no longer useful.
   renderProps: Props | null;
   renderPromise: Promise<VNode> | null;
+
   boundHandlers: { [key: number]: any };
-  observer?: Observer;
-  render?: CompiledTemplate;
+  observer: Observer | null;
+  render: CompiledTemplate | null;
   mountedHandlers: { [key: number]: Function };
-  classObj?: { [key: string]: boolean };
+  classObj: { [key: string]: boolean } | null;
 }
 
 // If a component does not define explicitely a template
@@ -68,7 +82,7 @@ const TEMPLATE_MAP: { [key: number]: { [name: string]: string } } = {};
 let nextId = 1;
 
 export class Component<T extends Env, Props extends {}, State extends {}> {
-  readonly __owl__: Meta<Env, Props>;
+  readonly __owl__: Internal<Env, Props>;
   template?: string;
 
   /**
@@ -135,7 +149,7 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
       if (QWeb.dev) {
         // we only validate props for root widgets here.  "Regular" widget
         // props are validated by the t-component directive
-        UTILS.validateProps(this.constructor, this.props);
+        QWeb.utils.validateProps(this.constructor, this.props);
       }
       this.env.qweb.on("update", this, () => {
         if (this.__owl__.isMounted) {
@@ -163,7 +177,10 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
       renderPromise: null,
       renderProps: props || null,
       boundHandlers: {},
-      mountedHandlers: {}
+      mountedHandlers: {},
+      observer: null,
+      render: null,
+      classObj: null
     };
   }
 
@@ -258,14 +275,26 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
    *
    * This should only be done if the component was created manually. Components
    * created declaratively in templates are managed by the Owl system.
+   *
+   * Note that a component can be mounted an unmounted several times
    */
-  async mount(target: HTMLElement): Promise<void> {
-    const vnode = await this.__prepare();
-    if (this.__owl__.isDestroyed) {
-      // component was destroyed before we get here...
+  async mount(target: HTMLElement, renderBeforeRemount: boolean = false): Promise<void> {
+    const __owl__ = this.__owl__;
+    if (__owl__.isMounted) {
       return;
     }
-    this.__patch(vnode);
+    if (!__owl__.vnode) {
+      const vnode = await this.__prepare();
+      if (__owl__.isDestroyed) {
+        // component was destroyed before we get here...
+        return;
+      }
+      this.__patch(vnode);
+    } else if (renderBeforeRemount) {
+      const patchQueue = [];
+      await this.__render(false, patchQueue, undefined, undefined);
+      this.__applyPatchQueue(<any[]>patchQueue);
+    }
     target.appendChild(this.el!);
 
     if (document.body.contains(target)) {
@@ -273,6 +302,10 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
     }
   }
 
+  /**
+   * The unmount method is the opposite of the mount method.  It is useful
+   * to call willUnmount calls and remove the component from the DOM.
+   */
   unmount() {
     if (this.__owl__.isMounted) {
       this.__callWillUnmount();
@@ -280,20 +313,26 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
     }
   }
 
-  async render(force: boolean = false, patchQueue?: any[], scope?: any, vars?: any): Promise<void> {
+  /**
+   * The render method is the main entry point to render a component (once it
+   * is ready. This method is not initially called when the component is
+   * rendered the first time).
+   *
+   * This method will cause all its sub components to potentially rerender
+   * themselves.  Note that `render` is not called if a component is updated via
+   * its props.
+   */
+  async render(force: boolean = false): Promise<void> {
     const __owl__ = this.__owl__;
     if (!__owl__.isMounted) {
       return;
     }
-    const shouldPatch: boolean = !patchQueue;
-    if (shouldPatch) {
-      patchQueue = [];
-    }
-    const renderVDom = this.__render(force, patchQueue, scope, vars);
-    const renderId = __owl__.renderId;
-    await renderVDom;
+    const patchQueue = [];
 
-    if (shouldPatch && __owl__.isMounted && renderId === __owl__.renderId) {
+    const renderId = ++__owl__.renderId;
+    await this.__render(force, patchQueue, undefined, undefined);
+
+    if (__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.
       this.__applyPatchQueue(<any[]>patchQueue);
@@ -370,6 +409,17 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
   // Private
   //--------------------------------------------------------------------------
 
+  /**
+   * Private helper to perform a full destroy, from the point of view of an Owl
+   * component. It does not remove the el (this is done only once on the top
+   * level destroyed component, for performance reasons).
+   *
+   * The job of this method is mostly to call willUnmount hooks, and to perform
+   * all necessary internal cleanup.
+   *
+   * Note that it does not call the __callWillUnmount method to avoid visiting
+   * all children many times.
+   */
   __destroy(parent: Component<any, any, any> | null) {
     const __owl__ = this.__owl__;
     const isMounted = __owl__.isMounted;
@@ -424,6 +474,10 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
     }
   }
 
+  /**
+   * The __updateProps method is called by the t-component directive whenever
+   * it updates a component (so, when the parent template is rerendered).
+   */
   async __updateProps(
     nextProps: Props,
     forceUpdate: boolean = false,
@@ -439,17 +493,17 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
       }
       await this.willUpdateProps(nextProps);
       this.props = nextProps;
-      await this.render(forceUpdate, patchQueue, scope, vars);
+      await this.__render(forceUpdate, patchQueue, scope, vars);
     }
   }
 
+  /**
+   * Main patching method. We call the virtual dom patch method here to convert
+   * a virtual dom vnode into some actual dom.
+   */
   __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);
   }
 
@@ -497,22 +551,20 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
     }
     __owl__.render = qweb.render.bind(qweb, this.template);
     this.__observeState();
+
     return this.__render(false, [], scope, vars);
   }
 
-  async __render(
+  __render(
     force: boolean = false,
     patchQueue: any[] = [],
     scope?: Object,
     vars?: any
   ): Promise<VNode> {
     const __owl__ = this.__owl__;
-    __owl__.renderId++;
     const promises: Promise<void>[] = [];
     const patch: any[] = [this];
-    if (__owl__.isMounted) {
-      patchQueue.push(patch);
-    }
+    patchQueue.push(patch);
     if (__owl__.observer) {
       __owl__.observer.allowMutations = false;
     }
@@ -542,9 +594,15 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
     // 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;
-    __owl__.renderPromise = Promise.all(promises).then(() => vnode);
-    return __owl__.renderPromise;
+
+    // we applly here the class information described on the component by the
+    // template (so, something like <MyComponent class="..."/>) to the actual
+    // root vnode
+    if (__owl__.classObj) {
+      vnode.data.class = Object.assign(vnode.data.class || {}, __owl__.classObj);
+    }
+
+    return Promise.all(promises).then(() => vnode);
   }
 
   /**
@@ -573,11 +631,15 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
     }
   }
 
+  /**
+   * Enable the observe feature on the state.  We only create an observer if
+   * there is some state to be observed.
+   */
   __observeState() {
     if (this.state) {
       const __owl__ = this.__owl__;
       __owl__.observer = new Observer();
-      __owl__.observer.observe(this.state);
+      this.state = __owl__.observer.observe(this.state);
       __owl__.observer.notifyCB = this.render.bind(this);
     }
   }
@@ -589,7 +651,7 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
    * prop object
    */
   __applyDefaultProps(props: Object | undefined, defaultProps: Object): Props {
-    props = props ? Object.create(props) : {};
+    props = props ? Object.assign({}, props) : {};
     for (let propName in defaultProps) {
       if (props![propName] === undefined) {
         props![propName] = defaultProps[propName];
@@ -633,13 +695,21 @@ export class Component<T extends Env, Props extends {}, State extends {}> {
 // Error handling
 //------------------------------------------------------------------------------
 
-function errorHandler(error, component) {
+/**
+ * This is the global error handler for errors occurring in Owl main lifecycle
+ * methods.  Caught errors are triggered on the QWeb instance, and are
+ * potentially given to some parent component which implements `catchError`.
+ *
+ * If there are no such component, we destroy everything. This is better than
+ * being in a corrupted state.
+ */
+function errorHandler(error: Error, component: Component<any, any, any>) {
   let canCatch = false;
   let qweb = component.env.qweb;
   let root = component;
   while (component && !(canCatch = component.catchError !== Component.prototype.catchError)) {
     root = component;
-    component = component.__owl__.parent;
+    component = component.__owl__.parent!;
   }
   console.error(error);
   // we trigger error on QWeb so it can be logged/handled

src/component/directive.ts

@@ -1,186 +1,5 @@
-import { QWeb, UTILS } from "./qweb_core";
-import { VNode } from "./vdom";
-
-/**
- * Owl QWeb Extensions
- *
- * This file contains the implementation of non standard QWeb directives, added
- * by Owl and that will only work on Owl projects:
- *
- * - t-on
- * - t-ref
- * - t-transition
- * - t-component/t-keepalive
- * - t-mounted
- * - t-slot
- * - t-model
- */
-
-//------------------------------------------------------------------------------
-// t-on
-//------------------------------------------------------------------------------
-// these are pieces of code that will be injected into the event handler if
-// modifiers are specified
-const MODS_CODE = {
-  prevent: "e.preventDefault();",
-  self: "if (e.target !== this.elm) {return}",
-  stop: "e.stopPropagation();"
-};
-
-QWeb.addDirective({
-  name: "on",
-  priority: 90,
-  atNodeCreation({ ctx, fullName, value, nodeID }) {
-    ctx.rootContext.shouldDefineOwner = true;
-    const [eventName, ...mods] = fullName.slice(5).split(".");
-    if (!eventName) {
-      throw new Error("Missing event name with t-on directive");
-    }
-    let extraArgs;
-    let handlerName = value.replace(/\(.*\)/, function(args) {
-      extraArgs = args.slice(1, -1);
-      return "";
-    });
-    ctx.addIf(`!context['${handlerName}']`);
-    ctx.addLine(
-      `throw new Error('Missing handler \\'' + '${handlerName}' + \`\\' when evaluating template '${ctx.templateName.replace(
-        /`/g,
-        "'"
-      )}'\`)`
-    );
-    ctx.closeIf();
-    let params = extraArgs ? `owner, ${ctx.formatExpression(extraArgs)}` : "owner";
-    let handler;
-    if (mods.length > 0) {
-      handler = `function (e) {`;
-      handler += mods
-        .map(function(mod) {
-          return MODS_CODE[mod];
-        })
-        .join("");
-      handler += `context['${handlerName}'].call(${params}, e);}`;
-    } else {
-      handler = `context['${handlerName}'].bind(${params})`;
-    }
-    if (extraArgs) {
-      ctx.addLine(`p${nodeID}.on['${eventName}'] = ${handler};`);
-    } else {
-      ctx.addLine(
-        `extra.handlers['${eventName}' + ${nodeID}] = extra.handlers['${eventName}' + ${nodeID}] || ${handler};`
-      );
-      ctx.addLine(`p${nodeID}.on['${eventName}'] = extra.handlers['${eventName}' + ${nodeID}];`);
-    }
-  }
-});
-
-//------------------------------------------------------------------------------
-// t-ref
-//------------------------------------------------------------------------------
-QWeb.addDirective({
-  name: "ref",
-  priority: 95,
-  atNodeCreation({ ctx, value, addNodeHook }) {
-    const refKey = `ref${ctx.generateID()}`;
-    ctx.addLine(`const ${refKey} = ${ctx.interpolate(value)};`);
-    addNodeHook("create", `context.refs[${refKey}] = n.elm;`);
-  }
-});
-
-//------------------------------------------------------------------------------
-// t-transition
-//------------------------------------------------------------------------------
-UTILS.nextFrame = function(cb: () => void) {
-  requestAnimationFrame(() => requestAnimationFrame(cb));
-};
-
-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 = () => {
-    elm.classList.remove(name + "-enter-active");
-    elm.classList.remove(name + "-enter-to");
-  };
-  this.nextFrame(() => {
-    elm.classList.remove(name + "-enter");
-    elm.classList.add(name + "-enter-to");
-    whenTransitionEnd(elm, finalize);
-  });
-};
-
-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 = () => {
-    elm.classList.remove(name + "-leave-active");
-    elm.classList.remove(name + "-leave-to");
-    rm();
-  };
-  this.nextFrame(() => {
-    elm.classList.remove(name + "-leave");
-    elm.classList.add(name + "-leave-to");
-    whenTransitionEnd(elm, finalize);
-  });
-};
-
-function getTimeout(delays: Array<string>, durations: Array<string>): number {
-  /* istanbul ignore next */
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays);
-  }
-
-  return Math.max.apply(
-    null,
-    durations.map((d, i) => {
-      return toMs(d) + toMs(delays[i]);
-    })
-  );
-}
-
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s: string): number {
-  return Number(s.slice(0, -1).replace(",", ".")) * 1000;
-}
-
-function whenTransitionEnd(elm: HTMLElement, cb) {
-  const styles = window.getComputedStyle(elm);
-  const delays: Array<string> = (styles.transitionDelay || "").split(", ");
-  const durations: Array<string> = (styles.transitionDuration || "").split(", ");
-  const timeout: number = getTimeout(delays, durations);
-  if (timeout > 0) {
-    elm.addEventListener("transitionend", cb, { once: true });
-  } else {
-    cb();
-  }
-}
-
-QWeb.addDirective({
-  name: "transition",
-  priority: 96,
-  atNodeCreation({ value, addNodeHook }) {
-    let name = value;
-    const hooks = {
-      insert: `this.utils.transitionInsert(vn, '${name}');`,
-      remove: `this.utils.transitionRemove(vn, '${name}', rm);`
-    };
-    for (let hookName in hooks) {
-      addNodeHook(hookName, hooks[hookName]);
-    }
-  }
-});
+import { QWeb } from "../qweb/index";
+import { MODS_CODE } from "../qweb/extensions";
 
 //------------------------------------------------------------------------------
 // t-component
@@ -190,7 +9,7 @@ const T_COMPONENT_MODS_CODE = Object.assign({}, MODS_CODE, {
   self: "if (e.target !== vn.elm) {return}"
 });
 
-UTILS.defineProxy = function defineProxy(target, source) {
+QWeb.utils.defineProxy = function defineProxy(target, source) {
   for (let k in source) {
     Object.defineProperty(target, k, {
       get() {
@@ -419,23 +238,23 @@ QWeb.addDirective({
     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 key${keyID} = 'key' + ${key};`);
     }
     ctx.addLine(`let def${defID};`);
     let templateID = key
       ? `key${keyID}`
       : ctx.inLoop
-      ? `String(-${componentID} - i)`
+      ? ctx.currentKey
+        ? `String(${ctx.currentKey} + '_k_' + i + '_c_' + ${componentID} )`
+        : `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}"`;
-      }
+      templateID = `"_slot_${templateID}"`;
+    }
+    if (key || ctx.inLoop) {
+      let id = ctx.generateID();
+      ctx.addLine(`let templateId${id} = ${templateID};`);
+      templateID = `templateId${id}`;
     }
 
     let ref = node.getAttribute("t-ref");
@@ -603,7 +422,7 @@ QWeb.addDirective({
           const key = slotNode.getAttribute("t-set")!;
           slotNode.removeAttribute("t-set");
           const slotFn = qweb._compile(`slot_${key}_template`, slotNode, ctx);
-          qweb.slots[`${slotId}_${key}`] = slotFn.bind(qweb);
+          qweb.slots[`${slotId}_${key}`] = slotFn;
         }
       }
       if (clone.childNodes.length) {
@@ -612,7 +431,7 @@ QWeb.addDirective({
           t.appendChild(child);
         }
         const slotFn = qweb._compile(`slot_default_template`, t, ctx);
-        qweb.slots[`${slotId}_default`] = slotFn.bind(qweb);
+        qweb.slots[`${slotId}_default`] = slotFn;
       }
     }
 
@@ -630,12 +449,19 @@ QWeb.addDirective({
       registerCode = `utils.defineProxy(vn${ctx.rootNode}, pvnode);`;
     }
     ctx.addLine(
-      `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}}}});${registerCode}w${componentID}.__owl__.pvnode = pvnode;});`
+      `def${defID} = def${defID}.then(vnode=>{if (w${componentID}.__owl__.isDestroyed){return}${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}}}});${registerCode}w${componentID}.__owl__.pvnode = pvnode;});`
     );
 
     ctx.addElse();
     // need to update component
-    const patchQueueCode = async ? `patchQueue${componentID}` : "extra.patchQueue";
+    let patchQueueCode = async ? `patchQueue${componentID}` : "extra.patchQueue";
+    if (keepAlive) {
+      // if we have t-keepalive="1", the component could be unmounted, but then
+      // we __updateProps is called.  This is ok, but we do not want to call
+      // the willPatch/patched hooks of the component in this case, so we
+      // disable the patch queue
+      patchQueueCode = `w${componentID}.__owl__.isMounted ? ${patchQueueCode} : []`;
+    }
     if (QWeb.dev) {
       ctx.addLine(`utils.validateProps(w${componentID}.constructor, props${componentID})`);
     }
@@ -673,198 +499,3 @@ QWeb.addDirective({
     return true;
   }
 });
-
-//------------------------------------------------------------------------------
-// Prop validation helper
-//------------------------------------------------------------------------------
-
-/**
- * Validate the component props (or next props) against the (static) props
- * description.  This is potentially an expensive operation: it may needs to
- * visit recursively the props and all the children to check if they are valid.
- * This is why it is only done in 'dev' mode.
- */
-UTILS.validateProps = function(Widget, props: Object) {
-  const propsDef = (<any>Widget).props;
-  if (propsDef instanceof Array) {
-    // list of strings (prop names)
-    for (let i = 0, l = propsDef.length; i < l; i++) {
-      const propName = propsDef[i];
-      if (propName[propName.length - 1] === "?") {
-        // optional prop
-        break;
-      }
-      if (!props[propName]) {
-        throw new Error(`Missing props '${propsDef[i]}' (component '${Widget.name}')`);
-      }
-    }
-    for (let key in props) {
-      if (!propsDef.includes(key) && !propsDef.includes(key + "?")) {
-        throw new Error(`Unknown prop '${key}' given to component '${Widget.name}'`);
-      }
-    }
-  } else if (propsDef) {
-    // propsDef is an object now
-    for (let propName in propsDef) {
-      if (props[propName] === undefined) {
-        if (propsDef[propName] && !propsDef[propName].optional) {
-          throw new Error(`Missing props '${propName}' (component '${Widget.name}')`);
-        } else {
-          break;
-        }
-      }
-      let isValid = isValidProp(props[propName], propsDef[propName]);
-      if (!isValid) {
-        throw new Error(`Props '${propName}' of invalid type in component '${Widget.name}'`);
-      }
-    }
-    for (let propName in props) {
-      if (!(propName in propsDef)) {
-        throw new Error(`Unknown prop '${propName}' given to component '${Widget.name}'`);
-      }
-    }
-  }
-};
-
-/**
- * Check if an invidual prop value matches its (static) prop definition
- */
-function isValidProp(prop, propDef): boolean {
-  if (propDef === true) {
-    return true;
-  }
-  if (typeof propDef === "function") {
-    // Check if a value is constructed by some Constructor.  Note that there is a
-    // slight abuse of language: we want to consider primitive values as well.
-    //
-    // So, even though 1 is not an instance of Number, we want to consider that
-    // it is valid.
-    if (typeof prop === "object") {
-      return prop instanceof propDef;
-    }
-    return typeof prop === propDef.name.toLowerCase();
-  } else if (propDef instanceof Array) {
-    // If this code is executed, this means that we want to check if a prop
-    // matches at least one of its descriptor.
-    let result = false;
-    for (let i = 0, iLen = propDef.length; i < iLen; i++) {
-      result = result || isValidProp(prop, propDef[i]);
-    }
-    return result;
-  }
-  // propsDef is an object
-  let result = isValidProp(prop, propDef.type);
-  if (propDef.type === Array) {
-    for (let i = 0, iLen = prop.length; i < iLen; i++) {
-      result = result && isValidProp(prop[i], propDef.element);
-    }
-  }
-  if (propDef.type === Object) {
-    const shape = propDef.shape;
-    for (let key in shape) {
-      result = result && isValidProp(prop[key], shape[key]);
-    }
-  }
-  return result;
-}
-
-//------------------------------------------------------------------------------
-// t-mounted
-//------------------------------------------------------------------------------
-QWeb.addDirective({
-  name: "mounted",
-  priority: 97,
-  atNodeCreation({ ctx, fullName, value, nodeID, addNodeHook }) {
-    ctx.rootContext.shouldDefineOwner = true;
-    const eventName = fullName.slice(5);
-    if (!eventName) {
-      throw new Error("Missing event name with t-on directive");
-    }
-    let extraArgs;
-    let handler = value.replace(/\(.*\)/, function(args) {
-      extraArgs = args.slice(1, -1);
-      return "";
-    });
-    let error = `(function () {throw new Error('Missing handler \\'' + '${handler}' + \`\\' when evaluating template '${ctx.templateName.replace(
-      /`/g,
-      "'"
-    )}'\`)})()`;
-    if (extraArgs) {
-      ctx.addLine(
-        `extra.mountedHandlers[${nodeID}] = (context['${handler}'] || ${error}).bind(owner, ${ctx.formatExpression(
-          extraArgs
-        )});`
-      );
-    } else {
-      ctx.addLine(
-        `extra.mountedHandlers[${nodeID}] = extra.mountedHandlers[${nodeID}] || (context['${handler}'] || ${error}).bind(owner);`
-      );
-    }
-    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.rootContext.shouldDefineOwner = true;
-    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
-      }, vars: extra.vars, parent: owner}));`
-    );
-    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}];`);
-  }
-});

src/component/props_validation.ts

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

src/core/observer.ts

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

src/index.ts

@@ -4,19 +4,21 @@
  *
  * Note that dynamic values, such as a date or a commit hash are added by rollup
  */
-export { Component } from "./component";
-export { EventBus } from "./event_bus";
-export { Observer } from "./observer";
-
-// we need to import manually the extra directives so they can register
-// themselves in QWeb, otherwise these files will not even be loaded.
-import "./qweb_directives";
-import "./qweb_extensions";
-import { QWeb } from "./qweb_core";
-export { QWeb };
-
-export { Store, ConnectedComponent } from "./store";
+import { EventBus } from "./core/event_bus";
+import { Observer } from "./core/observer";
+import { QWeb } from "./qweb/index";
+import { ConnectedComponent } from "./store/connected_component";
+import { Store } from "./store/store";
 import * as _utils from "./utils";
+import { Link } from "./router/Link";
+import { Router } from "./router/Router";
+
+export { Component } from "./component/component";
+export { QWeb };
+export const core = { EventBus, Observer };
+export const router = { Router, Link };
+export const store = { Store, ConnectedComponent };
+export const utils = _utils;
 
 export const __info__ = {};
 
@@ -36,4 +38,3 @@ Object.defineProperty(__info__, "mode", {
     }
   }
 });
-export const utils = _utils;

src/observer.ts

@@ -1,194 +0,0 @@
-/**
- * Owl Observer
- *
- * This code contains the logic that allows Owl to observe and react to state
- * changes.
- *
- * This is a Observer class that can observe any JS values.  The way it works
- * can be summarized thusly:
- * - primitive values are not observed at all
- * - Objects are observed by replacing all their keys with getters/setters
- *   (recursively)
- * - Arrays are observed by replacing their prototype with a customized version,
- *   which wrap some methods to allow the tracking of each state change.
- *
- * Note that this code is inspired by Vue.
- */
-
-//------------------------------------------------------------------------------
-// Modified Array prototype
-//------------------------------------------------------------------------------
-
-// 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 methodLen = methodsToPatch.length;
-
-const ArrayProto = Array.prototype;
-const ModifiedArrayProto = Object.create(ArrayProto);
-
-for (let i = 0; i < methodLen; i++) {
-  const method = methodsToPatch[i];
-  const initialMethod = ArrayProto[method];
-  ModifiedArrayProto[method] = function(...args) {
-    if (!this.__observer__.allowMutations) {
-      throw new Error(`Array cannot be changed here")`);
-    }
-    this.__observer__.rev++;
-    this.__observer__.notifyChange();
-    this.__owl__.rev++;
-    let parent = this;
-    do {
-      parent.__owl__.deepRev++;
-    } while ((parent = parent.__owl__.parent));
-    let inserted;
-    switch (method) {
-      case "push":
-      case "unshift":
-        inserted = args;
-        break;
-      case "splice":
-        inserted = args.slice(2);
-        break;
-    }
-    if (inserted) {
-      for (let i = 0, iLen = inserted.length; i < iLen; i++) {
-        this.__observer__.observe(inserted[i], this);
-      }
-    }
-    return initialMethod.call(this, ...args);
-  };
-}
-
-//------------------------------------------------------------------------------
-// Observer
-//------------------------------------------------------------------------------
-export class Observer {
-  rev: number = 1;
-  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;
-    Promise.resolve().then(() => {
-      if (this.dirty) {
-        this.dirty = false;
-        this.notifyCB();
-      }
-    });
-  }
-
-  observe(value: any, parent?: any) {
-    if (value === null) {
-      // fun fact: typeof null === 'object'
-      return;
-    }
-    if (typeof value !== "object") {
-      return;
-    }
-    if ("__owl__" in value) {
-      // already observed
-      value.__owl__.parent = parent;
-      return;
-    }
-    if (Array.isArray(value)) {
-      this._observeArr(value, parent);
-    } else {
-      this._observeObj(value, parent);
-    }
-  }
-
-  set(target: any, key: number | string, value: any) {
-    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,
-      observer: this
-    };
-    Object.defineProperty(obj, "__owl__", { enumerable: false });
-    for (let key in obj) {
-      this._addProp(obj, key, obj[key]);
-    }
-  }
-
-  _observeArr(arr: Array<any>, parent?: any) {
-    (<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;
-    for (let i = 0, iLen = arr.length; i < iLen; i++) {
-      this.observe(arr[i], arr);
-    }
-  }
-
-  _addProp<T extends { __owl__?: any }>(obj: T, key: string | number, value: any) {
-    var self = this;
-    Object.defineProperty(obj, key, {
-      configurable: true,
-      enumerable: true,
-      get() {
-        return value;
-      },
-      set(newVal) {
-        if (newVal !== value) {
-          if (!self.allowMutations) {
-            throw new Error(
-              `Observed state cannot be changed here! (key: "${key}", val: "${newVal}")`
-            );
-          }
-          self._updateRevNumber(obj);
-          value = newVal;
-          self.observe(newVal, 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);
-  }
-}

src/qweb/base_directives.ts

@@ -1,5 +1,6 @@
-import { Context, QWeb, UTILS } from "./qweb_core";
-import { QWebExprVar } from "./qweb_expressions";
+import { Context } from "./context";
+import { QWebExprVar } from "./expression_parser";
+import { QWeb } from "./qweb";
 
 /**
  * Owl QWeb Directives
@@ -18,7 +19,7 @@ import { QWebExprVar } from "./qweb_expressions";
 //------------------------------------------------------------------------------
 // t-esc and t-raw
 //------------------------------------------------------------------------------
-(<any>UTILS).getFragment = function(str: string): DocumentFragment {
+QWeb.utils.getFragment = function(str: string): DocumentFragment {
   const temp = document.createElement("template");
   temp.innerHTML = str;
   return temp.content;
@@ -57,7 +58,8 @@ function compileValueNode(value: any, node: Element, qweb: QWeb, ctx: Context) {
     }
   } else {
     let fragID = ctx.generateID();
-    ctx.addLine(`var frag${fragID} = this.utils.getFragment(${exprID})`);
+    ctx.rootContext.shouldDefineUtils = true;
+    ctx.addLine(`var frag${fragID} = 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),`);
@@ -80,6 +82,7 @@ QWeb.addDirective({
     if (node.nodeName !== "t") {
       let nodeID = qweb._compileGenericNode(node, ctx);
       ctx = ctx.withParent(nodeID);
+      ctx = ctx.subContext("currentKey", ctx.lastNodeKey);
     }
     let value = ctx.getValue(node.getAttribute("t-esc")!);
     compileValueNode(value, node, qweb, ctx.subContext("escaping", true));
@@ -94,6 +97,7 @@ QWeb.addDirective({
     if (node.nodeName !== "t") {
       let nodeID = qweb._compileGenericNode(node, ctx);
       ctx = ctx.withParent(nodeID);
+      ctx = ctx.subContext("currentKey", ctx.lastNodeKey);
     }
     let value = ctx.getValue(node.getAttribute("t-raw")!);
     compileValueNode(value, node, qweb, ctx);
@@ -200,8 +204,50 @@ QWeb.addDirective({
     const vars = Object.assign({}, ctx.variables, tempCtx.variables);
     ctx.rootContext.nextID = tempCtx.nextID;
 
+    const templateMap = Object.create(ctx.templates);
     // open new scope, if necessary
     const hasNewVariables = Object.keys(tempCtx.variables).length > 0;
+
+    // compile sub template
+    let subCtx = ctx.subContext("caller", nodeCopy).subContext("variables", Object.create(vars));
+    subCtx = subCtx.subContext("templates", templateMap);
+
+    if (templateMap[subTemplate]) {
+      // OUCH, IT IS A RECURSIVE TEMPLATE SITUATION...
+      // This is a tricky situation... We obviously cannot inline the compiled
+      // template. So, what we need to do is to compile it, and make sure we
+      // properly transfer everything from the current scope to the sub template.
+      ctx.rootContext.shouldTrackScope = true;
+      ctx.rootContext.shouldDefineOwner = true;
+      let subTemplateName;
+      if (ctx.hasParentWidget) {
+        subTemplateName = ctx.templateName;
+      } else {
+        subTemplateName = `__${ctx.generateID()}`;
+        subCtx.variables = {};
+        let id = 0;
+        for (let v in vars) {
+          subCtx.variables[v] = vars[v];
+          (vars[v] as any).id = `_v${id++}`;
+        }
+        const subTemplateFn = qweb._compile(subTemplateName, nodeTemplate.elem, subCtx);
+        qweb.recursiveFns[subTemplateName] = subTemplateFn;
+      }
+      let varCode = `{}`;
+      if (Object.keys(vars).length) {
+        let id = 0;
+        const content = Object.values(vars)
+          .map((v: any) => `_v${id++}: ${v.expr}`)
+          .join(",");
+        varCode = `{${content}}`;
+      }
+      ctx.addLine(
+        `this.recursiveFns['${subTemplateName}'].call(this, context, Object.assign({}, extra, {parentNode: c${ctx.parentNode}, vars: ${varCode}, scope}));`
+      );
+      return true;
+    }
+    templateMap[subTemplate] = true;
+
     if (hasNewVariables) {
       ctx.addLine("{");
       ctx.indent();
@@ -214,10 +260,6 @@ QWeb.addDirective({
         // todo: handle XML variables...
       }
     }
-
-    // compile sub template
-    const subCtx = ctx.subContext("caller", nodeCopy).subContext("variables", Object.create(vars));
-
     qweb._compileNode(nodeTemplate.elem, subCtx);
 
     // close new scope
@@ -226,6 +268,10 @@ QWeb.addDirective({
       ctx.addLine("}");
     }
 
+    if (node.hasAttribute("t-if") || node.hasAttribute("t-else") || node.hasAttribute("t-elif")) {
+      ctx.closeIf();
+    }
+
     return true;
   }
 });
@@ -255,11 +301,11 @@ QWeb.addDirective({
     ctx.addLine(`var _length${keysID} = _${keysID}.length;`);
     ctx.addLine(`for (let i = 0; i < _length${keysID}; i++) {`);
     ctx.indent();
-    ctx.addToScope(name + '_first', 'i === 0');
-    ctx.addToScope(name + '_last', `i === _length${keysID} - 1`);
-    ctx.addToScope(name + '_index', 'i');
+    ctx.addToScope(name + "_first", "i === 0");
+    ctx.addToScope(name + "_last", `i === _length${keysID} - 1`);
+    ctx.addToScope(name + "_index", "i");
     ctx.addToScope(name, `_${keysID}[i]`);
-    ctx.addToScope(name + '_value', `_${valuesID}[i]`);
+    ctx.addToScope(name + "_value", `_${valuesID}[i]`);
     const nodeCopy = <Element>node.cloneNode(true);
     let shouldWarn = nodeCopy.tagName !== "t" && !nodeCopy.hasAttribute("t-key");
     if (!shouldWarn && node.tagName === "t") {
@@ -277,9 +323,7 @@ QWeb.addDirective({
     }
     if (shouldWarn) {
       console.warn(
-        `Directive t-foreach should always be used with a t-key! (in template: '${
-          ctx.templateName
-        }')`
+        `Directive t-foreach should always be used with a t-key! (in template: '${ctx.templateName}')`
       );
     }
     nodeCopy.removeAttribute("t-foreach");

src/qweb/context.ts

@@ -0,0 +1,171 @@
+import { compileExpr, QWebVar } from "./expression_parser";
+
+//------------------------------------------------------------------------------
+// Compilation Context
+//------------------------------------------------------------------------------
+
+export class Context {
+  nextID: number = 1;
+  code: 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;
+  caller: Element | undefined;
+  shouldDefineOwner: boolean = false;
+  shouldDefineParent: boolean = false;
+  shouldDefineQWeb: boolean = false;
+  shouldDefineUtils: boolean = false;
+  shouldDefineResult: boolean = false;
+  shouldProtectContext: boolean = false;
+  shouldTrackScope: boolean = false;
+  inLoop: boolean = false;
+  inPreTag: boolean = false;
+  templateName: string;
+  allowMultipleRoots: boolean = false;
+  hasParentWidget: boolean = false;
+  scopeVars: any[] = [];
+  currentKey: string = "";
+  lastNodeKey: string = ""; // temp variable to communicate to previous caller
+  templates: { [key: string]: boolean } = {};
+
+  constructor(name?: string) {
+    this.rootContext = this;
+    this.templateName = name || "noname";
+    this.templates[this.templateName] = true;
+    this.addLine("var h = this.h;");
+  }
+
+  generateID(): number {
+    const id = this.rootContext.nextID++;
+    return id;
+  }
+
+  generateCode(): string[] {
+    const shouldTrackScope = this.shouldTrackScope && this.scopeVars.length;
+    if (shouldTrackScope) {
+      // add some vars to scope if needed
+      for (let scopeVar of this.scopeVars.reverse()) {
+        let { index, key, indent } = scopeVar;
+        const prefix = new Array(indent + 2).join("    ");
+        this.code.splice(index + 1, 0, prefix + `scope.${key} = context.${key};`);
+      }
+      this.code.unshift("    const scope = Object.create(null);");
+    }
+    if (this.shouldProtectContext) {
+      this.code.unshift("    context = Object.create(context);");
+    }
+    if (this.shouldDefineResult) {
+      this.code.unshift("    let result;");
+    }
+    if (this.shouldDefineOwner) {
+      // this is necessary to prevent some directives (t-forach for ex) to
+      // pollute the rendering context by adding some keys in it.
+      this.code.unshift("    let owner = context;");
+    }
+    if (this.shouldDefineParent) {
+      if (this.hasParentWidget) {
+        this.code.unshift("    let parent = extra.parent;");
+      } else {
+        this.code.unshift("    let parent = context;");
+      }
+    }
+    if (this.shouldDefineQWeb) {
+      this.code.unshift("    let QWeb = this.constructor;");
+    }
+    if (this.shouldDefineUtils) {
+      this.code.unshift("    let utils = this.constructor.utils;");
+    }
+    return this.code;
+  }
+
+  withParent(node: number): Context {
+    if (
+      !this.allowMultipleRoots &&
+      this === this.rootContext &&
+      (this.parentNode || this.parentTextNode)
+    ) {
+      throw new Error("A template should not have more than one root node");
+    }
+    if (!this.rootContext.rootNode) {
+      this.rootContext.rootNode = node;
+    }
+    return this.subContext("parentNode", node);
+  }
+
+  subContext(key: keyof Context, value: any): Context {
+    const newContext = Object.create(this);
+    newContext[key] = value;
+    return newContext;
+  }
+
+  indent() {
+    this.indentLevel++;
+  }
+
+  dedent() {
+    this.indentLevel--;
+  }
+
+  addLine(line: string): number {
+    const prefix = new Array(this.indentLevel + 2).join("    ");
+    this.code.push(prefix + line);
+    return this.code.length - 1;
+  }
+
+  addToScope(key: string, expr: string) {
+    const index = this.addLine(`context.${key} = ${expr};`);
+    this.rootContext.scopeVars.push({ index, key, indent: this.indentLevel });
+  }
+
+  addIf(condition: string) {
+    this.addLine(`if (${condition}) {`);
+    this.indent();
+  }
+
+  addElse() {
+    this.dedent();
+    this.addLine("} else {");
+    this.indent();
+  }
+
+  closeIf() {
+    this.dedent();
+    this.addLine("}");
+  }
+
+  getValue(val: any): any {
+    return val in this.variables ? this.getValue(this.variables[val]) : val;
+  }
+
+  /**
+   * Prepare an expression for being consumed at render time.  Its main job
+   * is to
+   * - replace unknown variables by a lookup in the context
+   * - replace already defined variables by their internal name
+   */
+  formatExpression(expr: string): string {
+    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 and enclosed in
+   * parentheses).
+   * For instance:
+   *   'Hello {{x}}!' -> `Hello ${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))})`;
+    }
+
+    let r = s.replace(/\{\{.*?\}\}/g, s => "${" + this.formatExpression(s.slice(2, -2)) + "}");
+    return "`" + r + "`";
+  }
+}

src/qweb/extensions.ts

@@ -0,0 +1,284 @@
+import { VNode } from "../vdom/index";
+import { QWeb } from "./qweb";
+
+/**
+ * Owl QWeb Extensions
+ *
+ * This file contains the implementation of non standard QWeb directives, added
+ * by Owl and that will only work on Owl projects:
+ *
+ * - t-on
+ * - t-ref
+ * - t-transition
+ * - t-mounted
+ * - t-slot
+ * - t-model
+ */
+
+//------------------------------------------------------------------------------
+// t-on
+//------------------------------------------------------------------------------
+// these are pieces of code that will be injected into the event handler if
+// modifiers are specified
+export const MODS_CODE = {
+  prevent: "e.preventDefault();",
+  self: "if (e.target !== this.elm) {return}",
+  stop: "e.stopPropagation();"
+};
+
+QWeb.addDirective({
+  name: "on",
+  priority: 90,
+  atNodeCreation({ ctx, fullName, value, nodeID }) {
+    ctx.rootContext.shouldDefineOwner = true;
+    const [eventName, ...mods] = fullName.slice(5).split(".");
+    if (!eventName) {
+      throw new Error("Missing event name with t-on directive");
+    }
+    let extraArgs;
+    let handlerName = value.replace(/\(.*\)/, function(args) {
+      extraArgs = args.slice(1, -1);
+      return "";
+    });
+    ctx.addIf(`!context['${handlerName}']`);
+    ctx.addLine(
+      `throw new Error('Missing handler \\'' + '${handlerName}' + \`\\' when evaluating template '${ctx.templateName.replace(
+        /`/g,
+        "'"
+      )}'\`)`
+    );
+    ctx.closeIf();
+    let params = extraArgs ? `owner, ${ctx.formatExpression(extraArgs)}` : "owner";
+    let handler;
+    if (mods.length > 0) {
+      handler = `function (e) {`;
+      handler += mods
+        .map(function(mod) {
+          return MODS_CODE[mod];
+        })
+        .join("");
+      handler += `context['${handlerName}'].call(${params}, e);}`;
+    } else {
+      handler = `context['${handlerName}'].bind(${params})`;
+    }
+    if (extraArgs) {
+      ctx.addLine(`p${nodeID}.on['${eventName}'] = ${handler};`);
+    } else {
+      ctx.addLine(
+        `extra.handlers['${eventName}' + ${nodeID}] = extra.handlers['${eventName}' + ${nodeID}] || ${handler};`
+      );
+      ctx.addLine(`p${nodeID}.on['${eventName}'] = extra.handlers['${eventName}' + ${nodeID}];`);
+    }
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-ref
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "ref",
+  priority: 95,
+  atNodeCreation({ ctx, value, addNodeHook }) {
+    const refKey = `ref${ctx.generateID()}`;
+    ctx.addLine(`const ${refKey} = ${ctx.interpolate(value)};`);
+    addNodeHook("create", `context.refs[${refKey}] = n.elm;`);
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-transition
+//------------------------------------------------------------------------------
+QWeb.utils.nextFrame = function(cb: () => void) {
+  requestAnimationFrame(() => requestAnimationFrame(cb));
+};
+
+QWeb.utils.transitionInsert = function(vn: VNode, name: string) {
+  const elm = <HTMLElement>vn.elm;
+  // remove potential duplicated vnode that is currently being removed, to
+  // prevent from having twice the same node in the DOM during an animation
+  const dup = elm.parentElement && elm.parentElement!.querySelector(`*[data-owl-key='${vn.key}']`);
+  if (dup) {
+    dup.remove();
+  }
+
+  elm.classList.add(name + "-enter");
+  elm.classList.add(name + "-enter-active");
+  const finalize = () => {
+    elm.classList.remove(name + "-enter-active");
+    elm.classList.remove(name + "-enter-to");
+  };
+  this.nextFrame(() => {
+    elm.classList.remove(name + "-enter");
+    elm.classList.add(name + "-enter-to");
+    whenTransitionEnd(elm, finalize);
+  });
+};
+
+QWeb.utils.transitionRemove = function(vn: VNode, name: string, rm: () => void) {
+  const elm = <HTMLElement>vn.elm;
+  elm.setAttribute("data-owl-key", vn.key!);
+
+  elm.classList.add(name + "-leave");
+  elm.classList.add(name + "-leave-active");
+  const finalize = () => {
+    elm.classList.remove(name + "-leave-active");
+    elm.classList.remove(name + "-leave-to");
+    rm();
+  };
+  this.nextFrame(() => {
+    elm.classList.remove(name + "-leave");
+    elm.classList.add(name + "-leave-to");
+    whenTransitionEnd(elm, finalize);
+  });
+};
+
+function getTimeout(delays: Array<string>, durations: Array<string>): number {
+  /* istanbul ignore next */
+  while (delays.length < durations.length) {
+    delays = delays.concat(delays);
+  }
+
+  return Math.max.apply(
+    null,
+    durations.map((d, i) => {
+      return toMs(d) + toMs(delays[i]);
+    })
+  );
+}
+
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s: string): number {
+  return Number(s.slice(0, -1).replace(",", ".")) * 1000;
+}
+
+function whenTransitionEnd(elm: HTMLElement, cb) {
+  const styles = window.getComputedStyle(elm);
+  const delays: Array<string> = (styles.transitionDelay || "").split(", ");
+  const durations: Array<string> = (styles.transitionDuration || "").split(", ");
+  const timeout: number = getTimeout(delays, durations);
+  if (timeout > 0) {
+    elm.addEventListener("transitionend", cb, { once: true });
+  } else {
+    cb();
+  }
+}
+
+QWeb.addDirective({
+  name: "transition",
+  priority: 96,
+  atNodeCreation({ ctx, value, addNodeHook }) {
+    ctx.rootContext.shouldDefineUtils = true;
+    let name = value;
+    const hooks = {
+      insert: `utils.transitionInsert(vn, '${name}');`,
+      remove: `utils.transitionRemove(vn, '${name}', rm);`
+    };
+    for (let hookName in hooks) {
+      addNodeHook(hookName, hooks[hookName]);
+    }
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-mounted
+//------------------------------------------------------------------------------
+QWeb.addDirective({
+  name: "mounted",
+  priority: 97,
+  atNodeCreation({ ctx, fullName, value, nodeID, addNodeHook }) {
+    ctx.rootContext.shouldDefineOwner = true;
+    const eventName = fullName.slice(5);
+    if (!eventName) {
+      throw new Error("Missing event name with t-on directive");
+    }
+    let extraArgs;
+    let handler = value.replace(/\(.*\)/, function(args) {
+      extraArgs = args.slice(1, -1);
+      return "";
+    });
+    let error = `(function () {throw new Error('Missing handler \\'' + '${handler}' + \`\\' when evaluating template '${ctx.templateName.replace(
+      /`/g,
+      "'"
+    )}'\`)})()`;
+    if (extraArgs) {
+      ctx.addLine(
+        `extra.mountedHandlers[${nodeID}] = (context['${handler}'] || ${error}).bind(owner, ${ctx.formatExpression(
+          extraArgs
+        )});`
+      );
+    } else {
+      ctx.addLine(
+        `extra.mountedHandlers[${nodeID}] = extra.mountedHandlers[${nodeID}] || (context['${handler}'] || ${error}).bind(owner);`
+      );
+    }
+    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.rootContext.shouldDefineOwner = true;
+    ctx.addLine(`const slot${slotKey} = this.slots[context.__owl__.slotId + '_' + '${value}'];`);
+    ctx.addIf(`slot${slotKey}`);
+    ctx.addLine(
+      `slot${slotKey}.call(this, context.__owl__.parent, Object.assign({}, extra, {parentNode: c${ctx.parentNode}, vars: extra.vars, parent: owner}));`
+    );
+    ctx.closeIf();
+    return true;
+  }
+});
+
+//------------------------------------------------------------------------------
+// t-model
+//------------------------------------------------------------------------------
+QWeb.utils.toNumber = function(val: string): number | string {
+  const n = parseFloat(val);
+  return isNaN(n) ? val : n;
+};
+
+QWeb.addDirective({
+  name: "model",
+  priority: 42,
+  atNodeCreation({ ctx, nodeID, value, node, fullName, addNodeHook }) {
+    const type = node.getAttribute("type");
+    let handler;
+    let event = fullName.includes(".lazy") ? "change" : "input";
+    const expr = ctx.formatExpression(`state.${value}`);
+    if (node.tagName === "select") {
+      ctx.addLine(`p${nodeID}.props = {value: ${expr}};`);
+      addNodeHook("create", `n.elm.value=${expr};`);
+      event = "change";
+      handler = `(ev) => {${expr} = ev.target.value}`;
+    } else if (type === "checkbox") {
+      ctx.addLine(`p${nodeID}.props = {checked: ${expr}};`);
+      handler = `(ev) => {${expr} = ev.target.checked}`;
+    } else if (type === "radio") {
+      const nodeValue = node.getAttribute("value")!;
+      ctx.addLine(`p${nodeID}.props = {checked:${expr} === '${nodeValue}'};`);
+      handler = `(ev) => {${expr} = ev.target.value}`;
+      event = "click";
+    } else {
+      ctx.addLine(`p${nodeID}.props = {value: ${expr}};`);
+      const trimCode = fullName.includes(".trim") ? ".trim()" : "";
+      let valueCode = `ev.target.value${trimCode}`;
+      if (fullName.includes(".number")) {
+        ctx.rootContext.shouldDefineUtils = true;
+        valueCode = `utils.toNumber(${valueCode})`;
+      }
+      handler = `(ev) => {${expr} = ${valueCode}}`;
+    }
+    ctx.addLine(
+      `extra.handlers['${event}' + ${nodeID}] = extra.handlers['${event}' + ${nodeID}] || (${handler});`
+    );
+    ctx.addLine(`p${nodeID}.on['${event}'] = extra.handlers['${event}' + ${nodeID}];`);
+  }
+});

src/qweb/index.ts

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

src/qweb/qweb.ts

@@ -1,6 +1,7 @@
-import { VNode, h, patch } from "./vdom";
-import { QWebVar, compileExpr } from "./qweb_expressions";
-import { EventBus } from "./event_bus";
+import { EventBus } from "../core/event_bus";
+import { h, patch, VNode } from "../vdom/index";
+import { Context } from "./context";
+import { shallowEqual } from "../utils";
 
 /**
  * Owl QWeb Engine
@@ -64,15 +65,6 @@ const DISABLED_TAGS = ["input", "textarea", "button", "select", "option", "optgr
 const lineBreakRE = /[\r\n]/;
 const whitespaceRE = /\s+/g;
 
-const DIRECTIVE_NAMES = {
-  name: 1,
-  att: 1,
-  attf: 1,
-  key: 1
-};
-
-const DIRECTIVES: Directive[] = [];
-
 const NODE_HOOKS_PARAMS = {
   create: "(_, n)",
   insert: "vn",
@@ -80,14 +72,12 @@ const NODE_HOOKS_PARAMS = {
 };
 
 interface Utils {
-  h: typeof h;
   toObj(expr: any): Object;
   shallowEqual(p1: Object, p2: Object): boolean;
   [key: string]: any;
 }
 
-export const UTILS: Utils = {
-  h: h,
+const UTILS: Utils = {
   toObj(expr) {
     if (typeof expr === "string") {
       expr = expr.trim();
@@ -103,14 +93,7 @@ export const UTILS: Utils = {
     }
     return expr;
   },
-  shallowEqual(p1, p2) {
-    for (let k in p1) {
-      if (p1[k] !== p2[k]) {
-        return false;
-      }
-    }
-    return true;
-  }
+  shallowEqual
 };
 
 function parseXML(xml: string): Document {
@@ -149,9 +132,18 @@ let nextID = 1;
 //------------------------------------------------------------------------------
 export class QWeb extends EventBus {
   templates: { [name: string]: Template } = {};
-  utils = UTILS;
+  static utils = UTILS;
   static components = Object.create(null);
 
+  static DIRECTIVE_NAMES: { [key: string]: 1 } = {
+    name: 1,
+    att: 1,
+    attf: 1,
+    key: 1
+  };
+  static DIRECTIVES: Directive[] = [];
+
+  h = h;
   // dev mode enables better error messages or more costly validations
   static dev: boolean = false;
 
@@ -165,6 +157,13 @@ export class QWeb extends EventBus {
   slots = {};
   nextSlotId = 1;
 
+  // recursiveTemplates contains sub templates called with t-call, but which
+  // ends up in recursive situations.  This is very similar to the slot situation,
+  // as in we need to propagate the scope.
+  recursiveFns = {};
+
+  isUpdating: boolean = false;
+
   constructor(data?: string) {
     super();
     if (data) {
@@ -173,11 +172,14 @@ export class QWeb extends EventBus {
   }
 
   static addDirective(directive: Directive) {
-    DIRECTIVES.push(directive);
-    DIRECTIVE_NAMES[directive.name] = 1;
-    DIRECTIVES.sort((d1, d2) => d1.priority - d2.priority);
+    if (directive.name in QWeb.DIRECTIVE_NAMES) {
+      throw new Error(`Directive "${directive.name} already registered`);
+    }
+    QWeb.DIRECTIVES.push(directive);
+    QWeb.DIRECTIVE_NAMES[directive.name] = 1;
+    QWeb.DIRECTIVES.sort((d1, d2) => d1.priority - d2.priority);
     if (directive.extraNames) {
-      directive.extraNames.forEach(n => (DIRECTIVE_NAMES[n] = 1));
+      directive.extraNames.forEach(n => (QWeb.DIRECTIVE_NAMES[n] = 1));
     }
   }
 
@@ -204,12 +206,12 @@ export class QWeb extends EventBus {
   }
 
   /**
-   * Load templates from a xml (as a string).  This will look up for the first
-   * <templates> tag, and will consider each child of this as a template, with
-   * the name given by the t-name attribute.
+   * Load templates from a xml (as a string or xml document).  This will look up
+   * for the first <templates> tag, and will consider each child of this as a
+   * template, with the name given by the t-name attribute.
    */
-  addTemplates(xmlstr: string) {
-    const doc = parseXML(xmlstr);
+  addTemplates(xmlstr: string | Document) {
+    const doc = typeof xmlstr === "string" ? parseXML(xmlstr) : xmlstr;
     const templates = doc.getElementsByTagName("templates")[0];
     if (!templates) {
       return;
@@ -305,10 +307,27 @@ export class QWeb extends EventBus {
     return (<HTMLElement>result.elm).outerHTML;
   }
 
+  /**
+   * Force all widgets connected to this QWeb instance to rerender themselves.
+   *
+   * This method is mostly useful for external code that want to modify the
+   * application in some cases.  For example, a router plugin.
+   */
+  forceUpdate() {
+    this.isUpdating = true;
+    Promise.resolve().then(() => {
+      if (this.isUpdating) {
+        this.isUpdating = false;
+        this.trigger("update");
+      }
+    });
+  }
+
   _compile(name: string, elem: Element, parentContext?: Context): CompiledTemplate {
     const isDebug = elem.attributes.hasOwnProperty("t-debug");
     const ctx = new Context(name);
     if (parentContext) {
+      ctx.templates = Object.create(parentContext.templates);
       ctx.variables = Object.create(parentContext.variables);
       ctx.nextID = parentContext.parentNode! + 1;
       ctx.parentNode = parentContext.parentNode!;
@@ -414,16 +433,16 @@ export class QWeb extends EventBus {
       let attrName = attributes[i].name;
       if (attrName.startsWith("t-")) {
         let dName = attrName.slice(2).split(/-|\./)[0];
-        if (!(dName in DIRECTIVE_NAMES)) {
+        if (!(dName in QWeb.DIRECTIVE_NAMES)) {
           throw new Error(`Unknown QWeb directive: '${attrName}'`);
         }
       }
     }
 
-    const DIR_N = DIRECTIVES.length;
+    const DIR_N = QWeb.DIRECTIVES.length;
     const ATTR_N = attributes.length;
     for (let i = 0; i < DIR_N; i++) {
-      let directive = DIRECTIVES[i];
+      let directive = QWeb.DIRECTIVES[i];
       let fullName;
       let value;
       for (let j = 0; j < ATTR_N; j++) {
@@ -460,6 +479,7 @@ export class QWeb extends EventBus {
     if (node.nodeName !== "t") {
       let nodeID = this._compileGenericNode(node, ctx, withHandlers);
       ctx = ctx.withParent(nodeID);
+      ctx = ctx.subContext("currentKey", ctx.lastNodeKey);
       let nodeHooks = {};
       let addNodeHook = function(hook, handler) {
         nodeHooks[hook] = nodeHooks[hook] || [];
@@ -571,7 +591,8 @@ export class QWeb extends EventBus {
         let formattedValue = v.id || ctx.formatExpression(v);
 
         if (attName === "class") {
-          formattedValue = `this.utils.toObj(${formattedValue})`;
+          ctx.rootContext.shouldDefineUtils = true;
+          formattedValue = `utils.toObj(${formattedValue})`;
           if (classObj) {
             ctx.addLine(`Object.assign(${classObj}, ${formattedValue})`);
           } else {
@@ -627,7 +648,9 @@ export class QWeb extends EventBus {
     let nodeID = ctx.generateID();
     let nodeKey: any = (<Element>node).getAttribute("t-key");
     if (nodeKey) {
-      nodeKey = ctx.formatExpression(nodeKey);
+      ctx.addLine(`const nodeKey${nodeID} = ${ctx.formatExpression(nodeKey)}`);
+      nodeKey = `nodeKey${nodeID}`;
+      ctx.lastNodeKey = nodeKey;
     } else {
       nodeKey = nodeID;
     }
@@ -673,169 +696,3 @@ export class QWeb extends EventBus {
     }
   }
 }
-
-//------------------------------------------------------------------------------
-// Compilation Context
-//------------------------------------------------------------------------------
-
-export class Context {
-  nextID: number = 1;
-  code: 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;
-  caller: Element | undefined;
-  shouldDefineOwner: boolean = false;
-  shouldDefineParent: boolean = false;
-  shouldDefineQWeb: boolean = false;
-  shouldDefineUtils: boolean = false;
-  shouldDefineResult: boolean = false;
-  shouldProtectContext: boolean = false;
-  shouldTrackScope: boolean = false;
-  inLoop: boolean = false;
-  inPreTag: boolean = false;
-  templateName: string;
-  allowMultipleRoots: boolean = false;
-  hasParentWidget: boolean = false;
-  scopeVars: any[] = [];
-
-  constructor(name?: string) {
-    this.rootContext = this;
-    this.templateName = name || "noname";
-    this.addLine("var h = this.utils.h;");
-  }
-
-  generateID(): number {
-    const id = this.rootContext.nextID++;
-    return id;
-  }
-
-  generateCode(): string[] {
-    const shouldTrackScope = this.shouldTrackScope && this.scopeVars.length;
-    if (shouldTrackScope) {
-      // add some vars to scope if needed
-      for (let scopeVar of this.scopeVars.reverse()) {
-        let { index, key, indent } = scopeVar;
-        const prefix = new Array(indent + 2).join("    ");
-        this.code.splice(index + 1, 0, prefix + `scope.${key} = context.${key};`);
-      }
-      this.code.unshift("    const scope = Object.create(null);");
-    }
-    if (this.shouldProtectContext) {
-      this.code.unshift("    context = Object.create(context);");
-    }
-    if (this.shouldDefineResult) {
-      this.code.unshift("    let result;");
-    }
-    if (this.shouldDefineOwner) {
-      // this is necessary to prevent some directives (t-forach for ex) to
-      // pollute the rendering context by adding some keys in it.
-      this.code.unshift("    let owner = context;");
-    }
-    if (this.shouldDefineParent) {
-      if (this.hasParentWidget) {
-        this.code.unshift("    let parent = extra.parent;");
-      } else {
-        this.code.unshift("    let parent = context;");
-      }
-    }
-    if (this.shouldDefineQWeb) {
-      this.code.unshift("    let QWeb = this.constructor;");
-    }
-    if (this.shouldDefineUtils) {
-      this.code.unshift("    let utils = this.utils;");
-    }
-    return this.code;
-  }
-
-  withParent(node: number): Context {
-    if (
-      !this.allowMultipleRoots &&
-      this === this.rootContext &&
-      (this.parentNode || this.parentTextNode)
-    ) {
-      throw new Error("A template should not have more than one root node");
-    }
-    if (!this.rootContext.rootNode) {
-      this.rootContext.rootNode = node;
-    }
-    return this.subContext("parentNode", node);
-  }
-
-  subContext(key: keyof Context, value: any): Context {
-    const newContext = Object.create(this);
-    newContext[key] = value;
-    return newContext;
-  }
-
-  indent() {
-    this.indentLevel++;
-  }
-
-  dedent() {
-    this.indentLevel--;
-  }
-
-  addLine(line: string): number {
-    const prefix = new Array(this.indentLevel + 2).join("    ");
-    this.code.push(prefix + line);
-    return this.code.length - 1;
-  }
-
-  addToScope(key: string, expr: string) {
-    const index = this.addLine(`context.${key} = ${expr};`);
-    this.rootContext.scopeVars.push({ index, key, indent: this.indentLevel });
-  }
-
-  addIf(condition: string) {
-    this.addLine(`if (${condition}) {`);
-    this.indent();
-  }
-
-  addElse() {
-    this.dedent();
-    this.addLine("} else {");
-    this.indent();
-  }
-
-  closeIf() {
-    this.dedent();
-    this.addLine("}");
-  }
-
-  getValue(val: any): any {
-    return val in this.variables ? this.getValue(this.variables[val]) : val;
-  }
-
-  /**
-   * Prepare an expression for being consumed at render time.  Its main job
-   * is to
-   * - replace unknown variables by a lookup in the context
-   * - replace already defined variables by their internal name
-   */
-  formatExpression(expr: string): string {
-    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 and enclosed in
-   * parentheses).
-   * For instance:
-   *   'Hello {{x}}!' -> `Hello ${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))})`;
-    }
-
-    let r = s.replace(/\{\{.*?\}\}/g, s => "${" + this.formatExpression(s.slice(2, -2)) + "}");
-    return "`" + r + "`";
-  }
-}

src/router/Link.ts

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

src/router/Router.ts

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

src/router/directive.ts

@@ -0,0 +1,31 @@
+import { RouterEnv } from "./Router";
+
+export function makeDirective(env: RouterEnv) {
+  return {
+    name: "routecomponent",
+    priority: 13,
+    atNodeEncounter({ node }): boolean {
+      let first = true;
+      const router = env.router;
+      for (let name of router.routeIds) {
+        const route = router.routes[name];
+        if (route.component) {
+          // make new t t-component element
+          const comp = node.ownerDocument.createElement("t");
+          comp.setAttribute("t-component", "__component__" + route.name);
+          comp.setAttribute(
+            first ? "t-if" : "t-elif",
+            `env.router.currentRouteName === '${route.name}'`
+          );
+          first = false;
+          for (let param of route.params) {
+            comp.setAttribute(param, `env.router.currentParams.${param}`);
+          }
+          node.appendChild(comp);
+        }
+      }
+      node.removeAttribute("t-routecomponent");
+      return false;
+    }
+  };
+}

src/store.ts

@@ -1,306 +0,0 @@
-import { Component, Env } from "./component";
-import { EventBus } from "./event_bus";
-import { Observer } from "./observer";
-
-/**
- * Owl Store
- *
- * We have here:
- * - a Store class
- * - the ConnectedComponent class
- *
- * The Owl store is our answer to the problem of managing complex state across
- * components. The main idea is that the store owns some state, allow external
- * code to modify it through actions/mutations, and for each state changes,
- * connected component will be notified, and updated if necessary.
- *
- * Note that this code is partly inspired by VueX and React/Redux
- */
-
-//------------------------------------------------------------------------------
-// Store Definition
-//------------------------------------------------------------------------------
-
-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 {
-  env?: Env;
-  state?: any;
-  actions?: { [name: string]: Action };
-  getters?: { [name: string]: Getter };
-  mutations?: { [name: string]: Mutation };
-}
-
-interface StoreOption {
-  debug?: boolean;
-}
-
-export class Store extends EventBus {
-  state: any;
-  actions: any;
-  mutations: any;
-  _commitLevel: number = 0;
-  history: any[] = [];
-  debug: boolean;
-  env: any;
-  observer: Observer;
-  getters: { [name: string]: (payload?) => any };
-  _gettersCache: { [name: string]: {} };
-  _updateId: number = 1;
-
-  constructor(config: StoreConfig, options: StoreOption = {}) {
-    super();
-    this.debug = options.debug || false;
-    this.state = config.state || {};
-    this.actions = config.actions;
-    this.mutations = config.mutations;
-    this.env = config.env;
-    this.observer = new Observer();
-    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 });
-    }
-
-    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 {
-    if (!this.actions[action]) {
-      throw new Error(`[Error] action ${action} is undefined`);
-    }
-    const result = this.actions[action](
-      {
-        commit: this.commit.bind(this),
-        dispatch: this.dispatch.bind(this),
-        env: this.env,
-        state: this.state,
-        getters: this.getters
-      },
-      ...payload
-    );
-    if (result instanceof Promise) {
-      return new Promise((resolve, reject) => {
-        result.then(() => resolve());
-        result.catch(reject);
-      });
-    }
-  }
-
-  commit(type: string, ...payload: any): any {
-    if (!this.mutations[type]) {
-      throw new Error(`[Error] mutation ${type} is undefined`);
-    }
-    this._commitLevel++;
-    this.observer.allowMutations = true;
-
-    const res = this.mutations[type].call(
-      null,
-      {
-        commit: this.commit.bind(this),
-        state: this.state,
-        getters: this.getters
-      },
-      ...payload
-    );
-
-    if (this._commitLevel === 1) {
-      this.observer.allowMutations = false;
-      if (this.debug) {
-        this.history.push({
-          state: this.state,
-          mutation: type,
-          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);
-      }
-    }
-  }
-}
-
-//------------------------------------------------------------------------------
-// Connect function
-//------------------------------------------------------------------------------
-
-function revNumber<T extends Object>(o: T): number {
-  if (o !== null && typeof o === "object" && (<any>o).__owl__) {
-    return (<any>o).__owl__.rev;
-  }
-  return 0;
-}
-
-function deepRevNumber<T extends Object>(o: T): number {
-  if (o !== null && typeof o === "object" && (<any>o).__owl__) {
-    return (<any>o).__owl__.deepRev;
-  }
-  return 0;
-}
-
-type HashFunction = (a: any, b: any) => number;
-
-export class ConnectedComponent<T extends Env, P, S> extends Component<T, P, S> {
-  deep: boolean = true;
-  getStore(env) {
-    return env.store;
-  }
-
-  hashFunction: HashFunction = ({ storeProps }, options) => {
-    let refFunction = this.deep ? deepRevNumber : revNumber;
-    if ("__owl__" in storeProps) {
-      return refFunction(storeProps);
-    }
-    const { currentStoreProps } = options;
-    let hash = 0;
-    for (let key in storeProps) {
-      const val = storeProps[key];
-      const hashVal = refFunction(val);
-      if (hashVal === 0) {
-        if (val !== currentStoreProps[key]) {
-          options.didChange = true;
-        }
-      } else {
-        hash += hashVal;
-      }
-    }
-    return hash;
-  };
-
-  static mapStoreToProps(storeState, ownProps, getters) {
-    return {};
-  }
-  constructor(parent, props?: any) {
-    super(parent, props);
-    const store = this.getStore(this.env);
-    const ownProps = Object.assign({}, props || {});
-    const storeProps = (<any>this.constructor).mapStoreToProps(
-      store.state,
-      ownProps,
-      store.getters
-    );
-    const mergedProps = Object.assign({}, props || {}, storeProps);
-    this.props = mergedProps;
-    (<any>this.__owl__).ownProps = ownProps;
-    (<any>this.__owl__).currentStoreProps = storeProps;
-    (<any>this.__owl__).store = store;
-    (<any>this.__owl__).storeHash = this.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 = (<any>this.constructor).mapStoreToProps(
-      (<any>this.__owl__).store.state,
-      ownProps,
-      (<any>this.__owl__).store.getters
-    );
-    const options: any = {
-      currentStoreProps: (<any>this.__owl__).currentStoreProps
-    };
-    const storeHash = this.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;
-      await this.__updateProps(ownProps, false);
-    }
-  }
-  __updateProps(nextProps, forceUpdate, patchQueue?: any[]) {
-    const __owl__ = <any>this.__owl__;
-    __owl__.currentUpdateId = __owl__.store._updateId;
-    if (__owl__.ownProps !== nextProps) {
-      __owl__.currentStoreProps = (<any>this.constructor).mapStoreToProps(
-        __owl__.store.state,
-        nextProps,
-        __owl__.store.getters
-      );
-    }
-    __owl__.ownProps = nextProps;
-    const mergedProps = Object.assign({}, nextProps, __owl__.currentStoreProps);
-    return super.__updateProps(mergedProps, forceUpdate, patchQueue);
-  }
-}

src/store/connected_component.ts

@@ -0,0 +1,149 @@
+import { Component, Env } from "../component/component";
+
+//------------------------------------------------------------------------------
+// Connect function
+//------------------------------------------------------------------------------
+
+type HashFunction = (a: any, b: any) => number;
+
+export class ConnectedComponent<T extends Env, P, S> extends Component<T, P, S> {
+  deep: boolean = true;
+  getStore(env) {
+    return env.store;
+  }
+
+  storeProps: any;
+
+  hashFunction: HashFunction = (storeProps, options) => {
+    const revFn = (this.__owl__ as any).revFn;
+    const rev = revFn(storeProps);
+    if (rev > 0) {
+      return rev;
+    }
+    let hash = 0;
+    for (let key in storeProps) {
+      const val = storeProps[key];
+      const hashVal = revFn(val);
+      if (hashVal === 0) {
+        if (val !== options.prevStoreProps[key]) {
+          options.didChange = true;
+        }
+      } else {
+        hash += hashVal;
+      }
+    }
+    return hash;
+  };
+
+  static mapStoreToProps(storeState, ownProps, getters) {
+    return {};
+  }
+
+  dispatch(name, ...payload) {
+    return (this.__owl__ as any).store.dispatch(name, ...payload);
+  }
+
+  /**
+   * Need to do this here so 'deep' can be overrided by subcomponent easily
+   */
+  async __prepareAndRender(
+    scope?: Object,
+    vars?: any
+  ): ReturnType<Component<any, any, any>["__prepareAndRender"]> {
+    const store = this.getStore(this.env);
+    const ownProps = this.props || {};
+    this.storeProps = (<any>this.constructor).mapStoreToProps(store.state, ownProps, store.getters);
+    const observer = store.observer;
+    const revFn = this.deep ? observer.deepRevNumber : observer.revNumber;
+    (this.__owl__ as any).store = store;
+    (this.__owl__ as any).ownProps = this.props;
+    (this.__owl__ as any).revFn = revFn.bind(observer);
+    (this.__owl__ as any).storeHash = this.hashFunction(this.storeProps, {
+      prevStoreProps: this.storeProps
+    });
+    (this.__owl__ as any).rev = observer.rev;
+    return super.__prepareAndRender(scope, vars);
+  }
+  /**
+   * 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.__owl__ as any).store.on("update", this, this.__checkUpdate);
+    super.__callMounted();
+  }
+  __callWillUnmount() {
+    (this.__owl__ as any).store.off("update", this);
+    super.__callWillUnmount();
+  }
+  __destroy(parent: any) {
+    (this.__owl__ as any).store.off("update", this);
+    super.__destroy(parent);
+  }
+
+  async render(force: boolean = false) {
+    this.__updateStoreProps(this.props);
+
+    // this is quite technical, so this deserves some explanation.
+    // When we have a connected component, it can be updated for 3 reasons:
+    // - some internal state changes (this will go through this method)
+    // - some props changes (if a parent is changed and need to rerender itself)
+    // - a store update
+    //
+    // It is possible (with connected component and parent) to have the following
+    // situation: the parent component is rendered first (from its state change),
+    // then immediately after, it is rendered (from store update). Then, if the
+    // __checkUpdate method is immediately over, the children component will
+    // be rendered again by the store update, even though it is supposed to be
+    // destroyed by the first rendering.
+    //
+    // So, the solution is to keep the information that there is a current
+    // rendering occuring with the same store state, the same props, and return
+    // that in the __checkUpdate method.  To do this, we use the renderPromise
+    // deferred, which is not used by the component system once the
+    // component is ready, so we can use it for our own purpose.
+    (this.__owl__ as any).renderPromise = super.render(force);
+    return (this.__owl__ as any).renderPromise;
+  }
+
+  async __updateProps(nextProps: P, f, p, s, v) {
+    this.__updateStoreProps(nextProps);
+    return super.__updateProps(nextProps, f, p, s, v);
+  }
+
+  __updateStoreProps(nextProps): boolean {
+    const __owl__ = this.__owl__ as any;
+    const store = __owl__.store;
+    const observer = store.observer;
+    if (observer.rev === __owl__.rev && nextProps === __owl__.ownProps) {
+      return false;
+    }
+
+    const storeProps = (<any>this.constructor).mapStoreToProps(
+      store.state,
+      nextProps,
+      store.getters
+    );
+    const options = { prevStoreProps: this.storeProps, didChange: false };
+    const storeHash = this.hashFunction(storeProps, options);
+    this.storeProps = storeProps;
+    let didChange = options.didChange;
+    if (storeHash !== __owl__.storeHash) {
+      __owl__.storeHash = storeHash;
+      didChange = true;
+    }
+    __owl__.rev = store.observer.rev;
+    __owl__.ownProps = nextProps;
+    return didChange;
+  }
+
+  async __checkUpdate() {
+    const didChange = this.__updateStoreProps(this.props);
+    if (didChange) {
+      return this.render();
+    }
+    // see note in render method
+    return (this.__owl__ as any).renderPromise;
+  }
+}

src/store/store.ts

@@ -0,0 +1,107 @@
+import { Env } from "../component/component";
+import { EventBus } from "../core/event_bus";
+import { Observer } from "../core/observer";
+
+/**
+ * Owl Store
+ *
+ * We have here:
+ * - a Store class
+ * - the ConnectedComponent class
+ *
+ * The Owl store is our answer to the problem of managing complex state across
+ * components. The main idea is that the store owns some state, allow external
+ * code to modify it through actions, and for each state changes,
+ * connected component will be notified, and updated if necessary.
+ *
+ * Note that this code is partly inspired by VueX and React/Redux
+ */
+
+//------------------------------------------------------------------------------
+// Store Definition
+//------------------------------------------------------------------------------
+
+export type Action = ({ state, dispatch, env, getters }, ...payload: any) => any;
+export type Getter = ({ state: any, getters }, payload?) => any;
+
+interface StoreConfig {
+  env?: Env;
+  state?: any;
+  actions?: { [name: string]: Action };
+  getters?: { [name: string]: Getter };
+}
+
+interface StoreOption {
+  debug?: boolean;
+}
+
+export class Store extends EventBus {
+  state: any;
+  actions: any;
+  mutations: any;
+  debug: boolean;
+  env: any;
+  observer: Observer;
+  getters: { [name: string]: (payload?) => any };
+
+  constructor(config: StoreConfig, options: StoreOption = {}) {
+    super();
+    this.debug = options.debug || false;
+    this.actions = config.actions;
+    this.env = config.env;
+    this.observer = new Observer();
+    this.observer.notifyCB = this.__notifyComponents.bind(this);
+    this.state = this.observer.observe(config.state || {});
+    this.getters = {};
+    if (config.getters) {
+      const firstArg = {
+        state: this.state,
+        getters: this.getters
+      };
+      for (let g in config.getters) {
+        this.getters[g] = config.getters[g].bind(this, firstArg);
+      }
+    }
+  }
+
+  dispatch(action: string, ...payload: any): Promise<void> | void {
+    if (!this.actions[action]) {
+      throw new Error(`[Error] action ${action} is undefined`);
+    }
+    const result = this.actions[action](
+      {
+        dispatch: this.dispatch.bind(this),
+        env: this.env,
+        state: this.state,
+        getters: this.getters
+      },
+      ...payload
+    );
+    return result;
+  }
+
+  /**
+   * 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() {
+    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);
+      }
+    }
+  }
+}

src/utils.ts

@@ -10,7 +10,7 @@
  * - debounce
  */
 
-export function whenReady(fn) {
+export function whenReady(fn?: any) {
   return new Promise(function(resolve) {
     if (document.readyState !== "loading") {
       resolve();
@@ -95,3 +95,12 @@ export function debounce(func: Function, wait: number, immediate?: boolean): Fun
     }
   };
 }
+
+export function shallowEqual(p1, p2): boolean {
+  for (let k in p1) {
+    if (p1[k] !== p2[k]) {
+      return false;
+    }
+  }
+  return true;
+}

src/vdom/index.ts

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

src/vdom/modules.ts

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

src/vdom/vdom.ts

@@ -27,6 +27,21 @@ declare global {
   }
 }
 
+type Props = Record<string, any>;
+type Attrs = Record<string, string | number | boolean>;
+type On = { [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void } & {
+  [event: string]: EventListener;
+};
+
+export interface Module {
+  pre: PreHook;
+  create: CreateHook;
+  update: UpdateHook;
+  destroy: DestroyHook;
+  remove: RemoveHook;
+  post: PostHook;
+}
+
 //------------------------------------------------------------------------------
 // vnode.ts
 //------------------------------------------------------------------------------
@@ -41,7 +56,7 @@ export interface VNode {
   key: Key | undefined;
 }
 
-interface VNodeData {
+export interface VNodeData {
   props?: Props;
   attrs?: Attrs;
   on?: On;
@@ -454,10 +469,6 @@ interface DOMAPI {
   nextSibling: (node: Node) => Node;
   tagName: (elm: Element) => string;
   setTextContent: (node: Node, text: string | null) => void;
-  getTextContent: (node: Node) => string | null;
-  isElement: (node: Node) => node is Element;
-  isText: (node: Node) => node is Text;
-  isComment: (node: Node) => node is Comment;
 }
 
 function createElement(tagName: any): HTMLElement {
@@ -504,22 +515,6 @@ function setTextContent(node: Node, text: string | null): void {
   node.textContent = text;
 }
 
-function getTextContent(node: Node): string | null {
-  return node.textContent;
-}
-
-function isElement(node: Node): node is Element {
-  return node.nodeType === 1;
-}
-
-function isText(node: Node): node is Text {
-  return node.nodeType === 3;
-}
-
-function isComment(node: Node): node is Comment {
-  return node.nodeType === 8;
-}
-
 const htmlDomApi = {
   createElement,
   createElementNS,
@@ -531,11 +526,7 @@ const htmlDomApi = {
   parentNode,
   nextSibling,
   tagName,
-  setTextContent,
-  getTextContent,
-  isElement,
-  isText,
-  isComment
+  setTextContent
 } as DOMAPI;
 
 //------------------------------------------------------------------------------
@@ -631,258 +622,3 @@ export function h(sel: any, b?: any, c?: any): VNode {
   }
   return vnode(sel, data, children, text, undefined);
 }
-
-//------------------------------------------------------------------------------
-// module/props.ts
-//------------------------------------------------------------------------------
-type Props = Record<string, any>;
-
-function updateProps(oldVnode: VNode, vnode: VNode): void {
-  var key: string,
-    cur: any,
-    old: any,
-    elm = vnode.elm,
-    oldProps = (oldVnode.data as VNodeData).props,
-    props = (vnode.data as VNodeData).props;
-
-  if (!oldProps && !props) return;
-  if (oldProps === props) return;
-  oldProps = oldProps || {};
-  props = props || {};
-
-  for (key in oldProps) {
-    if (!props[key]) {
-      delete (elm as any)[key];
-    }
-  }
-  for (key in props) {
-    cur = props[key];
-    old = oldProps[key];
-    if (old !== cur && (key !== "value" || (elm as any)[key] !== cur)) {
-      (elm as any)[key] = cur;
-    }
-  }
-}
-
-export const propsModule = {
-  create: updateProps,
-  update: updateProps
-} as Module;
-
-//------------------------------------------------------------------------------
-// module/module.ts
-//------------------------------------------------------------------------------
-interface Module {
-  pre: PreHook;
-  create: CreateHook;
-  update: UpdateHook;
-  destroy: DestroyHook;
-  remove: RemoveHook;
-  post: PostHook;
-}
-
-//------------------------------------------------------------------------------
-// module/eventlisteners.ts
-//------------------------------------------------------------------------------
-type On = { [N in keyof HTMLElementEventMap]?: (ev: HTMLElementEventMap[N]) => void } & {
-  [event: string]: EventListener;
-};
-
-function invokeHandler(handler: any, vnode?: VNode, event?: Event): void {
-  if (typeof handler === "function") {
-    // call function handler
-    handler.call(vnode, event, vnode);
-  } else if (typeof handler === "object") {
-    // call handler with arguments
-    if (typeof handler[0] === "function") {
-      // special case for single argument for performance
-      if (handler.length === 2) {
-        handler[0].call(vnode, handler[1], event, vnode);
-      } else {
-        var args = handler.slice(1);
-        args.push(event);
-        args.push(vnode);
-        handler[0].apply(vnode, args);
-      }
-    } else {
-      // call multiple handlers
-      for (let i = 0, iLen = handler.length; i < iLen; i++) {
-        invokeHandler(handler[i], vnode, event);
-      }
-    }
-  }
-}
-
-function handleEvent(event: Event, vnode: VNode) {
-  var name = event.type,
-    on = (vnode.data as VNodeData).on;
-
-  // call event handler(s) if exists
-  if (on && on[name]) {
-    invokeHandler(on[name], vnode, event);
-  }
-}
-
-function createListener() {
-  return function handler(event: Event) {
-    handleEvent(event, (handler as any).vnode);
-  };
-}
-
-function updateEventListeners(oldVnode: VNode, vnode?: VNode): void {
-  var oldOn = (oldVnode.data as VNodeData).on,
-    oldListener = (oldVnode as any).listener,
-    oldElm: Element = oldVnode.elm as Element,
-    on = vnode && (vnode.data as VNodeData).on,
-    elm: Element = (vnode && vnode.elm) as Element,
-    name: string;
-
-  // optimization for reused immutable handlers
-  if (oldOn === on) {
-    return;
-  }
-
-  // remove existing listeners which no longer used
-  if (oldOn && oldListener) {
-    // if element changed or deleted we remove all existing listeners unconditionally
-    if (!on) {
-      for (name in oldOn) {
-        // remove listener if element was changed or existing listeners removed
-        oldElm.removeEventListener(name, oldListener, false);
-      }
-    } else {
-      for (name in oldOn) {
-        // remove listener if existing listener removed
-        if (!on[name]) {
-          oldElm.removeEventListener(name, oldListener, false);
-        }
-      }
-    }
-  }
-
-  // add new listeners which has not already attached
-  if (on) {
-    // reuse existing listener or create new
-    var listener = ((vnode as any).listener = (oldVnode as any).listener || createListener());
-    // update vnode for listener
-    listener.vnode = vnode;
-
-    // if element changed or added we add all needed listeners unconditionally
-    if (!oldOn) {
-      for (name in on) {
-        // add listener if element was changed or new listeners added
-        elm.addEventListener(name, listener, false);
-      }
-    } else {
-      for (name in on) {
-        // add listener if new listener added
-        if (!oldOn[name]) {
-          elm.addEventListener(name, listener, false);
-        }
-      }
-    }
-  }
-}
-
-export const eventListenersModule = {
-  create: updateEventListeners,
-  update: updateEventListeners,
-  destroy: updateEventListeners
-} as Module;
-
-//------------------------------------------------------------------------------
-// attributes.ts
-//------------------------------------------------------------------------------
-type Attrs = Record<string, string | number | boolean>;
-
-const xlinkNS = "http://www.w3.org/1999/xlink";
-const xmlNS = "http://www.w3.org/XML/1998/namespace";
-const colonChar = 58;
-const xChar = 120;
-
-function updateAttrs(oldVnode: VNode, vnode: VNode): void {
-  var key: string,
-    elm: Element = vnode.elm as Element,
-    oldAttrs = (oldVnode.data as VNodeData).attrs,
-    attrs = (vnode.data as VNodeData).attrs;
-
-  if (!oldAttrs && !attrs) return;
-  if (oldAttrs === attrs) return;
-  oldAttrs = oldAttrs || {};
-  attrs = attrs || {};
-
-  // update modified attributes, add new attributes
-  for (key in attrs) {
-    const cur = attrs[key];
-    const old = oldAttrs[key];
-    if (old !== cur) {
-      if (cur === true) {
-        elm.setAttribute(key, "");
-      } else if (cur === false) {
-        elm.removeAttribute(key);
-      } else {
-        if (key.charCodeAt(0) !== xChar) {
-          elm.setAttribute(key, cur);
-        } else if (key.charCodeAt(3) === colonChar) {
-          // Assume xml namespace
-          elm.setAttributeNS(xmlNS, key, cur);
-        } else if (key.charCodeAt(5) === colonChar) {
-          // Assume xlink namespace
-          elm.setAttributeNS(xlinkNS, key, cur);
-        } else {
-          elm.setAttribute(key, cur);
-        }
-      }
-    }
-  }
-  // remove removed attributes
-  // use `in` operator since the previous `for` iteration uses it (.i.e. add even attributes with undefined value)
-  // the other option is to remove all attributes with value == undefined
-  for (key in oldAttrs) {
-    if (!(key in attrs)) {
-      elm.removeAttribute(key);
-    }
-  }
-}
-
-export const attrsModule = {
-  create: updateAttrs,
-  update: updateAttrs
-} as Module;
-
-//------------------------------------------------------------------------------
-// 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]);

tests/__snapshots__/animations.test.ts.snap

@@ -3,11 +3,11 @@
 exports[`animations t-transition combined with component 1`] = `
 "function anonymous(context,extra
 ) {
-    let utils = this.utils;
+    let utils = this.constructor.utils;
     let QWeb = this.constructor;
     let parent = context;
     let owner = context;
-    var h = this.utils.h;
+    var h = this.h;
     let c1 = [], p1 = {key:1};
     var vn1 = h('div', p1, c1);
     //COMPONENT
@@ -31,7 +31,7 @@ exports[`animations t-transition combined with component 1`] = `
         w4 = new W4(parent, props4);
         parent.__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, 'chimay');},remove() {},destroy(vn) {let finalize = () => {
+        def3 = def3.then(vnode=>{if (w4.__owl__.isDestroyed){return}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, 'chimay', finalize);}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
@@ -47,11 +47,11 @@ exports[`animations t-transition combined with component 1`] = `
 exports[`animations t-transition combined with t-component and t-if 1`] = `
 "function anonymous(context,extra
 ) {
-    let utils = this.utils;
+    let utils = this.constructor.utils;
     let QWeb = this.constructor;
     let parent = context;
     let owner = context;
-    var h = this.utils.h;
+    var h = this.h;
     let c1 = [], p1 = {key:1};
     var vn1 = h('div', p1, c1);
     if (context['state'].display) {
@@ -76,7 +76,7 @@ exports[`animations t-transition combined with t-component and t-if 1`] = `
             w4 = new W4(parent, props4);
             parent.__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, 'chimay');},remove() {},destroy(vn) {let finalize = () => {
+            def3 = def3.then(vnode=>{if (w4.__owl__.isDestroyed){return}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, 'chimay', finalize);}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
@@ -93,15 +93,16 @@ exports[`animations t-transition combined with t-component and t-if 1`] = `
 exports[`animations t-transition with no delay/duration 1`] = `
 "function anonymous(context,extra
 ) {
-    var h = this.utils.h;
+    let utils = this.constructor.utils;
+    var h = this.h;
     let c1 = [], p1 = {key:1};
     var vn1 = h('span', p1, c1);
     p1.hook = {
       insert: vn => {
-        this.utils.transitionInsert(vn, 'jupiler');
+        utils.transitionInsert(vn, 'jupiler');
       },
       remove: (vn, rm) => {
-        this.utils.transitionRemove(vn, 'jupiler', rm);
+        utils.transitionRemove(vn, 'jupiler', rm);
       },
     };
     c1.push({text: \`blue\`});
@@ -112,15 +113,16 @@ exports[`animations t-transition with no delay/duration 1`] = `
 exports[`animations t-transition, on a simple node (insert) 1`] = `
 "function anonymous(context,extra
 ) {
-    var h = this.utils.h;
+    let utils = this.constructor.utils;
+    var h = this.h;
     let c1 = [], p1 = {key:1};
     var vn1 = h('span', p1, c1);
     p1.hook = {
       insert: vn => {
-        this.utils.transitionInsert(vn, 'chimay');
+        utils.transitionInsert(vn, 'chimay');
       },
       remove: (vn, rm) => {
-        this.utils.transitionRemove(vn, 'chimay', rm);
+        utils.transitionRemove(vn, 'chimay', rm);
       },
     };
     c1.push({text: \`blue\`});

tests/animations.test.ts

@@ -1,5 +1,5 @@
-import { Component, Env } from "../src/component";
-import { QWeb } from "../src/qweb_core";
+import { Component, Env } from "../src/component/component";
+import { QWeb } from "../src/qweb/index";
 import {
   makeDeferred,
   makeTestFixture,

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

@@ -1,13 +1,17 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`default props default values are also set whenever component is updated 1`] = `"<div>1</div>"`;
+
+exports[`default props default values are also set whenever component is updated 2`] = `"<div>4</div>"`;
+
 exports[`props validation props are validated in dev mode (code snapshot) 1`] = `
 "function anonymous(context,extra
 ) {
-    let utils = this.utils;
+    let utils = this.constructor.utils;
     let QWeb = this.constructor;
     let parent = context;
     let owner = context;
-    var h = this.utils.h;
+    var h = this.h;
     let c1 = [], p1 = {key:1};
     var vn1 = h('div', p1, c1);
     //COMPONENT
@@ -32,7 +36,7 @@ exports[`props validation props are validated in dev mode (code snapshot) 1`] =
         w4 = new W4(parent, props4);
         parent.__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;},remove() {},destroy(vn) {w4.destroy();}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
+        def3 = def3.then(vnode=>{if (w4.__owl__.isDestroyed){return}let pvnode=h(vnode.sel, {key: 4, hook: {insert(vn) {let nvn=w4.__mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;},remove() {},destroy(vn) {w4.destroy();}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
     } else {
         utils.validateProps(w4.constructor, props4)
         def3 = def3 || w4.__updateProps(props4, extra.forceUpdate, extra.patchQueue);

tests/component/component.test.ts

@@ -1,6 +1,6 @@
-import { Component, Env } from "../src/component";
-import { QWeb } from "../src/qweb_core";
-import { EventBus } from "../src/event_bus";
+import { Component, Env } from "../../src/component/component";
+import { QWeb } from "../../src/qweb/qweb";
+import { EventBus } from "../../src/core/event_bus";
 import {
   makeDeferred,
   makeTestFixture,
@@ -9,7 +9,7 @@ import {
   nextTick,
   normalize,
   editInput
-} from "./helpers";
+} from "../helpers";
 
 //------------------------------------------------------------------------------
 // Setup and helpers
@@ -160,6 +160,30 @@ describe("basic widget properties", () => {
     widget.render();
     expect(fixture.innerHTML).toBe(`<div><span></span></div>`);
   });
+
+  test("reconciliation alg is not confused in some specific situation", async () => {
+    // in this test, we set t-key to 4 because it was in conflict with the
+    // template id corresponding to the first child.
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="Parent">
+                <Child />
+                <Child t-key="4"/>
+            </div>
+            <span t-name="Child">child</span>
+        </templates>
+    `);
+
+    class Child extends Component<any, any, any> {}
+
+    class Parent extends Component<any, any, any> {
+      components = { Child };
+    }
+
+    const widget = new Parent(env);
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>child</span><span>child</span></div>");
+  });
 });
 
 describe("lifecycle hooks", () => {
@@ -733,15 +757,16 @@ describe("lifecycle hooks", () => {
     // we make sure here that willPatch/patched is only called if widget is in
     // dom, mounted
     const steps: string[] = [];
-    env.qweb.addTemplate(
-      "ParentWidget",
-      `
-        <div>
-            <t t-if="state.flag" t-component="child" v="state.n" t-keepalive="1"/>
-        </div>`
-    );
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="ParentWidget">
+                <ChildWidget t-if="state.flag" v="state.n" t-keepalive="1"/>
+            </div>
+        </templates>
+    `);
+
     class ParentWidget extends Widget {
-      components = { child: ChildWidget };
+      components = { ChildWidget };
       state = { n: 1, flag: true };
     }
 
@@ -761,6 +786,8 @@ describe("lifecycle hooks", () => {
     }
     const widget = new ParentWidget(env);
     await widget.mount(fixture);
+
+    expect(env.qweb.templates.ParentWidget.fn.toString()).toMatchSnapshot();
     expect(steps).toEqual(["child:mounted"]);
     widget.state.flag = false;
     await nextTick();
@@ -830,6 +857,50 @@ describe("destroy method", () => {
     expect(fixture.innerHTML).toBe("");
     expect(isRendered).toBe(false);
   });
+
+  test("destroying a widget before being mounted", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="Parent" t-on-some-event="doStuff">
+                <Child />
+            </div>
+            <span t-name="Child">
+                <GrandChild t-if="state.flag" val="something"/>
+                <button t-on-click="doSomething">click</button>
+            </span>
+            <span t-name="GrandChild">
+                <t t-esc="props.val.val"/>
+            </span>
+        </templates>`);
+    class Parent extends Component<any, any, any> {
+      components = { Child };
+      state = { p: 1 };
+      doStuff() {
+        this.state.p = 2;
+      }
+    }
+
+    class Child extends Component<any, any, any> {
+      components = { GrandChild };
+      state = { val: 33, flag: false };
+      doSomething() {
+        this.state.val = 12;
+        this.state.flag = true;
+        this.trigger("some-event");
+      }
+      get something() {
+        return { val: this.state.val };
+      }
+    }
+    class GrandChild extends Component<any, any, any> {}
+
+    const parent = new Parent(env);
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span><button>click</button></span></div>");
+    fixture.querySelector("button")!.click();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span><span>12</span><button>click</button></span></div>");
+  });
 });
 
 describe("composition", () => {
@@ -1124,6 +1195,7 @@ describe("composition", () => {
     const input2 = fixture.getElementsByTagName("input")[0];
     expect(input).toBe(input2);
     expect(input2.value).toBe("test");
+    expect(env.qweb.templates.ParentWidget.fn.toString()).toMatchSnapshot();
   });
 
   test("sub widget with t-ref and t-keepalive", async () => {
@@ -1270,6 +1342,62 @@ describe("composition", () => {
     );
   });
 
+  test("list of sub components inside other nodes", async () => {
+    // this confuses the patching algorithm...
+    env.qweb.addTemplate("ChildWidget", `<span>child</span>`);
+
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="Parent">
+                <div t-foreach="state.blips" t-as="blip" t-key="blip.id">
+                    <SubWidget />
+                </div>
+            </div>
+            <span t-name="SubWidget">asdf</span>
+        </templates>`);
+
+    class SubWidget extends Widget {}
+    class Parent extends Widget {
+      components = { SubWidget };
+      state = { blips: [{ a: "a", id: 1 }, { b: "b", id: 2 }, { c: "c", id: 4 }] };
+    }
+    const parent = new Parent(env);
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe(
+      "<div><div><span>asdf</span></div><div><span>asdf</span></div><div><span>asdf</span></div></div>"
+    );
+    parent.state.blips.splice(0, 1);
+    await nextTick();
+    expect(fixture.innerHTML).toBe(
+      "<div><div><span>asdf</span></div><div><span>asdf</span></div></div>"
+    );
+  });
+
+  test("list of two sub components inside other nodes", async () => {
+    // this confuses the patching algorithm...
+    env.qweb.addTemplate("ChildWidget", `<span>child</span>`);
+
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="Parent">
+                <div t-foreach="state.blips" t-as="blip" t-key="blip.id">
+                    <SubWidget />
+                    <SubWidget />
+                </div>
+            </div>
+            <span t-name="SubWidget">asdf</span>
+        </templates>`);
+
+    class SubWidget extends Widget {}
+    class Parent extends Widget {
+      components = { SubWidget };
+      state = { blips: [{ a: "a", id: 1 }] };
+    }
+    const parent = new Parent(env);
+    await parent.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><div><span>asdf</span><span>asdf</span></div></div>");
+  });
+
   test("t-component with dynamic value", async () => {
     env.qweb.addTemplate("ParentWidget", `<div><t t-component="{{state.widget}}"/></div>`);
     class ParentWidget extends Widget {
@@ -2608,6 +2736,39 @@ describe("async rendering", () => {
 
     expect(fixture.querySelector(".children")!.innerHTML).toBe("<span>1/1</span><span>1/1</span>");
   });
+
+  test("rendering component again in next microtick", async () => {
+    class Child extends Widget {}
+
+    class App extends Widget {
+      components = { Child };
+
+      async onClick() {
+        (env as any).flag = true;
+        this.render();
+        await Promise.resolve();
+        this.render();
+      }
+    }
+
+    env.qweb.addTemplates(`
+      <templates>
+        <div t-name="Child">Child</div>
+
+        <div t-name="App">
+            <button t-on-click="onClick">Click</button>
+            <t t-if="env.flag"><Child/></t>
+        </div>
+    </templates>
+    `);
+
+    const app = new App(env);
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><button>Click</button></div>");
+    fixture.querySelector("button")!.click();
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><button>Click</button><div>Child</div></div>");
+  });
 });
 
 describe("updating environment", () => {
@@ -2890,6 +3051,8 @@ describe("t-slot directive", () => {
     );
     expect(env.qweb.templates.Parent.fn.toString()).toMatchSnapshot();
     expect(env.qweb.templates.Dialog.fn.toString()).toMatchSnapshot();
+    expect(env.qweb.slots['1_header'].toString()).toMatchSnapshot();
+    expect(env.qweb.slots['1_footer'].toString()).toMatchSnapshot();
   });
 
   test("slots are rendered with proper context", async () => {
@@ -2925,6 +3088,7 @@ describe("t-slot directive", () => {
     expect(fixture.innerHTML).toBe(
       '<div><span class="counter">1</span><span><button>do something</button></span></div>'
     );
+    expect(env.qweb.slots['1_footer'].toString()).toMatchSnapshot();
   });
 
   test("slots are rendered with proper context, part 2", async () => {
@@ -2962,6 +3126,7 @@ describe("t-slot directive", () => {
     expect(fixture.innerHTML).toBe(
       '<div><u><li><a href="/user/1">User Aaron</a></li><li><a href="/user/2">User Mathieu</a></li></u></div>'
     );
+    expect(env.qweb.slots['1_default'].toString()).toMatchSnapshot();
   });
 
   test("slots are rendered with proper context, part 3", async () => {
@@ -3000,6 +3165,7 @@ describe("t-slot directive", () => {
     expect(fixture.innerHTML).toBe(
       '<div><u><li><a href="/user/1">User Aaron</a></li><li><a href="/user/2">User Mathieu</a></li></u></div>'
     );
+    expect(env.qweb.slots['1_default'].toString()).toMatchSnapshot();
   });
 
   test("slots are rendered with proper context, part 4", async () => {
@@ -3032,6 +3198,7 @@ describe("t-slot directive", () => {
     app.state.user.name = "David";
     await nextTick();
     expect(fixture.innerHTML).toBe('<div><a href="/user/1">User David</a></div>');
+    expect(env.qweb.slots['1_default'].toString()).toMatchSnapshot();
   });
 
   test("refs are properly bound in slots", async () => {
@@ -3067,6 +3234,7 @@ describe("t-slot directive", () => {
     expect(fixture.innerHTML).toBe(
       '<div><span class="counter">1</span><span><button>do something</button></span></div>'
     );
+    expect(env.qweb.slots['1_footer'].toString()).toMatchSnapshot();
   });
 
   test("content is the default slot", async () => {
@@ -3088,6 +3256,7 @@ describe("t-slot directive", () => {
     await parent.mount(fixture);
 
     expect(fixture.innerHTML).toBe("<div><div><span>sts rocks</span></div></div>");
+    expect(env.qweb.slots['1_default'].toString()).toMatchSnapshot();
   });
 
   test("default slot work with text nodes", async () => {
@@ -3107,6 +3276,7 @@ describe("t-slot directive", () => {
     await parent.mount(fixture);
 
     expect(fixture.innerHTML).toBe("<div><div>sts rocks</div></div>");
+    expect(env.qweb.slots['1_default'].toString()).toMatchSnapshot();
   });
 
   test("multiple roots are allowed in a named slot", async () => {
@@ -3131,6 +3301,7 @@ describe("t-slot directive", () => {
     await parent.mount(fixture);
 
     expect(fixture.innerHTML).toBe("<div><div><span>sts</span><span>rocks</span></div></div>");
+    expect(env.qweb.slots['1_content'].toString()).toMatchSnapshot();
   });
 
   test("multiple roots are allowed in a default slot", async () => {
@@ -3153,6 +3324,7 @@ describe("t-slot directive", () => {
     await parent.mount(fixture);
 
     expect(fixture.innerHTML).toBe("<div><div><span>sts</span><span>rocks</span></div></div>");
+    expect(env.qweb.slots['1_default'].toString()).toMatchSnapshot();
   });
 
   test("missing slots are ignored", async () => {
@@ -3422,6 +3594,50 @@ describe("t-model directive", () => {
     expect(env.qweb.templates.SomeComponent.fn.toString()).toMatchSnapshot();
   });
 
+  test("on a select, initial state", async () => {
+    env.qweb.addTemplates(`
+    <templates>
+        <div t-name="SomeComponent">
+            <select t-model="color">
+                <option value="">Please select one</option>
+                <option value="red">Red</option>
+                <option value="blue">Blue</option>
+            </select>
+        </div>
+    </templates>`);
+    class SomeComponent extends Widget {
+      state = { color: "red" };
+    }
+    const comp = new SomeComponent(env);
+    await comp.mount(fixture);
+    const select = fixture.querySelector("select")!;
+    expect(select.value).toBe("red");
+  });
+
+  test("on a sub state key", async () => {
+    env.qweb.addTemplates(`
+    <templates>
+        <div t-name="SomeComponent">
+            <input t-model="something.text"/>
+            <span><t t-esc="state.something.text"/></span>
+        </div>
+    </templates>`);
+
+    class SomeComponent extends Widget {
+      state = { something: {text: "" }};
+    }
+    const comp = new SomeComponent(env);
+    await comp.mount(fixture);
+
+    expect(fixture.innerHTML).toBe("<div><input><span></span></div>");
+
+    const input = fixture.querySelector("input")!;
+    await editInput(input, "test");
+    expect(comp.state.something.text).toBe("test");
+    expect(fixture.innerHTML).toBe("<div><input><span>test</span></div>");
+    expect(env.qweb.templates.SomeComponent.fn.toString()).toMatchSnapshot();
+  });
+
   test(".lazy modifier", async () => {
     env.qweb.addTemplates(`
     <templates>
@@ -3506,7 +3722,7 @@ describe("environment and plugins", () => {
     env.someFlag = true;
     bus.on("some-event", null, () => {
       env.someFlag = !env.someFlag;
-      env.qweb.trigger("update");
+      env.qweb.forceUpdate();
     });
   };
 
@@ -3839,7 +4055,6 @@ describe("top level sub widgets", () => {
     expect(env.qweb.templates.Parent.fn.toString()).toMatchSnapshot();
   });
 
-
   test("sub widget is interactive", async () => {
     env.qweb.addTemplates(`
         <templates>
@@ -3849,10 +4064,10 @@ describe("top level sub widgets", () => {
           <span t-name="Child"><button t-on-click="inc">click</button>child<t t-esc="state.val"/></span>
         </templates>`);
     class Child extends Widget {
-        state = {val: 1};
-        inc() {
-            this.state.val++;
-        }
+      state = { val: 1 };
+      inc() {
+        this.state.val++;
+      }
     }
     class Parent extends Widget {
       components = { Child };
@@ -3860,7 +4075,7 @@ describe("top level sub widgets", () => {
     const parent = new Parent(env);
     await parent.mount(fixture);
     expect(fixture.innerHTML).toBe("<span><button>click</button>child1</span>");
-    const button = fixture.querySelector('button')!;
+    const button = fixture.querySelector("button")!;
     button.click();
     await nextTick();
     expect(fixture.innerHTML).toBe("<span><button>click</button>child2</span>");
@@ -3907,7 +4122,7 @@ describe("top level sub widgets", () => {
     class Child extends Widget {}
     class OtherChild extends Widget {}
     class Parent extends Widget {
-        state = {flag: true}
+      state = { flag: true };
       components = { Child, OtherChild };
     }
     let parent = new Parent(env);
@@ -3916,7 +4131,136 @@ describe("top level sub widgets", () => {
     parent.state.flag = false;
     await nextTick();
     expect(fixture.innerHTML).toBe("<div>CHILD 2</div>");
+  });
+});
 
+describe("unmounting and remounting", () => {
+  test("widget can be unmounted and remounted", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+          <div t-name="MyWidget">Hey</div>
+        </templates>`);
+
+    const steps: string[] = [];
+    class MyWidget extends Widget {
+      async willStart() {
+        steps.push("willstart");
+      }
+      mounted() {
+        steps.push("mounted");
+      }
+      willUnmount() {
+        steps.push("willunmount");
+      }
+    }
+
+    const w = new MyWidget(env);
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>Hey</div>");
+    expect(steps).toEqual(["willstart", "mounted"]);
+
+    w.unmount();
+    expect(fixture.innerHTML).toBe("");
+    expect(steps).toEqual(["willstart", "mounted", "willunmount"]);
+
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>Hey</div>");
+    expect(steps).toEqual(["willstart", "mounted", "willunmount", "mounted"]);
   });
 
+  test("widget can be mounted twice without ill effect", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+          <div t-name="MyWidget">Hey</div>
+        </templates>`);
+
+    const steps: string[] = [];
+    class MyWidget extends Widget {
+      async willStart() {
+        steps.push("willstart");
+      }
+      mounted() {
+        steps.push("mounted");
+      }
+      willUnmount() {
+        steps.push("willunmount");
+      }
+    }
+
+    const w = new MyWidget(env);
+    await w.mount(fixture);
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>Hey</div>");
+    expect(steps).toEqual(["willstart", "mounted"]);
+  });
+
+  test("state changes in willUnmount do not trigger rerender", async () => {
+    const steps: string[] = [];
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="Parent">
+                <Child t-if="state.flag" val="state.val"/>
+            </div>
+            <span t-name="Child"><t t-esc="props.val"/><t t-esc="state.n"/></span>
+        </templates>
+    `);
+
+    class Child extends Widget {
+      state = { n: 2 };
+      __render(a, b, c, d) {
+        steps.push("render");
+        return super.__render(a, b, c, d);
+      }
+      willPatch() {
+        steps.push("willPatch");
+      }
+      patched() {
+        steps.push("patched");
+      }
+
+      willUnmount() {
+        steps.push("willUnmount");
+        this.state.n = 3;
+      }
+    }
+    class Parent extends Widget {
+      components = { Child };
+      state = { val: 1, flag: true };
+    }
+
+    const widget = new Parent(env);
+    await widget.mount(fixture);
+    expect(steps).toEqual(["render"]);
+    expect(fixture.innerHTML).toBe("<div><span>12</span></div>");
+    widget.state.flag = false;
+    await nextTick();
+    // we make sure here that no call to __render is done
+    expect(steps).toEqual(["render", "willUnmount"]);
+  });
+
+  test("state changes in willUnmount will be applied on remount", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="TestWidget"><t t-esc="state.val"/></div>
+        </templates>
+    `);
+
+    class TestWidget extends Widget {
+      state = { val: 1 };
+      willUnmount() {
+        this.state.val = 3;
+      }
+    }
+
+    const widget = new TestWidget(env);
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>1</div>");
+    widget.unmount();
+    expect(fixture.innerHTML).toBe("");
+    await widget.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div>1</div>");
+    widget.unmount();
+    await widget.mount(fixture, true);
+    expect(fixture.innerHTML).toBe("<div>3</div>");
+  });
 });

tests/component/props_validation.test.ts

@@ -1,6 +1,6 @@
-import { Component, Env } from "../src/component";
-import { makeTestFixture, makeTestEnv } from "./helpers";
-import { QWeb, UTILS } from "../src/qweb_core";
+import { Component, Env } from "../../src/component/component";
+import { makeTestFixture, makeTestEnv } from "../helpers";
+import { QWeb } from "../../src/qweb";
 
 //------------------------------------------------------------------------------
 // Setup and helpers
@@ -251,10 +251,10 @@ describe("props validation", () => {
     }
 
     expect(() => {
-      UTILS.validateProps(TestWidget, { someProp: 1 });
+      QWeb.utils.validateProps(TestWidget, { someProp: 1 });
     }).toThrow();
     expect(() => {
-      UTILS.validateProps(TestWidget, { message: 1 });
+      QWeb.utils.validateProps(TestWidget, { message: 1 });
     }).not.toThrow();
   });
 
@@ -264,7 +264,7 @@ describe("props validation", () => {
     }
 
     expect(() => {
-      UTILS.validateProps(TestWidget, {});
+      QWeb.utils.validateProps(TestWidget, {});
     }).toThrow();
   });
 
@@ -274,17 +274,17 @@ describe("props validation", () => {
     }
 
     expect(() => {
-      UTILS.validateProps(TestWidget, { message: 1, flag: true });
+      QWeb.utils.validateProps(TestWidget, { message: 1, flag: true });
     }).toThrow();
   });
 
   test("props: extra props cause an error, part 2", async () => {
     class TestWidget extends Widget {
-      static props = {message: true};
+      static props = { message: true };
     }
 
     expect(() => {
-      UTILS.validateProps(TestWidget, { message: 1, flag: true });
+      QWeb.utils.validateProps(TestWidget, { message: 1, flag: true });
     }).toThrow();
   });
 
@@ -294,23 +294,22 @@ describe("props validation", () => {
     }
 
     expect(() => {
-      UTILS.validateProps(TestWidget, { message: 1});
+      QWeb.utils.validateProps(TestWidget, { message: 1 });
     }).not.toThrow();
   });
 
   test("optional prop do not cause an error if value is undefined", async () => {
     class TestWidget extends Widget {
-      static props = {message: {type: String, optional: true}};
+      static props = { message: { type: String, optional: true } };
     }
 
     expect(() => {
-      UTILS.validateProps(TestWidget, { message: undefined});
+      QWeb.utils.validateProps(TestWidget, { message: undefined });
     }).not.toThrow();
     expect(() => {
-      UTILS.validateProps(TestWidget, { message: null});
+      QWeb.utils.validateProps(TestWidget, { message: null });
     }).toThrow();
   });
-
 });
 
 describe("default props", () => {
@@ -327,9 +326,17 @@ describe("default props", () => {
     class TestWidget extends Widget {
       static defaultProps = { p: 4 };
     }
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="TestWidget"><t t-esc="props.p"/></div>
+        </templates>`);
 
     const w = new TestWidget(env, { p: 1 });
+    await w.mount(fixture);
+    expect(fixture.innerHTML).toMatchSnapshot();
     await w.__updateProps({});
+    await w.render();
     expect(w.props.p).toBe(4);
+    expect(fixture.innerHTML).toMatchSnapshot();
   });
 });

tests/core/event_bus.test.ts

@@ -1,4 +1,4 @@
-import { EventBus } from "../src/event_bus";
+import { EventBus } from "../../src/core/event_bus";
 
 describe("event bus behaviour", () => {
   test("can subscribe and be notified", () => {

tests/core/observer.test.ts

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

tests/helpers.ts

@@ -1,8 +1,9 @@
-import { Env } from "../src/component";
-import { EvalContext, QWeb, UTILS } from "../src/qweb_core";
+import { Env } from "../src/component/component";
+import { EvalContext, QWeb } from "../src/qweb/qweb";
 import { patch } from "../src/vdom";
-import "../src/qweb_directives";
-import "../src/qweb_extensions";
+import "../src/qweb/base_directives";
+import "../src/qweb/extensions";
+import "../src/component/directive";
 
 export function nextMicroTick(): Promise<void> {
   return Promise.resolve();
@@ -90,15 +91,15 @@ export function renderToString(qweb: QWeb, t: string, context: EvalContext = {})
 // is useful for animations tests, as we hook before repaints to trigger
 // animations (thanks to requestAnimationFrame). Patching nextFrame allows to
 // simulate calls to this hook. One must not forget to unpatch afterwards.
-let nextFrame = UTILS.nextFrame;
+let nextFrame = QWeb.utils.nextFrame;
 export function patchNextFrame(f: Function) {
-  UTILS.nextFrame = (cb: () => void) => {
+  QWeb.utils.nextFrame = (cb: () => void) => {
     setTimeout(() => f(cb));
   };
 }
 
 export function unpatchNextFrame() {
-  UTILS.nextFrame = nextFrame;
+  QWeb.utils.nextFrame = nextFrame;
 }
 
 export async function editInput(input: HTMLInputElement | HTMLTextAreaElement, value: string) {

tests/observer.test.ts

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

tests/qweb/qweb.test.ts

@@ -1,5 +1,5 @@
-import { QWeb } from "../src/qweb_core";
-import { normalize, renderToDOM, renderToString, trim } from "./helpers";
+import { QWeb } from "../../src/qweb/index";
+import { normalize, renderToDOM, renderToString, trim, nextTick } from "../helpers";
 
 //------------------------------------------------------------------------------
 // Setup and helpers
@@ -501,6 +501,13 @@ describe("t-call (template calling", () => {
     expect(renderToString(qweb, "caller")).toBe(expected);
   });
 
+  test("t-call with t-if", () => {
+    qweb.addTemplate("sub", "<span>ok</span>");
+    qweb.addTemplate("caller", '<div><t t-if="flag" t-call="sub"/></div>');
+    const expected = "<div><span>ok</span></div>";
+    expect(renderToString(qweb, "caller", { flag: true })).toBe(expected);
+  });
+
   test("t-call not allowed on a non t node", () => {
     qweb.addTemplate("_basic-callee", "<t>ok</t>");
     qweb.addTemplate("caller", '<div t-call="_basic-callee"/>');
@@ -566,6 +573,76 @@ describe("t-call (template calling", () => {
     const expected = "<div>ok</div>";
     expect(trim(renderToString(qweb, "caller"))).toBe(expected);
   });
+
+  test("recursive template, part 1", () => {
+    qweb.addTemplates(`
+        <templates>
+            <div t-name="recursive">
+                <span>hey</span>
+                <t t-if="false">
+                    <t t-call="recursive"/>
+                </t>
+            </div>
+        </templates>
+    `);
+    const expected = "<div><span>hey</span></div>";
+    expect(renderToString(qweb, "recursive")).toBe(expected);
+    const recursiveFn = Object.values(qweb.recursiveFns)[0];
+    expect(recursiveFn.toString()).toMatchSnapshot();
+
+  });
+
+  test("recursive template, part 2", () => {
+    qweb.addTemplates(`
+        <templates>
+            <div t-name="Parent">
+                <t t-call="nodeTemplate">
+                    <t t-set="node" t-value="root"/>
+                </t>
+            </div>
+            <div t-name="nodeTemplate">
+                <p><t t-esc="node.val"/></p>
+                <t t-foreach="node.children or []" t-as="subtree">
+                    <t t-call="nodeTemplate">
+                        <t t-set="node" t-value="subtree"/>
+                    </t>
+                </t>
+            </div>
+
+        </templates>
+    `);
+    const root = { val: "a", children: [{val: "b"}, {val: "c"}]};
+    const expected = "<div><div><p>a</p><div><p>b</p></div><div><p>c</p></div></div></div>";
+    expect(renderToString(qweb, "Parent", {root })).toBe(expected);
+    const recursiveFn = Object.values(qweb.recursiveFns)[0];
+    expect(recursiveFn.toString()).toMatchSnapshot();
+  });
+
+  test("recursive template, part 3", () => {
+    qweb.addTemplates(`
+        <templates>
+            <div t-name="Parent">
+                <t t-call="nodeTemplate">
+                    <t t-set="node" t-value="root"/>
+                </t>
+            </div>
+            <div t-name="nodeTemplate">
+                <p><t t-esc="node.val"/></p>
+                <t t-foreach="node.children or []" t-as="subtree">
+                    <t t-call="nodeTemplate">
+                        <t t-set="node" t-value="subtree"/>
+                    </t>
+                </t>
+            </div>
+
+        </templates>
+    `);
+    const root = { val: "a", children: [{val: "b", children: [{val: "d"}]}, {val: "c"}]};
+    const expected = "<div><div><p>a</p><div><p>b</p><div><p>d</p></div></div><div><p>c</p></div></div></div>";
+    expect(renderToString(qweb, "Parent", {root })).toBe(expected);
+    const recursiveFn = Object.values(qweb.recursiveFns)[0];
+    expect(recursiveFn.toString()).toMatchSnapshot();
+  });
 });
 
 describe("foreach", () => {
@@ -1171,3 +1248,15 @@ describe("debugging", () => {
     console.log = consoleLog;
   });
 });
+
+describe("update on event bus", () => {
+  test("two consecutive forceUpdates only causes one listener update", async () => {
+    const fn = jest.fn();
+    qweb.on("update", null, fn);
+    qweb.forceUpdate();
+    qweb.forceUpdate();
+    expect(fn).toBeCalledTimes(0);
+    await nextTick();
+    expect(fn).toBeCalledTimes(1);
+  });
+});

tests/qweb/qweb_expressions.test.ts

@@ -1,4 +1,4 @@
-import { compileExpr, tokenize } from "../src/qweb_expressions";
+import { compileExpr, tokenize } from "../../src/qweb/expression_parser";
 
 describe("tokenizer", () => {
   test("simple tokens", () => {

tests/router/Link.test.ts

@@ -0,0 +1,84 @@
+import { Component } from "../../src/component/component";
+import { Link, LINK_TEMPLATE_NAME } from "../../src/router/Link";
+import { RouterEnv } from "../../src/router/Router";
+import { makeTestEnv, makeTestFixture, nextTick } from "../helpers";
+import { TestRouter } from "./TestRouter";
+
+describe("Link component", () => {
+  let fixture: HTMLElement;
+  let env: RouterEnv;
+  let router: TestRouter | null = null;
+
+  beforeEach(() => {
+    fixture = makeTestFixture();
+    env = <RouterEnv>makeTestEnv();
+  });
+
+  afterEach(() => {
+    fixture.remove();
+    if (router) {
+      router.destroy();
+    }
+    router = null;
+  });
+
+  test("can render simple cases", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="App">
+                <Link to="'about'">About</Link>
+            </div>
+        </templates>
+    `);
+    class App extends Component<any, any, any> {
+      components = { Link: Link };
+    }
+
+    const routes = [{ name: "about", path: "/about" }, { name: "users", path: "/users" }];
+
+    router = new TestRouter(env, routes, { mode: "history" });
+    router.navigate({ to: "users" });
+    const app = new App(env);
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe('<div><a href="/about">About</a></div>');
+
+    expect(window.location.pathname).toBe("/users");
+    fixture.querySelector("a")!.click();
+    await nextTick();
+    expect(window.location.pathname).toBe("/about");
+    expect(fixture.innerHTML).toBe(
+      '<div><a href="/about" class="router-link-active">About</a></div>'
+    );
+
+    expect(env.qweb.templates[LINK_TEMPLATE_NAME].fn.toString()).toMatchSnapshot();
+  });
+
+  test("do not redirect if right clicking", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="App">
+                <Link to="'about'">About</Link>
+            </div>
+        </templates>
+    `);
+    class App extends Component<any, any, any> {
+      components = { Link: Link };
+    }
+
+    const routes = [{ name: "about", path: "/about" }, { name: "users", path: "/users" }];
+
+    router = new TestRouter(env, routes, { mode: "history" });
+    router.navigate({ to: "users" });
+    const app = new App(env);
+    await app.mount(fixture);
+
+    expect(window.location.pathname).toBe("/users");
+    var evt = new MouseEvent("click", {
+      button: 1
+    });
+
+    fixture.querySelector("a")!.dispatchEvent(evt);
+    await nextTick();
+    expect(window.location.pathname).toBe("/users");
+  });
+});

tests/router/TestRouter.ts

@@ -0,0 +1,17 @@
+import { Router } from "../../src/router/Router";
+import { QWeb } from "../../src/qweb/index";
+
+export class TestRouter extends Router {
+  destroy() {
+    window.removeEventListener("popstate", (this as any)._listener);
+    delete QWeb.DIRECTIVE_NAMES.routecomponent;
+    QWeb.DIRECTIVES = QWeb.DIRECTIVES.filter(d => d.name !== "routecomponent");
+
+    // remove component defined inroutes
+    for (let key in QWeb.components) {
+      if (key.startsWith("__component__")) {
+        delete QWeb.components[key];
+      }
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Link component can render simple cases 1`] = `
+"function anonymous(context,extra
+) {
+    let utils = this.constructor.utils;
+    let owner = context;
+    var h = this.h;
+    let _1 = utils.toObj({'router-link-active':context['isActive']});
+    var _2 = context['href'];
+    let c3 = [], p3 = {key:3,attrs:{href: _2},class:_1,on:{}};
+    var vn3 = h('a', p3, c3);
+    if (!context['navigate']) {
+        throw new Error('Missing handler \\\\'' + 'navigate' + \`\\\\' when evaluating template '__owl__-router-link'\`)
+    }
+    extra.handlers['click' + 3] = extra.handlers['click' + 3] || context['navigate'].bind(owner);
+    p3.on['click'] = extra.handlers['click' + 3];
+    const slot4 = this.slots[context.__owl__.slotId + '_' + 'default'];
+    if (slot4) {
+        slot4.call(this, context.__owl__.parent, Object.assign({}, extra, {parentNode: c3, vars: extra.vars, parent: owner}));
+    }
+    return vn3;
+}"
+`;

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

@@ -0,0 +1,159 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`router directive t-routecomponent can render parameterized route 1`] = `
+"function anonymous(context,extra
+) {
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    let owner = context;
+    var h = this.h;
+    let c1 = [], p1 = {key:1};
+    var vn1 = h('div', p1, c1);
+    if (context['env'].router.currentRouteName==='book') {
+        //COMPONENT
+        let def3;
+        let w4 = 4 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[4]] : false;
+        let _2_index = c1.length;
+        c1.push(null);
+        let props4 = {title:context['env'].router.currentParams.title};
+        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 componentKey4 = \`__component__book\`;
+            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(parent, props4);
+            parent.__owl__.cmap[4] = w4.__owl__.id;
+            def3 = w4.__prepare();
+            def3 = def3.then(vnode=>{if (w4.__owl__.isDestroyed){return}let pvnode=h(vnode.sel, {key: 4, hook: {insert(vn) {let nvn=w4.__mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;},remove() {},destroy(vn) {w4.destroy();}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
+        } else {
+            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);
+    }
+    return vn1;
+}"
+`;
+
+exports[`router directive t-routecomponent can render parameterized route with suffixes 1`] = `
+"function anonymous(context,extra
+) {
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    let owner = context;
+    var h = this.h;
+    let c1 = [], p1 = {key:1};
+    var vn1 = h('div', p1, c1);
+    if (context['env'].router.currentRouteName==='book') {
+        //COMPONENT
+        let def3;
+        let w4 = 4 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[4]] : false;
+        let _2_index = c1.length;
+        c1.push(null);
+        let props4 = {title:context['env'].router.currentParams.title,val:context['env'].router.currentParams.val};
+        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 componentKey4 = \`__component__book\`;
+            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(parent, props4);
+            parent.__owl__.cmap[4] = w4.__owl__.id;
+            def3 = w4.__prepare();
+            def3 = def3.then(vnode=>{if (w4.__owl__.isDestroyed){return}let pvnode=h(vnode.sel, {key: 4, hook: {insert(vn) {let nvn=w4.__mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;},remove() {},destroy(vn) {w4.destroy();}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
+        } else {
+            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);
+    }
+    return vn1;
+}"
+`;
+
+exports[`router directive t-routecomponent can render simple cases 1`] = `
+"function anonymous(context,extra
+) {
+    let utils = this.constructor.utils;
+    let QWeb = this.constructor;
+    let parent = context;
+    let owner = context;
+    var h = this.h;
+    let c1 = [], p1 = {key:1};
+    var vn1 = h('div', p1, c1);
+    if (context['env'].router.currentRouteName==='about') {
+        //COMPONENT
+        let def3;
+        let w4 = 4 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[4]] : false;
+        let _2_index = c1.length;
+        c1.push(null);
+        let props4 = {};
+        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 componentKey4 = \`__component__about\`;
+            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(parent, props4);
+            parent.__owl__.cmap[4] = w4.__owl__.id;
+            def3 = w4.__prepare();
+            def3 = def3.then(vnode=>{if (w4.__owl__.isDestroyed){return}let pvnode=h(vnode.sel, {key: 4, hook: {insert(vn) {let nvn=w4.__mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;},remove() {},destroy(vn) {w4.destroy();}}});c1[_2_index]=pvnode;w4.__owl__.pvnode = pvnode;});
+        } else {
+            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);
+    }
+    else if (context['env'].router.currentRouteName==='users') {
+        //COMPONENT
+        let def6;
+        let w7 = 7 in parent.__owl__.cmap ? parent.__owl__.children[parent.__owl__.cmap[7]] : false;
+        let _5_index = c1.length;
+        c1.push(null);
+        let props7 = {};
+        if (w7 && w7.__owl__.renderPromise && !w7.__owl__.vnode) {
+            if (utils.shallowEqual(props7, w7.__owl__.renderProps)) {
+                def6 = w7.__owl__.renderPromise;
+            } else {
+                w7.destroy();
+                w7 = false;
+            }
+        }
+        if (!w7) {
+            let componentKey7 = \`__component__users\`;
+            let W7 = context.components && context.components[componentKey7] || QWeb.components[componentKey7];
+            if (!W7) {throw new Error('Cannot find the definition of component \\"' + componentKey7 + '\\"')}
+            w7 = new W7(parent, props7);
+            parent.__owl__.cmap[7] = w7.__owl__.id;
+            def6 = w7.__prepare();
+            def6 = def6.then(vnode=>{if (w7.__owl__.isDestroyed){return}let pvnode=h(vnode.sel, {key: 7, hook: {insert(vn) {let nvn=w7.__mount(vnode, pvnode.elm);pvnode.elm=nvn.elm;},remove() {},destroy(vn) {w7.destroy();}}});c1[_5_index]=pvnode;w7.__owl__.pvnode = pvnode;});
+        } else {
+            def6 = def6 || w7.__updateProps(props7, extra.forceUpdate, extra.patchQueue);
+            def6 = def6.then(()=>{if (w7.__owl__.isDestroyed) {return};let pvnode=w7.__owl__.pvnode;c1[_5_index]=pvnode;});
+        }
+        extra.promises.push(def6);
+    }
+    return vn1;
+}"
+`;

tests/router/directive.test.ts

@@ -0,0 +1,106 @@
+import { Component } from "../../src/component/component";
+import { RouterEnv } from "../../src/router/Router";
+import { makeTestEnv, makeTestFixture, nextTick } from "../helpers";
+import { TestRouter } from "./TestRouter";
+
+describe("router directive t-routecomponent", () => {
+  let fixture: HTMLElement;
+  let env: RouterEnv;
+  let router: TestRouter | null = null;
+
+  beforeEach(() => {
+    fixture = makeTestFixture();
+    env = <RouterEnv>makeTestEnv();
+  });
+
+  afterEach(() => {
+    fixture.remove();
+    if (router) {
+      router.destroy();
+    }
+    router = null;
+  });
+
+  test("can render simple cases", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="App">
+                <t t-routecomponent="1" />
+            </div>
+            <span t-name="About">About</span>
+            <span t-name="Users">Users</span>
+        </templates>
+    `);
+    class About extends Component<any, any, any> {}
+    class Users extends Component<any, any, any> {}
+    class App extends Component<any, any, any> {
+      components = { About, Users };
+    }
+
+    const routes = [
+      { name: "about", path: "/about", component: About },
+      { name: "users", path: "/users", component: Users }
+    ];
+
+    router = new TestRouter(env, routes, { mode: "history" });
+    await router.navigate({ to: "about" });
+    const app = new App(env);
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>About</span></div>");
+
+    await router.navigate({ to: "users" });
+    await nextTick();
+    expect(fixture.innerHTML).toBe("<div><span>Users</span></div>");
+    expect(env.qweb.templates.App.fn.toString()).toMatchSnapshot();
+  });
+
+  test("can render parameterized route", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="App">
+                <t t-routecomponent="1" />
+            </div>
+            <span t-name="Book">Book <t t-esc="props.title"/></span>
+        </templates>
+    `);
+    class Book extends Component<any, any, any> {}
+    class App extends Component<any, any, any> {
+      components = { Book };
+    }
+
+    const routes = [{ name: "book", path: "/book/{{title}}", component: Book }];
+    router = new TestRouter(env, routes, { mode: "history" });
+    await router.navigate({ to: "book", params: { title: "1984" } });
+    const app = new App(env);
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>Book 1984</span></div>");
+    expect(env.qweb.templates.App.fn.toString()).toMatchSnapshot();
+  });
+
+  test("can render parameterized route with suffixes", async () => {
+    env.qweb.addTemplates(`
+        <templates>
+            <div t-name="App">
+                <t t-routecomponent="1" />
+            </div>
+            <span t-name="Book">Book <t t-esc="props.title"/>|<t t-esc="incVal"/></span>
+        </templates>
+    `);
+    class Book extends Component<any, any, any> {
+      get incVal() {
+        return this.props.val + 1;
+      }
+    }
+    class App extends Component<any, any, any> {
+      components = { Book };
+    }
+
+    const routes = [{ name: "book", path: "/book/{{title}}/{{val.number}}", component: Book }];
+    router = new TestRouter(env, routes, { mode: "history" });
+    await router.navigate({ to: "book", params: { title: "1984", val: "123" } });
+    const app = new App(env);
+    await app.mount(fixture);
+    expect(fixture.innerHTML).toBe("<div><span>Book 1984|124</span></div>");
+    expect(env.qweb.templates.App.fn.toString()).toMatchSnapshot();
+  });
+});

tests/router/router.test.ts

@@ -0,0 +1,258 @@
+import { Destination, RouterEnv, Route } from "../../src/router/Router";
+import { makeTestEnv, nextTick } from "../helpers";
+import { TestRouter } from "./TestRouter";
+
+let env: RouterEnv;
+let router: TestRouter | null = null;
+
+beforeEach(() => {
+  env = <RouterEnv>makeTestEnv();
+  window.history.pushState({}, "/", "/");
+});
+
+afterEach(() => {
+  if (router) {
+    router.destroy();
+  }
+  router = null;
+});
+
+describe("router miscellaneous", () => {
+  test("validate routes shape", () => {
+    expect(() => {
+      router = new TestRouter(env, [
+        { name: "someroute", path: "/some/path", redirect: { abc: "hey" } as Destination }
+      ]);
+    }).toThrow(`Invalid destination: {"abc":"hey"}`);
+  });
+
+  test("navigate to same route but with different params should trigger update", async () => {
+    router = new TestRouter(env, [{ name: "users", path: "/users/{{id}}" }]);
+    env.qweb.forceUpdate = jest.fn();
+    await router.navigate({ to: "users", params: { id: 3 } });
+    expect(window.location.pathname).toBe("/users/3");
+    expect(env.qweb.forceUpdate).toHaveBeenCalledTimes(1);
+
+    await router.navigate({ to: "users", params: { id: 5 } });
+    expect(window.location.pathname).toBe("/users/5");
+    expect(env.qweb.forceUpdate).toHaveBeenCalledTimes(2);
+  });
+
+  test("changing url to same route but with different params should trigger update (hash mode)", async () => {
+    env.qweb.forceUpdate = jest.fn();
+    router = new TestRouter(env, [{ name: "users", path: "/users/{{id}}" }], { mode: "hash" });
+    await router.start();
+    await router.navigate({ to: "users", params: { id: 3 } });
+    expect(window.location.hash).toBe("#/users/3");
+    expect(env.qweb.forceUpdate).toHaveBeenCalledTimes(1);
+
+    window.location.hash = "/users/5";
+    window.dispatchEvent(new Event("hashchange"));
+    await nextTick();
+    expect(window.location.hash).toBe("#/users/5");
+    expect(env.qweb.forceUpdate).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("routeToPath", () => {
+  test("simple non parameterized path", () => {
+    router = new TestRouter(env, []);
+    expect(router["routeToPath"]({ path: "/abc" } as Route, {})).toBe("/abc");
+    expect(router["routeToPath"]({ path: "/abc/def" } as Route, {})).toBe("/abc/def");
+    expect(router["routeToPath"]({ path: "/abc" } as Route, { val: 12 })).toBe("/abc");
+  });
+
+  test("simple parameterized path", () => {
+    router = new TestRouter(env, []);
+    expect(router["routeToPath"]({ path: "/abc/{{def}}" } as Route, { def: 34 })).toBe("/abc/34");
+  });
+
+  test("simple non parameterized path, mode = hash", () => {
+    router = new TestRouter(env, [], { mode: "hash" });
+    expect(router["routeToPath"]({ path: "/abc" } as Route, {})).toBe("#/abc");
+    expect(router["routeToPath"]({ path: "/abc/def" } as Route, {})).toBe("#/abc/def");
+    expect(router["routeToPath"]({ path: "/abc" } as Route, { val: 12 })).toBe("#/abc");
+  });
+
+  test("simple parameterized path, mode=hash", () => {
+    router = new TestRouter(env, [], { mode: "hash" });
+    expect(router["routeToPath"]({ path: "/abc/{{def}}" } as Route, { def: 34 })).toBe("#/abc/34");
+  });
+});
+
+describe("destToPath", () => {
+  test("validate destination shape", () => {
+    router = new TestRouter(env, [{ name: "someroute", path: "/some/path" }]);
+    expect(() => {
+      router!.destToPath({ abc: 123 } as Destination);
+    }).toThrow('Invalid destination: {"abc":123}');
+
+    expect(() => {
+      router!.destToPath({ to: "someroute" } as Destination);
+    }).not.toThrow();
+
+    expect(() => {
+      router!.destToPath({ path: "/someroute", to: "otherroute" } as Destination);
+    }).toThrow();
+  });
+});
+
+describe("getRouteParams", () => {
+  test("properly match simple routes", () => {
+    router = new TestRouter(env, []);
+    // simple route
+    expect(router["getRouteParams"]({ path: "/home" } as Route, "/home")).toEqual({});
+
+    // no match
+    expect(router["getRouteParams"]({ path: "/home" } as Route, "/otherpath")).toEqual(false);
+
+    // fallback route
+    expect(router["getRouteParams"]({ path: "*" } as Route, "somepath")).toEqual({});
+  });
+
+  test("properly match simple routes, mode hash", () => {
+    router = new TestRouter(env, [], { mode: "hash" });
+    // simple route
+    expect(router["getRouteParams"]({ path: "/home" } as Route, "#/home")).toEqual({});
+
+    // no match
+    expect(router["getRouteParams"]({ path: "/home" } as Route, "#/otherpath")).toEqual(false);
+
+    // fallback route
+    expect(router["getRouteParams"]({ path: "*" } as Route, "#/somepath")).toEqual({});
+  });
+
+  test("match some parameterized routes", () => {
+    router = new TestRouter(env, []);
+    expect(router["getRouteParams"]({ path: "/invoices/{{id}}" } as Route, "/invoices/3")).toEqual({
+      id: "3"
+    });
+  });
+
+  test("match some parameterized routes, mode hash", () => {
+    router = new TestRouter(env, [], { mode: "hash" });
+    expect(router["getRouteParams"]({ path: "/invoices/{{id}}" } as Route, "#/invoices/3")).toEqual(
+      {
+        id: "3"
+      }
+    );
+  });
+
+  test("can convert to number if needed", () => {
+    router = new TestRouter(env, []);
+    expect(
+      router["getRouteParams"]({ path: "/invoices/{{id.number}}" } as Route, "/invoices/3")
+    ).toEqual({
+      id: 3
+    });
+  });
+
+  test("can convert to number if needed, mode: hash", () => {
+    router = new TestRouter(env, [], { mode: "hash" });
+    expect(
+      router["getRouteParams"]({ path: "/invoices/{{id.number}}" } as Route, "#/invoices/3")
+    ).toEqual({
+      id: 3
+    });
+  });
+});
+
+describe("redirect", () => {
+  test("can redirect to other route", async () => {
+    router = new TestRouter(env, [
+      { name: "routea", path: "/some/path" },
+      { name: "routeb", path: "/some/other/path", redirect: { to: "routea" } }
+    ]);
+
+    await router.start();
+    expect(window.location.pathname).toBe("/");
+    await router.navigate({ to: "routeb" });
+    expect(window.location.pathname).toBe("/some/path");
+    expect(router.currentRouteName).toBe("routea");
+  });
+
+  test("can redirect to other path", async () => {
+    router = new TestRouter(env, [
+      { name: "routea", path: "/some/path" },
+      { name: "routeb", path: "/some/other/path", redirect: { path: "/some/path" } }
+    ]);
+    router.navigate = jest.fn(router.navigate);
+
+    await router.start();
+    await router.navigate({ to: "routeb" });
+
+    // once because we ask for it, once because it is redirected
+    // expect(router.navigate).toBeCalledTimes(2);
+    expect(window.location.pathname).toBe("/some/path");
+    expect(router.currentRouteName).toBe("routea");
+  });
+});
+
+describe("beforeRouteEnter", () => {
+  test("navigation guard is called and properly handle return true", async () => {
+    expect(window.location.pathname).not.toBe("/some/path");
+    const guard = jest.fn(() => true);
+    router = new TestRouter(env, [{ name: "route", path: "/some/path", beforeRouteEnter: guard }]);
+
+    await router.start();
+    await router.navigate({ to: "route" });
+    expect(guard).toBeCalledTimes(1);
+    expect(window.location.pathname).toBe("/some/path");
+    expect(router.currentRouteName).toBe("route");
+  });
+
+  test("navigation is cancelled if guard return false", async () => {
+    expect(window.location.pathname).toBe("/");
+    const guard = jest.fn(() => false);
+    router = new TestRouter(env, [
+      { name: "routea", path: "/some/patha" },
+      { name: "routeb", path: "/some/pathb", beforeRouteEnter: guard }
+    ]);
+
+    await router.start();
+    await router.navigate({ to: "routea" });
+    expect(window.location.pathname).toBe("/some/patha");
+    const result = await router.navigate({ to: "routeb" });
+    expect(result).toBe(false);
+    expect(guard).toBeCalledTimes(1);
+    expect(window.location.pathname).toBe("/some/patha");
+    expect(router.currentRouteName).toBe("routea");
+  });
+
+  test("navigation is redirected if guard decides so", async () => {
+    expect(window.location.pathname).toBe("/");
+    const guard = jest.fn(() => {
+      return { to: "routec" };
+    });
+    router = new TestRouter(env, [
+      { name: "routea", path: "/some/patha" },
+      { name: "routeb", path: "/some/pathb", beforeRouteEnter: guard },
+      { name: "routec", path: "/some/pathc" }
+    ]);
+
+    await router.start();
+    const result = await router.navigate({ to: "routea" });
+    expect(result).toBe(true);
+    expect(window.location.pathname).toBe("/some/patha");
+    await router.navigate({ to: "routeb" });
+    expect(guard).toBeCalledTimes(1);
+    expect(window.location.pathname).toBe("/some/pathc");
+    expect(router.currentRouteName).toBe("routec");
+  });
+
+  test("navigation is initially redirected if guard decides so", async () => {
+    expect(window.location.pathname).toBe("/");
+    const guard = jest.fn(() => {
+      return { to: "otherroute" };
+    });
+    router = new TestRouter(env, [
+      { name: "landing", path: "/", beforeRouteEnter: guard },
+      { name: "otherroute", path: "/some/other/route" }
+    ]);
+
+    expect(window.location.pathname).toBe("/");
+
+    await router.start();
+    expect(window.location.pathname).toBe("/some/other/route");
+  });
+});

tests/store/__snapshots__/connected_component.test.ts.snap

@@ -15,3 +15,7 @@ exports[`connecting a component to store deep and shallow connecting a component
 exports[`connecting a component to store deep and shallow connecting a component 3`] = `"<div><span>Bertinchamps</span></div>"`;
 
 exports[`connecting a component to store deep and shallow connecting a component 4`] = `"<div><span>Kasteel</span></div>"`;
+
+exports[`various scenarios scenarios with async store updates and some components events 1`] = `"<div><button>Do stuff</button><div><span>Attachment 100</span><span>Name: text.txt</span></div></div>"`;
+
+exports[`various scenarios scenarios with async store updates and some components events 2`] = `"<div><button>Do stuff</button></div>"`;

tests/store/store.test.ts

@@ -0,0 +1,328 @@
+import { Env } from "../../src/component/component";
+import { Store, Getter } from "../../src/store/store";
+import { nextTick, nextMicroTick } from "../helpers";
+
+describe("basic use", () => {
+  test("dispatch an action", () => {
+    const state = { n: 1 };
+    const actions = {
+      inc({ state }, delta) {
+        state.n += delta;
+      }
+    };
+    const store = new Store({ state, actions });
+
+    expect(store.state.n).toBe(1);
+    store.dispatch("inc", 14);
+    expect(store.state.n).toBe(15);
+  });
+
+  test("dispatch an action with positional arguments", () => {
+    const state = { n1: 1, n2: 1, n3: 1 };
+
+    const actions = {
+      batchInc({ state }, delta1, delta2, delta3) {
+        state.n1 += delta1;
+        state.n2 += delta2;
+        state.n3 += delta3;
+      }
+    };
+    const store = new Store({ state, 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("can dispatch an action in an action", () => {
+    const state = { n: 1 };
+
+    const actions = {
+      inc({ state }, delta) {
+        state.n += delta;
+      },
+      inc100({ dispatch }) {
+        dispatch("inc", 100);
+      }
+    };
+    const store = new Store({ state, actions });
+
+    expect(store.state.n).toBe(1);
+    store.dispatch("inc100");
+    expect(store.state.n).toBe(101);
+  });
+
+  test("return data from dispatching an action", () => {
+    const state = { n: 1 };
+    const actions = {
+      inc({ state }) {
+        return ++state.n;
+      }
+    };
+    const store = new Store({ state, actions });
+
+    expect(store.state.n).toBe(1);
+    const res = store.dispatch("inc");
+    expect(store.state.n).toBe(2);
+    expect(res).toBe(2);
+  });
+
+  test("dispatch allow synchronizing between actions", async () => {
+    const state = { n: 1 };
+    const actions = {
+      inc({ state }, delta) {
+        state.n += delta;
+      },
+      setN({ state }, n) {
+        state.n = n;
+      },
+      async dosomething({ dispatch }) {
+        await dispatch("setTo10");
+        dispatch("inc", 3);
+      },
+      async setTo10({ dispatch }) {
+        await Promise.resolve();
+        dispatch("setN", 10);
+      }
+    };
+    const store = new Store({ state, actions });
+
+    expect(store.state.n).toBe(1);
+    store.dispatch("dosomething");
+    expect(store.state.n).toBe(1);
+    await nextTick();
+    expect(store.state.n).toBe(13);
+  });
+
+  test("return data from dispatching an action", async () => {
+    const state = { n: 1 };
+    const actions = {
+      inc({ state }, delta) {
+        state.n += delta;
+      },
+      setN({ state }, n) {
+        state.n = n;
+      },
+      async dosomething({ dispatch }) {
+        const val = await dispatch("setTo10");
+        dispatch("inc", val);
+      },
+      async setTo10({ dispatch }) {
+        await Promise.resolve();
+        dispatch("setN", 10);
+        return 5;
+      }
+    };
+    const store = new Store({ state, actions });
+
+    expect(store.state.n).toBe(1);
+    store.dispatch("dosomething");
+    expect(store.state.n).toBe(1);
+    await nextTick();
+    expect(store.state.n).toBe(15);
+  });
+
+  test("env is given to actions", () => {
+    expect.assertions(1);
+    const someEnv = <Env>{};
+    const actions = {
+      someaction({ env }) {
+        expect(env).toBe(someEnv);
+      }
+    };
+    const store = new Store({ state: {}, actions, env: someEnv });
+
+    store.dispatch("someaction");
+  });
+
+  test("can have getters from store", async () => {
+    const state = {
+      beers: {
+        1: {
+          id: 1,
+          name: "bertinchamps",
+          tasterID: 1
+        }
+      },
+      tasters: {
+        1: {
+          id: 1,
+          name: "aaron"
+        }
+      }
+    };
+    const getters: { [key: string]: Getter } = {
+      beerTasterName({ state }, beerID) {
+        return state.tasters[state.beers[beerID].tasterID].name;
+      },
+      bestBeerName({ state }) {
+        return state.beers[1].name;
+      }
+    };
+    const store = new Store({ state, actions: {}, getters });
+    expect(store.getters).toBeDefined();
+    expect((<any>store.getters).bestBeerName()).toBe("bertinchamps");
+    expect((<any>store.getters).beerTasterName(1)).toBe("aaron");
+  });
+
+  test("getters given to actions", async () => {
+    expect.assertions(3);
+    const state = {
+      beers: {
+        1: {
+          id: 1,
+          name: "bertinchamps",
+          tasterID: 1
+        }
+      },
+      tasters: {
+        1: {
+          id: 1,
+          name: "aaron"
+        }
+      }
+    };
+    const getters = {
+      beerTasterName({ state }, beerID) {
+        return state.tasters[state.beers[beerID].tasterID].name;
+      },
+      bestBeerName({ state }) {
+        return state.beers[1].name;
+      }
+    };
+    const actions = {
+      action({ getters }) {
+        expect(getters).toBeDefined();
+        expect(getters.bestBeerName()).toBe("bertinchamps");
+        expect(getters.beerTasterName(1)).toBe("aaron");
+      }
+    };
+    const store = new Store({ state, actions, getters });
+    store.dispatch("action");
+  });
+
+  test("can use getters inside a getter", () => {
+    const getters = {
+      a({ getters }) {
+        return `${getters.b()}${getters.c(1)}`;
+      },
+      b() {
+        return "b";
+      },
+      c({}, i) {
+        return `c${i}`;
+      }
+    };
+    const store = new Store({ getters, state: {}, actions: {} });
+
+    expect(store.getters.a()).toBe("bc1");
+  });
+});
+
+describe("advanced state properties", () => {
+  test("state in the store is reference equal after mutation", async () => {
+    const actions = {
+      donothing() {}
+    };
+    const store = new Store({ state: {}, actions });
+    const state = store.state;
+    store.dispatch("donothing");
+    expect(store.state).toBe(state);
+  });
+
+  test("can use array properties in mutations", () => {
+    expect.assertions(3);
+    const state = { a: [1, 2, 3] };
+    const actions = {
+      m({ state }) {
+        expect(state.a.length).toBe(3);
+        const l = state.a.push(53);
+        expect(l).toBe(4);
+      }
+    };
+    const store = new Store({ state, actions });
+    store.dispatch("m");
+    expect(store.state.a).toEqual([1, 2, 3, 53]);
+  });
+
+  test("can use object assign in store", async () => {
+    const actions = {
+      dosomething({ state }) {
+        Object.assign(state.westmalle, { a: 3, b: 4 });
+      }
+    };
+    const store = new Store({
+      state: { westmalle: { a: 1, b: 2 } },
+      actions
+    });
+    store.dispatch("dosomething");
+    expect(store.state.westmalle).toEqual({ a: 3, b: 4 });
+  });
+
+  test("aku reactive store state 1", async () => {
+    const actions = {
+      inc({ state }) {
+        state.counter++;
+      }
+    };
+    const state = { counter: 0 };
+    const store = new Store({ state, actions });
+    expect(store.state.counter).toBe(0);
+    store.dispatch("inc", {});
+    expect(store.state.counter).toBe(1);
+  });
+});
+
+describe("updates triggered by the store", () => {
+  test("multiple commits trigger one update", async () => {
+    let updateCounter = 0;
+    const state = { n: 1 };
+    const actions = {
+      inc({ state }, delta) {
+        state.n += delta;
+      }
+    };
+    const store = new Store({ state, actions });
+    store.on("update", null, () => updateCounter++);
+
+    store.dispatch("inc", 14);
+    expect(updateCounter).toBe(0);
+    store.dispatch("inc", 50);
+    expect(updateCounter).toBe(0);
+    await nextMicroTick();
+    expect(updateCounter).toBe(1);
+  });
+
+  test("empty commits do not trigger updates", async () => {
+    let updateCounter = 0;
+    const state = { n: 1 };
+    const actions = {
+      inc({ state }, delta) {
+        state.n += delta;
+      },
+      noop() {},
+      noop2({ state }) {
+        const val = state.n;
+        state.n = val;
+      }
+    };
+    const store = new Store({ state, actions });
+    store.on("update", null, () => updateCounter++);
+
+    store.dispatch("noop");
+    await nextMicroTick();
+    expect(updateCounter).toBe(0);
+
+    store.dispatch("inc", 50);
+    await nextMicroTick();
+    expect(updateCounter).toBe(1);
+
+    store.dispatch("noop2");
+    await nextMicroTick();
+    expect(updateCounter).toBe(1);
+  });
+});

tests/vdom.test.ts

@@ -1,4 +1,5 @@
-import { h, patch, init } from "../src/vdom";
+import { h, patch } from "../src/vdom";
+import { init } from "../src/vdom/vdom";
 
 function map(list, fn) {
   var ret: any[] = [];

tools/benchmarks/owl-0.17.0/app.js

@@ -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 {
+  components = { 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 {
+  components = { 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 += "!!!";
+        owl.Observer.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();

tools/benchmarks/owl-0.17.0/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OWL 0.17.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>

tools/benchmarks/owl-0.17.0/templates.xml

@@ -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">
+                  <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>
+    <Counter/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>

tools/benchmarks/owl-0.18.0/app.js

@@ -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 {
+  components = { 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 {
+  components = { 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 += "!!!";
+        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();

tools/benchmarks/owl-0.18.0/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>OWL 0.18.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>

tools/benchmarks/owl-0.18.0/templates.xml

@@ -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">
+                  <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>
+    <Counter/>
+  </div>
+
+  <div t-name="Counter">
+    <button t-on-click="increment">Value: <t t-esc="state.counter"/></button>
+  </div>
+
+</templates>

tools/benchmarks/owl-master/app.js

@@ -107,12 +107,11 @@ class App extends owl.Component {
 
   updateSomeMessages() {
     this.benchmark("update every 10th", () => {
-      const setState = owl.Observer.set;
       const messages = this.state.messages;
-      for (let i = 0; i < this.state.messages.length; i += 10) {
+      for (let i = 0; i < messages.length; i += 10) {
         const msg = Object.assign({}, messages[i]);
         msg.author += "!!!";
-        setState(messages, i, msg);
+        messages[i] = msg;
       }
     });
   }

tools/index.html

@@ -37,6 +37,8 @@
                 <li><a href="benchmarks/owl-0.14.0">OWL 0.14.0</a></li>
                 <li><a href="benchmarks/owl-0.15.0">OWL 0.15.0</a></li>
                 <li><a href="benchmarks/owl-0.16.0">OWL 0.16.0</a></li>
+                <li><a href="benchmarks/owl-0.17.0">OWL 0.17.0</a></li>
+                <li><a href="benchmarks/owl-0.18.0">OWL 0.18.0</a></li>
                 <li><a href="benchmarks/owl-master">OWL Master</a></li>
             </ul>
             <ul>

tools/playground/samples.js

@@ -268,56 +268,42 @@ const TODO_APP_STORE = `// This example is an implementation of the TodoList app
 
 const ENTER_KEY = 13;
 const ESC_KEY = 27;
-const LOCALSTORAGE_KEY = "todos-odoo";
+const LOCALSTORAGE_KEY = "todomvc";
 
 //------------------------------------------------------------------------------
 // Store Definition
 //------------------------------------------------------------------------------
 const actions = {
-    addTodo({ commit }, title) {
-        commit("addTodo", title);
-    },
-    removeTodo({ commit }, id) {
-        commit("removeTodo", id);
-    },
-    toggleTodo({ state, commit }, id) {
-        const todo = state.todos.find(t => t.id === id);
-        commit("editTodo", { id, completed: !todo.completed });
-    },
-    clearCompleted({ state, commit }) {
-        state.todos
-            .filter(todo => todo.completed)
-            .forEach(todo => {
-                commit("removeTodo", todo.id);
-            });
-    },
-    toggleAll({ state, commit }, completed) {
-        state.todos.forEach(todo => {
-            commit("editTodo", {
-                id: todo.id,
-                completed
-            });
-        });
-    },
-    editTodo({ commit }, { id, title }) {
-        commit("editTodo", { id, title });
-    }
-};
-
-const mutations = {
     addTodo({ state }, title) {
-        const id = state.nextId++;
-        const todo = {
-            id,
+        state.todos.push({
+            id: state.nextId++,
             title,
             completed: false
-        };
-        state.todos.push(todo);
+        });
     },
     removeTodo({ state }, id) {
         const index = state.todos.findIndex(t => t.id === id);
         state.todos.splice(index, 1);
     },
+    toggleTodo({ state, dispatch }, id) {
+        const todo = state.todos.find(t => t.id === id);
+        dispatch("editTodo", { id, completed: !todo.completed });
+    },
+    clearCompleted({ state, dispatch }) {
+        state.todos
+            .filter(todo => todo.completed)
+            .forEach(todo => {
+                dispatch("removeTodo", todo.id);
+            });
+    },
+    toggleAll({ state, dispatch }, completed) {
+        state.todos.forEach(todo => {
+            dispatch("editTodo", {
+                id: todo.id,
+                completed
+            });
+        });
+    },
     editTodo({ state }, { id, title, completed }) {
         const todo = state.todos.find(t => t.id === id);
         if (title !== undefined) {
@@ -329,24 +315,20 @@ const mutations = {
     }
 };
 
+function saveState(state) {
+    const str = JSON.stringify(state);
+    window.localStorage.setItem(LOCALSTORAGE_KEY, str);
+}
+
+function loadState() {
+    const localState = window.localStorage.getItem(LOCALSTORAGE_KEY);
+    return localState ? JSON.parse(localState) : { todos: [], nextId: 1};
+}
+
 function makeStore() {
-    const todos = JSON.parse(
-        window.localStorage.getItem(LOCALSTORAGE_KEY) || "[]"
-    );
-    const nextId = Math.max(0, ...todos.map(t => t.id || 0)) + 1;
-    const state = {
-        todos,
-        nextId
-    };
-    const store = new owl.Store({
-        state,
-        actions,
-        mutations
-    });
-    store.on("update", null, () => {
-        const state = JSON.stringify(store.state.todos);
-        window.localStorage.setItem(LOCALSTORAGE_KEY, state);
-    });
+    const state = loadState();
+    const store = new owl.store.Store({ state, actions });
+    store.on("update", null, () => saveState(store.state));
     return store;
 }
 
@@ -357,11 +339,11 @@ class TodoItem extends owl.Component {
     state = { isEditing: false };
 
     removeTodo() {
-        this.env.dispatch("removeTodo", this.props.id);
+        this.env.store.dispatch("removeTodo", this.props.id);
     }
 
     toggleTodo() {
-        this.env.dispatch("toggleTodo", this.props.id);
+        this.env.store.dispatch("toggleTodo", this.props.id);
     }
 
     async editTodo() {
@@ -393,7 +375,7 @@ class TodoItem extends owl.Component {
         if (!value) {
             this.removeTodo(this.props.id);
         } else {
-            this.env.dispatch("editTodo", {
+            this.env.store.dispatch("editTodo", {
                 id: this.props.id,
                 title: value
             });
@@ -405,7 +387,7 @@ class TodoItem extends owl.Component {
 //------------------------------------------------------------------------------
 // TodoApp
 //------------------------------------------------------------------------------
-class TodoApp extends owl.ConnectedComponent {
+class TodoApp extends owl.store.ConnectedComponent {
     components = { TodoItem };
     state = { filter: "all" };
 
@@ -415,7 +397,7 @@ class TodoApp extends owl.ConnectedComponent {
         };
     }
     get visibleTodos() {
-        let todos = this.props.todos;
+        let todos = this.storeProps.todos;
         if (this.state.filter === "active") {
             todos = todos.filter(t => !t.completed);
         }
@@ -426,11 +408,11 @@ class TodoApp extends owl.ConnectedComponent {
     }
 
     get allChecked() {
-        return this.props.todos.every(todo => todo.completed);
+        return this.storeProps.todos.every(todo => todo.completed);
     }
 
     get remaining() {
-        return this.props.todos.filter(todo => !todo.completed).length;
+        return this.storeProps.todos.filter(todo => !todo.completed).length;
     }
 
     get remainingText() {
@@ -442,20 +424,12 @@ class TodoApp extends owl.ConnectedComponent {
         if (ev.keyCode === ENTER_KEY) {
             const title = ev.target.value;
             if (title.trim()) {
-                this.env.dispatch("addTodo", title);
+                this.dispatch("addTodo", title);
             }
             ev.target.value = "";
         }
     }
 
-    clearCompleted() {
-        this.env.dispatch("clearCompleted");
-    }
-
-    toggleAll() {
-        this.env.dispatch("toggleAll", !this.allChecked);
-    }
-
     setFilter(filter) {
         this.state.filter = filter;
     }
@@ -469,7 +443,6 @@ const qweb = new owl.QWeb(TEMPLATES);
 const env = {
     qweb,
     store,
-    dispatch: store.dispatch.bind(store),
 };
 const app = new TodoApp(env);
 app.mount(document.body);
@@ -481,8 +454,8 @@ const TODO_APP_STORE_XML = `<templates>
       <h1>todos</h1>
       <input class="new-todo" autofocus="true" autocomplete="off" placeholder="What needs to be done?" t-on-keyup="addTodo"/>
     </header>
-    <section class="main" t-if="props.todos.length">
-      <input class="toggle-all" id="toggle-all" type="checkbox" t-att-checked="allChecked" t-on-click="toggleAll"/>
+    <section class="main" t-if="storeProps.todos.length">
+      <input class="toggle-all" id="toggle-all" type="checkbox" t-att-checked="allChecked" t-on-click="dispatch('toggleAll', !allChecked)"/>
       <label for="toggle-all"></label>
       <ul class="todo-list">
         <t t-foreach="visibleTodos" t-as="todo">
@@ -490,7 +463,7 @@ const TODO_APP_STORE_XML = `<templates>
         </t>
       </ul>
     </section>
-    <footer class="footer" t-if="props.todos.length">
+    <footer class="footer" t-if="storeProps.todos.length">
       <span class="todo-count">
         <strong>
             <t t-esc="remaining"/>
@@ -508,7 +481,7 @@ const TODO_APP_STORE_XML = `<templates>
           <a t-on-click="setFilter('completed')" t-att-class="{selected: state.filter === 'completed'}">Completed</a>
         </li>
       </ul>
-      <button class="clear-completed" t-if="props.todos.length gt remaining" t-on-click="clearCompleted">
+      <button class="clear-completed" t-if="storeProps.todos.length gt remaining" t-on-click="dispatch('clearCompleted')">
         Clear completed
       </button>
     </footer>
@@ -953,7 +926,7 @@ function setupResponsivePlugin(env) {
     const updateEnv = owl.utils.debounce(() => {
         if (env.isMobile !== isMobile()) {
             env.isMobile = !env.isMobile;
-            env.qweb.trigger('update');
+            env.qweb.forceUpdate();
         }
     }, 15);
     window.addEventListener("resize", updateEnv);
@@ -1334,6 +1307,246 @@ const FORM_XML = `<templates>
 </templates>
 `;
 
+const WMS = `// This example is slightly more complex than usual. We demonstrate
+// here a way to manage sub windows in Owl, declaratively. This is still just a
+// demonstration. Managing windows can be as complex as we want.  For example,
+// we could implement the following features:
+// - resizing windows
+// - minimizing windows
+// - configuration options for windows to make a window non resizeable
+// - minimal width/height
+// - better heuristic for initial window position
+// - ...
+
+class HelloWorld extends owl.Component {}
+
+class Counter extends owl.Component {
+  state = { value: 0 };
+
+  inc() {
+    this.state.value++;
+  }
+}
+
+class Window extends owl.Component {
+  get style() {
+    let { width, height, top, left, zindex } = this.props.info;
+
+    return \`width: \${width}px;height: \${height}px;top:\${top}px;left:\${left}px;z-index:\${zindex}\`;
+  }
+  close() {
+    this.trigger("close-window", { id: this.props.info.id });
+  }
+  startDragAndDrop(ev) {
+    this.updateZIndex();
+    this.el.classList.add('dragging');
+    const offsetX = this.props.info.left - ev.pageX;
+    const offsetY = this.props.info.top - ev.pageY;
+    let left, top;
+
+    const el = this.el;
+    const self = this;
+    window.addEventListener("mousemove", moveWindow);
+    window.addEventListener("mouseup", stopDnD, { once: true });
+
+    function moveWindow(ev) {
+      left = Math.max(offsetX + ev.pageX, 0);
+      top = Math.max(offsetY + ev.pageY, 0);
+      el.style.left = \`\${left}px\`;
+      el.style.top = \`\${top}px\`;
+    }
+    function stopDnD() {
+      window.removeEventListener("mousemove", moveWindow);
+      const options = { id: self.props.info.id, left, top };
+      self.el.classList.remove('dragging');
+      self.trigger("set-window-position", options);
+    }
+  }
+  updateZIndex() {
+    this.trigger("update-z-index", { id: this.props.info.id });
+  }
+}
+
+class WindowManager extends owl.Component {
+  components = { Window };
+  windows = [];
+  nextId = 1;
+  currentZindex = 1;
+  addWindow(name) {
+    const info = this.env.windows.find(w => w.name === name);
+    const id = \`w\${this.nextId++}\`;
+    this.windows.push({
+      id: id,
+      title: info.title,
+      width: info.defaultWidth,
+      height: info.defaultHeight,
+      top: 0,
+      left: 0,
+      zindex: this.currentZindex++
+    });
+    this.components[id] = info.component;
+    this.render();
+  }
+  closeWindow(ev) {
+    const id = ev.detail.id;
+    delete this.components[id];
+    const index = this.windows.findIndex(w => w.id === id);
+    this.windows.splice(index, 1);
+    this.render();
+  }
+  setWindowPosition(ev) {
+    const id = ev.detail.id;
+    const w = this.windows.find(w => w.id === id);
+    w.top = ev.detail.top;
+    w.left = ev.detail.left;
+  }
+  updateZIndex(ev) {
+    const id = ev.detail.id;
+    const w = this.windows.find(w => w.id === id);
+    w.zindex = this.currentZindex++;
+    ev.target.style["z-index"] = w.zindex;
+  }
+}
+
+class App extends owl.Component {
+  components = { WindowManager };
+
+  addWindow(name) {
+    this.refs.wm.addWindow(name);
+  }
+}
+
+const qweb = new owl.QWeb(TEMPLATES);
+const windows = [
+  {
+    name: "Hello",
+    title: "Hello",
+    component: HelloWorld,
+    defaultWidth: 200,
+    defaultHeight: 100
+  },
+  {
+    name: "Counter",
+    title: "Click Counter",
+    component: Counter,
+    defaultWidth: 300,
+    defaultHeight: 120
+  }
+];
+
+const env = { qweb, windows };
+const app = new App(env);
+app.mount(document.body);
+`;
+
+const WMS_XML = `<templates>
+  <div t-name="Window" class="window" t-att-style="style" t-on-click="updateZIndex">
+    <div class="header">
+      <span t-on-mousedown="startDragAndDrop"><t t-esc="props.info.title"/></span>
+      <span class="close" t-on-click="close">×</span>
+    </div>
+    <t t-slot="default"/>
+  </div>
+
+  <div t-name="WindowManager" class="window-manager"
+       t-on-close-window="closeWindow"
+       t-on-update-z-index="updateZIndex"
+       t-on-set-window-position="setWindowPosition">
+    <Window t-foreach="windows" t-as="w" t-key="w.id" info="w">
+      <t t-component="{{w.id}}"/>
+    </Window>
+  </div>
+
+  <div t-name="App" class="app">
+    <WindowManager t-ref="wm"/>
+    <div class="menubar">
+      <button t-on-click="addWindow('Hello')">Say Hello</button>
+      <button t-on-click="addWindow('Counter')">Counter</button>
+    </div>
+  </div>
+
+  <div t-name="HelloWorld">
+    World
+  </div>
+
+  <div t-name="Counter" class="counter">
+    <button t-on-click="inc">Inc</button>
+    <span><t t-esc="state.value"/></span>
+  </div>
+</templates>
+`;
+
+const WMS_CSS = `body {
+    margin: 0;
+}
+
+.app {
+    width: 100%;
+    height: 100%;
+    display: grid;
+    grid-template-rows: auto 50px;
+}
+
+.window-manager {
+    position: relative;
+    width: 100%;
+    height: 100%;
+    background-color: #eeeeee;
+    overflow: hidden;
+}
+
+.menubar {
+    background-color: #875a7b;
+    color: white;
+}
+
+.menubar button {
+    height: 40px;
+    font-size: 18px;
+    margin: 5px;
+}
+
+.window {
+    display: grid;
+    grid-template-rows: 30px auto;
+    border: 1px solid gray;
+    background-color: white;
+    position: absolute;
+    box-shadow: 1px 1px 2px 1px grey;
+}
+
+.window.dragging {
+    opacity: 0.75;
+}
+
+.window .header {
+    background-color: #875a7b;
+    display: grid;
+    grid-template-columns: auto 24px;
+    color: white;
+    line-height: 30px;
+    padding-left: 5px;
+    cursor: default;
+    user-select: none;
+}
+
+.window .header .close {
+    cursor: pointer;
+    font-size: 22px;
+    padding-left: 4px;
+    padding-right: 4px;
+    font-weight: bold;
+}
+
+.counter {
+    font-size: 20px;
+}
+.counter button {
+    width: 80px;
+    height:40px;
+    font-size: 20px;
+}`;
+
 export const SAMPLES = [
   {
     description: "Components",
@@ -1376,6 +1589,12 @@ export const SAMPLES = [
     xml: SLOTS_XML,
     css: SLOTS_CSS
   },
+  {
+      description: "Window Management System",
+      code: WMS,
+      xml: WMS_XML,
+      css: WMS_CSS,
+  },
   {
     description: "Asynchronous components",
     code: ASYNC_COMPONENTS,

tsconfig.json

@@ -5,7 +5,7 @@
     "noImplicitThis": true,
     "removeComments": false,
     "declaration": true,
-    "target": "es5",
+    "target": "esnext",
     "outDir": "dist",
     "alwaysStrict": true,
     "noUnusedLocals": true,
@@ -15,5 +15,5 @@
     "strictPropertyInitialization": true,
     "strictNullChecks": true
   },
-  "include": ["src/*.ts"]
+  "include": ["src/**/*.ts","src/*.ts"]
 }