[IMP] types: correctly support Set type for props-validation

Previously, having a Set as a type in the static props description
of a component would would lead to a type error.

This commit adds Set to the list of supported types in the Schema

.eslintrc

@@ -0,0 +1,47 @@
+{
+    "env": {
+        "browser": true,
+        "node": true,
+        "es2022": true
+    },
+    "parser": "@typescript-eslint/parser",
+    "plugins": ["@typescript-eslint"],
+    "parserOptions": {
+        "sourceType": "module"
+    },
+    "root": true,
+    "rules": {
+        "no-restricted-globals": ["error", "event", "self"],
+        "no-const-assign": ["error"],
+        "no-debugger": ["error"],
+        "no-dupe-class-members": ["error"],
+        "no-dupe-keys": ["error"],
+        "no-dupe-args": ["error"],
+        "no-dupe-else-if": ["error"],
+        "no-unsafe-negation": ["error"],
+        "no-duplicate-imports": ["error"],
+        "valid-typeof": ["error"],
+        "@typescript-eslint/no-unused-vars": ["error", { "vars": "all", "args": "none", "ignoreRestSiblings": false, "caughtErrors": "all" }],
+        "no-restricted-syntax": [
+            "error",
+            {
+                "selector": "MemberExpression[object.name='test'][property.name='only']",
+                "message": "test.only(...) is forbidden",
+            },
+            {
+                "selector": "MemberExpression[object.name='describe'][property.name='only']",
+                "message": "describe.only(...) is forbidden",
+            }
+        ],
+    },
+    "globals": {
+        "describe": true,
+        "expect": true,
+        "test": true,
+        "beforeEach": true,
+        "beforeAll": true,
+        "afterEach": true,
+        "afterAll": true,
+        "jest": true,
+    },
+}

.github/workflows/deploy.yml

@@ -14,7 +14,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [12.x, 14.x]
+        node-version: [12.x, 14.x, 16.x]
 
     steps:
     - uses: actions/checkout@v2
@@ -22,6 +22,8 @@ jobs:
       uses: actions/setup-node@v1
       with:
         node-version: ${{ matrix.node-version }}
-    - run: npm install
+    - run: npm ci
     - run: npm run test
-    - run: npm run prettier
+    - run: npm run check-formatting
+    - run: npm run lint
+    - run: npm run build

.gitignore

@@ -14,21 +14,22 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 
-package-lock.json
-yarn.lock
-
 #ide's
-.vscode
+**/.vscode/*
 .idea
 
 node_modules
 
-# Extras temp file
-/tools/owl.js
-
 release-notes.md
 
 .rpt2_cache
 
 # useful in some cases
-/temp
+/temp
+
+# owl-vision
+*/owl-vision/out/
+*/owl-vision/.vs/
+**/*.vsix
+!*/owl-vision/.vscode/launch.json
+!*/owl-vision/.vscode/tasks.json

CHANGELOG.md

@@ -0,0 +1,766 @@
+# Changelog
+
+This document contains an overview of all changes between Owl 1.x and
+Owl 2.x, with some pointers on how to update the code.
+
+Note that some of these changes can be magically implemented (for example, by
+patching the `setup` method of `Component` to auto register all the lifecycle
+methods as hooks). This will be done for the transition period, but will be
+removed after.
+
+## From Owl 1.x to Owl 2.0
+
+All changes are documented here in no particular order.
+
+**Components**
+
+- components can now have empty content or multiple root nodes (htmlelement or text) ([details](#31-components-can-now-have-arbitrary-content))
+- breaking: component.el is removed ([details](#9-componentel-is-removed))
+- new `useEffect` hook ([doc](doc/reference/hooks.md#useeffect))
+- new `onWillDestroy`, `onWillRender` and `onRendered` hooks ([doc](doc/reference/component.md#lifecycle))
+- breaking: lifecycle methods are removed ([details](#1-component-lifecycle-methods-are-removed))
+- breaking: can no longer be mounted on detached DOM ([details](#2-components-can-no-longer-be-mounted-in-a-detached-dom-element))
+- breaking: standalone `mount` method API is simpler ([details](#4-mount-method-api-is-simpler))
+- breaking: components can no longer be instantiated and mounted by hand ([details](#5-components-can-no-longer-be-instantiated-and-mounted-by-hand))
+- breaking: components can no longer be unmounted/remounted ([details](#6-components-can-no-longer-be-unmountedremounted))
+- breaking: template name is no longer inferred from the class name ([details](#7-template-name-is-no-longer-inferred-from-the-class-name))
+- breaking: components no longer have a `shouldUpdate` method ([details](#8-components-no-longer-have-a-shouldupdate-method))
+- breaking: components can no longer be mounted with position=self ([details](#11-components-can-no-longer-be-mounted-with-positionself))
+- breaking: `render` method does not return a promise anymore ([details](#35-render-method-does-not-return-a-promise-anymore))
+- breaking: `catchError` method is replaced by `onError` hook ([details](#36-catcherror-method-is-replaced-by-onerror-hook))
+- breaking: Support for inline css (`css` tag and static `style`) has been removed ([details](#37-support-for-inline-css-css-tag-and-static-style-has-been-removed))
+- new: prop validation system can now describe that additional props are allowed (with `*`) ([doc](doc/reference/props.md#props-validation))
+- breaking: prop validation system does not allow default prop on a mandatory (not optional) prop ([doc](doc/reference/props.md#props-validation))
+- breaking: rendering a component does not necessarily render child components ([details](#40-rendering-a-component-does-not-necessarily-render-child-components))
+
+
+
+**Templates**
+
+- breaking: `t-foreach` should always have a corresponding `t-key` ([details](#20-t-foreach-should-always-have-a-corresponding-t-key))
+- breaking: `t-ref` does not work on components ([details](#29-t-ref-does-not-work-on-component))
+- breaking: `t-raw` directive has been removed (replaced by `t-out`) ([details](#38-t-raw-directive-has-been-removed-replaced-by-t-out))
+- new: add support for synthetic events ([doc](doc/reference/event_handling.md#synthetic-events))
+- breaking: style/class on components are now regular props ([details](#10-styleclass-on-components-are-now-regular-props))
+- new: components can use the `.bind` suffix to bind function props ([doc](doc/reference/props.md#binding-function-props))
+- breaking: `t-on` does not accept expressions, only functions ([details](#30-t-on-does-not-accept-expressions-only-functions))
+- new: an error is thrown if an handler defined in a `t-on-` directive is not a function (failed silently previously in some cases)
+- breaking: `t-component` no longer accepts strings ([details](#17-t-component-no-longer-accepts-strings))
+- new: the `this` variable in template expressions is now bound to the component
+
+
+**Reactivity**
+
+- finer grained reactivity: owl 2 tracks change per key/component
+- finer grained reactivity: sub components can reobserve state ([doc](doc/reference/reactivity.md))
+- new: `reactive` function: create reactive state (without being linked to a component) ([doc](doc/reference/reactivity.md#reactive))
+- new: `markRaw` function: mark an object or array so that it is ignored by the reactivity system ([doc](doc/reference/reactivity.md#markraw))
+- new: `toRaw` function: given a reactive objet, return the raw (non reactive) underlying object ([doc](doc/reference/reactivity.md#toraw))
+
+
+**Slots**
+
+- breaking: `t-set` does not define a slot any more ([details](#3-t-set-will-no-longer-work-to-define-a-slot))
+- slots capabilities have been improved ([doc](doc/reference/slots.md))
+  - params can be give to slot content (to pass information from slot owner to slot user)
+  - slots are given as a `prop` (and can be manipulated/propagated to sub components )
+  - slots can define scopes (to pass information from slot user to slot owner)
+
+
+**Portal**
+
+- Portal are now defined with `t-portal` ([details](#33-portal-are-now-defined-with-t-portal))
+- portals can now have arbitrary content (no longer restricted to one single child)
+- breaking: does no longer transfer dom events ([details](#13-portal-does-no-longer-transfer-dom-events))
+- breaking: does render as an empty text node instead of `<portal/>` ([details](#14-portal-does-render-as-an-empty-text-node-instead-of-portal))
+
+
+**Miscellaneous**
+
+- improved performance
+- much simpler code 
+- new App class to encapsulate a root Owl component (with the config for that application) ([doc](doc/reference/app.md))
+- new `useEffect` hook ([doc](doc/reference/hooks.md#useeffect))
+- breaking: `Context` is removed ([details](#15-context-is-removed))
+- breaking: `env` is now totally empty ([details](#16-env-is-now-totally-empty))
+- breaking: `env` is now frozen ([details](#28-env-is-now-frozen))
+- new hook: `useChildSubEnv` (only applies to child components) ([details](#27-usechildsubenv-only-applies-to-child-components))
+- breaking: most exports are exported at top level ([details](#18-most-exports-are-exported-at-top-level))
+- breaking: properties are no longer set as attributes ([details](#19-properties-are-no-longer-set-as-attributes))
+- breaking: `EventBus` api changed: it is now an `EventTarget` ([details](#21-eventbus-api-changed-it-is-now-an-eventtarget))
+- breaking: `Store` is removed ([details](#22-store-is-removed))
+- breaking: `Router` is removed ([details](#23-router-is-removed))
+- breaking: transition system is removed ([details](#24-transition-system-is-removed))
+- breaking: no more global components or templates ([details](#25-no-more-global-components-or-templates))
+- breaking: `AsyncRoot` utility component is removed ([details](#26-asyncroot-utility-component-is-removed))
+- breaking: `renderToString` function on qweb has been removed ([details](#32-rendertostring-on-qweb-has-been-removed))
+- breaking: `debounce` utility function has been removed ([details](#34-debounce-utility-function-has-been-removed))
+- breaking: `browser` object has been removed ([details](#39-browser-object-has-been-removed))
+
+## Details/Rationale/Migration
+
+All changes are listed in no particular order.
+
+### 1. component lifecycle methods are removed
+
+There was two ways to define hooks: the component methods (`willStart`, `mounted`, ...) and the hooks (`onWillStart`, `onMounted`, ...). In Owl 2, the component methods have been removed.
+
+Rationale: it makes the implementation simpler and slightly faster. Hooks are more composable
+than component methods. It enforces a single entry point to check all the useful lifecycle
+calls (instead of it being scattered in the component definition). It feels more "modern".
+
+Migration: lifecycle methods should be defined in the `setup`:
+
+```js
+class MyComponent extends Component {
+  mounted() {
+    // do something
+  }
+}
+```
+should become:
+```js
+class MyComponent extends Component {
+  setup() {
+    onMounted(() => {
+      // do something
+    });
+  }
+}
+```
+
+Documentation: [Component Lifecycle](doc/reference/component.md#lifecycle)
+
+### 2. components can no longer be mounted in a detached dom element
+
+Nor document fragment.
+
+Rationale: it is actually very difficult to do it: this implies that a component
+can be mounted more than once, that we need to check every time different status,
+that some elements is in the dom, and was a cause for bugs. Also, we don't use it
+in practice. Removing this means that we have a much simpler mental model of what
+happens.
+
+Migration: well, not really easy. The code needs to be refactored in a different way.
+
+
+### 3. **`t-set` will no longer work to define a slot**
+
+The `t-set` directive cannot define a slot anymore. Only the `t-set-slot` directive
+can do it.
+
+Rationale: it was left for compatibility reason, but was deprecated anyway.
+
+Migration: `t-set` should be changed to `t-set-slot` (when defining a slot)
+
+Example:
+
+```xml
+<SideBar><t t-set="content">content</t></SideBar>
+```
+should become:
+```xml
+<SideBar><t t-set-slot="content">content</t></SideBar>
+```
+
+### 4. `mount` method API is simpler
+
+Before, the `mount` method was used like this:
+
+```js
+await mount(Root, { target: document.body });
+```
+
+It is now simpler and takes the root component and a target argument:
+
+```js
+await mount(Root, document.body);
+```
+
+Rationale: the `mount` method is only useful anyway for small toy examples,
+because real applications will need to configure the templates, the translations,
+and other stuff. All complex usecases need to go through the new `App` class,
+that encapsulates the root of an owl application.
+
+Documentation: [Mounting a component](doc/reference/app.md#mount-helper)
+
+### 5. components can no longer be instantiated and mounted by hand
+
+In Owl 1, it was possible to instantiate a component by hand:
+
+```js
+const root = new Root();
+await root.mount(document.body);
+```
+
+Now, it is no longer possible. All component instantiations should be done by
+the owl framework itself.
+
+Rationale: the `mount` method does not make sense for all non root components.
+Also, the fact that it was possible for a component to be sometimes root,
+sometimes a child made for a weird constructor signature. This changes makes it
+simpler.
+
+Migration: all code doing that should use either the `mount` method (if the use
+case is simple enough, or the `App` class):
+
+```js
+const app = new App(Root);
+app.configure({ templates: ..., ...});
+await app.mount(document.body);
+```
+
+### 6. components can no longer be unmounted/remounted
+
+Rationale: this is a very difficult feature to implement (it adds a lot of possible
+state transitions), compared to its benefit.
+
+Migration: all code using it should find a way to export and reimport the state
+
+### 7. template name is no longer inferred from the class name
+
+Before, it was possible to define a component without specifying its template:
+
+```js
+class Blabla extends Component {
+    // no static template here!
+}
+```
+with the `Blabla` template. It also worked with subclasses. But then, this means
+that the code had to look up all the super classes names to find the correct
+template.
+
+Rationale: in practice, it is not really useful, since all templates are usually
+namespaced: `web.SomeComponent` anyway. All the trouble to do that was just not
+worth it.
+
+Migration: simply explicitely defines the template key everytime:
+
+```js
+class Blabla extends Component {}
+Blabla.template = "Blabla";
+```
+
+### 8. components no longer have a `shouldUpdate` method
+
+Rationale: `shouldUpdate` is a dangerous method to use, that may cause a lot of
+issues. Vue does not have such a mechanism (see https://github.com/vuejs/vue/issues/4255),
+because the reactivity system in Vue is smart enough to only rerender the minimal
+subset of components that is subscribed to a piece of state. Now, Owl 2 features
+a much more powerful reactivity system, so the same rationale applies: in a way,
+it's like each Owl 2 component has a `shouldUpdate` method that precisely tracks
+every value used by the component.
+
+Migration code: remove the `shouldUpdate` methods, and it should work as well
+as before.
+
+### 9. component.el is removed
+
+This comes from the fact that Owl 2 supports fragments (arbitrary content).
+
+Migration: if one need a reference to the root htmlelement of a template, it is
+suggested to simply add a `ref` on it, and access the reference as needed.
+
+Documentation: [Refs](doc/reference/refs.md)
+
+### 10. style/class on components are now regular props
+
+Before, it was possible to do this in a template:
+
+```xml
+<Child style="..." class="..."/>
+```
+(or with `t-att-style` and `t-att-class`). This does no longer work, as they are
+now considered normal props.
+
+Rationale: with the move to fragments, the semantics of where the style/class
+attribute should be set is unclear. Also, it is actually very hard to implement
+properly, in particular with higher order components. And another issue is that
+it (slightly) breaks the encapsulation of behaviour from the `Child` component
+perspective.
+
+Migration: each component that wishes to be customized should explicitely add
+the `class` and `style` attributes in its template. Also, the parent component
+should be aware that since we are talking about props, it should be a javascript expression:
+
+In parent:
+
+```xml
+<Child class="'o_my_god'"/>
+```
+and in child:
+
+```xml
+    <div t-att-class="props.class">
+        ...
+    </div>
+```
+
+### 11. components can no longer be mounted with position=self
+
+Rationale: this is due to the implementation of owl 2 virtual dom. The hack
+necessary to support position=self does not work. This position also is not
+compatible with the fact that a component can have a root `<div>` then later,
+change it to something else, or even a text node.
+
+Migration: no real way to do the same. Owl application needs to be appended or
+prepended in something, maybe a `div`. Remember that you the root component
+can have multiple roots
+
+Documentation:
+- [Fragments](doc/reference/templates.md#fragments)
+- [Mounting a component](doc/reference/app.md#mount-helper)
+
+
+### 13. Portal does no longer transfer DOM events
+
+In Owl 1, a Portal component would listen to events emitted on its portalled
+child, and redispatch them on itself. It no longer works.
+
+Rationale: Portal now supports an arbitrary content (so, more than one child,
+and potentially no html element), so it is already unclear what it should listen
+to. Also, redispatching events was an hack. And this changes allows the portal
+to render itself as a text node, which is nice. This is also in line with the
+fact that modern Owl moves toward using callback instead of `t-on` for communication.
+
+Migration: use callback if possible to communicate. Otherwise, use a sub env.
+
+### 14. Portal does render as an empty text node instead of `<portal/>`
+
+That is pretty nice. No real migration needed.
+
+### 15. Context is removed
+
+Context was an abstraction in Owl that was used to define some reactive state
+and to let some components subscribe to it, then only them would be rerendered
+if the context was updated. This has been removed.
+
+Rationale: first, the Context api and code was kind of awkward, which is a sign
+that the abstraction is not well thought. But the good news is that it is actually
+completely replaced by the new reactivity system, which is even more powerful,
+since it can tracks changes key by key.
+
+Migration: replace all uses of Context with the new reactivity system.
+
+```js
+// somewhere, maybe in a service, or in the global env
+const context = observe({some: "state"})
+
+// in a component that would previously get a reference to the context:
+
+setup() {
+    this.context = useState(context);
+    // now the component is subscribed to the context and will react to any
+    // change for any key read by the component, and only those changes
+}
+```
+
+### 16. `env` is now totally empty
+
+In Owl 1, the `env` object had to contain a QWeb instance. This was the way
+components would get a reference to their template function. It no longer works
+that way: the `env` object is now totally empty (from the perspective of Owl).
+It is now a user space concept, useful for the application.
+
+Rationale: first, there is no longer a QWeb class. Also, this changes simplifies
+the way components works internally.
+
+Migration: there is no proper way to get an equivalent. The closest is to get
+a reference to the root App using `this.__owl__.app`. If you need to do this,
+let us know. If this is a legitimate usecase, we may add a `useApp` hook.
+
+Documentation: [Environment](doc/reference/environment.md)
+
+### 17. `t-component` no longer accepts strings
+
+In owl 1, we could write this:
+
+```xml
+<t t-component="Coucou"/>
+```
+
+This meant that Owl would look for the component class like this: `components["Coucou"]`,
+so, essentially equivalent to `<Coucou/>`. In Owl 2, the `t-component` directive
+is assumed to be an expression evaluating to a component class:
+
+```js
+class Parent extends Component {
+  static template = xml`<t t-component="Child"/>`;
+  Child = Child;
+}
+```
+
+Rationale: it simply seems more consistent with the way directive works. Also,
+the implementation is slightly simpler.
+
+Migration: simply using `constructor.components.Coucou` instead of `Coucou` will
+do the trick.
+
+Documentation: [Component](doc/reference/component.md#dynamic-sub-components)
+
+### 18. most exports are exported at top level
+
+Most exports are flattened: for ex, `onMounted` is in owl, not in `owl.hooks`.
+
+Rationale: this makes it easier to work with, instead of importing stuff from 
+`owl`, then `owl.hooks` and `owl.tags` for example.
+
+Migration: all import code simply need to be slightly adapted.
+
+### 19. Properties are no longer set as attributes
+
+Formerly, html properties `<input type="checkbox" t-att-checked="blah"/>` were
+set as property and as attribute, so, they would be visible in the DOM:
+`<input type="checkbox" checked="blah"/>`. Now, they are treated as property only:
+`<input type="checkbox"/>`.
+
+Rationale: this is actually simple to do, is faster, and makes more sense to me.
+
+### 20. `t-foreach` should always have a corresponding `t-key`
+
+It was possible in Owl 1 to write a `t-foreach` without a `t-key`. In that case,
+the index was used as key.  Since it was clearly a possible bug, Owl 1 had a
+warning in some cases, when it could detect that there was definitely not a `t-key`.
+However, this was imperfect, and in some cases no warning was displayed. In Owl 2,
+the tag with a `t-foreach` has to have a corresponding `t-key`.
+
+Rationale: this makes it easier to avoid bugs.
+
+Migration: simply move the `t-key` to the tag with the `t-foreach`. If this is
+a situation where there is really not a need for a `t-key`, you can still add
+it with the `_index` suffix:
+
+```xml
+<div t-foreach="items" t-as="item" t-key="item_index">
+  ...
+</div>
+```
+
+### 21. `EventBus` api changed: it is now an `EventTarget`
+
+In Owl 1, the `EventBus` class was done manually, with a custom API. In Owl 2,
+it simply extends `EventTarget` (the native Dom class), so its implementation
+is basically only 5 lines long. This means that it has now the usual DOM interface:
+
+```js
+bus.addEventListener('event-name', callback);
+```
+
+Rationale: it makes it easier to have just one interface to remember, it makes
+the code simpler
+
+Migration: most bus methods need to be adapted. So, `bus.on("event-type", owner, (info) => {...})` has to be
+rewritten like this: `bus.addEventListener("event-type", (({detail: info}) => {...}).bind(owner))`.
+
+Do not forget to similarly replace `bus.off(...)` by `bus.removeEventListener(...)`
+
+Documentation: [EventBus](doc/reference/utils.md#eventbus)
+
+### 22. `Store` is removed
+
+The Store system had been abandoned in owl 2.
+
+Rationale: first, it was complicated to maintain. Second, it was not really
+used in Odoo. Finally, the new reactivity system seems to be a pretty good basis
+to write a store, and it should not take much work. Also, this can be done in
+user space (so, not necessarily at the framework level). Another point is that
+the store API was invented before the hooks, then was still a little awkward.
+
+Migration:
+- rewrite the code not to use a store
+- probably use the reactivity system instead and build a store class and a few
+  hooks on top of it.
+
+### 23. `Router` is removed
+
+Rationale: Router was not used that much, and it felt like it did not fit in Owl 2.
+Its API needs to be reworked, and we are not confident that it is a good
+experience to use it. Also, it can be done in userspace (it does not need specific
+integration at the framework level)
+
+Migration: reimport all missing piece from the code in Owl 1.
+
+### 24. transition system is removed
+
+Rationale: this was a high ratio cost/value, with a lot of potential for bugs.
+We feel like there should be a way to reimplement in userspace the simple cases.
+
+Maybe something like: add a `t-ref` in the template, and define a hook `useFadeOut`
+that takes the ref, and add a fadeout class at initial render, then in mounted,
+wait for a micro tick and remove it.
+
+Migration: try to reimplement it manually. 
+
+### 25. no more global components or templates
+
+It was possible in Owl 1 to register globally a component or a template. This is
+no longer the case in Owl 2.
+
+Rationale: first, this was a tradeoff: ease of use was gained, but at the cost
+of a higher complexity. Users had to know that there was a magic mechanism. Also,
+it was not used much in practice, and the cost of having to import manually components
+is low.  Finally, this can be mostly done in user space (for example, by subclassing
+`Component`).
+
+Migration: import manually all required global components, or find a way to organize
+the code to do it.
+
+### 26. `AsyncRoot` utility component is removed
+
+Rationale: it was difficult to understand, never used, and not really useful.
+It seems better to control the asynchrony of an application by simply controlling
+how/when the state is updated, and how each component is loading/updating itself.
+
+Migration: remove the `AsyncRoot` component, then possibly, reorganize the code
+to fetch data in a higher order component, and using a `t-if/t-else` to display
+either a fallback when the data is not ready, or the actual component with data
+as props.  If there is no escape, and `AsyncRoot` is needed, please reach out to
+us so we can study this usecase.
+
+### 27. `useChildSubEnv` (only applies to child components)
+
+In Owl, a call to `useSubEnv` would define a new environment for the children
+AND the component. It is very useful, but in some cases, one only need to update
+the children component environment. This can now be done with a new hook:
+[`useChildSubEnv`](doc/reference/hooks.md#usesubenv-and-usechildsubenv)
+
+### 28. `env` is now frozen
+
+In Owl 2, the `env` object is frozen. It can no longer be modified (structurally)
+arbitrarily. 
+
+Rationale: it seems like the `env` object purpose is to have a global channel of
+communication between components. It is however scary if anyone can add something
+to it.  The usual use case is to add something to the environment for some child
+components. This use case still works with `useSubEnv`.
+
+Migration: use `useSubEnv` instead of writing directly to the env.  Also, note
+that the environment given to the App can initially contain anything.
+
+Documentation: [Environment](doc/reference/environment.md)
+
+### 29. `t-ref` does not work on component
+
+Before, `t-ref` could be used to get a reference to a child component. It no
+longer works.
+
+Rationale: the possibility of having a ref to a child component breaks the
+encapsulation provided by Owl components: a child component now has a private
+and a public interface.  Another issue is that it may be unclear when the ref
+should be set: is the component active on setup, or on mounted? Also, it is
+kind of awkward to implement.
+
+Migration: the `env` and `props` should provide a communication channel wide enough:
+the sub component can expose its public API by calling a callback at the proper
+timing, or by triggering an event.
+
+### 30. `t-on` does not accept expressions, only functions
+
+In Owl 1, it was possible to define simple expressions inline, in a template:
+
+```xml
+<button t-on-click="state.value = state.value + 1">blabla</button>
+<button t-on-click="someFunction(someVar)">blabla</button>
+```
+
+This does not work anymore. Now, the `t-on` directive assumes that what it get is
+a function.
+
+Rationale: the fact that owl 1 had to support expressions meant that it was not
+possible to properly inject the event in general. With this restriction, Owl 2
+can support more general use cases. Also, the examples above can simply be
+wrapped in a lambda function. 
+
+Migration: use lambda functions. For example, the two examples above can be
+adapted like this:
+
+```xml
+<button t-on-click="() => state.value = state.value + 1">blabla</button>
+<button t-on-click="() => this.someFunction(someVar)">blabla</button>
+```
+
+Documentation: [Event Handling](doc/reference/event_handling.md)
+
+### 31. components can now have arbitrary content
+
+Before Owl 2, components had to limit themselves to one single htmlelement as
+root. Now, the content is arbitrary: it can be empty, or multiple html elements.
+So, the following template works for components:
+
+```xml
+  <div>1</div>
+  <div>2</div>
+  hello
+```
+
+Documentation: [Fragments](doc/reference/templates.md#fragments)
+
+### 32. `renderToString` on QWeb has been removed
+
+Rationale: the `renderToString` function was a qweb method, which made sense because
+the qweb instance knew all templates. But now, the closest analogy is the `App`
+class, but it is not as convenient, since the `app` instance is no longer visible
+to components (while before, `qweb` was in the environment).
+
+Also, this can easily be done in userspace, by mounting a component in a div.  For example:
+
+```js
+export async function renderToString(template, context) {
+  class C extends Component {
+    static template = template;
+    setup () {
+        Object.assign(this, context);
+    }
+  }
+  const div = document.createElement('div');
+  document.body.appendChild(div);
+  const app = new App(C);
+  await app.mount(div);
+  const result = div.innerHTML;
+  app.destroy();
+  div.remove();
+  return result;
+}
+```
+
+The function above works for most cases, but is asynchronous.  An alternative
+function could look like this:
+
+```js
+const { App, blockDom } = owl;
+const app = new App(Component); // act as a template repository
+
+function renderToString(template, context = {}) {
+  app.addTemplate(template, template, { allowDuplicate: true });
+  const templateFn = app.getTemplate(template);
+  const bdom = templateFn(context, {});
+  const div = document.createElement('div')
+  blockDom.mount(bdom, div);
+  return div.innerHTML;
+}
+```
+
+This is a synchronous function, so it will not work with components, but it should
+be useful for most simple templates.
+
+Also note that these two examples do not translate their templates. To do that,
+they need to be modified to pass the proper translate function to the `App`
+configuration.
+
+### 33. Portal are now defined with `t-portal`
+
+Before Owl 2, one could use the `Portal` component by importing it and using it.
+Now, it is no longer available. Instead, we can simply use the `t-portal` directive:
+
+```xml
+<div>
+  some content
+  <span t-portal="'body'">
+    portalled content
+  </span>
+<div>
+```
+
+Rationale: it makes it slightly simpler to use (just need the directive, instead
+of having to import and use a sub component), it makes the implementation slightly
+simpler as well. Also, it prevents subclassing the Portal component, which could
+be dangerous, since it is really doing weird stuff under the hood, and could
+easily be broken inadvertendly.
+
+### 34. `debounce` utility function has been removed
+
+Rationale: it did not really help that much, is available as utility function
+elsewhere, so, we decided to have a smaller footprint by focusing Owl on what
+it does best.
+
+### 35. `render` method does not return a promise anymore
+
+Rationale: using the `render` method directly and waiting for it to complete
+was slightly un-declarative. Also, it can be done using the lifecycle hooks
+any way.
+
+Migration: if necessary, one can use the lifecycle hooks to execute code after
+the next mounted/patched operation.
+
+### 36. `catchError` method is replaced by `onError` hook
+
+The `catchError` method was used to provide a way to components to handle errors
+occurring during the component lifecycle. This has been replaced by a `onError`
+hook, with a similar API.
+
+Rationale: `catchError` felt a little big awkward, when most of the way we
+interact with componentss is via hooks.  Using hooks felt more natural and
+consistent.
+
+Migration: mostly replace all `catchError` methods by `onError` hooks in the
+`setup` method.
+
+Documentation: [Error Handling](doc/reference/error_handling.md)
+
+
+## 37. Support for inline css (`css` tag and static `style`) has been removed
+
+Rationale: Owl tries to focus on what it does best, and supporting inline css
+was not a priority.  It used to support some simplified scss language, but it
+was feared that it would cause more trouble than it was worth. Also, it seems
+like it can be done in userspace.
+
+Migration: it seems possible to implement an equivalent solution using hooks. A
+simple implementation could look like this:
+
+```js
+let cache = {};
+
+function useStyle(css) {
+  if (!css in cache) {
+    const sheet = document.createElement("style");
+    sheet.innerHTML = css;
+    cache[css] = sheet;
+    document.head.appendChild(sheet);
+  }
+}
+```
+
+## 38. `t-raw` directive has been removed (replaced by `t-out`)
+
+To match the Odoo qweb server implementation, Owl does no longer implement `t-raw`.
+It is replaced by the `t-out` directive, which is safer: it requires the data
+to be marked explicitely as markup if it is to be inserted without escaping.
+Otherwise, it will be escaped (just like `t-esc`).
+
+Migration: replace all `t-raw` uses by `t-out`, and uses the `markup` function
+to mark all the js values.
+
+Documentation: [Outputting data](doc/reference/templates.md#outputting-data)
+
+## 39. `browser` object has been removed
+
+Rationale: the `browser` object caused more trouble than it was worth. Also, it
+seems like this should be done in user space, not at the framework level.  
+
+Migration: code should just be adapted to either use another browser object,
+or to use native browser function (and then, just mock them directly).
+
+## 40. Rendering a component does not necessarily render child components
+
+Before, if one had the following component tree:
+
+```mermaid
+  graph TD;
+      A-->B;
+      A-->C;
+```
+
+when `A` would render, it would also render `B` and `C`. Now, in Owl 2, it will 
+(shallow) compare the before and after props, and `B` or `C` will only be rerendered
+if their props have changed.
+
+Now, the question is what happens if the props have changed, but in a deeper way?
+In that case, Owl will know, because each props are now reactive. So, if some
+inner value read by `B` was changed, then only `B` will be updated.
+
+Rationale: This was just not possible in Owl 1, but it now possible. This is
+due to the rewriteof the underlying rendering engine and the reactivity
+system. The goal is to have a big performance boost in large screen with many
+components: now Owl only rerender what is strictly useful.
+

README.md

@@ -1,114 +1,119 @@
-<h1 align="center">🦉 <a href="https://odoo.github.io/owl/">OWL Framework</a> 🦉</h1>
+<h1 align="center">🦉 <a href="https://odoo.github.io/owl/">Owl Framework</a> 🦉</h1>
+
+ [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+[![npm version](https://badge.fury.io/js/@odoo%2Fowl.svg)](https://badge.fury.io/js/@odoo%2Fowl)
+[![Downloads](https://img.shields.io/npm/dm/@odoo%2Fowl.svg)](https://www.npmjs.com/package/@odoo/owl)
 
 _Class based components with hooks, reactive state and concurrent mode_
 
+**Try it online!** you can experiment with the Owl framework in an online [playground](https://odoo.github.io/owl/playground).
+
 ## Project Overview
 
-The Odoo Web Library (OWL) is a smallish (~<20kb gzipped) UI framework intended to
-be the basis for the [Odoo](https://www.odoo.com/) Web Client. Owl is a modern
+The Odoo Web Library (Owl) is a smallish (~<20kb gzipped) UI framework built by
+[Odoo](https://www.odoo.com/) for its products. Owl is a modern
 framework, written in Typescript, taking the best ideas from React and Vue in a
 simple and consistent way. Owl's main features are:
 
 - a declarative component system,
-- a reactivity system based on hooks,
-- concurrent mode by default,
-- a store and a frontend router
+- a fine grained reactivity system similar to Vue,
+- hooks
+- fragments
+- asynchronous rendering
 
-Owl components are defined with ES6 classes, they use QWeb templates, an
+Owl components are defined with ES6 classes and xml templates, uses an
 underlying virtual DOM, integrates beautifully with hooks, and the rendering is
 asynchronous.
 
-**Try it online!** An online playground is available at
-[https://odoo.github.io/owl/playground](https://odoo.github.io/owl/playground)
-to let you experiment with the Owl framework. There are some code examples to
-showcase some interesting features.
+Quick links:
 
-Owl is currently stable.  Possible future changes are explained in the
-[roadmap](roadmap.md).
-
-## Why Owl?
-
-Why did Odoo decide to make Yet Another Framework?  This is really a question
-that deserves [a long answer](doc/miscellaneous/why_owl.md). But in short, we believe that
-while the current state of the art frameworks are excellent, they are not
-optimized for our use case, and there is still room for something else.
-
-If you are interested in a comparison with React or Vue, you will
-find some more additional information [here](doc/miscellaneous/comparison.md).
+- [documentation](#documentation),
+- [changelog](CHANGELOG.md) (from Owl 1.x to 2.x),
+- [playground](https://odoo.github.io/owl/playground)
 
 ## Example
 
 Here is a short example to illustrate interactive components:
 
 ```javascript
-const { Component, useState, mount } = owl;
-const { xml } = owl.tags;
+const { Component, useState, mount, xml } = owl;
 
 class Counter extends Component {
   static template = xml`
-    <button t-on-click="state.value++">
+    <button t-on-click="() => state.value = state.value + props.increment">
       Click Me! [<t t-esc="state.value"/>]
     </button>`;
 
   state = useState({ value: 0 });
 }
 
-class App extends Component {
+class Root extends Component {
   static template = xml`
-    <div>
-      <span>Hello Owl</span>
-      <Counter />
-    </div>`;
+    <span>Hello Owl</span>
+    <Counter increment="2"/>`;
 
   static components = { Counter };
 }
 
-mount(App, { target: document.body });
+mount(Root, document.body);
 ```
 
 Note that the counter component is made reactive with the [`useState` hook](doc/reference/hooks.md#usestate).
-Also, all examples here uses the [`xml` helper](doc/reference/tags.md#xml-tag) to define inline templates.
+Also, all examples here uses the [`xml` helper](doc/reference/templates.md#inline-templates) to define inline templates.
 But this is not mandatory, many applications will load templates separately.
 
 More interesting examples can be found on the
 [playground](https://odoo.github.io/owl/playground) application.
 
-## Design Principles
-
-OWL is designed to be used in highly dynamic applications where changing
-requirements are common and code needs to be maintained by large teams.
-
-- **XML based**: templates are based on the XML format, which allows interesting
-  applications. For example, they could be stored in a database and modified
-  dynamically with `xpaths`.
-- **templates compilation in the browser**: this may not be a good fit for all
-  applications, but if you need to generate dynamically user interfaces in the
-  browser, this is very powerful. For example, a generic form view component
-  could generate a specific form user interface for each various models, from a XML view.
-- **no toolchain required**: this is extremely useful for some applications, if,
-  for various reasons (security/deployment/dynamic modules/specific assets tools),
-  it is not ok to use standard web tools based on `npm`.
-
-Owl is not designed to be fast nor small (even though it is quite good on those
-two topics). It is a no nonsense framework to build applications. There is only
-one way to define components (with classes). There is no black magic. It just
-works.
-
-
 ## Documentation
 
-A complete documentation for Owl can be found here:
+### Learning Owl
 
-- [Main documentation page](doc/readme.md).
+Are you new to Owl? This is the place to start!
 
-Some of the most important pages are:
-
-- [Tutorial: TodoList application](doc/learning/tutorial_todoapp.md)
+- [Tutorial: create a TodoList application](doc/learning/tutorial_todoapp.md)
 - [How to start an Owl project](doc/learning/quick_start.md)
-- [QWeb templating language](doc/reference/qweb_templating_language.md)
-- [Component](doc/reference/component.md)
-- [Hooks](doc/reference/hooks.md)
+- [How to test Components](doc/learning/how_to_test.md)
 
+### Reference
+
+- [Overview](doc/readme.md)
+- [App](doc/reference/app.md)
+- [Component](doc/reference/component.md)
+- [Component Lifecycle](doc/reference/component.md#lifecycle)
+- [Concurrency Model](doc/reference/concurrency_model.md)
+- [Dev mode](doc/reference/app.md#dev-mode)
+- [Dynamic sub components](doc/reference/component.md#dynamic-sub-components)
+- [Environment](doc/reference/environment.md)
+- [Error Handling](doc/reference/error_handling.md)
+- [Event Handling](doc/reference/event_handling.md)
+- [Form Input Bindings](doc/reference/input_bindings.md)
+- [Fragments](doc/reference/templates.md#fragments)
+- [Hooks](doc/reference/hooks.md)
+- [Loading Templates](doc/reference/app.md#loading-templates)
+- [Mounting a component](doc/reference/app.md#mount-helper)
+- [Portal](doc/reference/portal.md)
+- [Precompiling templates](doc/reference/precompiling_templates.md)
+- [Props](doc/reference/props.md)
+- [Props Validation](doc/reference/props.md#props-validation)
+- [Reactivity](doc/reference/reactivity.md)
+- [Rendering SVG](doc/reference/templates.md#rendering-svg)
+- [Refs](doc/reference/refs.md)
+- [Slots](doc/reference/slots.md)
+- [Sub components](doc/reference/component.md#sub-components)
+- [Sub templates](doc/reference/templates.md#sub-templates)
+- [Templates (Qweb)](doc/reference/templates.md)
+- [Translations](doc/reference/translations.md)
+- [Utils](doc/reference/utils.md)
+
+### Other Topics
+
+- [Notes On Owl Architecture](doc/miscellaneous/architecture.md)
+- [Comparison with React/Vue](doc/miscellaneous/comparison.md)
+- [Why did Odoo build Owl?](doc/miscellaneous/why_owl.md)
+- [Changelog (from owl 1.x to 2.x)](CHANGELOG.md)
+- [Notes on compiled templates](doc/miscellaneous/compiled_template.md)
+- [Owl devtools extension](doc/tools/devtools.md)
 
 ## Installing Owl
 
@@ -117,11 +122,28 @@ Owl is available on `npm` and can be installed with the following command:
 ```
 npm install @odoo/owl
 ```
-
 If you want to use a simple `<script>` tag, the last release can be downloaded here:
 
-- [owl-1.4.4](https://github.com/odoo/owl/releases/tag/v1.4.4)
+- [owl](https://github.com/odoo/owl/releases/latest)
+
+## Installing Owl devtools
+
+The Owl devtools browser extension is also available in the [release](https://github.com/odoo/owl/releases/latest):
+Unzip the owl-devtools.zip file and follow the instructions depending on your browser:
+
+### Chrome
+
+Go to your chrome extensions admin panel, activate developer mode and click on `Load unpacked`.
+Select the devtools-chrome folder and that's it, your extension is active! 
+There is a convenient refresh button on the extension card (still on the same admin page) to update your code. 
+Do note that if you got some problems, you may need to completly remove and reload the extension to completly refresh the extension.
+
+### Firefox 
+Go to the address about:debugging#/runtime/this-firefox and click on `Load temporary Add-on...`.
+Select any file in the devtools-firefox folder and that's it, your extension is active! 
+Here, you can use the reload button to refresh the extension.
+
+Note that you may have to open another window or reload your tab to see the extension working.
+Also note that the extension will only be active on pages that have a sufficient version of owl.
 
-## License
 
-OWL is [LGPL licensed](./LICENSE).

doc/learning/how_to_debug.md

@@ -1,43 +0,0 @@
-# 🦉 How to debug Owl applications 🦉
-
-Non trivial applications become quickly more difficult to understand. It is then
-useful to have a solid understanding of what is going on. To help with that,
-logging useful information is extremely valuable. There is a [javascript file](../../tools/debug.js) which can be evaluated in an application.
-
-Once it is executed, it will log a lot of information on each component main hooks. The following code is a minified version to make it easier to copy/paste:
-
-```
-function debugOwl(t,e){let n,o="[OWL_DEBUG]";function r(t){let e;try{e=JSON.stringify(t||{})}catch(t){e="<JSON error>"}return e.length>200&&(e=e.slice(0,200)+"..."),e}if(Object.defineProperty(t.Component,"current",{get:()=>n,set(s){n=s;const i=s.constructor.name;if(e.componentBlackList&&e.componentBlackList.test(i))return;if(e.componentWhiteList&&!e.componentWhiteList.test(i))return;let l;Object.defineProperty(n,"__owl__",{get:()=>l,set(n){!function(n,s,i){let l=`${s}<id=${i}>`,c=t=>console.log(`${o} ${l} ${t}`),u=t=>(!e.methodBlackList||!e.methodBlackList.includes(t))&&!(e.methodWhiteList&&!e.methodWhiteList.includes(t));u("constructor")&&c(`constructor, props=${r(n.props)}`);u("willStart")&&t.hooks.onWillStart(()=>{c("willStart")});u("mounted")&&t.hooks.onMounted(()=>{c("mounted")});u("willUpdateProps")&&t.hooks.onWillUpdateProps(t=>{c(`willUpdateProps, nextprops=${r(t)}`)});u("willPatch")&&t.hooks.onWillPatch(()=>{c("willPatch")});u("patched")&&t.hooks.onPatched(()=>{c("patched")});u("willUnmount")&&t.hooks.onWillUnmount(()=>{c("willUnmount")});const d=n.__render.bind(n);n.__render=function(...t){c("rendering template"),d(...t)};const h=n.render.bind(n);n.render=function(...t){const e=n.__owl__;let o="render";return e.isMounted||e.currentFiber||(o+=" (warning: component is not mounted, this render has no effect)"),c(o),h(...t)};const p=n.mount.bind(n);n.mount=function(...t){return c("mount"),p(...t)}}(s,i,(l=n).id)}})}}),e.logScheduler){let e=t.Component.scheduler.start,n=t.Component.scheduler.stop;t.Component.scheduler.start=function(){this.isRunning||console.log(`${o} scheduler: start running tasks queue`),e.call(this)},t.Component.scheduler.stop=function(){this.isRunning&&console.log(`${o} scheduler: stop running tasks queue`),n.call(this)}}if(e.logStore){let e=t.Store.prototype.dispatch;t.Store.prototype.dispatch=function(t,...n){return console.log(`${o} store: action '${t}' dispatched. Payload: '${r(n)}'`),e.call(this,t,...n)}}}
-debugOwl(owl, {
-  // componentBlackList: /App/,  // regexp
-  // componentWhiteList: /SomeComponent/, // regexp
-  // methodBlackList: ["mounted"], // list of method names
-  // methodWhiteList: ["willStart"], // list of method names
-  logScheduler: false,  // display/mute scheduler logs
-  logStore: true,     // display/mute store logs
-});
-```
-
-The above code, once pasted somewhere in the main javascript file of an owl
-application, will log information looking like this:
-
-```
-[OWL_DEBUG] TodoApp<id=1> constructor, props={}
-[OWL_DEBUG] TodoApp<id=1> mount
-[OWL_DEBUG] TodoApp<id=1> willStart
-[OWL_DEBUG] TodoApp<id=1> rendering template
-[OWL_DEBUG] TodoItem<id=2> constructor, props={"id":2,"completed":false,"title":"hey"}
-[OWL_DEBUG] TodoItem<id=2> willStart
-[OWL_DEBUG] TodoItem<id=3> constructor, props={"id":4,"completed":false,"title":"aaa"}
-[OWL_DEBUG] TodoItem<id=3> willStart
-[OWL_DEBUG] TodoItem<id=2> rendering template
-[OWL_DEBUG] TodoItem<id=3> rendering template
-[OWL_DEBUG] TodoItem<id=3> mounted
-[OWL_DEBUG] TodoItem<id=2> mounted
-[OWL_DEBUG] TodoApp<id=1> mounted
-```
-
-Each component has an internal `id`, which is very useful when debugging.
-
-Note that it is certainly useful to run this code at some point in an application,
-just to get a feel of what each user action implies, for the framework.

doc/learning/how_to_test.md

@@ -30,27 +30,21 @@ To help with this, it is useful to have a `helper.js` file that contains some
 common utility functions:
 
 ```js
+let lastFixture = null;
+
 export function makeTestFixture() {
   let fixture = document.createElement("div");
   document.body.appendChild(fixture);
+  if (lastFixture) {
+    lastFixture.remove();
+  }
+  lastFixture = fixture;
   return fixture;
 }
 
-export function nextTick() {
-  let requestAnimationFrame = owl.Component.scheduler.requestAnimationFrame;
-  return new Promise(function(resolve) {
-    setTimeout(() => requestAnimationFrame(() => resolve()));
-  });
-}
-
-export function makeTestEnv() {
-    // application specific. It needs a way to load actual templates
-    const templates = ...;
-
-    return {
-        qweb: new QWeb(templates),
-        ..., // each service can be mocked here
-    };
+export async function nextTick() {
+  await new Promise((resolve) => setTimeout(resolve));
+  await new Promise((resolve) => requestAnimationFrame(resolve));
 }
 ```
 
@@ -59,7 +53,7 @@ With such a file, a typical test suite for Jest will look like this:
 ```js
 // in SomeComponent.test.js
 import { SomeComponent } from "../../src/ui/SomeComponent";
-import { nextTick, makeTestFixture, makeTestEnv} from '../helpers';
+import { nextTick, makeTestFixture } from '../helpers';
 
 
 //------------------------------------------------------------------------------
@@ -70,9 +64,6 @@ let env: Env;
 
 beforeEach(() => {
   fixture = makeTestFixture();
-  env = makeTestEnv();
-  // we set here the default environment for each component created in the test
-  Component.env = env;
 });
 
 afterEach(() => {
@@ -85,7 +76,7 @@ afterEach(() => {
 describe("SomeComponent", () => {
   test("component behaves as expected", async () => {
     const props = {...}; // depends on the component
-    const comp = await mount(SomeComponent, { target: fixture, props });
+    const comp = await mount(SomeComponent, fixture, { props });
 
     // do some assertions
     expect(...).toBe(...);
@@ -102,29 +93,3 @@ describe("SomeComponent", () => {
 Note that Owl does wait for the next animation frame to actually update the DOM.
 This is why it is necessary to wait with the `nextTick` (or other methods) to
 make sure that the DOM is up-to-date.
-
-It is sometimes useful to wait until Owl is completely done updating components
-(in particular, if we have a highly concurrent user interface). This next
-helper simply polls every 20ms the internal Owl task queue and returns a promise
-which resolves when it is empty:
-
-```js
-function afterUpdates() {
-  return new Promise((resolve, reject) => {
-    let timer = setTimeout(poll, 20);
-    let counter = 0;
-    function poll() {
-      counter++;
-      if (owl.Component.scheduler.tasks.length) {
-        if (counter > 10) {
-          reject(new Error("timeout"));
-        } else {
-          timer = setTimeout(poll);
-        }
-      } else {
-        resolve();
-      }
-    }
-  });
-}
-```

doc/learning/how_to_write_sfc.md

@@ -1,52 +0,0 @@
-# 🦉 How to write Single File Components 🦉
-
-It is very useful to group code by feature instead of by type of file. It makes
-it easier to scale application to larger size.
-
-To do so, Owl has two small helpers that make it easy to define a
-template or a stylesheet inside a javascript (or typescript) file: the
-[`xml`](../reference/tags.md#xml-tag) and [`css`](../reference/tags.md#css-tag)
-helper.
-
-This means that the template, the style and the javascript code can be defined in
-the same file. For example:
-
-```js
-const { Component } = owl;
-const { xml, css } = owl.tags;
-
-// -----------------------------------------------------------------------------
-// TEMPLATE
-// -----------------------------------------------------------------------------
-const TEMPLATE = xml/* xml */ `
-	<div class="main">
-		<Sidebar/>
-		<Content />
-	</div>`;
-
-// -----------------------------------------------------------------------------
-// STYLE
-// -----------------------------------------------------------------------------
-const STYLE = css/* css */ `
-  .main {
-    display: grid;
-    grid-template-columns: 200px auto;
-  }
-`;
-
-// -----------------------------------------------------------------------------
-// CODE
-// -----------------------------------------------------------------------------
-class Main extends Component {
-  static template = TEMPLATE;
-  static style = STYLE;
-  static components = { Sidebar, Content };
-
-  // rest of component...
-}
-```
-
-Note that the above example has an inline xml comment, just after the `xml` call.
-This is useful for some editor plugins, such as the VS Code addon
-`Comment tagged template`, which, if installed, add syntax highlighting to the
-content of the template string.

doc/learning/overview.md

@@ -1,133 +0,0 @@
-# 🦉 Quick Overview 🦉
-
-Owl components in an application are used to define a (dynamic) tree of components.
-
-```
-        Root
-        /   \
-       A     B
-      / \
-     C   D
-```
-
-**State:** each component can manage its own local state. It is a simple ES6
-class, there are no special rules:
-
-```js
-class Counter extends Component {
-  static template = xml`
-    <button t-on-click="increment">
-      Click Me! [<t t-esc="state.value"/>]
-    </button>`;
-
-  state = { value: 0 };
-
-  increment() {
-    this.state.value++;
-    this.render();
-  }
-}
-```
-
-The example above shows a component with a local state. Note that since there
-is nothing magical to the `state` object, we need to manually call the `render`
-function whenever we update it. This can quickly become annoying (and not
-efficient if we do it too much). There is a better way: using the `useState`
-hook, which transforms an object into a reactive version of itself:
-
-```js
-const { useState } = owl.hooks;
-
-class Counter extends Component {
-  static template = xml`
-    <button t-on-click="increment">
-      Click Me! [<t t-esc="state.value"/>]
-    </button>`;
-
-  state = useState({ value: 0 });
-
-  increment() {
-    this.state.value++;
-  }
-}
-```
-
-Note that the `t-on-click` handler can even be replaced by an inline statement:
-
-```xml
-    <button t-on-click="state.value++">
-```
-
-**Props:** sub components often needs some information from their parents. This
-is done by adding the required information to the template. This will then be
-accessible by the sub component in the `props` object. Note that there is an
-important rule here: the information contained in the `props` object is not
-owned by the sub component, and should never be modified.
-
-```js
-class Child extends Component {
-  static template = xml`<div>Hello <t t-esc="props.name"/></div>`;
-}
-
-class Parent extends Component {
-  static template = xml`
-    <div>
-        <Child name="'Owl'" />
-        <Child name="'Framework'" />
-    </div>`;
-  static components = { Child };
-}
-```
-
-**Communication:** there are multiple ways to communicate information between
-components. However, the two most important ways are the following:
-
-- from parent to children: by using `props`,
-- from a children to one of its parent: by triggering events.
-
-The following example illustrate both mechanisms:
-
-```js
-class OrderLine extends Component {
-  static template = xml`
-    <div t-on-click="add">
-        <div><t t-esc="props.line.name"/></div>
-        <div>Quantity: <t t-esc="props.line.quantity"/></div>
-    </div>`;
-
-  add() {
-    this.trigger("add-to-order", { line: this.props.line });
-  }
-}
-
-class Parent extends Component {
-  static template = xml`
-    <div t-on-add-to-order="addToOrder">
-        <OrderLine
-            t-foreach="orders"
-            t-as="line"
-            line="line" />
-    </div>`;
-  static components = { OrderLine };
-  orders = useState([
-    { id: 1, name: "Coffee", quantity: 0 },
-    { id: 2, name: "Tea", quantity: 0 },
-  ]);
-
-  addToOrder(event) {
-    const line = event.detail.line;
-    line.quantity++;
-  }
-}
-```
-
-In this example, the `OrderLine` component trigger a `add-to-order` event. This
-will generate a DOM event which will bubble along the DOM tree. It will then be
-intercepted by the parent component, which will then get the line (from the
-`detail` key) and then increment its quantity. See the page on [event handling](../reference/event_handling.md)
-for more details on how events work.
-
-Note that this example would have also worked if the `OrderLine` component
-directly modifies the `line` object. However, this is not a good practice: this
-only works because the `props` object received by the child component is reactive,
-so the child component is then coupled to the parents implementation.

doc/learning/quick_start.md

@@ -36,6 +36,8 @@ hello_owl/
 The file `owl.js` can be downloaded from the last release published at
 [https://github.com/odoo/owl/releases](https://github.com/odoo/owl/releases). It
 is a single javascript file which export all Owl into the global `owl` object.
+Note that there are multiple files, and in this case, we need one of the two
+files suffixed with `.iife`: they are built to be directly used in a browser.
 
 Now, `index.html` should contain the following:
 
@@ -45,30 +47,24 @@ Now, `index.html` should contain the following:
   <head>
     <title>Hello Owl</title>
     <script src="owl.js"></script>
-    <script src="app.js"></script>
   </head>
-  <body></body>
+  <body>
+    <script src="app.js"></script>
+  </body>
 </html>
 ```
 
 And `app.js` should look like this:
 
 ```js
-const { Component, mount } = owl;
-const { xml } = owl.tags;
-const { whenReady } = owl.utils;
+const { Component, mount, xml } = owl;
 
 // Owl Components
-class App extends Component {
+class Root extends Component {
   static template = xml`<div>Hello Owl</div>`;
 }
 
-// Setup code
-function setup() {
-  mount(App, target: { document.body })
-}
-
-whenReady(setup);
+mount(Root, document.body);
 ```
 
 Now, simply loading this html file in a browser should display a welcome message.
@@ -93,14 +89,16 @@ Let us start a new project with the following file structure:
 ```
 hello_owl/
   src/
-    app.js
     index.html
     main.js
     owl.js
+    root.js
 ```
 
 As previously, the file `owl.js` can be downloaded from the last release published at
 [https://github.com/odoo/owl/releases](https://github.com/odoo/owl/releases).
+Note that there are multiple files, and in this case, we need one of the two
+files suffixed with `.iife`: they are built to be directly used in a browser.
 
 Now, `index.html` should contain the following:
 
@@ -110,37 +108,33 @@ Now, `index.html` should contain the following:
   <head>
     <title>Hello Owl</title>
     <script src="owl.js"></script>
-    <script src="main.js" type="module"></script>
   </head>
-  <body></body>
+  <body>
+    <script src="main.js" type="module"></script>
+  </body>
 </html>
 ```
 
 Not that the `main.js` script tag has the `type="module"` attribute. This means
 that the browser will parse the script as a module, and load all its dependencies.
 
-Here is the content of `app.js` and `main.js`:
+Here is the content of `root.js` and `main.js`:
 
 ```js
-// app.js ----------------------------------------------------------------------
-const { Component, mount } = owl;
-const { xml } = owl.tags;
+// root.js ----------------------------------------------------------------------
+const { Component, mount, xml } = owl;
 
-export class App extends Component {
+export class Root extends Component {
   static template = xml`<div>Hello Owl</div>`;
 }
 
 // main.js ---------------------------------------------------------------------
-import { App } from "./app.js";
+import { Root } from "./root.js";
 
-function setup() {
-  mount(App, { target: document.body });
-}
-
-owl.utils.whenReady(setup);
+mount(Root, document.body);
 ```
 
-The `main.js` file import the `app.js` file. Note that the import statement has
+The `main.js` file imports the `root.js` file. Note that the import statement has
 a `.js` suffix, which is important. Most text editor can understand this syntax
 and will provide autocompletion.
 
@@ -193,11 +187,11 @@ hello_owl/
     index.html
   src/
     components/
-      App.js
+      Root.js
     main.js
   tests/
     components/
-      App.test.js
+      Root.test.js
     helpers.js
   .gitignore
   package.json
@@ -224,13 +218,15 @@ Note that there are no `<script>` tag here. They will be injected by webpack.
 Now, let's have a look at the javascript files:
 
 ```js
-// src/components/App.js -------------------------------------------------------
-import { Component, tags, useState } from "@odoo/owl";
+// src/components/Root.js -------------------------------------------------------
+import { Component, xml, useState } from "@odoo/owl";
 
-const { xml } = tags;
+export class Root extends Component {
+  static template = xml`
+    <div t-on-click="update">
+      Hello <t t-esc="state.text"/>
+    </div>`;
 
-export class App extends Component {
-  static template = xml`<div t-on-click="update">Hello <t t-esc="state.text"/></div>`;
   state = useState({ text: "Owl" });
   update() {
     this.state.text = this.state.text === "Owl" ? "World" : "Owl";
@@ -239,16 +235,12 @@ export class App extends Component {
 
 // src/main.js -----------------------------------------------------------------
 import { utils, mount } from "@odoo/owl";
-import { App } from "./components/App";
+import { Root } from "./components/Root";
 
-function setup() {
-  mount(App, { target: document.body });
-}
+mount(Root, document.body);
 
-utils.whenReady(setup);
-
-// tests/components/App.test.js ------------------------------------------------
-import { App } from "../../src/components/App";
+// tests/components/Root.test.js ------------------------------------------------
+import { Root } from "../../src/components/Root";
 import { makeTestFixture, nextTick, click } from "../helpers";
 import { mount } from "@odoo/owl";
 
@@ -262,9 +254,9 @@ afterEach(() => {
   fixture.remove();
 });
 
-describe("App", () => {
+describe("Root", () => {
   test("Works as expected...", async () => {
-    await mount(App, { target: fixture });
+    await mount(Root, fixture);
     expect(fixture.innerHTML).toBe("<div>Hello Owl</div>");
 
     click(fixture, "div");
@@ -278,9 +270,8 @@ import { Component } from "@odoo/owl";
 import "regenerator-runtime/runtime";
 
 export async function nextTick() {
-  return new Promise(function (resolve) {
-    setTimeout(() => Component.scheduler.requestAnimationFrame(() => resolve()));
-  });
+  await new Promise((resolve) => setTimeout(resolve));
+  await new Promise((resolve) => requestAnimationFrame(resolve));
 }
 
 export function makeTestFixture() {

doc/learning/tutorial_todoapp.md

@@ -50,10 +50,11 @@ the following content:
     <meta charset="UTF-8" />
     <title>OWL Todo App</title>
     <link rel="stylesheet" href="app.css" />
+  </head>
+  <body>
     <script src="owl.js"></script>
     <script src="app.js"></script>
-  </head>
-  <body></body>
+  </body>
 </html>
 ```
 
@@ -70,43 +71,35 @@ just put the following code:
 Note that we put everything inside an immediately executed function to avoid leaking
 anything to the global scope.
 
-Finally, `owl.js` should be the last version downloaded from the Owl repository (you can use `owl.min.js` if you prefer).
+Finally, `owl.js` should be the last version downloaded from the Owl repository (you can use `owl.min.js` if you prefer). Be aware that you should download the `owl.iife.js` or `owl.iife.min.js`, because these files
+are built to run directly on the browser, and rename it `owl.js` (other files such as `owl.cjs.js` are
+built to be bundled by other tools).
 
 Now, the project should be ready. Loading the `index.html` file into a browser
 should show an empty page, with the title `Owl Todo App`, and it should log a
-message such as `hello owl 1.0.0` in the console.
+message such as `hello owl 2.x.y` in the console.
 
 ## 2. Adding a first component
 
 An Owl application is made out of [components](../reference/component.md), with
-a single root component. Let us start by defining an `App` component. Replace the
+a single root component. Let us start by defining a `Root` component. Replace the
 content of the function in `app.js` by the following code:
 
 ```js
-const { Component, mount } = owl;
-const { xml } = owl.tags;
-const { whenReady } = owl.utils;
+const { Component, mount, xml } = owl;
 
 // Owl Components
-class App extends Component {
+class Root extends Component {
   static template = xml`<div>todo app</div>`;
 }
 
-// Setup code
-function setup() {
-  mount(App, { target: document.body });
-}
-
-whenReady(setup);
+mount(Root, document.body);
 ```
 
 Now, reloading the page in a browser should display a message.
 
-The code is pretty simple, but let us explain the last line in more detail. The
-browser tries to execute the javascript code in `app.js` as quickly as possible,
-and it could happen that the DOM is not ready yet when we try to mount the `App`
-component. To avoid this situation, we use the [`whenReady`](../reference/utils.md#whenready)
-helper to delay the execution of the `setup` function until the DOM is ready.
+The code is pretty simple: we define a component with an inline template, then
+mount it in the document body.
 
 Note 1: in a larger project, we would split the code in multiple files, with
 components in a sub folder, and a main file that would initialize the application.
@@ -123,7 +116,7 @@ class App extends Component {}
 App.template = xml`<div>todo app</div>`;
 ```
 
-Note 3: writing inline templates with the [`xml` helper](../reference/tags.md#xml-tag)
+Note 3: writing inline templates with the [`xml` helper](../reference/templates.md#inline-templates)
 is nice, but there is no syntax highlighting, and this makes it very easy to
 have malformed xml. Some editors support syntax highlighting for this situation.
 For example, VS Code has an addon `Comment tagged template`, which, if installed,
@@ -147,20 +140,20 @@ with the following keys:
   tasks. Since the title is something created/edited by the user, it offers
   no guarantee that it is unique. So, we will generate a unique `id` number for
   each task.
-- `title`: a string, to explain what the task is about.
+- `text`: a string, to explain what the task is about.
 - `isCompleted`: a boolean, to keep track of the status of the task
 
 Now that we decided on the internal format of the state, let us add some demo
 data and a template to the `App` component:
 
 ```js
-class App extends Component {
+class Root extends Component {
   static template = xml/* xml */ `
     <div class="task-list">
         <t t-foreach="tasks" t-as="task" t-key="task.id">
             <div class="task">
                 <input type="checkbox" t-att-checked="task.isCompleted"/>
-                <span><t t-esc="task.title"/></span>
+                <span><t t-esc="task.text"/></span>
             </div>
         </t>
     </div>`;
@@ -168,26 +161,26 @@ class App extends Component {
   tasks = [
     {
       id: 1,
-      title: "buy milk",
+      text: "buy milk",
       isCompleted: true,
     },
     {
       id: 2,
-      title: "clean house",
+      text: "clean house",
       isCompleted: false,
     },
   ];
 }
 ```
 
-The template contains a [`t-foreach`](../reference/qweb_templating_language.md#loops) loop to iterate
-through the tasks. It can find the `tasks` list from the component, since the
-component is the rendering context. Note that we use the `id` of each task as a
-`t-key`, which is very common. There are two css classes: `task-list` and `task`,
+The template contains a [`t-foreach`](../reference/templates.md#loops) loop to iterate
+through the tasks. It can find the `tasks` list from the component, since the rendering
+context contains the properties of the component. Note that we use the `id` of each task
+as a `t-key`, which is very common. There are two css classes: `task-list` and `task`,
 that we will use in the next section.
 
 Finally, notice the use of the `t-att-checked` attribute:
-prefixing an attribute by [`t-att`](../reference/qweb_templating_language.md#dynamic-attributes) makes
+prefixing an attribute by [`t-att`](../reference/templates.md#dynamic-attributes) makes
 it dynamic. Owl will evaluate the expression and set it as the value of the
 attribute.
 
@@ -243,29 +236,25 @@ a little bit:
 // -------------------------------------------------------------------------
 // Task Component
 // -------------------------------------------------------------------------
-const TASK_TEMPLATE = xml /* xml */`
-    <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
-        <input type="checkbox" t-att-checked="props.task.isCompleted"/>
-        <span><t t-esc="props.task.title"/></span>
-    </div>`;
-
 class Task extends Component {
-    static template = TASK_TEMPLATE;
-    static props = ["task"];
+  static template = xml /* xml */`
+    <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
+      <input type="checkbox" t-att-checked="props.task.isCompleted"/>
+      <span><t t-esc="props.task.text"/></span>
+    </div>`;
+  static props = ["task"];
 }
 
 // -------------------------------------------------------------------------
-// App Component
+// Root Component
 // -------------------------------------------------------------------------
-const APP_TEMPLATE = xml /* xml */`
+class Root extends Component {
+  static template = xml /* xml */`
     <div class="task-list">
-        <t t-foreach="tasks" t-as="task" t-key="task.id">
-            <Task task="task"/>
-        </t>
+      <t t-foreach="tasks" t-as="task" t-key="task.id">
+        <Task task="task"/>
+      </t>
     </div>`;
-
-class App extends Component {
-    static template = APP_TEMPLATE;
     static components = { Task };
 
     tasks = [
@@ -274,14 +263,9 @@ class App extends Component {
 }
 
 // -------------------------------------------------------------------------
-// Setup code
+// Setup
 // -------------------------------------------------------------------------
-function setup() {
-    owl.config.mode = "dev";
-    mount(App, { target: document.body });
-}
-
-whenReady(setup);
+mount(Root, document.body, {dev: true});
 ```
 
 A lot of stuff happened here:
@@ -290,24 +274,22 @@ A lot of stuff happened here:
 - whenever we define a sub component, it needs to be added to the static
   [`components`](../reference/component.md#static-properties)
   key of its parent, so Owl can get a reference to it,
-- the templates have been extracted out of the components, to make it easier to
-  differentiate the "view/template" code from the "script/behavior" code,
 - the `Task` component has a `props` key: this is only useful for validation
   purpose. It says that each `Task` should be given exactly one prop, named
   `task`. If this is not the case, Owl will throw an
-  [error](../reference/props_validation.md). This is extremely
+  [error](../reference/props.md#props-validation). This is extremely
   useful when refactoring components
 - finally, to activate the props validation, we need to set Owl's
-  [mode](../reference/config.md#mode) to `dev`. This is done in the `setup`
-  function. Note that this should be removed when an app is used in a real
+  [mode](../reference/app.md#configuration) to `dev`. This is done in the last argument
+  of the `mount` function. Note that this should be removed when an app is used in a real
   production environment, since `dev` mode is slightly slower, due to extra
   checks and validations.
 
 ## 6. Adding tasks (part 1)
 
 We still use a list of hardcoded tasks. It's really time to give the user a way
-to add tasks himself. The first step is to add an input to the `App` component.
-But this input will be outside of the task list, so we need to adapt `App`
+to add tasks himself. The first step is to add an input to the `Root` component.
+But this input will be outside of the task list, so we need to adapt `Root`
 template, js, and css:
 
 ```xml
@@ -325,9 +307,9 @@ template, js, and css:
 addTask(ev) {
     // 13 is keycode for ENTER
     if (ev.keyCode === 13) {
-        const title = ev.target.value.trim();
+        const text = ev.target.value.trim();
         ev.target.value = "";
-        console.log('adding task', title);
+        console.log('adding task', text);
         // todo
     }
 }
@@ -356,10 +338,9 @@ task. Notice that when you load the page, the input is not focused. But adding
 tasks is a core feature of a task list, so let us make it as fast as possible by
 focusing the input.
 
-Since `App` is a component, it has a
-[`mounted` lifecycle method](../reference/component.md#lifecycle) that we can
-implement. We will also need to get a reference to the input, by using the
-`t-ref` directive with the [`useRef`](../reference/hooks.md#useref) hook:
+We need to execute code when the `Root` component is ready (mounted). Let's do
+that using the `onMounted` hook. We will also need to get a reference to the
+input, by using the `t-ref` directive with the [`useRef`](../reference/hooks.md#useref) hook:
 
 ```xml
 <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
@@ -367,22 +348,21 @@ implement. We will also need to get a reference to the input, by using the
 
 ```js
 // on top of file:
-const { useRef } = owl.hooks;
+const { Component, mount, xml, useRef, onMounted } = owl;
 ```
 
 ```js
 // in App
-inputRef = useRef("add-input");
-
-mounted() {
-    this.inputRef.el.focus();
+setup() {
+    const inputRef = useRef("add-input");
+    onMounted(() => inputRef.el.focus());
 }
 ```
 
-The `inputRef` is defined as a class field, so it is equivalent to defining it
-in the constructor. It simply instructs Owl to keep a reference to anything with
-the corresponding `t-ref` keyword. We then implement the `mounted` lifecycle
-method, where we now have an active reference that we can use to focus the input.
+This is a very common situation: whenever we need to perform some actions depending
+on the lifecycle of a component, we need to do it in the `setup` method, by using
+one of the lifecycle hook. Here, we first get a reference to the `inputRef`,
+then in the `onMounted` hook, we simply focus the html element.
 
 ## 7. Adding tasks (part 2)
 
@@ -403,12 +383,12 @@ Now, the `addTask` method can be implemented:
 addTask(ev) {
     // 13 is keycode for ENTER
     if (ev.keyCode === 13) {
-        const title = ev.target.value.trim();
+        const text = ev.target.value.trim();
         ev.target.value = "";
-        if (title) {
+        if (text) {
             const newTask = {
                 id: this.nextId++,
-                title: title,
+                text: text,
                 isCompleted: false,
             };
             this.tasks.push(newTask);
@@ -426,7 +406,7 @@ the user interface. We can fix the issue by making `tasks` reactive, with the
 
 ```js
 // on top of the file
-const { useRef, useState } = owl.hooks;
+const { Component, mount, xml, useRef, onMounted, useState } = owl;
 
 // replace the task definition in App with the following:
 tasks = useState([]);
@@ -441,12 +421,8 @@ did not change in opacity. This is because there is no code to modify the
 `isCompleted` flag.
 
 Now, this is an interesting situation: the task is displayed by the `Task`
-component, but it is not the owner of its state, so it cannot modify it. Instead,
-we want to communicate the request to toggle a task to the `App` component.
-Since `App` is a parent of `Task`, we can
-[trigger](../reference/event_handling.md) an event in `Task` and listen
-for it in `App`.
-
+component, but it is not the owner of its state, so ideally, it should not modify it.
+However, for now, that's what we will do (this will be improved in a later step).
 In `Task`, change the `input` to:
 
 ```xml
@@ -457,36 +433,23 @@ and add the `toggleTask` method:
 
 ```js
 toggleTask() {
-    this.trigger('toggle-task', {id: this.props.task.id});
-}
-```
-
-We now need to listen for that event in the `App` template:
-
-```xml
-<div class="task-list" t-on-toggle-task="toggleTask">
-```
-
-and implement the `toggleTask` code:
-
-```js
-toggleTask(ev) {
-    const task = this.tasks.find(t => t.id === ev.detail.id);
-    task.isCompleted = !task.isCompleted;
+  this.props.task.isCompleted = !this.props.task.isCompleted;
 }
 ```
 
 ## 9. Deleting tasks
 
-Let us now add the possibility do delete tasks. To do that, we first need to add
-a trash icon on each task, then we will proceed just like in the previous section.
+Let us now add the possibility do delete tasks. This is different from the previous
+feature: deleting task has to be done on the task itself, but the actual operation
+need to be done on the task list. So, we need to communicate the request to the
+`Root` component. This is usually done by providing a callback in a prop.
 
 First, let us update the `Task` template, css and js:
 
 ```xml
 <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
     <input type="checkbox" t-att-checked="props.task.isCompleted" t-on-click="toggleTask"/>
-    <span><t t-esc="props.task.title"/></span>
+    <span><t t-esc="props.task.text"/></span>
     <span class="delete" t-on-click="deleteTask">🗑</span>
 </div>
 ```
@@ -515,218 +478,230 @@ First, let us update the `Task` template, css and js:
 ```
 
 ```js
+static props = ["task", "onDelete"];
+
 deleteTask() {
-    this.trigger('delete-task', {id: this.props.task.id});
+    this.props.onDelete(this.props.task);
 }
 ```
 
-And now, we need to listen to the `delete-task` event in `App`:
+And now, we need to provide the `onDelete` callback to each tasks in the `Root`
+component:
 
 ```xml
-<div class="task-list" t-on-toggle-task="toggleTask" t-on-delete-task="deleteTask">
+  <Task task="task" onDelete.bind="deleteTask"/>
 ```
 
 ```js
-deleteTask(ev) {
-    const index = this.tasks.findIndex(t => t.id === ev.detail.id);
+deleteTask(task) {
+    const index = this.tasks.findIndex(t => t.id === task.id);
     this.tasks.splice(index, 1);
 }
 ```
 
+Notice that the `onDelete` prop is defined with a `.bind` suffix: this is a special
+suffix that makes sure the function callback is bound to the component.
+
+Notice also that we have two functions named `deleteTask`. The one in the Task
+component just delegates the work to the Root component that owns the task list
+via the `onDelete` property.
+
 ## 10. Using a store
 
-Looking at the code, it is apparent that we now have code to handle tasks
-scattered in more than one place. Also, it mixes UI code and business logic
-code. Owl has a way to manage state separately from the user interface: a
-[`Store`](../reference/store.md).
+Looking at the code, it is apparent that all the code handling tasks is scattered
+all around the application. Also, it mixes UI code and business logic
+code. Owl does not provide any high level abstraction to manage business logic,
+but it is easy to do it with the basic reactivity primitives (`useState` and `reactive`).
 
-Let us use it in our application. This is a pretty large refactoring (for our
-application), since it involves extracting all task related code out of the
-components. Here is the new content of the `app.js` file:
+Let us use it in our application to implement a central store. This is a pretty
+large refactoring (for our application), since it involves extracting all task
+related code out of the components. Here is the new content of the `app.js` file:
 
 ```js
-const { Component, Store, mount } = owl;
-const { xml } = owl.tags;
-const { whenReady } = owl.utils;
-const { useRef, useDispatch, useStore } = owl.hooks;
+const { Component, mount, xml, useRef, onMounted, useState, reactive, useEnv } = owl;
 
 // -------------------------------------------------------------------------
 // Store
 // -------------------------------------------------------------------------
-const actions = {
-  addTask({ state }, title) {
-    title = title.trim();
-    if (title) {
+function useStore() {
+  const env = useEnv();
+  return useState(env.store);
+}
+
+// -------------------------------------------------------------------------
+// TaskList
+// -------------------------------------------------------------------------
+class TaskList {
+  nextId = 1;
+  tasks = [];
+
+  addTask(text) {
+    text = text.trim();
+    if (text) {
       const task = {
-        id: state.nextId++,
-        title: title,
+        id: this.nextId++,
+        text: text,
         isCompleted: false,
       };
-      state.tasks.push(task);
+      this.tasks.push(task);
     }
-  },
-  toggleTask({ state }, id) {
-    const task = state.tasks.find((t) => t.id === id);
+  }
+
+  toggleTask(task) {
     task.isCompleted = !task.isCompleted;
-  },
-  deleteTask({ state }, id) {
-    const index = state.tasks.findIndex((t) => t.id === id);
-    state.tasks.splice(index, 1);
-  },
-};
-const initialState = {
-  nextId: 1,
-  tasks: [],
-};
+  }
+
+  deleteTask(task) {
+    const index = this.tasks.findIndex((t) => t.id === task.id);
+    this.tasks.splice(index, 1);
+  }
+}
+
+function createTaskStore() {
+  return reactive(new TaskList());
+}
 
 // -------------------------------------------------------------------------
 // Task Component
 // -------------------------------------------------------------------------
-const TASK_TEMPLATE = xml/* xml */ `
+class Task extends Component {
+  static template = xml/* xml */ `
     <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
-        <input type="checkbox" t-att-checked="props.task.isCompleted"
-                t-on-click="dispatch('toggleTask', props.task.id)"/>
-        <span><t t-esc="props.task.title"/></span>
-        <span class="delete" t-on-click="dispatch('deleteTask', props.task.id)">🗑</span>
+      <input type="checkbox" t-att-checked="props.task.isCompleted" t-on-click="() => store.toggleTask(props.task)"/>
+      <span><t t-esc="props.task.text"/></span>
+      <span class="delete" t-on-click="() => store.deleteTask(props.task)">🗑</span>
     </div>`;
 
-class Task extends Component {
-  static template = TASK_TEMPLATE;
   static props = ["task"];
-  dispatch = useDispatch();
+
+  setup() {
+    this.store = useStore();
+  }
 }
 
 // -------------------------------------------------------------------------
-// App Component
+// Root Component
 // -------------------------------------------------------------------------
-const APP_TEMPLATE = xml/* xml */ `
+class Root extends Component {
+  static template = xml/* xml */ `
     <div class="todo-app">
-        <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
-        <div class="task-list">
-            <t t-foreach="tasks" t-as="task" t-key="task.id">
-                <Task task="task"/>
-            </t>
-        </div>
+      <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
+      <div class="task-list">
+        <t t-foreach="store.tasks" t-as="task" t-key="task.id">
+          <Task task="task"/>
+        </t>
+      </div>
     </div>`;
-
-class App extends Component {
-  static template = APP_TEMPLATE;
   static components = { Task };
 
-  inputRef = useRef("add-input");
-  tasks = useStore((state) => state.tasks);
-  dispatch = useDispatch();
-
-  mounted() {
-    this.inputRef.el.focus();
+  setup() {
+    const inputRef = useRef("add-input");
+    onMounted(() => inputRef.el.focus());
+    this.store = useStore();
   }
 
   addTask(ev) {
     // 13 is keycode for ENTER
     if (ev.keyCode === 13) {
-      this.dispatch("addTask", ev.target.value);
+      this.store.addTask(ev.target.value);
       ev.target.value = "";
     }
   }
 }
 
 // -------------------------------------------------------------------------
-// Setup code
+// Setup
 // -------------------------------------------------------------------------
-function setup() {
-  owl.config.mode = "dev";
-  const store = new Store({ actions, state: initialState });
-  App.env.store = store;
-  mount(App, { target: document.body });
-}
-
-whenReady(setup);
+const env = {
+  store: createTaskStore(),
+};
+mount(Root, document.body, { dev: true, env });
 ```
 
-## 11-Saving tasks in local storage
+## 11. Saving tasks in local storage
 
 Now, our TodoApp works great, except if the user closes or refresh the browser!
 It is really inconvenient to only keep the state of the application in memory.
 To fix this, we will save the tasks in the local storage. With our current
-codebase, it is a simple change: only the setup code needs to be updated.
+codebase, it is a simple change: we need to save tasks to local storage and
+listen to any change.
 
 ```js
-function makeStore() {
-  const localState = window.localStorage.getItem("todoapp");
-  const state = localState ? JSON.parse(localState) : initialState;
-  const store = new Store({ state, actions });
-  store.on("update", null, () => {
-    localStorage.setItem("todoapp", JSON.stringify(store.state));
-  });
-  return store;
+class TaskList {
+  constructor(tasks) {
+    this.tasks = tasks || [];
+    const taskIds = this.tasks.map((t) => t.id);
+    this.nextId = taskIds.length ? Math.max(...taskIds) + 1 : 1;
+  }
+  // ...
 }
 
-function setup() {
-  owl.config.mode = "dev";
-  const env = { store: makeStore() };
-  mount(App, { target: document.body, env });
+function createTaskStore() {
+  const saveTasks = () => localStorage.setItem("todoapp", JSON.stringify(taskStore.tasks));
+  const initialTasks = JSON.parse(localStorage.getItem("todoapp") || "[]");
+  const taskStore = reactive(new TaskList(initialTasks), saveTasks);
+  saveTasks();
+  return taskStore;
 }
 ```
 
-The key point is to use the fact that the store is an
-[`EventBus`](../reference/event_bus.md) which triggers an `update` event
-whenever it is updated.
+The key point is that the `reactive` function takes a callback that will be called
+every time an observed value is changed. Note that we need to call the `saveTasks`
+method initially to make sure we observe all current values.
 
 ## 12. Filtering tasks
 
 We are almost done, we can add/update/delete tasks. The only missing feature is
 the possibility to display the task according to their completed status. We will
-need to keep track of the state of the filter in `App`, then filter the visible
+need to keep track of the state of the filter in `Root`, then filter the visible
 tasks according to its value.
 
 ```js
-// on top of file, readd useState:
-const { useRef, useDispatch, useState, useStore } = owl.hooks;
-
-// in App:
-filter = useState({value: "all"})
-
-get displayedTasks() {
-    switch (this.filter.value) {
-        case "active": return this.tasks.filter(t => !t.isCompleted);
-        case "completed": return this.tasks.filter(t => t.isCompleted);
-        case "all": return this.tasks;
-    }
-}
-
-setFilter(filter) {
-    this.filter.value = filter;
-}
-```
-
-Finally, we need to display the visible filters. We can do that, and at the
-same time, display the number of tasks in a small panel below the main list:
-
-```xml
-<div class="todo-app">
-    <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
-    <div class="task-list">
+class Root extends Component {
+  static template = xml /* xml */`
+    <div class="todo-app">
+      <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
+      <div class="task-list">
         <t t-foreach="displayedTasks" t-as="task" t-key="task.id">
-            <Task task="task"/>
+          <Task task="task"/>
         </t>
-    </div>
-    <div class="task-panel" t-if="tasks.length">
+      </div>
+      <div class="task-panel" t-if="store.tasks.length">
         <div class="task-counter">
-            <t t-esc="displayedTasks.length"/>
-            <t t-if="displayedTasks.length lt tasks.length">
-                / <t t-esc="tasks.length"/>
-            </t>
-            task(s)
+          <t t-esc="displayedTasks.length"/>
+          <t t-if="displayedTasks.length lt store.tasks.length">
+              / <t t-esc="store.tasks.length"/>
+          </t>
+          task(s)
         </div>
         <div>
-            <span t-foreach="['all', 'active', 'completed']"
-                t-as="f" t-key="f"
-                t-att-class="{active: filter.value===f}"
-                t-on-click="setFilter(f)"
-                t-esc="f"/>
+          <span t-foreach="['all', 'active', 'completed']"
+            t-as="f" t-key="f"
+            t-att-class="{active: filter.value===f}"
+            t-on-click="() => this.setFilter(f)"
+            t-esc="f"/>
         </div>
-    </div>
-</div>
+      </div>
+    </div>`;
+
+  setup() {
+    ...
+    this.filter = useState({ value: "all" });
+  }
+
+  get displayedTasks() {
+    const tasks = this.store.tasks;
+    switch (this.filter.value) {
+      case "active": return tasks.filter(t => !t.isCompleted);
+      case "completed": return tasks.filter(t => t.isCompleted);
+      case "all": return tasks;
+    }
+  }
+
+  setFilter(filter) {
+    this.filter.value = filter;
+  }
+}
 ```
 
 ```css
@@ -751,8 +726,8 @@ same time, display the number of tasks in a small panel below the main list:
 }
 ```
 
-Notice here that we set dynamically the class of the filter with the object
-syntax: each key is a class that we want to set if its value is truthy.
+Notice here that we set dynamically the css class of the filter with the object
+syntax.
 
 ## 13. The Final Touch
 
@@ -767,16 +742,16 @@ the user experience.
 }
 ```
 
-2. Make the title of a task clickable, to toggle its checkbox:
+2. Make the text of a task clickable, to toggle its checkbox:
 
 ```xml
 <input type="checkbox" t-att-checked="props.task.isCompleted"
     t-att-id="props.task.id"
-    t-on-click="dispatch('toggleTask', props.task.id)"/>
-<label t-att-for="props.task.id"><t t-esc="props.task.title"/></label>
+    t-on-click="() => store.toggleTask(props.task)"/>
+<label t-att-for="props.task.id"><t t-esc="props.task.text"/></label>
 ```
 
-3. Strike the title of completed task:
+3. Strike the text of completed task:
 
 ```css
 .task.done label {
@@ -799,151 +774,155 @@ For reference, here is the final code:
     <meta charset="UTF-8" />
     <title>OWL Todo App</title>
     <link rel="stylesheet" href="app.css" />
+  </head>
+  <body>
     <script src="owl.js"></script>
     <script src="app.js"></script>
-  </head>
-  <body></body>
+  </body>
 </html>
 ```
 
 ```js
 (function () {
-  const { Component, Store, mount } = owl;
-  const { xml } = owl.tags;
-  const { whenReady } = owl.utils;
-  const { useRef, useDispatch, useState, useStore } = owl.hooks;
+  const { Component, mount, xml, useRef, onMounted, useState, reactive, useEnv } = owl;
 
   // -------------------------------------------------------------------------
   // Store
   // -------------------------------------------------------------------------
-  const actions = {
-    addTask({ state }, title) {
-      title = title.trim();
-      if (title) {
+  function useStore() {
+    const env = useEnv();
+    return useState(env.store);
+  }
+
+  // -------------------------------------------------------------------------
+  // TaskList
+  // -------------------------------------------------------------------------
+  class TaskList {
+    constructor(tasks) {
+      this.tasks = tasks || [];
+      const taskIds = this.tasks.map((t) => t.id);
+      this.nextId = taskIds.length ? Math.max(...taskIds) + 1 : 1;
+    }
+
+    addTask(text) {
+      text = text.trim();
+      if (text) {
         const task = {
-          id: state.nextId++,
-          title: title,
+          id: this.nextId++,
+          text: text,
           isCompleted: false,
         };
-        state.tasks.push(task);
+        this.tasks.push(task);
       }
-    },
-    toggleTask({ state }, id) {
-      const task = state.tasks.find((t) => t.id === id);
-      task.isCompleted = !task.isCompleted;
-    },
-    deleteTask({ state }, id) {
-      const index = state.tasks.findIndex((t) => t.id === id);
-      state.tasks.splice(index, 1);
-    },
-  };
+    }
 
-  const initialState = {
-    nextId: 1,
-    tasks: [],
-  };
+    toggleTask(task) {
+      task.isCompleted = !task.isCompleted;
+    }
+
+    deleteTask(task) {
+      const index = this.tasks.findIndex((t) => t.id === task.id);
+      this.tasks.splice(index, 1);
+    }
+  }
+
+  function createTaskStore() {
+    const saveTasks = () => localStorage.setItem("todoapp", JSON.stringify(taskStore.tasks));
+    const initialTasks = JSON.parse(localStorage.getItem("todoapp") || "[]");
+    const taskStore = reactive(new TaskList(initialTasks), saveTasks);
+    saveTasks();
+    return taskStore;
+  }
 
   // -------------------------------------------------------------------------
   // Task Component
   // -------------------------------------------------------------------------
-  const TASK_TEMPLATE = xml/* xml */ `
-    <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
-        <input type="checkbox" t-att-checked="props.task.isCompleted"
-            t-att-id="props.task.id"
-            t-on-click="dispatch('toggleTask', props.task.id)"/>
-        <label t-att-for="props.task.id"><t t-esc="props.task.title"/></label>
-        <span class="delete" t-on-click="dispatch('deleteTask', props.task.id)">🗑</span>
-    </div>`;
-
   class Task extends Component {
-    static template = TASK_TEMPLATE;
+    static template = xml/* xml */ `
+      <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
+        <input type="checkbox"
+          t-att-id="props.task.id"
+          t-att-checked="props.task.isCompleted"
+          t-on-click="() => store.toggleTask(props.task)"/>
+        <label t-att-for="props.task.id"><t t-esc="props.task.text"/></label>
+        <span class="delete" t-on-click="() => store.deleteTask(props.task)">🗑</span>
+      </div>`;
+
     static props = ["task"];
-    dispatch = useDispatch();
+
+    setup() {
+      this.store = useStore();
+    }
   }
 
   // -------------------------------------------------------------------------
-  // App Component
+  // Root Component
   // -------------------------------------------------------------------------
-  const APP_TEMPLATE = xml/* xml */ `
-    <div class="todo-app">
+  class Root extends Component {
+    static template = xml/* xml */ `
+      <div class="todo-app">
         <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
         <div class="task-list">
-            <Task t-foreach="displayedTasks" t-as="task" t-key="task.id" task="task"/>
+          <t t-foreach="displayedTasks" t-as="task" t-key="task.id">
+            <Task task="task"/>
+          </t>
         </div>
-        <div class="task-panel" t-if="tasks.length">
-            <div class="task-counter">
-                <t t-esc="displayedTasks.length"/>
-                <t t-if="displayedTasks.length lt tasks.length">
-                    / <t t-esc="tasks.length"/>
-                </t>
-                task(s)
-            </div>
-            <div>
-                <span t-foreach="['all', 'active', 'completed']"
-                    t-as="f" t-key="f"
-                    t-att-class="{active: filter.value===f}"
-                    t-on-click="setFilter(f)"
-                    t-esc="f"/>
-            </div>
+        <div class="task-panel" t-if="store.tasks.length">
+          <div class="task-counter">
+            <t t-esc="displayedTasks.length"/>
+            <t t-if="displayedTasks.length lt store.tasks.length">
+                / <t t-esc="store.tasks.length"/>
+            </t>
+            task(s)
+          </div>
+          <div>
+            <span t-foreach="['all', 'active', 'completed']"
+              t-as="f" t-key="f"
+              t-att-class="{active: filter.value===f}"
+              t-on-click="() => this.setFilter(f)"
+              t-esc="f"/>
+          </div>
         </div>
-    </div>`;
-
-  class App extends Component {
-    static template = APP_TEMPLATE;
+      </div>`;
     static components = { Task };
 
-    inputRef = useRef("add-input");
-    tasks = useStore((state) => state.tasks);
-    filter = useState({ value: "all" });
-    dispatch = useDispatch();
-
-    mounted() {
-      this.inputRef.el.focus();
+    setup() {
+      const inputRef = useRef("add-input");
+      onMounted(() => inputRef.el.focus());
+      this.store = useStore();
+      this.filter = useState({ value: "all" });
     }
 
     addTask(ev) {
       // 13 is keycode for ENTER
       if (ev.keyCode === 13) {
-        this.dispatch("addTask", ev.target.value);
+        this.store.addTask(ev.target.value);
         ev.target.value = "";
       }
     }
 
     get displayedTasks() {
+      const tasks = this.store.tasks;
       switch (this.filter.value) {
         case "active":
-          return this.tasks.filter((t) => !t.isCompleted);
+          return tasks.filter((t) => !t.isCompleted);
         case "completed":
-          return this.tasks.filter((t) => t.isCompleted);
+          return tasks.filter((t) => t.isCompleted);
         case "all":
-          return this.tasks;
+          return tasks;
       }
     }
+
     setFilter(filter) {
       this.filter.value = filter;
     }
   }
 
   // -------------------------------------------------------------------------
-  // Setup code
+  // Setup
   // -------------------------------------------------------------------------
-  function makeStore() {
-    const localState = window.localStorage.getItem("todoapp");
-    const state = localState ? JSON.parse(localState) : initialState;
-    const store = new Store({ state, actions });
-    store.on("update", null, () => {
-      localStorage.setItem("todoapp", JSON.stringify(store.state));
-    });
-    return store;
-  }
-
-  function setup() {
-    owl.config.mode = "dev";
-    const env = { store: makeStore() };
-    mount(App, { target: document.body, env });
-  }
-
-  whenReady(setup);
+  const env = { store: createTaskStore() };
+  mount(Root, document.body, { dev: true, env });
 })();
 ```
 

doc/miscellaneous/architecture.md

@@ -0,0 +1,68 @@
+# 🦉 Notes On Owl Architecture 🦉
+
+We explain here how Owl is designed
+
+Warning: these notes are technical by nature, and intended for people working
+on Owl (or interested in understanding its design).
+
+## Overview
+
+Roughly speaking, Owl has 5 main parts:
+
+- a virtual dom system (in `src/blockdom`)
+- a component system (in `src/component`)
+- a template compiler (located in the `src/compiler` folder)
+- a small runtime code to tie them together (in `src/app`)
+- a reactivity system (in `src/reactivity.ts`)
+
+There are some other files, but the core of Owl can be understood with these
+five main parts.
+
+The virtual dom is an optimized virtual dom based on blocks, which supports
+multi blocks (for fragments). Everything that owl renders is internally
+represented by a virtual node. The job of the virtual dom is to efficiently
+represent the current state of the application, and to build an actual DOM
+representation when needed, or update the DOM whenever it is needed.
+
+- some other helpers/smaller scale stuff
+  A rendering occurs in two phases:
+
+- virtual rendering: this generates the virtual dom in memory, asynchronously
+- patch: applies a virtual tree to the screen (synchronously)
+
+There are several classes involved in a rendering:
+
+- components
+- a scheduler
+- fibers: small objects containing some metadata, associated with a rendering of
+  a specific component
+
+Components are organized in a dynamic component tree, visible in the user
+interface. Whenever a rendering is initiated in a component `C`:
+
+- a fiber is created on `C` with the rendering props information
+- the virtual rendering phase starts on C (will asynchronously render all the
+  child components)
+- the fiber is added to the scheduler, which will poll continuously, every
+  animation frame, if the fiber is done
+- once it is done, the scheduler will call the task callback, which will apply
+  the patch (if it was not cancelled in the meantime).
+
+# 🦉 VDom 🦉
+
+Owl is a declarative component system: we declare the structure of the component
+tree, and Owl will translate that to a list of imperative operations. This
+translation is done by a virtual dom. This is the low level layer of Owl, most
+developer will not need to call directly the virtual dom functions.
+
+The main idea behind a virtual dom is to keep a in-memory representation of the
+DOM (called a virtual node), and whenever some change is needed, to regenerate
+a new representation, compute the difference between the old and the new, then
+apply the changes.
+
+`vdom` exports two functions:
+
+- `h`: create a new virtual node
+- `patch`: compare two virtual nodes, and apply the difference.
+
+Note: Owl's virtual dom is a fork of [snabbdom](https://github.com/snabbdom/snabbdom).

doc/miscellaneous/comparison.md

@@ -14,8 +14,7 @@ discussed, feel free to open an issue/submit a PR to correct this text.
 - [Tooling/Build Step](#toolingbuild-step)
 - [Templating](#templating)
 - [Asynchronous rendering](#asynchronous-rendering)
-- [Reactiveness](#reactiveness)
-- [State Management](#state-management)
+- [Reactivity](#reactivity)
 - [Hooks](#hooks)
 
 ## Size
@@ -79,7 +78,7 @@ additional tools, we made a lot of effort to make the most of the web platform.
 
 For example, Owl uses the standard `xml` parser that comes with every browser.
 Because of that, Owl did not have to write its own template parser. Another
-example is the [`xml`](../reference/tags.md#xml-tag) tag helper function, which makes use of
+example is the [`xml`](../reference/templates.md#inline-templates) tag helper function, which makes use of
 native template literals to allow in a natural way to write `xml` templates
 directly in the javascript code. This can be easily integrated with editor
 plugins to have autocompletion inside the template.
@@ -127,7 +126,7 @@ structured than a template language. Note that the tooling is quite impressive:
 there is a syntax highlighter for jsx here on github!
 
 By comparison, here is the equivalent Owl component, written with the
-[`xml`](../reference/tags.md#xml-tag) tag helper:
+[`xml`](../reference/templates.md#inline-templates) tag helper:
 
 ```js
 class Clock extends Component {
@@ -173,7 +172,7 @@ more convoluted. For example, in Vue, you need to use a dynamic import keyword
 that needs to be transpiled at build time in order for the component to be loaded
 asynchronously (see [the documentation](https://vuejs.org/v2/guide/components-dynamic-async.html#Async-Components)).
 
-## Reactiveness
+## Reactivity
 
 React has a simple model: whenever the state changes, it is
 replaced with a new state (via the `setState` method). Then, the DOM is patched.
@@ -189,95 +188,6 @@ 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
-
-Managing the state of an application is a tricky issue. Many solutions have
-been proposed these last few years. It also depends on the kind of application we
-are talking about. A small application may not need much more than a simple
-object to contain its state.
-
-However, there are some common solutions for React and Vue: redux and vuex.
-Both of them are a centralized store that own the state, and they dictate how
-the state can be mutated.
-
-**Redux**
-
-In Redux, the state is mutated by reducers. Reducers are functions
-that modify the state by returning a different object:
-
-```javascript
-  ...
-  switch (action.type) {
-    case ADD_TODO: {
-      const { id, content } = action.payload;
-      return {
-        ...state,
-        allIds: [...state.allIds, id],
-        byIds: {
-          ...state.byIds,
-          [id]: {
-            content,
-            completed: false
-          }
-        }
-      };
-    }
-```
-
-This is a little bit awkward to write, but this allows the component system to
-check if a part of the state was changed. This is exactly what is done by the
-`connect` function: it create a _connected_ component, which is subscribed to
-the state and triggers a rerender if some part of the state was modified.
-
-**VueX**
-
-VueX is based on a different principle: the state is mutated through
-some special functions (the mutations), which modify the state in place:
-
-```javascript
-    function ({state}, payload) {
-        const { id, content } = payload;
-        const message = {id, content, completed: false};
-        state.messages.push(message)
-    }
-```
-
-This is simpler, but there is a little bit more happening behind the scene:
-each key from the state is silently replaced by getters and setters, and VueX
-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 actions (but not
-mutations), and like VueX, it keeps track of the state changes. However, it does
-not notify a component when the state changes. Instead, components need to connect
-to the store like in redux, with the `useStore` hook (see the [store documentation](../reference/store.md#connecting-a-component)).
-
-```javascript
-const actions = {
-  increment({ state }, val) {
-    state.counter.value += val;
-  },
-};
-
-const state = {
-  counter: { value: 0 },
-};
-const store = new owl.Store({ state, actions });
-
-class Counter extends Component {
-  static template = xml`
-      <button t-name="Counter" t-on-click="dispatch('increment')">
-        Click Me! [<t t-esc="counter.value"/>]
-      </button>`;
-  counter = useStore((state) => state.counter);
-  dispatch = useDispatch();
-}
-
-Counter.env.store = store;
-const counter = new Counter();
-```
-
 ## Hooks
 
 [Hooks](https://reactjs.org/docs/hooks-intro.html#motivation) recently took over
@@ -342,4 +252,4 @@ class Example extends Component {
 
 Since the Owl framework had hooks from early in its life, its main APIs
 are designed to be interacted with hooks from the start. For example, the
-`Context` and `Store` abstractions.
+`Context` abstraction.

doc/miscellaneous/compiled_template.md

@@ -0,0 +1,98 @@
+# 🦉 Notes On Owl Compiled Templates 🦉
+
+This page will explain what an Owl compiled template look like. This is a
+technical document intended for developers interested in understanding how Owl
+works internally.
+
+Broadly speaking, Owl compiles templates into a javascript function (a closure)
+that returns a function (the "render" function). The point of the closure is to
+have a place to store all values specific to the template (in particular, "blocks").
+Once a template is compiled, its closure function is called once to get the
+render function, and from then on, only the render function is used.
+
+The render function takes some context (and some additional information) and
+return a virtual dom representation of the rendered template, as a block tree.
+A block tree is a very light weight representation that only contains the dynamic
+part of the template, and its structure. It is actually independant of the
+static part of the templates (which are contained in the blocks captured by the
+closure). This means that the work performed at render time is only to collect
+dynamic data, and to describe the block structure of the result.
+
+It looks like this, in pseudo code:
+
+```js
+function closure(bdom, helpers) {
+    // here is some place to put stuff specific to the template, such as
+    // blocks
+    ...
+
+    return function render(context, node, key) {
+        // only build here all dynamic parts of the template
+        // build a block tree
+        return tree;
+    }
+}
+```
+
+Now, let us see an example. Consider the following template:
+
+```xml
+<div class="some-class">
+    <div class="blabla">
+        <span><t t-esc="state.value"/></span>
+    </div>
+    <t t-if="state.info">
+        <p class="info" t-att-class="someAttribute">
+            <t t-esc="state.info"/>
+        </p>
+    </t>
+    <SomeComponent value="value"/>
+</div>
+```
+
+If you look carefully, there are 5 dynamic things:
+
+- a text value (the first `t-esc`),
+- a sub block (the `t-if`),
+- a dynamic attribute (the `t-att-class` attribute),
+- another text value (the second `t-esc`),
+- and finally, a sub component
+
+Here is the compiled code for this template:
+
+```js
+function closure(bdom, helpers) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+
+  let block1 = createBlock(
+    `<div class="some-class"><div class="blabla"><span><block-text-0/></span></div><block-child-0/><block-child-1/></div>`
+  );
+  let block2 = createBlock(`<p class="info" block-attribute-0="class"><block-text-1/></p>`);
+
+  return function render(ctx, node, key = "") {
+    let b2, b3;
+    let txt1 = ctx["state"].value;
+    if (ctx["state"].info) {
+      let attr1 = ctx["someAttribute"];
+      let txt2 = ctx["state"].info;
+      b2 = block2([attr1, txt2]);
+    }
+    b3 = component(`SomeComponent`, { value: ctx["value"] }, key + `__1`, node, ctx);
+    return block1([txt1], [b2, b3]);
+  };
+}
+```
+
+The values captured in the closure capture the static part of the template: we
+define here two blocks (which contains a template node, that can be deep cloned
+whenever a block is mounted). Then the render function only describes the block
+tree structure of the result, depending on the context. This means that we
+minimize the amount of work done at render time.
+
+Then, when we want to patch the dom, Owl will uses the `patch` function from
+blockdom, which then will diff the block tree, and deep clone new blocks whenever
+a new block is inserted, keep track of dynamic parts of each block, and update
+them accordingly.
+
+With this design, the cost of rendering a template is proportional to the number
+of dynamic values, and not to the size of the template.

doc/miscellaneous/rendering.md

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

doc/miscellaneous/vdom.md

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

doc/readme.md

@@ -1,57 +1,49 @@
-# 🦉 OWL Documentation 🦉
+# 🦉 Owl overview 🦉
 
-## Learning Owl
+Here is a list of everything exported by the Owl library:
 
-Are you new to Owl? This is the place to start!
+Main entities:
 
-- [Tutorial: create a TodoList application](learning/tutorial_todoapp.md)
-- [Quick Overview](learning/overview.md)
-- [How to start an Owl project](learning/quick_start.md)
-- [How to test Components](learning/how_to_test.md)
-- [How to write Single File Components](learning/how_to_write_sfc.md)
-- [How to write debug Owl applications](learning/how_to_debug.md)
+- [`App`](reference/app.md): represent an Owl application (mainly a root component,a set of templates, and a config)
+- [`Component`](reference/component.md): the main class to define a concrete Owl component
+- [`mount`](reference/app.md#mount-helper): main entry point for most application: mount a component to a target
+- [`xml`](reference/templates.md#inline-templates): helper to define an inline template
 
-## Reference
+Reactivity
 
-You will find here a complete reference of every feature, class or object
-provided by Owl.
+- [`useState`](reference/reactivity.md#usestate): create a reactive object (hook, linked to a specific component)
+- [`reactive`](reference/reactivity.md#reactive): create a reactive object (not linked to any component)
+- [`markRaw`](reference/reactivity.md#markraw): mark an object or array so that it is ignored by the reactivity system
+- [`toRaw`](reference/reactivity.md#toraw): given a reactive objet, return the raw (non reactive) underlying object
 
-- [Animations](reference/animations.md)
-- [Browser](reference/browser.md)
-- [Component](reference/component.md)
-- [Content](reference/content.md)
-- [Concurrency Model](reference/concurrency_model.md)
-- [Configuration](reference/config.md)
-- [Context](reference/context.md)
-- [Environment](reference/environment.md)
-- [Event Bus](reference/event_bus.md)
-- [Event Handling](reference/event_handling.md)
-- [Error Handling](reference/error_handling.md)
-- [Hooks](reference/hooks.md)
-- [Mounting a component](reference/mounting.md)
-- [Miscellaneous Components](reference/misc.md)
-- [Observer](reference/observer.md)
-- [Props](reference/props.md)
-- [Props Validation](reference/props_validation.md)
-- [QWeb Templating Language](reference/qweb_templating_language.md)
-- [QWeb Engine](reference/qweb_engine.md)
-- [Router](reference/router.md)
-- [Store](reference/store.md)
-- [Slots](reference/slots.md)
-- [Tags](reference/tags.md)
-- [Utils](reference/utils.md)
+Lifecycle hooks:
 
-## Other Topics
+- [`onWillStart`](reference/component.md#willstart): hook to define asynchronous code that should be executed before component is rendered
+- [`onMounted`](reference/component.md#mounted): hook to define code that should be executed when component is mounted
+- [`onWillPatch`](reference/component.md#willpatch): hook to define code that should be executed before component is patched
+- [`onWillUpdateProps`](reference/component.md#willupdateprops): hook to define code that should be executed before component is updated
+- [`onPatched`](reference/component.md#patched): hook to define code that should be executed when component is patched
+- [`onWillRender`](reference/component.md#willrender): hook to define code that should be executed before component is rendered
+- [`onRendered`](reference/component.md#rendered): hook to define code that should be executed after component is rendered
+- [`onWillUnmount`](reference/component.md#willunmount): hook to define code that should be executed before component is unmounted
+- [`onWillDestroy`](reference/component.md#willdestroy): hook to define code that should be executed before component is destroyed
+- [`onError`](reference/component.md#onerror): hook to define a Owl error handler
 
-This section provides miscellaneous document that explains some topics
-which cannot be considered either a tutorial, or reference documentation.
+Other hooks:
 
-- [Owl architecture: the Virtual DOM](miscellaneous/vdom.md)
-- [Owl architecture: the rendering pipeline](miscellaneous/rendering.md)
-- [Comparison with React/Vue](miscellaneous/comparison.md)
-- [Why did Odoo built Owl?](miscellaneous/why_owl.md)
+- [`useComponent`](reference/hooks.md#usecomponent): return a reference to the current component (useful to create derived hooks)
+- [`useEffect`](reference/hooks.md#useeffect): define an effect with its dependencies
+- [`useEnv`](reference/hooks.md#useenv): return a reference to the current env
+- [`useExternalListener`](reference/hooks.md#useexternallistener): add a listener outside of a component DOM
+- [`useRef`](reference/hooks.md#useref): get an object representing a reference (`t-ref`)
+- [`useChildSubEnv`](reference/hooks.md#usesubenv-and-usechildsubenv): extend the current env with additional information (for child components)
+- [`useSubEnv`](reference/hooks.md#usesubenv-and-usechildsubenv): extend the current env with additional information (for current component and child components)
 
----
+Utility/helpers:
 
-Found an issue in the documentation? A broken link? Some outdated information?
-Please open an issue or submit a PR!
+- [`EventBus`](reference/utils.md#eventbus): a simple event bus
+- [`loadFile`](reference/utils.md#loadfile): an helper to load a file from the server
+- [`markup`](reference/templates.md#outputting-data): utility function to define strings that represent html (should not be escaped)
+- [`status`](reference/component.md#status-helper): utility function to get the status of a component (new, mounted or destroyed)
+- [`validate`](reference/utils.md#validate): validates if an object satisfies a specified schema
+- [`whenReady`](reference/utils.md#whenready): utility function to execute code when DOM is ready

doc/reference/animations.md

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

doc/reference/app.md

@@ -0,0 +1,125 @@
+# 🦉 App 🦉
+
+## Content
+
+- [Overview](#overview)
+- [API](#api)
+- [Configuration](#configuration)
+- [`mount` helper](#mount-helper)
+- [Loading templates](#loading-templates)
+
+## Overview
+
+Every Owl application has a root element, a set of templates, an environment and
+possibly a few other settings. The `App` class is a simple class that represents
+all of these elements. Here is an example:
+
+```js
+const {Component, App } = owl;
+
+class MyComponent extends Component { ... }
+
+const app = new App(MyComponent, { props: {...}, templates: "..."});
+app.mount(document.body);
+```
+
+The basic workflow is: create an `App` instance configured with the root
+component, the templates, and possibly other settings. Then, we mount that
+instance somewhere in the DOM.
+
+## API
+
+- **`constructor(Root[, config])`**: first argument should be a component class (not
+  an instance), and the optional second argument is a configuration object (see below).
+
+- **`mount(target, options)`**: first argument is an html element, and the optional
+  second argument is an object with mounting options (see below). Mount the app
+  to a target in the DOM. Note that this is an asynchronous operation: the `mount`
+  method returns a promise that resolves to the component instance whenever it
+  is complete.
+
+  The `option` object is an object with the following keys:
+
+  - **`position (string)`**: either `first-child` or `last-child`. This option determines
+    the position of the application in the target: either first or last child.
+
+- **`destroy()`**: destroys the application
+
+## Configuration
+
+The `config` object is an object with some of the following keys:
+
+- **`env (object)`**: if given, this will be the shared `env` given to each component
+- **`props (object)`**: the props given to the root component
+- **`dev (boolean, default=false)`**: if `true`, the application is rendered in
+  [`dev` mode](#dev-mode);
+- **`test (boolean, default=false)`**: `test` mode is the same as `dev` mode, except
+  that Owl will not log a message to warn that Owl is in `dev` mode.
+- **`translatableAttributes (string[])`**: a list of additional attributes that should
+  be translated (see [translations](translations.md))
+- **`translateFn (function)`**: a function that will be called by owl to translate
+  templates (see [translations](translations.md))
+- **`templates (string | xml document)`**: all the templates that will be used by
+  the components created by the application.
+- **`getTemplate ((s: string) => Element | Function | string | void)`**: a function that will be called by owl when it
+  needs a template. If undefined is returned, owl looks into the app templates.
+- **`warnIfNoStaticProps (boolean, default=false)`**: if true, Owl will log a warning
+  whenever it encounters a component that does not provide a [static props description](props.md#props-validation).
+
+## `mount` helper
+
+Note that there is a `mount` helper to do that in just a line:
+
+```js
+const { mount, Component } = owl;
+
+class MyComponent extends Component {
+    ...
+}
+
+mount(MyComponent, document.body, { props: {...}, templates: "..."});
+```
+
+Here is the `mount` function signature:
+
+**`mount(Component, target, config)`** with the following arguments:
+
+- **`Component`**: a component class (Root component of the app)
+- **`target`**: an html element, where the component will be mounted as last child
+- **`config (optional)`**: a config object (the same as the App config object)
+
+Most of the time, the `mount` helper is more convenient, but whenever one needs
+a reference to the actual Owl App, then using the `App` class directly is
+possible.
+
+## Loading templates
+
+Most applications will need to load templates whenever they start. Here is
+what it could look like in practice:
+
+```js
+// in the main js file:
+const { loadFile, mount } = owl;
+
+// async, so we can use async/await
+(async function setup() {
+  const templates = await loadFile(`/some/endpoint/that/return/templates`);
+  const env = {
+    _t: someTranslateFn,
+    templates,
+    // possibly other stuff
+  };
+
+  mount(Root, document.body, { env });
+})();
+```
+
+## Dev mode
+
+Dev mode activates some additional checks and developer amenities:
+
+- [Props validation](./props.md#props-validation) is performed
+- [t-foreach](./templates.md#loops) loops check for key unicity
+- Lifecycle hooks are wrapped to report their errors in a more developer-friendly way
+- onWillStart and onWillUpdateProps will emit a warning in the console when they
+  take longer than 3 seconds in an effort to ease debugging the presence of deadlocks

doc/reference/browser.md

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

doc/reference/concurrency_model.md

@@ -11,7 +11,7 @@
 
 Owl was designed from the very beginning with asynchronous components. This comes
 from the `willStart` and the `willUpdateProps` lifecycle hooks. With these
-methods, it is possible to build complex highly concurrent applications.
+asynchronous hooks, it is possible to build complex highly concurrent applications.
 
 Owl concurrent mode has several benefits: it makes it possible to delay the
 rendering until some asynchronous operation is complete, it makes it possible
@@ -35,7 +35,8 @@ two phases: _virtual rendering_ and _patching_.
 
 ### Virtual rendering
 
-This phase represent the process of rendering a template, in memory, which create a virtual representation of the desired component html). The output of this phase is a
+This phase represent the process of rendering a template, in memory, which creates
+a virtual representation of the desired component html). The output of this phase is a
 virtual DOM.
 
 It is asynchronous: each subcomponents needs to either be created (so, `willStart`
@@ -94,7 +95,7 @@ component (with some code like `app.mount(document.body)`).
 5. The method `mounted` is called recursively on all components in the following
    order: `E`, `D`, `C`, `B`, `A`.
 
-**Scenario 2: rerendering a component**. Now, let's assume that the user clicked on some
+**Scenario 2: updating a component**. Now, let's assume that the user clicked on some
 button in `C`, and this results in a state update, which is supposed to:
 
 - update `D`,
@@ -136,8 +137,7 @@ Here is what Owl will do:
 6. `mounted` hook is called on `F`, `patched` hooks are called on `D`, `C`
 
 Tags are very small helpers to make it easy to write inline templates. There is
-only one currently available tag: `xml`, but we plan to add other tags later,
-such as a `css` tag, which will be used to write [single file components](../learning/how_to_write_sfc.md).
+only one currently available tag: `xml`.
 
 ### Asynchronous Rendering
 
@@ -158,26 +158,6 @@ There are two different common problems with Owl asynchronous rendering model:
 Here are a few tips on how to work with asynchronous components:
 
 1. Minimize the use of asynchronous components!
-2. Maybe move the asynchronous logic in a store, which then triggers (mostly)
-   synchronous renderings
-3. Lazy loading external libraries is a good use case for async rendering. This
+2. Lazy loading external libraries is a good use case for async rendering. This
    is mostly fine, because we can assume that it will only takes a fraction of a
-   second, and only once (see [`owl.utils.loadJS`](utils.md#loadjs))
-4. For all the other cases, the [`AsyncRoot`](misc.md#asyncroot) component is there to help you. When
-   this component is met, a new rendering
-   sub tree is created, such that the rendering of that component (and its
-   children) is not tied to the rendering of the rest of the interface. It can
-   be used on an asynchronous component, to prevent it from delaying the
-   rendering of the whole interface, or on a synchronous one, such that its
-   rendering isn't delayed by other (asynchronous) components. Note that this
-   directive has no effect on the first rendering, but only on subsequent ones
-   (triggered by state or props changes).
-
-   ```xml
-   <div t-name="ParentComponent">
-     <SyncChild />
-     <AsyncRoot>
-        <AsyncChild/>
-     </AsyncRoot>
-   </div>
-   ```
+   second, and only once.

doc/reference/config.md

@@ -1,44 +0,0 @@
-# 🦉 Config 🦉
-
-The Owl framework is designed to work in many situations. However, it is
-sometimes necessary to customize some behaviour. This is done by using the
-global `config` object. It provides two settings:
-
-- [`mode`](#mode) (default value: `prod`),
-- [`enableTransitions`](#enabletransitions) (default value: `true`).
-
-## Mode
-
-By default, Owl is in _production_ mode, this means that it will try to do its
-job fast, and skip some expensive operations. However, it is sometimes necessary
-to have better information on what is going on, this is the purpose
-of the `dev` mode.
-
-Owl has a mode flag, in `owl.config.mode`. Its default value is `prod`, but
-it can be set to `dev`:
-
-```js
-owl.config.mode = "dev";
-```
-
-Note that templates compiled with the `prod` settings will not be recompiled.
-So, changing this setting is best done at startup.
-
-An important job done by the `dev` mode is to validate props for each component
-creation and update. Also, extra props will cause an error.
-
-## `enableTransitions`
-
-Transitions are usually nice, but they can cause issues in some specific cases,
-such as automated tests. It is uncomfortable having to wait for a transition
-to end before moving to the next step.
-
-To solve this issue, Owl can be configured to ignore the `t-transition` directive.
-To do that, one only needs to set the `enableTransitions` flag to false:
-
-```js
-owl.config.enableTransitions = false;
-```
-
-Note that it suffers from the same drawback as the "dev" mode: all compiled
-templates, if any, will keep their current behaviours.

doc/reference/content.md

@@ -1,40 +0,0 @@
-# 🦉 Owl Content 🦉
-
-Here is a complete visual representation of everything exported by the `owl`
-global object.
-
-For example, `Component` is available at `owl.Component` and `EventBus` is
-exported as `owl.core.EventBus`.
-
-```
-browser
-Component                               misc
-Context                                     AsyncRoot
-QWeb                                        Portal
-mount                                   router
-Store                                       Link
-useState                                    RouteComponent
-config                                      Router
-    mode
-core                                    tags
-    EventBus                                css
-    Observer                                xml
-hooks                                   utils
-    onWillStart                             debounce
-    onMounted                               escape
-    onWillUpdateProps                       loadJS
-    onWillPatch                             loadFile
-    onPatched                               shallowEqual
-    onWillUnmount                           whenReady
-    useContext
-    useState
-    useRef
-    useComponent
-    useEnv
-    useSubEnv
-    useStore
-    useDispatch
-    useGetters
-```
-
-Note that for convenience, the `useState` hook is also exported at the root of the `owl` object.

doc/reference/context.md

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

doc/reference/environment.md

@@ -6,15 +6,15 @@
 - [Setting an Environment](#setting-an-environment)
 - [Using a sub environment](#using-a-sub-environment)
 - [Content of an Environment](#content-of-an-environment)
-- [Special keys](#special-keys)
 
 ## Overview
 
-An environment is an object which contains a [`QWeb` instance](qweb_engine.md). Whenever
-a root component is created, it is assigned an environment (see
-[below](#setting-an-environment) for more info on this). This environment is
-then automatically given to each sub component (and accessible in the `this.env`
-property).
+An environment is a shared object given to all components in a tree. It is not
+used by Owl itself, but it is useful for application developers to provide a
+simple communication channel between components (in addition to the props).
+
+The `env` given to the [`App`](app.md) is assigned to the `env` component
+property.
 
 ```
     Root
@@ -22,31 +22,14 @@ property).
    A    B
 ```
 
-This way, all components share the same `QWeb` instance. Owl internally requires
-that the environment has a `qweb` key which maps to a
-[`QWeb`](qweb_engine.md) instance. This is the QWeb instance that will be used to
-render each templates in this specific component tree. Note that if no `QWeb`
-instance is provided, Owl will simply generate it on the fly.
-
-The environment is mostly static. Each application is free to add anything to
-the environment, which is very useful, since this can be accessed by each sub
-component.
+Also, the `env` object is frozen when the application is started. This is done
+to ensure a simpler mental model of what's happening in runtime. Note that it
+is only shallowly frozen, so sub objects can be modified.
 
 ## Setting an environment
 
-An Owl application needs an [environment](environment.md) to be executed. The
-environment has an important key: the [QWeb](qweb_engine.md) instance, which will render
-all templates.
-
-Whenever a root component `App` is mounted, Owl will setup a valid environment by
-following the next steps:
-
-- take the `env` object defined on `App.env` (if no `env` was explicitly setup,
-  this will return the empty `env` object defined on `Component`)
-- if `env.qweb` is not set, then Owl will create a `QWeb` instance.
-
-The correct way to customize an environment is to simply set it up on the root
-component class, before the first component is created:
+The correct way to customize an environment is to simply give it to the `App`,
+whenever it is created.
 
 ```js
 const env = {
@@ -56,81 +39,38 @@ const env = {
         ...
     },
 };
-mount(App, { target: document.body, env });
+
+new App(Root, { env }).mount(document.body);
+
+// or alternatively
+mount(App, document.body, { env });
 ```
 
-It is also possible to simply share an environment between all root components,
-by simply doing this:
-
-```js
-Component.env = myEnv; // will be the default env for all components
-```
-
-Note that this environment is the global owl environment for an application. The
-next section explains how to extend an environment for a specific sub component
-and its children.
-
 ## Using a sub environment
 
 It is sometimes useful to add one (or more) specific keys to the environment,
 from the perspective of a specific component and its children. In that case, the
 solution presented above will not work, since it sets the global environment.
 
-There is a hook for this situation: [`useSubEnv`](hooks.md#usesubenv).
+There are two hooks for this situation: [`useSubEnv` and `useChildSubEnv`](hooks.md#usesubenv-and-usechildsubenv).
 
 ```js
-class FormComponent extends Component {
-  constructor(parent, props) {
-    super(parent, props);
-    useSubEnv({ myKey: someValue });
+class SomeComponent extends Component {
+  setup() {
+    useSubEnv({ myKey: someValue }); // myKey is now available for all child components
   }
 }
 ```
 
 ## Content of an Environment
 
-Some good use cases for additional keys in the environment are:
+The `env` object content is totally up to the application developer. However,
+some good use cases for additional keys in the environment are:
 
 - some configuration keys,
 - session information,
 - generic services (such as doing rpcs).
+- other utility functions that one want to inject, such as a translation function.
 
 Doing it this way means that components are easily testable: we can simply
 create a test environment with mock services.
-
-For example:
-
-```js
-async function myEnv() {
-  const templates = await loadTemplates();
-  const qweb = new QWeb({ templates });
-  const session = getSession();
-
-  return {
-    _t: myTranslateFunction,
-    session: session,
-    qweb: qweb,
-    services: {
-      localStorage: localStorage,
-      rpc: rpc,
-    },
-    debug: false,
-    inMobileMode: true,
-  };
-}
-
-async function start() {
-  const env = await myEnv();
-  mount(App, { target: document.body, env });
-}
-```
-
-## Special Keys
-
-There are two special key/value added by Owl if not provided in the environment:
-the `QWeb` instance and a `browser` object:
-
-- `qweb` will be set to an empty `QWeb` instance. This is absolutely necessary
-  for Owl to be able to render anything
-- `browser`: this is an object that contains some common access points to the
-  browser methods with a side effect. See [browser](browser.md) for more information. Note that the browser object will be removed from the environment in Owl 2.0.

doc/reference/error_handling.md

@@ -3,60 +3,30 @@
 ## Content
 
 - [Overview](#overview)
+- [Managing Errors](#managing-errors)
 - [Example](#example)
-- [Reference](#reference)
 
 ## Overview
 
 By default, whenever an error occurs in the rendering of an Owl application, we
 destroy the whole application. Otherwise, we cannot offer any guarantee on the
 state of the resulting component tree. It might be hopelessly corrupted, but
-without any user-visible state.
+without any user-visible feedback.
 
-Clearly, it sometimes is a little bit extreme to destroy the application. This
-is why we have a builtin mechanism to handle rendering errors (and errors coming
-from lifecycle hooks): the `catchError` hook.
+Clearly, it is usually a little bit extreme to destroy the application. This
+is why we need a mechanism to handle rendering errors (and errors coming
+from lifecycle hooks): the `onError` hook.
 
-## Example
+The main idea is that the `onError` hook register a function that will be called
+with the error. This function need to handle the situation, most of the time by
+updating some state and rerendering itself, so the application can return to a
+normal state.
 
-For example, here is how we could implement an `ErrorBoundary` component:
+## Managing Errors
 
-```xml
-<div t-name="ErrorBoundary">
-    <t t-if="state.error">
-        Error handled
-    </t>
-    <t t-else="">
-        <t t-slot="default" />
-    </t>
-</div>
-```
-
-```js
-class ErrorBoundary extends Component {
-  state = useState({ error: false });
-
-  catchError() {
-    this.state.error = true;
-  }
-}
-```
-
-Using the `ErrorBoundary` is then extremely simple:
-
-```xml
-<ErrorBoundary><SomeOtherComponent/></ErrorBoundary>
-```
-
-Note that we need to be careful here: the fallback UI should not throw any
-error, otherwise we risk going into an infinite loop (also, see the page on
-[slots](slots.md) for more information on the `t-slot` directive).
-
-## Reference
-
-Whenever the `catchError` lifecycle hook is implemented, all errors coming from
+Whenever the `onError` lifecycle hook is used, all errors coming from
 sub components rendering and/or lifecycle method calls will be caught and given
-to the `catchError` method. This allows us to properly handle the error, and to
+to the `onError` method. This allows us to properly handle the error, and to
 not break the application.
 
 There are important things to know:
@@ -65,17 +35,41 @@ There are important things to know:
   Owl will destroy the full application. This is done on purpose, because Owl
   cannot guarantee that the state is not corrupted from this point on.
 
-- errors coming from event handlers are NOT managed by `catchError` or any other
+- errors coming from event handlers are NOT managed by `onError` or any other
   owl mechanism. This is up to the application developer to properly recover
   from an error
 
-Also, it may be useful to know that whenever an error is caught, it is then
-broadcasted to the application by an event on the `qweb` instance. It may be
-useful, for example, to log the error somewhere.
+- if an error handler is unable to properly handle an error, it can just rethrow
+  an error, and Owl will try looking for another error handler up the component
+  tree.
+
+## Example
+
+For example, here is how we could implement a generic component `ErrorBoundary`
+that render its content, and a fallback if an error happened.
 
 ```js
-env.qweb.on("error", null, function (error) {
-  // do something
-  // react to the error
-});
+class ErrorBoundary extends Component {
+  static template = xml`
+    <t t-if="state.error" t-slot="fallback">An error occurred</t>
+    <t t-else="" t-slot="default"/>`;
+
+  setup() {
+    this.state = useState({ error: false });
+    onError(() => (this.state.error = true));
+  }
+}
 ```
+
+Using the `ErrorBoundary` is then simple simple:
+
+```xml
+<ErrorBoundary>
+  <SomeOtherComponent/>
+  <t t-set-slot="fallback">Some specific error message</t>
+</ErrorBoundary>
+```
+
+Note that we need to be careful here: the fallback UI should not throw any
+error, otherwise we risk going into an infinite loop (also, see the page on
+[slots](slots.md) for more information on the `t-slot` directive).

doc/reference/event_bus.md

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

doc/reference/event_handling.md

@@ -3,22 +3,15 @@
 ## Content
 
 - [Event Handling](#event-handling)
-- [Business DOM Events](#business-dom-events)
-- [Inline Event Handlers](#inline-event-handlers)
 - [Modifiers](#modifiers)
+- [Synthetic Events](#synthetic-events)
+- [On Components](#on-components)
 
 ## Event Handling
 
 In a component's template, it is useful to be able to register handlers on DOM
-elements to some specific events. This is what makes a template _alive_. There
-are four different use cases.
-
-1. Register an event handler on a DOM node (_pure_ DOM event)
-2. Register an event handler on a component (_pure_ DOM event)
-3. Register an event handler on a DOM node (_business_ DOM event)
-4. Register an event handler on a component (_business_ DOM event)
-
-A _pure_ DOM event is directly triggered by a user interaction (e.g. a `click`).
+elements to some specific events. This is what makes a template _alive_. This
+is done with the `t-on` directive. For example:
 
 ```xml
 <button t-on-click="someMethod">Do something</button>
@@ -31,93 +24,28 @@ button.addEventListener("click", component.someMethod.bind(component));
 ```
 
 The suffix (`click` in this example) is simply the name of the actual DOM
-event.
-
-## Business DOM Events
-
-A _business_ DOM event is triggered by a call to `trigger` on a component.
+event. The value of the `t-on` expression should be a valid javascript expression
+that evaluates to a function in the context of the current component. So, one
+can get a reference to the event, or pass some additional arguments. For example,
+all the following expressions are valid:
 
 ```xml
-<MyComponent t-on-menu-loaded="someMethod" />
+<button t-on-click="someMethod">Do something</button>
+<button t-on-click="() => this.increment(3)">Add 3</button>
+<button t-on-click="ev => this.doStuff(ev, 'value')">Do something</button>
 ```
 
-```js
- class MyComponent {
-     someWhere() {
-         const payload = ...;
-         this.trigger('menu-loaded', payload);
-     }
- }
-```
+Notice the use of the `this` keyword in the lambda function: this is the
+correct way to call a method on the component in a lambda function.
 
-The call to `trigger` generates an `OwlEvent`, a subclass of [_CustomEvent_](https://developer.mozilla.org/docs/Web/Guide/Events/Creating_and_triggering_events)
-with an additional attribute `originalComponent` (the component that triggered
-the event). The generated event is of type `menu-loaded` and dispatches it on
-the component's DOM element (`this.el`). The event bubbles and is cancelable.
-The parent component listening to event `menu-loaded` will receive the payload
-in its `someMethod` handler (in the `detail` property of the event), whenever
-the event is triggered.
-
-```js
- class ParentComponent {
-     someMethod(ev) {
-         const payload = ev.detail;
-         ...
-     }
- }
-```
-
-By convention, we use KebabCase for the name of _business_ events.
-
-The `t-on` directive allows to prebind its arguments. For example,
+One could use the following expression:
 
 ```xml
-<button t-on-click="someMethod(expr)">Do something</button>
+<button t-on-click="() => increment(3)">Add 3</button>
 ```
 
-Here, `expr` is a valid Owl expression, so it could be `true` or some variable
-from the rendering context.
-
-### Type Hinting
-
-Note that if you work with Typescript, the `trigger` method is generic on the type of the payload.
-
-You can then describe the type of the event, so you will see typing errors...
-
-```typescript
-this.trigger<MyCustomPayload>("my-custom-event", payload);
-```
-
-```typescript
-myCustomEventHandler(ev: OwlEvent<MyCustomPayload>) { ... }
-```
-
-## Inline Event Handlers
-
-One can also directly specify inline statements. For example,
-
-```xml
-<button t-on-click="state.counter++">Increment counter</button>
-```
-
-Here, `state` must be defined in the rendering context (typically the component)
-as it will be translated to:
-
-```js
-button.addEventListener("click", () => {
-  context.state.counter++;
-});
-```
-
-Warning: inline expressions are evaluated in the context of the template. This
-means that they can access the component methods and properties. But if they set
-a key, the inline statement will actually not modify the component, but a key in
-a sub scope.
-
-```xml
-<button t-on-click="value = 1">Set value to 1 (does not work!!!)</button>
-<button t-on-click="state.value = 1">Set state.value to 1 (work as expected)</button>
-```
+But then, the increment function may be unbound (unless the component binds it
+in its setup function, for example).
 
 ## Modifiers
 
@@ -125,12 +53,13 @@ In order to remove the DOM event details from the event handlers (like calls to
 `event.preventDefault`) and let them focus on data logic, _modifiers_ can be
 specified as additional suffixes of the `t-on` directive.
 
-| Modifier   | Description                                                                                                              |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------ |
-| `.stop`    | calls `event.stopPropagation()` before calling the method                                                                |
-| `.prevent` | calls `event.preventDefault()` before calling the method                                                                 |
-| `.self`    | calls the method only if the `event.target` is the element itself                                                        |
-| `.capture` | bind the event handler in [capture](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener) mode. |
+| Modifier     | Description                                                                                                              |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------ |
+| `.stop`      | calls `event.stopPropagation()` before calling the method                                                                |
+| `.prevent`   | calls `event.preventDefault()` before calling the method                                                                 |
+| `.self`      | calls the method only if the `event.target` is the element itself                                                        |
+| `.capture`   | bind the event handler in [capture](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener) mode. |
+| `.synthetic` | define a synthetic event handler (see below)                                                                             |
 
 ```xml
 <button t-on-click.stop="someMethod">Do something</button>
@@ -149,3 +78,42 @@ modifiers. For example,
 ```
 
 This will simply stop the propagation of the event.
+
+## Synthetic Events
+
+In some cases, attaching an event handler for each element of large lists has
+a non trivial cost. Owl provides a way to efficiently improve the performance:
+with synthetic event, it actually adds only one handler on the document body,
+and will properly call the handler, just as expected.
+
+The only difference with regular events is that the event is caught at the document
+body, so it cannot be stopped before it actually gets there. Since it may be
+surprising in some cases, it is not enabled by default.
+
+To enable it, one can just use the `.synthetic` suffix:
+
+```xml
+<div>
+    <t t-foreach="largeList" t-as="elem" t-key="elem.id">
+        <button t-on-click.synthetic="doSomething" ...>
+            <!-- some content -->
+        </button>
+    </t>
+</div>
+```
+
+## On Components
+
+The `t-on` directive also works on a child component:
+
+```xml
+<div>
+    in some template
+    <Child t-on-click="dosomething"/>
+</div>
+```
+
+This will catch all click events on any html element contained in the `Child`
+sub component. Note that if the child component is reduced to one (or more) text
+nodes, then clicking on it will not call the handler, since the event will be
+dispatched by the browser on the parent element (a `div` in this case).

doc/reference/hooks.md

@@ -3,27 +3,17 @@
 ## Content
 
 - [Overview](#overview)
-- [Example: Mouse Position](#example-mouse-position)
-- [Example: Autofocus](#example-autofocus)
-- [Reference](#reference)
-  - [One Rule](#one-rule)
+- [The Hook Rule](#the-hook-rule)
+- [Lifecycle hooks](#lifecycle-hooks)
+- [Other hooks](#other-hooks)
   - [`useState`](#usestate)
-  - [`onMounted`](#onmounted)
-  - [`onWillUnmount`](#onwillunmount)
-  - [`onWillPatch`](#onwillpatch)
-  - [`onPatched`](#onpatched)
-  - [`onWillStart`](#onwillstart)
-  - [`onWillUpdateProps`](#onwillupdateprops)
-  - [`useContext`](#usecontext)
   - [`useRef`](#useref)
-  - [`useSubEnv`](#usesubenv)
+  - [`useSubEnv` and `useChildSubEnv`](#usesubenv-and-usechildsubenv)
   - [`useExternalListener`](#useexternallistener)
-  - [`useStore`](#usestore)
-  - [`useDispatch`](#usedispatch)
-  - [`useGetters`](#usegetters)
   - [`useComponent`](#usecomponent)
   - [`useEnv`](#useenv)
-  - [Making customized hooks](#making-customized-hooks)
+  - [`useEffect`](#useeffect)
+- [Example: Mouse Position](#example-mouse-position)
 
 ## Overview
 
@@ -42,96 +32,9 @@ Hooks work beautifully with Owl components: they solve the problems mentioned
 above, and in particular, they are the perfect way to make your component
 reactive.
 
-## Example: mouse position
+## The Hook Rule
 
-Here is the classical example of a non trivial hook to track the mouse position.
-
-```js
-const { useState, onMounted, onWillUnmount } = owl.hooks;
-
-// We define here a custom behaviour: this hook tracks the state of the mouse
-// position
-function useMouse() {
-  const position = useState({ x: 0, y: 0 });
-
-  function update(e) {
-    position.x = e.clientX;
-    position.y = e.clientY;
-  }
-  onMounted(() => {
-    window.addEventListener("mousemove", update);
-  });
-  onWillUnmount(() => {
-    window.removeEventListener("mousemove", update);
-  });
-
-  return position;
-}
-
-// Main root component
-class App extends owl.Component {
-  static template = xml`
-    <div t-name="App">
-      <div>Mouse: <t t-esc="mouse.x"/>, <t t-esc="mouse.y"/></div>
-    </div>`;
-
-  // this hooks is bound to the 'mouse' property.
-  mouse = useMouse();
-}
-```
-
-Note that we use the prefix `use` for hooks, just like in React. This is just
-a convention.
-
-## Example: autofocus
-
-Hooks can be combined to create the desired effect. For example, the following
-hook combines the `useRef` hook with the `onPatched` and `onMounted` functions
-to create an easy way to focus an input whenever it appears in the DOM:
-
-```js
-function useAutofocus(name) {
-  let ref = useRef(name);
-  let isInDom = false;
-  function updateFocus() {
-    if (!isInDom && ref.el) {
-      isInDom = true;
-      ref.el.focus();
-    } else if (isInDom && !ref.el) {
-      isInDom = false;
-    }
-  }
-  onPatched(updateFocus);
-  onMounted(updateFocus);
-}
-```
-
-This hook takes the name of a valid `t-ref` directive, which should be present
-in the template. It then checks whenever the component is mounted or patched if
-the reference is not valid, and in this case, it will focus the node element.
-This hook can be used like this:
-
-```js
-class SomeComponent extends Component {
-  static template = xml`
-    <div>
-        <input />
-        <input t-ref="myinput"/>
-    </div>`;
-
-  constructor(...args) {
-    super(...args);
-    useAutofocus("myinput");
-  }
-}
-```
-
-## Reference
-
-### One rule
-
-There is only one rule: every hook for a component has to be called in the
-constructor, in the _setup_ method, or in class fields:
+There is only one rule: every hook for a component has to be called in the _setup_ method, or in class fields:
 
 ```js
 // ok
@@ -139,14 +42,6 @@ class SomeComponent extends Component {
   state = useState({ value: 0 });
 }
 
-// also ok
-class SomeComponent extends Component {
-  constructor(...args) {
-    super(...args);
-    this.state = useState({ value: 0 });
-  }
-}
-
 // also ok
 class SomeComponent extends Component {
   setup() {
@@ -162,15 +57,24 @@ class SomeComponent extends Component {
 }
 ```
 
-As you can see, the `useState` hook does not need to be given a reference to
-the component. This is possible because there is a way to get a reference to the
-current component: the `Component.current` static property is the reference to the
-component instance that is currently being created.
+## Lifecycle Hooks
 
-Hooks need to be called in the constructor to ensure that this reference is
-properly set. This is also a good thing for performance reasons (Owl can use
-this to optimize its implementation), and for a clean architecture (this makes
-it easier for developers to understand what is really happening in a component).
+All lifecycle hooks are documented in detail in their specific [section](component.md#lifecycle).
+
+| Hook                                                  | Description                                                            |
+| ----------------------------------------------------- | ---------------------------------------------------------------------- |
+| **[onWillStart](component.md#willstart)**             | async, before first rendering                                          |
+| **[onWillRender](component.md#willrender)**           | just before component is rendered                                      |
+| **[onRendered](component.md#rendered)**               | just after component is rendered                                       |
+| **[onMounted](component.md#mounted)**                 | just after component is rendered and added to the DOM                  |
+| **[onWillUpdateProps](component.md#willupdateprops)** | async, before props update                                             |
+| **[onWillPatch](component.md#willpatch)**             | just before the DOM is patched                                         |
+| **[onPatched](component.md#patched)**                 | just after the DOM is patched                                          |
+| **[onWillUnmount](component.md#willunmount)**         | just before removing component from DOM                                |
+| **[onWillDestroy](component.md#willdestroy)**         | just before component is destroyed                                     |
+| **[onError](component.md#onerror)**                   | catch and handle errors (see [error handling page](error_handling.md)) |
+
+## Other Hooks
 
 ### `useState`
 
@@ -181,9 +85,9 @@ The `useState` hook has to be given an object or an array, and will return
 an observed version of it (using a `Proxy`).
 
 ```javascript
-const { useState } = owl.hooks;
+const { useState, Component } = owl;
 
-class Counter extends owl.Component {
+class Counter extends Component {
   static template = xml`
     <button t-on-click="increment">
         Click Me! [<t t-esc="state.value"/>]
@@ -200,265 +104,222 @@ class Counter extends owl.Component {
 It is important to remember that `useState` only works with objects or arrays. It
 is necessary, since Owl needs to react to a change in state.
 
-### `onMounted`
-
-`onMounted` is not a user hook, but is a building block designed to help make useful
-abstractions. `onMounted` registers a callback, which will be called when the component
-is mounted (see example on top of this page).
-
-### `onWillUnmount`
-
-`onWillUnmount` is not a user hook, but is a building block designed to help make useful
-abstractions. `onWillUnmount` registers a callback, which will be called when the component
-is unmounted (see example on top of this page).
-
-### `onWillPatch`
-
-`onWillPatch` is not a user hook, but is a building block designed to help make useful
-abstractions. `onWillPatch` registers a callback, which will be called just
-before the component patched.
-
-### `onPatched`
-
-`onPatched` is not a user hook, but is a building block designed to help make useful
-abstractions. `onPatched` registers a callback, which will be called just
-after the component patched.
-
-### `onWillStart`
-
-`onWillStart` is an asynchronous hook. This means that the function registered
-in the hook will be run just before the component is first rendered and can return a
-promise, to express the fact that it is an asynchronous operation.
-
-Note that if there are more than one `onWillStart` registered callback, then they
-will all be run in parallel.
-
-It can be used to load some initial data. For example, the following hook will
-automatically load some data from the server, and return an object that will
-be ready whenever the component is rendered:
-
-```js
-function useLoader() {
-  const component = Component.current;
-  const record = useState({});
-  onWillStart(async () => {
-    const recordId = component.props.id;
-    Object.assign(record, await fetchSomeRecord(recordId));
-  });
-  return record;
-}
-```
-
-Note that this example does not update the record value whenever props are
-updated. For that situation, we need to use the `onWillUpdateProps` hook.
-
-### `onWillUpdateProps`
-
-Just like `onWillStart`, `onWillUpdateProps` is an asynchronous hook. It is
-designed to be run whenever the component props are updated. This could be
-useful to perform some asynchronous task such as fetching updated data.
-
-```js
-function useLoader() {
-  const component = Component.current;
-  const record = useState({});
-
-  async function updateRecord(id) {
-    Object.assign(record, await fetchSomeRecord(id));
-  }
-
-  onWillStart(() => updateRecord(component.props.id));
-  onWillUpdateProps((nextProps) => updateRecord(nextProps.id));
-
-  return record;
-}
-```
-
-Note that if there are more than one `onWillUpdateProps` registered callback,
-then they will all be run in parallel.
-
-### `useContext`
-
-See [`useContext`](context.md#usecontext) for reference documentation.
-
 ### `useRef`
 
 The `useRef` hook is useful when we need a way to interact with some inside part
-of a component, rendered by Owl. It can work either on a DOM node, or on a component,
-tagged by the `t-ref` directive:
+of a component, rendered by Owl. It only work on a html element tagged by the
+`t-ref` directive:
 
 ```xml
 <div>
-    <div t-ref="someDiv"/>
-    <SubComponent t-ref="someComponent"/>
+    <input t-ref="someInput"/>
+    <span>hello</span>
 </div>
 ```
 
-In this example, the component will be able to access the `div` and the component
-`SubComponent` using the `useRef` hook:
+In this example, the component will be able to access the `input` with the `useRef` hook:
 
 ```js
 class Parent extends Component {
-  subRef = useRef("someComponent");
-  divRef = useRef("someDiv");
+  inputRef = useRef("someInput");
 
   someMethod() {
     // here, if component is mounted, refs are active:
-    // - this.divRef.el is the div HTMLElement
-    // - this.subRef.comp is the instance of the sub component
-    // - this.subRef.el is the root HTML node of the sub component (i.e. this.subRef.comp.el)
+    // - this.inputRef.el is the input HTMLElement
   }
 }
 ```
 
-As shown by the example above, html elements are accessed by using the `el`
-key, and components references are accessed with `comp`.
-
-Notes:
-
-- if used on a component, the reference will be set in the `refs`
-  variable between `willPatch` and `patched`,
-- on a component, accessing `ref.el` will get the root node of the component.
+As shown by the example above, the actual HTMLElement instance is accessed with
+the `el` key.
 
 The `t-ref` directive also accepts dynamic values with string interpolation
-(like the [`t-attf-`](qweb_templating_language.md#dynamic-attributes) and
+(like the [`t-attf-`](templates.md#dynamic-attributes) and
 `t-component` directives). For example,
 
 ```xml
-<div t-ref="component_{{someCondition ? '1' : '2'}}"/>
+<div t-ref="div_{{someCondition ? '1' : '2'}}"/>
 ```
 
 Here, the references need to be set like this:
 
 ```js
-this.ref1 = useRef("component_1");
-this.ref2 = useRef("component_2");
+this.ref1 = useRef("div_1");
+this.ref2 = useRef("div_2");
 ```
 
 References are only guaranteed to be active while the parent component is mounted.
-If this is not the case, accessing `el` or `comp` on it will return `null`.
+If this is not the case, accessing `el` on it will return `null`.
 
-### `useSubEnv`
+### `useSubEnv` and `useChildSubEnv`
 
 The environment is sometimes useful to share some common information between
 all components. But sometimes, we want to _scope_ that knowledge to a subtree.
 
 For example, if we have a form view component, maybe we would like to make some
 `model` object available to all sub components, but not to the whole application.
-This is where the `useSubEnv` hook may be useful: it lets a component add some
-information to the environment in a way that only the component and its children
+This is where the `useChildSubEnv` hook may be useful: it lets a component add some
+information to the environment in a way that only its children
 can access it:
 
 ```js
 class FormComponent extends Component {
-  constructor(...args) {
-    super(...args);
+  setup() {
     const model = makeModel();
+    // model will be available on this.env for this component and all children
     useSubEnv({ model });
+    // someKey will be available on this.env for all children
+    useChildSubEnv({ someKey: "value" });
   }
 }
 ```
 
-The `useSubEnv` takes one argument: an object which contains some key/value that
-will be added to the parent environment. Note that it will extend, not replace
-the parent environment. And of course, the parent environment will not be
-affected.
+The `useSubEnv` and `useChildSubEnv` hooks take one argument: an object which
+contains some key/value that will be added to the current environment. These hooks
+will create a new env object with the new information:
+
+- `useSubEnv` will assign this new `env` to itself and to all children components
+- `useChildSubEnv` will only assign this new `env` to all children components.
+
+As usual in Owl, [environments](environment.md) created with these two hooks are
+frozen, to prevent unwanted modifications.
+
+Note that both these hooks can be called an arbitrary number of times. The `env`
+will then be updated accordingly.
 
 ### `useExternalListener`
 
 The `useExternalListener` hook helps solve a very common problem: adding and removing
-a listener on some target whenever a component is mounted/unmounted. For example,
+a listener on some target whenever a component is mounted/unmounted. It takes a target
+as its first argument, forwards the other arguments to `addEventListener`. For example,
 a dropdown menu (or its parent) may need to listen to a `click` event on `window`
 to be closed:
 
 ```js
-useExternalListener(window, "click", this.closeMenu);
+useExternalListener(window, "click", this.closeMenu, { capture: true });
 ```
 
-### `useStore`
-
-The `useStore` hook is the entry point for a component to connect to the store.
-See the [store documentation](store.md) for more information.
-
-### `useDispatch`
-
-The `useDispatch` hook is the way for components to get a reference to the store
-`dispatch` function. See the [store documentation](store.md) for more information.
-
-### `useGetters`
-
-The `useGetters` hook is the way for components to get a reference to the store
-getters. See the [store documentation](store.md) for more information.
-
 ### `useComponent`
 
 The `useComponent` hook is useful as a building block for some customized hooks,
 that may need a reference to the component calling them.
 
+```js
+function useSomething() {
+  const component = useComponent();
+  // now, component is bound to the instance of the current component
+}
+```
+
 ### `useEnv`
 
 The `useEnv` hook is useful as a building block for some customized hooks,
 that may need a reference to the env of the component calling them.
 
-### Making customized hooks
+```js
+function useSomething() {
+  const env = useEnv();
+  // now, env is bound to the env of the current component
+}
+```
 
-Hooks are a wonderful way to organize the code of a complex component by feature
-instead of by lifecycle methods. They are like mixins, except that they can be
-easily composed together.
+### `useEffect`
 
-But, like every good things in life, hooks should be used with moderation. They are
-not the solution to every problem.
+This hook will run a callback when a component is mounted and patched, and
+will run a cleanup function before patching and before unmounting the
+the component (only if some dependencies have changed).
 
-- they may be overkill: if your component needs to perform some action specific
-  to itself (so, the specific code does not need to be shared), there is nothing
-  wrong with a simple class method:
+It has almost the same API as the React `useEffect` hook, except that the dependencies
+are defined by a function instead of just the dependencies.
 
-  ```js
-  // maybe overkill
-  class A extends Component {
-    constructor(...args) {
-      super(...args);
-      useMySpecificHook();
-    }
+The `useEffect` hook takes two function: the effect function and the dependency
+function. The effect function perform some task and return (optionally) a cleanup
+function. The dependency function returns a list of dependencies, these dependencies
+are passed as parameters in the effect function . If any of these
+dependencies changes, then the current effect will be cleaned up and reexecuted.
+
+Here is an example without any dependencies:
+
+```js
+useEffect(
+  () => {
+    window.addEventListener("mousemove", someHandler);
+    return () => window.removeEventListener("mousemove", someHandler);
+  },
+  () => []
+);
+```
+
+In the example above, the dependency list is empty, so the effect is only cleaned
+up when the component is unmounted.
+
+If the dependency function is skipped, then the effect will be cleaned up and
+rerun at every patch.
+
+Here is another example, of how one could implement a `useAutofocus` hook with
+the `useEffect` hook:
+
+```js
+function useAutofocus(name) {
+  let ref = useRef(name);
+  useEffect(
+    (el) => el && el.focus(),
+    () => [ref.el]
+  );
+}
+```
+
+This hook takes the name of a valid `t-ref` directive, which should be present
+in the template. It then checks whenever the component is mounted or patched if
+the reference is not valid, and in this case, it will focus the node element.
+This hook can be used like this:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+    <div>
+        <input />
+        <input t-ref="myinput"/>
+    </div>`;
+
+  setup() {
+    useAutofocus("myinput");
   }
+}
+```
 
-  // ok
-  class B extends Component {
-    constructor(...args) {
-      super(...args);
-      this.performSpecificTask();
-    }
+## Example: mouse position
+
+Here is the classical example of a non trivial hook to track the mouse position.
+
+```js
+const { useState, onWillDestroy, Component } = owl;
+
+// We define here a custom behaviour: this hook tracks the state of the mouse
+// position
+function useMouse() {
+  const position = useState({ x: 0, y: 0 });
+
+  function update(e) {
+    position.x = e.clientX;
+    position.y = e.clientY;
   }
-  ```
+  window.addEventListener("mousemove", update);
+  onWillDestroy(() => {
+    window.removeEventListener("mousemove", update);
+  });
 
-  Note that the second solution is easier to extend in sub components.
+  return position;
+}
 
-- they may be harder to test: if a customized hook injects some external side
-  effect dependency, then it is harder to test without doing some non obvious
-  manipulation. For example, assume that we want to give a reference to a
-  router in a `useRouter` hook. We could do this:
+// Main root component
+class Root extends Component {
+  static template = xml`<div>Mouse: <t t-esc="mouse.x"/>, <t t-esc="mouse.y"/></div>`;
 
-  ```js
-  const router = new Router(...);
+  // this hooks is bound to the 'mouse' property.
+  mouse = useMouse();
+}
+```
 
-  function useRouter() {
-      return router;
-  }
-  ```
-
-  As you can see, this does not _hook_ into the internal of the component. It
-  simply returns a global object, which is difficult to mock.
-
-  A better way would be to do something like this: get the reference from the
-  environment.
-
-  ```js
-  function useRouter() {
-    const env = useEnv();
-    return env.router;
-  }
-  ```
-
-  This means that we give control to the application developer to create the
-  router, which is good, so they can set it up, subclass it, ... And then, to
-  test our components, we can just add a mock router in the environment.
+Note that we use the prefix `use` for hooks, just like in React. This is just
+a convention.

doc/reference/input_bindings.md

@@ -0,0 +1,92 @@
+# 🦉 Form Input Bindings 🦉
+
+It is very common to need to be able to read the value out of an html `input` (or
+`textarea`, or `select`) in order to use it (note: it does not need to be in a
+form!). A possible way to do this is to do it by hand:
+
+```js
+class Form extends owl.Component {
+  state = useState({ text: "" });
+
+  _updateInputValue(event) {
+    this.state.text = event.target.value;
+  }
+}
+```
+
+```xml
+<div>
+  <input t-on-input="_updateInputValue" />
+  <span t-esc="state.text" />
+</div>
+```
+
+This works. However, this requires a little bit of _plumbing_ code. Also, the
+plumbing code is slightly different if you need to interact with a checkbox,
+or with radio buttons, or with select tags.
+
+To help with this situation, Owl has a builtin directive `t-model`: its value
+should be an observed value in the component (usually `state.someValue`). With
+the `t-model` directive, we can write a shorter code, equivalent to the previous
+example:
+
+```js
+class Form extends owl.Component {
+  state = { text: "" };
+}
+```
+
+```xml
+<div>
+  <input t-model="state.text" />
+  <span t-esc="state.text" />
+</div>
+```
+
+The `t-model` directive works with `<input>`, `<input type="checkbox">`,
+`<input type="radio">`, `<textarea>` and `<select>`:
+
+```xml
+<div>
+    <div>Text in an input: <input t-model="state.someVal"/></div>
+    <div>Textarea: <textarea t-model="state.otherVal"/></div>
+    <div>Boolean value: <input type="checkbox" t-model="state.someFlag"/></div>
+    <div>Selection:
+        <select t-model="state.color">
+            <option value="">Select a color</option>
+            <option value="red">Red</option>
+            <option value="blue">Blue</option>
+        </select>
+    </div>
+    <div>
+        Selection with radio buttons:
+        <span>
+            <input type="radio" name="color" id="red" value="red" t-model="state.color"/>
+            <label for="red">Red</label>
+        </span>
+        <span>
+            <input type="radio" name="color" id="blue" value="blue" t-model="state.color" />
+            <label for="blue">Blue</label>
+        </span>
+    </div>
+</div>
+```
+
+Like event handling, the `t-model` directive accepts the following modifiers:
+
+| Modifier  | Description                                                          |
+| --------- | -------------------------------------------------------------------- |
+| `.lazy`   | update the value on the `change` event (default is on `input` event) |
+| `.number` | try to parse the value to a number (using `parseFloat`)              |
+| `.trim`   | trim the resulting value                                             |
+
+For example:
+
+```xml
+<input t-model.lazy="state.someVal" />
+```
+
+These modifiers can be combined. For instance, `t-model.lazy.number` will only
+update a number whenever the change is done.
+
+Note: the online playground has an example to show how it works.

doc/reference/misc.md

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

doc/reference/mounting.md

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

doc/reference/observer.md

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

doc/reference/portal.md

@@ -0,0 +1,17 @@
+# 🦉 Portal 🦉
+
+It is sometimes useful to be able to render some content outside the boundaries
+of a component. To do that, Owl provides a special directive: `t-portal`:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+      <div>this is inside the component</div>
+      <div t-portal="'body'">and this is outside</div>
+    `;
+}
+```
+
+The `t-portal` directive takes a valid css selector as argument. The content of
+the portalled template will be mounted at the corresponding location. Note that
+Owl need to insert an empty text node at the location of the portalled content.

doc/reference/precompiling_templates.md

@@ -0,0 +1,30 @@
+# 🦉 Precompiling templates 🦉
+
+Owl is designed to be used by the Odoo javascript framework. Since Odoo handles
+its assets in its own non standard way, it was decided/assumed that Owl would
+compile templates at runtime.
+
+However, in some cases, it is not optimal, or even worse, not possible to do that.
+For example, browser extensions do not allow javascript code to create a new
+function (using the `new Function(...)` syntax).
+
+Therefore, in these cases, it is required to compile templates ahead of time. It
+is possible to do that in Owl, but the tooling is still rough. For now, the
+process is the following:
+
+1. write your templates in xml files (with a `t-name` directive to declare the name
+   of the template)
+2. Compile them in a `templates.js` file
+3. get the `owl.iife.runtime.js` file (which is a owl build without the compiler)
+4. bundle `owl.iife.runtime.js` and `template.js` with your assets (owl needs to
+   be positioned before the templates)
+
+Here is a more detailed explanation on how to compile xml files into a js file:
+
+1. clone the owl repository locally
+2. `npm install` to install all the required tooling
+3. `npm run build:runtime` to build the `owl.iife.runtime.js` file
+4. `npm run build:compiler` to build the template compiler
+5. `npm run compile_templates -- path/to/your/templates` will scan your target
+   folder, find all xml files, get all templates, compile them, and generate a
+   `templates.js` file.

doc/reference/props.md

@@ -4,8 +4,12 @@
 
 - [Overview](#overview)
 - [Definition](#definition)
-- [Good Practices](#good-practices)
+- [Props comparison](#props-comparison)
+- [Binding function props](#binding-function-props)
 - [Dynamic Props](#dynamic-props)
+- [Default Props](#default-props)
+- [Props validation](#props-validation)
+- [Good Practices](#good-practices)
 
 ## Overview
 
@@ -38,8 +42,6 @@ The `props` object is made of every attributes defined on the template, with the
 following exceptions:
 
 - every attribute starting with `t-` are not props (they are QWeb directives),
-- `style` and `class` attributes are excluded as well (they are applied by Owl on
-  the root element of the component).
 
 In the following example:
 
@@ -47,7 +49,6 @@ In the following example:
 <div>
     <ComponentA a="state.a" b="'string'"/>
     <ComponentB t-if="state.flag" model="model"/>
-    <ComponentC style="color:red;" class="left-pane" />
 </div>
 ```
 
@@ -55,7 +56,246 @@ the `props` object contains the following keys:
 
 - for `ComponentA`: `a` and `b`,
 - for `ComponentB`: `model`,
-- for `ComponentC`: empty object
+
+## Props comparison
+
+Whenever Owl encounters a subcomponent in a template, it performs a shallow
+comparison of all props. If they are all referentially equal, then the subcomponent
+will not even be updated. Otherwise, if at least one props has changed, then
+Owl will update it.
+
+However, in some cases, we know that two values are different, but they have the
+same effect, and should not be considered different by Owl. For example, anonymous
+functions in a template are always different, but most of them should not be
+considered different:
+
+```xml
+<t t-foreach="todos" t-as="todo" t-key="todo.id">
+  <Todo todo="todo" onDelete="() => deleteTodo(todo.id)" />
+</t>
+```
+
+In that case, one can use the `.alike` suffix:
+
+```xml
+<t t-foreach="todos" t-as="todo" t-key="todo.id">
+  <Todo todo="todo" onDelete.alike="() => deleteTodo(todo.id)" />
+</t>
+```
+
+This tells Owl that this specific prop should always be considered equivalent
+(or, in other words, should be removed from the list of comparable props).
+
+Note that even if most anonymous functions should probably be considered `alike`,
+it is not necessarily true in all cases. It depends on what values are captured
+by the anonymous function. The following example shows a case where it is probably
+wrong to use `.alike`.
+
+```xml
+<t t-foreach="todos" t-as="todo" t-key="todo.id">
+  <!-- Probably wrong! todo.isCompleted may change -->
+  <Todo todo="todo" toggle.alike="() => toggleTodo(todo.isCompleted)" />
+</t>
+```
+
+## Binding function props
+
+It is common to have the need to pass a callback as a prop. Since Owl components
+are class based, the callback frequently needs to be bound to its owner component.
+So, one can do this:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+    <div>
+      <Child callback="doSomething"/>
+    </div>`;
+
+  setup() {
+    this.doSomething = this.doSomething.bind(this);
+  }
+
+  doSomething() {
+    // ...
+  }
+}
+```
+
+However, this is such a common use case that Owl provides a special suffix to do
+just that: `.bind`. This looks like this:
+
+```js
+class SomeComponent extends Component {
+  static template = xml`
+    <div>
+      <Child callback.bind="doSomething"/>
+    </div>`;
+
+  doSomething() {
+    // ...
+  }
+}
+```
+
+The `.bind` suffix also implies `.alike`, so these props will not cause additional
+renderings.
+
+## Dynamic Props
+
+The `t-props` directive can be used to specify totally dynamic props:
+
+```xml
+<div t-name="ParentComponent">
+    <Child t-props="some.obj"/>
+</div>
+```
+
+```js
+class ParentComponent {
+  static components = { Child };
+  some = { obj: { a: 1, b: 2 } };
+}
+```
+
+## Default Props
+
+If the static `defaultProps` property is defined, it will be used to complete
+props received by the parent, if missing.
+
+```js
+class Counter extends owl.Component {
+  static defaultProps = {
+    initialValue: 0,
+  };
+  ...
+}
+```
+
+In the example above, the `initialValue` props is now by default set to 0.
+
+## Props Validation
+
+As an application becomes complex, it may be quite unsafe to define props in an informal way. This leads to two issues:
+
+- hard to tell how a component should be used, by looking at its code.
+- unsafe, it is easy to send wrong props into a component, either by refactoring a component, or one of its parents.
+
+A props type system solves both issues, by describing the types and shapes
+of the props. Here is how it works in Owl:
+
+- `props` key is a static key (so, different from `this.props` in a component instance)
+- it is optional: it is ok for a component to not define a `props` key.
+- props are validated whenever a component is created/updated
+- props are only validated in `dev` mode (see [how to configure an app](app.md#configuration))
+- if a key does not match the description, an error is thrown
+- it validates keys defined in (static) `props`. Additional keys given by the
+  parent will cause an error (unless the special prop `*` is present).
+- it is an object or a list of strings
+- a list of strings is a simplified props definition, which only lists the name
+  of the props. Also, if the name ends with `?`, it is considered optional.
+- all props are by default required, unless they are defined with `optional: true`
+  (in that case, it is only done if there is a value)
+- valid types are: `Number, String, Boolean, Object, Array, Date, Function`, and all
+  constructor functions (so, if you have a `Person` class, it can be used as a type)
+- arrays are homogeneous (all elements have the same type/shape)
+
+For each key, a `prop` definition is either a boolean, a constructor, a list of constructors, or an object:
+
+- a boolean: indicate that the props exists, and is mandatory.
+- a constructor: this should describe the type, for example: `id: Number` describe
+  the props `id` as a number
+- an object describing a value as type. This is done by using the `value` key. For example, `{value: false}` specifies that the corresponding value should be equal to false.
+- a list of constructors. In that case, this means that we allow more than one
+  type. For example, `id: [Number, String]` means that `id` can be either a string
+  or a number.
+- an object. This makes it possible to have more expressive definition. The following sub keys are then allowed (but not mandatory):
+  - `type`: the main type of the prop being validated
+  - `element`: if the type was `Array`, then the `element` key describes the type of each element in the array. If it is not set, then we only validate the array, not its elements,
+  - `shape`: if the type was `Object`, then the `shape` key describes the interface of the object. If it is not set, then we only validate the object, not its elements,
+  - `values`: if the type was `Object`, then the `values` key describes the interface of values in the object, this allows validating objects that are used as mappings, where keys are not known in advance but the shape of the values is.
+  - `validate`: this is a function which should return a boolean to determine if
+    the value is valid or not. Useful for custom validation logic.
+  - `optional`: if true, the prop is not mandatory
+
+There is a special `*` prop that means that additional prop are allowed. This is
+sometimes useful for generic components that will propagate some or all their
+props to their child components.
+
+Note that default values cannot be defined for a mandatory props. Doing so will
+result in a prop validation error.
+
+Examples:
+
+```js
+class ComponentA extends owl.Component {
+    static props = ['id', 'url'];
+
+    ...
+}
+
+class ComponentB extends owl.Component {
+  static props = {
+    count: {type: Number},
+    messages: {
+      type: Array,
+      element: {type: Object, shape: {id: Boolean, text: String }
+    },
+   date: Date,
+   combinedVal: [Number, Boolean],
+   optionalProp: { type: Number, optional: true }
+  };
+
+  ...
+}
+```
+
+```js
+  // only the existence of those 3 keys is documented
+  static props = ['message', 'id', 'date'];
+```
+
+```js
+  // only the existence of those 3 keys is documented. any other key is allowed.
+  static props = ['message', 'id', 'date', '*'];
+```
+
+```js
+  // size is optional
+  static props = ['message', 'size?'];
+```
+
+```js
+  static props = {
+    messageIds: {type: Array, element: Number},  // list of number
+    otherArr: {type: Array},   // just array. no validation is made on sub elements
+    otherArr2: Array,   // same as otherArr
+    someObj: {type: Object},  // just an object, no internal validation
+    someObj2: {
+      type: Object,
+      shape: {
+        id: Number,
+        name: {type: String, optional: true},
+        url: String
+      ]},    // object, with keys id (number), name (string, optional) and url (string)
+    someObj3: {
+      type: Object,
+      values: { type: Array, element: String },
+    }, // object with arbitary keys where values are arrays of strings
+    someFlag: Boolean,     // a boolean, mandatory (even if `false`)
+    someVal: [Boolean, Date],   // either a boolean or a date
+    otherValue: true,     // indicates that it is a prop
+    kindofsmallnumber: {
+      type: Number,
+      validate: n => (0 <= n && n <= 10)
+    },
+    size: {
+      validate:  e => ["small", "medium", "large"].includes(e)
+    },
+    someId: [Number, {value: false}], // either a number or false
+  };
+```
+
+Note: the props validation code is done by using the [validate utility function](utils.md#validate).
 
 ## Good Practices
 
@@ -78,20 +318,3 @@ sent to the parent (for example, with an event).
 Any value can go in a props. Strings, objects, classes, or even callbacks could
 be given to a child component (but then, in the case of callbacks, communicating
 with events seems more appropriate).
-
-## Dynamic Props
-
-The `t-props` directive can be used to specify totally dynamic props:
-
-```xml
-<div t-name="ParentComponent">
-    <Child t-props="some.obj"/>
-</div>
-```
-
-```js
-class ParentComponent {
-  static components = { Child };
-  some = { obj: { a: 1, b: 2 } };
-}
-```

doc/reference/props_validation.md

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

doc/reference/qweb_engine.md

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

doc/reference/reactivity.md

@@ -0,0 +1,395 @@
+# 🦉 Reactivity 🦉
+
+## Content
+
+- [Introduction](#introduction)
+- [`useState`](#usestate)
+- [`reactive`](#reactive)
+- [`Escape hatches`](#escape-hatches)
+- [`Advanced usage`](#advanced-usage)
+
+## Introduction
+
+Reactivity is a big topic in javascript frameworks. The goal is to provide a
+simple way to manipulate state, in such a way that the interface updates automatically
+according to state changes, and to do so in a performant manner.
+
+To this end, Owl provides a proxy-based reactivity system, based on the `reactive` primitive.
+The `reactive` function takes an object as a first argument, and an optional callback as its second
+argument, it returns a proxy of the object. This proxy tracks what properties are read
+through the proxy, and calls the provided callback whenever one of these properties is changed
+through any reactive version of the same object. It does so in depth, by returning reactive versions
+of the subobjects when they are read.
+
+## `useState`
+
+While the `reactive` primitive is very powerful, its usage in components follow a very standard pattern:
+components want to be rerendered when part of the state which they depend on for rendering changes. To
+this end, owl provides a standard hook: `useState`. To put it simply, this hook simply calls reactive
+with the provided object, and the current component's render function as its callback. This will cause
+it to rerender whenever any part of the state object that has been read by this component is modified.
+
+Here is a simple example of how `useState` can be used:
+
+```js
+class Counter extends Component {
+  static template = xml`
+    <div t-on-click="() => this.state.value++">
+      <t t-esc="state.value"/>
+    </div>`;
+
+  setup() {
+    this.state = useState({ value: 0 });
+  }
+}
+```
+
+This component reads `state.value` when it renders, subscribing it to changes to that key. Whenever
+the value changes, Owl will update the component. Note that there is nothing special about the
+`state` property, you can name your state variables whatever you want, and you can have multiple of
+them on the same component if it makes sense to do so. This also allows `useState` to be used in custom
+hooks that may require state that is specific to that hook.
+
+### Reactive props
+
+Since version 2.0, Owl renders are no longer "deep" by default: a component is only rerendered by its
+parent if its props have changed (using a simple equality test). What if the contents of a props have
+changed in a deeper property? If that prop is reactive, owl will rerender the child components that
+need to be updated automatically, and only those components, it does so by reobserving reactive
+objects passed as props to components. Consider the following example:
+
+```js
+class Counter extends Component {
+  static template = xml`
+    <div t-on-click="() => props.state.value++">
+      <t t-esc="props.state.value"/>
+    </div>`;
+}
+
+class Parent extends Component {
+  static template = xml`
+    <Counter state="this.state"/>
+    <button t-on-click="() => this.state.value = 0">Reset counter</button>
+    <button t-on-click="() => this.state.test++" t-esc="this.state.test"/>`;
+
+  setup() {
+    this.state = useState({ value: 0, test: 1 });
+  }
+}
+```
+
+When clicking on the counter button, only the Counter rerenders, because the Parent has never read
+the "value" key in the state. When clicking on the "Reset Counter" button, the same thing happens:
+only the Counter component rerenders. What matters is not _where_ the state is updated, but which
+parts of the state are updated, and which components depend on them. This is achieved by Owl by
+automatically calling `useState` on reactive objects passed as props to a child component.
+
+When clicking on the last button, the parent is rerendered, but the child does not care about the
+`test` key: it has not read it. The props that we give it (`this.state`) have also not changed,
+as such, the parent updates but the child doesn't.
+
+For most day-to-day operations, `useState` should cover all of your needs. If
+you are curious about more advanced use cases and technical details, read on.
+
+### Debugging subscriptions
+
+Owl provides a way to show which reactive objects and keys a component is subscribed to: you can
+look at `component.__owl__.subscriptions`. Note that this is on the internal `__owl__` field, and
+should not be used in any type of production code as the name of this property or any of its properties
+or methods are subject to change at any point, even in stable versions of Owl, and may become available
+only in debug mode in the future.
+
+## `reactive`
+
+The `reactive` function is the basic reactivity primitive. It takes an object
+or an array as first argument, and optionally, a function as the second argument.
+The function is called whenever any tracked value is updated.
+
+```js
+const obj = reactive({ a: 1 }, () => console.log("changed"));
+
+obj.a = 2; // does not log anything: the 'a' key has not been read yet
+console.log(obj.a); // logs 2 and reads the 'a' key => it is now tracked
+obj.a = 3; // logs 'changed' because we updated a tracked value
+```
+
+An important property of reactive objects is that they can be reobserved: this
+will create an independent proxy that tracks another set of keys:
+
+```js
+const obj1 = reactive({ a: 1, b: 2 }, () => console.log("observer 1"));
+const obj2 = reactive(obj1, () => console.log("observer 2"));
+
+console.log(obj1.a); // logs 1, and reads the 'a' key => it is now tracked by observer 1
+console.log(obj2.b); // logs 2, and 'b' is now tracked by observer 2
+obj2.a = 3; // only logs 'observer1', because observer2 does not track a
+obj2.b = 3; // only logs 'observer2', because observer1 does not track b
+console.log(obj2.a, obj1.b); // logs 3 and 3, while the object is observed independently, it is still a single object
+```
+
+Because `useState` returns a normal reactive object, it is possible to call `reactive` on the result
+of a `useState` to observe changes to that object while outside the context of a component, or to
+call `useState` on reactive objects created outside of components. In those cases, one needs to be
+careful with regards to the lifetime of those reactive objects, as holding references to these
+objects may prevent garbage collection of the component and its data even if Owl has destroyed it.
+
+### Subscriptions are ephemereal
+
+Subscription to state changes are ephemereal, whenever an observer is notified that a state object
+has changed, all of its subscriptions are cleared, meaning that if it still cares about it, it
+should read the properties it cares about again. For example:
+
+```js
+const obj = reactive({ a: 1 }, () => console.log("observer called"));
+
+console.log(obj.a); // logs 1, and reads the 'a' key => it is now tracked by the observer
+obj.a = 3; // logs 'observer1' and clears the subscriptions of the observer
+obj.a = 4; // doesn't log anything, the key is no longer observed
+```
+
+This may seem counter-intuitive, but it makes perfect sense in the context of components:
+
+```js
+class DoubleCounter extends Component {
+  static template = xml`
+    <t t-esc="'selected: ' + state.selected + ', value: ' + state[state.selected]"/>
+    <button t-on-click="() => this.state.count1++">increment count 1</button>
+    <button t-on-click="() => this.state.count2++">increment count 2</button>
+    <button t-on-click="changeCounter">Switch counter</button>
+  `;
+
+  setup() {
+    this.state = useState({ selected: "count1", count1: 0, count2: 0 });
+  }
+
+  changeCounter() {
+    this.state.selected = this.state.selected === "count1" ? "count2" : "count1";
+  }
+}
+```
+
+In this component, if we increment the value of the second counter, the component will not rerender,
+which makes sense as rerendering will have no effect, as the second counter is not displayed. If we
+toggle the component to display the second counter, we now no longer want the component to rerender
+when the value of the first counter changes, and this is what happens: a component only rerenders
+when there are changes to pieces of state that have been read during or after the previous render.
+If a piece of state has not been read in the last render, we know that its value won't influence the
+rendered output, and so we can ignore it.
+
+### reactive `Map` and `Set`
+
+The reactivity system has special support built-in for the standard container types `Map` and `Set`.
+They behave like one would expect: reading a key subscribes the observer to that key, adding or
+removing an item to them notifies observers that have used any of the iterators on that reactive
+object, such as `.entries()` or `.keys()`, likewise with clearing them.
+
+## Escape hatches
+
+Sometimes, it is desirable to bypass the reactivity system. Creating proxies when interacting with
+reactive objects is expensive, and while on the whole, the performance benefit that we get by
+rerendering only the parts of the interface that need it outweighs that cost, in some cases, we want
+to be able to opt out of creating them in the first place. This is the purpose of `markRaw`:
+
+### `markRaw`
+
+Marks an object so that it is ignored by the reactivity system, meaning that if this object is ever
+part of a reactive object, it will be returned as is, and no keys in that object will be
+observed.
+
+```js
+const someObject = markRaw({ b: 1 });
+const state = useState({
+  a: 1,
+  obj: someObject,
+});
+console.log(state.obj.b); // attempt to subscribe to the "b" key in someObject
+state.obj.b = 2; // No rerender will occur here
+console.log(someObject === state.obj); // true
+```
+
+This is useful in some rare cases. One such example would be if you want to use an array of objects
+that is potentially large to render a list, but those objects are known to be immutable:
+
+```js
+this.items = useState([
+  { label: "some text", value: 42 },
+  // ... 1000 total objects
+]);
+```
+
+in the template:
+
+```xml
+<t t-foreach="items" t-as="item" t-key="item.label" t-esc="item.label + item.value"/>
+```
+
+Here, on every render, we go and read one thousand keys from a reactive object, which causes
+one thousand reactive objects to be created. If we know that the content of these objects
+cannot change, this is wasted work. If instead all of these objects are marked as raw, we avoid
+all of this work while keeping the ability to lean on the reactivity to track the presence and
+identity of these objects:
+
+```js
+this.items = useState([
+  markRaw({ label: "some text", value: 42 }),
+  // ... 1000 total objects
+]);
+```
+
+However, use this function with caution: this is an escape hatch from the reactivity
+system, and as such, using it may cause subtle and unintended issues! For example:
+
+```js
+// This will cause a rerender
+this.items.push(markRaw({ label: "another label", value: 1337 }));
+
+// THIS WILL NOT CAUSE A RENDER!
+this.items[17].value = 3;
+// The UI is now desynced from component's state until the next render caused by something else
+```
+
+In short: only use `markRaw` if your application is slowing down noticeably and profiling reveals
+that a lot of time is spent creating useless reactive objects.
+
+### `toRaw`
+
+While `markRaw` marks an object so that it is never made reactive, `toRaw` takes an object and
+returns the underlying non-reactive object. It can be useful in some niche cases. In particular,
+because the reactivity system returns a proxy, the returned object does not compare equal to the
+original object:
+
+```js
+const obj = {};
+const reactiveObj = reactive(obj);
+console.log(obj === reactiveObj); // false
+console.log(obj === toRaw(reactiveObj)); // true
+```
+
+It can also be useful during debugging, as unfolding proxies recursively in debuggers can be confusing.
+
+## Advanced usage
+
+The following is a collection of small snippets that leverage the reactivity system in
+"non-standard" ways to help you understand its power and where using it might make your code simpler.
+
+### Notification manager
+
+Showing notifications is a pretty common need in web applications, you may want to show a
+notification from any other component within the application, and the notifications should stack on
+top of one another regardless of which component spawned them, here is how we can leverage the
+reactivity to accomplish this:
+
+```js
+let notificationId = 1;
+const notifications = reactive({});
+class NotificationContainer extends Component {
+  static template = xml`
+    <t t-foreach="notifications" t-as="notification" t-key="notification_key" t-esc="notification"/>
+  `;
+  setup() {
+    this.notifications = useState(notifications);
+  }
+}
+
+export function addNotification(label) {
+  const id = notificationId++;
+  notifications[id] = label;
+  return () => {
+    delete notifications[id];
+  };
+}
+```
+
+Here, the `notifications` variable is a reactive object. Notice how we didn't give `reactive` a
+callback: this is because in this case, all we care about is that adding or removing notifications
+in the `addNotification` function goes through the reactivity system. The `NotificationContainer`
+component reobserves this object with `useState`, and is updated whenever notifications are
+added or removed.
+
+### Store
+
+Centralizing application state is a pretty common want/need in web applications. Because of the way
+the reactivity system works, you can treat any reactive object as a store, and if you call `useState`
+on it, components automatically observe only the part of the store that they're interested in:
+
+```js
+export const store = reactive({
+  list: [],
+  add(item) {
+    this.list.push(item);
+  },
+});
+
+export function useStore() {
+  return useState(store);
+}
+```
+
+In any component:
+
+```js
+import { useStore } from "./store";
+
+class List extends Component {
+  static template = xml`
+    <t t-foreach="store.list" t-as="item" t-key="item" t-esc="item"/>
+  `;
+  setup() {
+    this.store = useStore();
+  }
+}
+```
+
+Anywhere in the application:
+
+```js
+import { store } from "./store";
+// Will cause any instance of the List component in the app to update
+store.add("New list item!");
+```
+
+Notice how we can make objects with methods into reactive objects, and when these methods are used
+to mutate the store contents, it works as expected. And while stores are generally one-off objects,
+it is entirely possible to make class instances reactive:
+
+```js
+class Store {
+  list = [];
+  add(item) {
+    this.list.push(item);
+  }
+}
+// Essentially equivalent to the previous code
+export const store = reactive(new Store());
+```
+
+Which can be useful to unit test the class separately.
+
+### Local storage synchronization
+
+Sometimes, you want to persist some state accross reloads, you can do this by storing it in the
+`localStorage`, but what if you want to update the `localStorage` item every time the state changes,
+so that you don't have to manually synchronize the states? Well, you can use the reactivity system
+to write a custom hook that will do that for you:
+
+```js
+function useStoredState(key, initialState) {
+  const state = JSON.parse(localStorage.getItem(key)) || initialState;
+  const store = (obj) => localStorage.setItem(key, JSON.stringify(obj));
+  const reactiveState = reactive(state, () => store(reactiveState));
+  store(reactiveState);
+  return useState(state);
+}
+
+class MyComponent extends Component {
+  setup() {
+    this.state = useStoredState("MyComponent.state", { value: 1 });
+  }
+}
+```
+
+One important thing to notice is that both times we call `store`, we call it with `reactiveState`,
+not `state`: we need `store` to read the keys through a reactive object for it to correctly
+subscribe to state changes. Notice also that we call `store` the first time by hand, as otherwise it
+will not be subscribed to anything, and no amount of change in the object will cause the reactive
+callback to be invoked.

doc/reference/refs.md

@@ -0,0 +1,37 @@
+# 🦉 References 🦉
+
+The `useRef` hook is useful when we need a way to interact with some inside part
+of a component, rendered by Owl. It can work either on a DOM node, or on a component,
+targeted by the `t-ref` directive. See the [hooks section](hooks.md#useref) for
+more detail.
+
+As a short example, here is how we could set the focus on a given input:
+
+```xml
+<div>
+    <input t-ref="input"/>
+    <button t-on-click="focusInput">Click</button>
+</div>
+```
+
+```js
+import { useRef } from "owl/hooks";
+
+class SomeComponent extends Component {
+  inputRef = useRef("input");
+
+  focusInput() {
+    this.inputRef.el.focus();
+  }
+}
+```
+
+Be aware that the `el` property will only be set when the target of the `t-ref`
+directive is mounted in the DOM. Otherwise, it will be set to `null`.
+
+The `useRef` hook cannot be used to get a reference to an instance of a sub
+component.
+
+Note that this example uses the suffix `ref` to name the reference. This
+is not mandatory, but it is a useful convention, so we do not forget that it is
+a reference object.

doc/reference/router.md

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

doc/reference/slots.md

@@ -3,71 +3,92 @@
 ## Content
 
 - [Overview](#overview)
-- [Example](#example)
-- [Reference](#reference)
+- [Named slots](#named-slots)
+- [Rendering Context](#rendering-context)
+- [Default Slot](#default-slot)
+- [Default Content](#default-content)
+- [Dynamic slots](#dynamic-slots)
+- [Slots and props](#slots-and-props)
+- [Slot params](#slot-params)
+- [Slot scopes](#slot-scopes)
 
 ## Overview
 
 Owl is a template based component system. There is therefore a need to be able
-to make generic components. For example, imagine a generic `Dialog`
-component, which is able to display some arbitrary content.
-
-Obviously, we want to use this component everywhere in our application, to
-display various different content. The `Dialog` component is technically the
-owner of its content, but is only a container. The user of the `Dialog` is
-the component that want to _inject_ something inside the `Dialog`. This is
-exactly what slots are for.
-
-## Example
-
-To make generic components, it is useful to be able for a parent component to _inject_
-some sub template, but still be the owner. For example, a generic dialog component
-will need to render some content, some footer, but with the parent as the
-rendering context.
-
-Slots are inserted with the `t-slot` directive:
+to make generic components. For example, imagine a generic `Navbar`
+component, which displays a navbar, but with some customizable content. Since
+the specific content is only known to the user of the `Navbar`, it would be nice
+to specify it in the template where `Navbar` is used:
 
 ```xml
-<div t-name="Dialog" class="modal">
-  <div class="modal-title"><t t-esc="props.title"/></div>
-  <div class="modal-content">
+  <div>
+    <Navbar>
+      <span>Hello Owl</span>
+    </Navbar>
+  </div>
+```
+
+This is exactly the way slots work! In the example above, the user of the `Navbar`
+component specify some content (here, in the default slot). The `Navbar`
+component can insert that content in its own template at the appropriate location.
+An important information to notice is that the content of the slot is rendered in
+the parent context, not in the navbar. As such, it can access values and methods
+from the parent component.
+
+Here is how the `Navbar` component could be defined, with the `t-slot` directive:
+
+```xml
+<div class="navbar">
+  <t t-slot="default"/>
+  <ul>
+    <!-- rest of the navbar here -->
+  </ul>
+</div>
+```
+
+## Named slots
+
+Default slots are very useful, but sometimes, we may need more than one slot.
+This is what named slots are for! For example, suppose we implement a component
+`InfoBox` that display a title and some specific content. Its template could look
+like this:
+
+```xml
+<div class="info-box">
+  <div class="info-box-title">
+    <t t-slot="title"/>
+    <span class="info-box-close-button" t-on-click="close">X</span>
+  </div>
+  <div class="info-box-content">
     <t t-slot="content"/>
   </div>
-  <div class="modal-footer">
-    <t t-slot="footer"/>
-  </div>
 </div>
 ```
 
-Slots are defined by the caller, with the `t-set-slot` directive:
+And one could use it with the `t-set-slot` directive:
 
 ```xml
-<div t-name="SomeComponent">
-  <div>some component</div>
-  <Dialog title="'Some Dialog'">
-    <t t-set-slot="content">
-      <div>hey</div>
-    </t>
-    <t t-set-slot="footer">
-      <button t-on-click="doSomething">ok</button>
-    </t>
-  </Dialog>
-</div>
+<InfoBox>
+  <t t-set-slot="title">
+    Specific Title. It could be html also.
+  </t>
+  <t t-set-slot="content">
+    <!-- some template here, with html, events, whatever -->
+  </t>
+</InfoBox>
 ```
 
-In this example, the component `Dialog` will render the slots `content` and `footer`
-with its parent as rendering context. This means that clicking on the button
-will execute the `doSomething` method on the parent, not on the dialog.
+## Rendering context
 
-Note: Owl previously used the `t-set` directive to define the content of a slot.
-This is deprecated and should no longer be used in new code.
+The content of the slots is actually rendered with the rendering context corresponding
+to where it was defined, not where it is positioned. This allows the user to define
+event handlers that will be bound to the correct component (usually, the
+grandparent of the slot content).
 
-## Reference
+## Default Slot
 
-### Default Slot
-
-The first element inside the component which is not a named slot will
-be considered the `default` slot. For example:
+All elements inside the component which are not a named slot will be treated as
+part of the content of the `default` slot. For example:
 
 ```xml
 <div t-name="Parent">
@@ -81,7 +102,20 @@ be considered the `default` slot. For example:
 </div>
 ```
 
-### Default content
+One can mix default slot and named slots:
+
+```xml
+<div>
+  <Child>
+    default content
+    <t t-set-slot="footer">
+      content for footer slot here
+    </t>
+  </Child>
+</div>
+```
+
+## Default content
 
 Slots can define a default content, in case the parent did not define them:
 
@@ -96,12 +130,7 @@ Slots can define a default content, in case the parent did not define them:
 <!-- will be rendered as: <div><span>default content</span></div> -->
 ```
 
-Rendering context: the content of the slots is actually rendered with the
-rendering context corresponding to where it was defined, not where it is
-positioned. This allows the user to define event handlers that will be bound
-to the correct component (usually, the grandparent of the slot content).
-
-### Dynamic Slots
+## Dynamic Slots
 
 The `t-slot` directive is actually able to use any expressions, using string
 interplolation:
@@ -109,3 +138,123 @@ interplolation:
 ```xml
  <t t-slot="{{current}}" />
 ```
+
+This will evaluate the `current` expression, and insert the corresponding slot
+at the place of the `t-slot` directive.
+
+## Slots and props
+
+In a sense, slots are almost the same as a prop: they define some information
+to pass to the child component. To make it possible to use it, and to pass it
+down to sub component, Owl actually define a special prop `slots` that contains
+all slot information given to the component. It looks like this:
+
+```js
+{ slotName_1: slotInfo_1, ..., slotName_m: slotInfo_m }
+```
+
+So, a component can pass its slots to a subcomponent like this:
+
+```xml
+<Child slots="props.slots"/>
+```
+
+## Slot params
+
+For advanced usecases, it may be necessary to pass additional information to a
+slot. This can be done by providing extra key/value pairs to the `t-set-slot`
+directive. Then, the generic component can read them in its prop `slots`.
+
+For example, here is how a Notebook component could be implemented (a component
+with multiple page, and a tab bar, which only render the current active page,
+and each page has a title).
+
+```js
+class Notebook extends Component {
+  static template = xml`
+    <div class="notebook">
+      <div class="tabs">
+        <t t-foreach="tabNames" t-as="tab" t-key="tab_index">
+          <span t-att-class="{active:tab_index === activeTab}" t-on-click="() => state.activeTab=tab_index">
+            <t t-esc="props.slots[tab].title"/>
+          </span>
+        </t>
+      </div>
+      <div class="page">
+        <t t-slot="{{currentSlot}}"/>
+      </div>
+    </div>`;
+
+  setup() {
+    this.state = useState({ activeTab: 0 });
+    this.tabNames = Object.keys(this.props.slots);
+  }
+
+  get currentSlot() {
+    return this.tabNames[this.state.activeTab];
+  }
+}
+```
+
+Notice how one can read the `title` value for each slots. Here is how one could
+use this `Notebook` component:
+
+```xml
+<Notebook>
+  <t t-set-slot="page1" title="'Page 1'">
+    <div>this is in the page 1</div>
+  </t>
+  <t t-set-slot="page2" title="'Page 2'" hidden="somevalue">
+    <div>this is in the page 2</div>
+  </t>
+</Notebook>
+```
+
+Slot params works like normal props, so one can use the `.bind` suffix to
+bind a function if needed.
+
+## Slot scopes
+
+For other kinds of advanced use cases, the content of a slot may depends on some
+information specific to the generic component. This is the opposite of the slot
+params.
+
+To solve this kind of problems, one can use the `t-slot-scope` directive along
+with the `t-set-slot`. This defines the name of a variable that can access
+everything given by the child component:
+
+```xml
+<MyComponent>
+    <t t-set-slot="foo" t-slot-scope="scope">
+        content
+        <t t-esc="scope.bool"/>
+        <t t-esc="scope.num"/>
+    </t>
+</MyComponent>
+```
+
+And the child component that includes the slot can provide values like this:
+
+```xml
+<t t-slot="foo" bool="other_var" num="5">
+```
+
+or this:
+
+```xml
+<t t-slot="foo" t-props="someObject">
+```
+
+In the case of the default slot, you may declare the slot scope directly on the
+component itself:
+
+```xml
+<MyComponent t-slot-scope="scope">
+    content
+    <t t-esc="scope.bool"/>
+    <t t-esc="scope.num"/>
+</MyComponent>
+```
+
+Slot values works like normal props, so one can use the `.bind` suffix to
+bind a function if needed.

doc/reference/store.md

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

doc/reference/tags.md

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

doc/reference/templates.md

@@ -1,12 +1,11 @@
-# 🦉 QWeb Templating Language🦉
+# 🦉 Templates 🦉
 
 ## Content
 
 - [Overview](#overview)
 - [Directives](#directives)
-- [Reference](#reference)
+- [QWeb Template reference](#qweb-template-reference)
   - [White Spaces](#white-spaces)
-  - [Root Nodes](#root-nodes)
   - [Expression Evaluation](#expression-evaluation)
   - [Static html Nodes](#static-html-nodes)
   - [Outputting Data](#outputting-data)
@@ -16,17 +15,20 @@
   - [Dynamic Class Attribute](#dynamic-class-attribute)
   - [Dynamic Tag Names](#dynamic-tag-names)
   - [Loops](#loops)
-  - [Rendering Sub Templates](#rendering-sub-templates)
+  - [Sub Templates](#sub-templates)
   - [Dynamic Sub Templates](#dynamic-sub-templates)
-  - [Translations](#translations)
   - [Debugging](#debugging)
+- [Fragments](#fragments)
+- [Inline templates](#inline-templates)
+- [Rendering svg](#rendering-svg)
+- [Restrictions](#restrictions)
 
 ## Overview
 
-[QWeb](https://www.odoo.com/documentation/13.0/reference/qweb.html) is the primary
-templating engine used by Odoo. It is based on the XML format, and used
+Owl templates are describe using the [QWeb](https://www.odoo.com/documentation/13.0/reference/qweb.html) specification. It is based on the XML format, and used
 mostly to generate HTML. In OWL, QWeb templates are compiled into functions that
-generate a virtual dom representation of the HTML.
+generate a virtual dom representation of the HTML. Also, since Owl is a live
+component system, there are additional directives specific to Owl (such as `t-on`).
 
 ```xml
 <div>
@@ -53,34 +55,33 @@ extensions.
 
 For reference, here is a list of all standard QWeb directives:
 
-| Name                           | Description                                                    |
-| ------------------------------ | -------------------------------------------------------------- |
-| `t-esc`                        | [Outputting safely a value](#outputting-data)                  |
-| `t-raw`                        | [Outputting value, without escaping](#outputting-data)         |
-| `t-set`, `t-value`             | [Setting variables](#setting-variables)                        |
-| `t-if`, `t-elif`, `t-else`,    | [conditionally rendering](#conditionals)                       |
-| `t-foreach`, `t-as`            | [Loops](#loops)                                                |
-| `t-att`, `t-attf-*`, `t-att-*` | [Dynamic attributes](#dynamic-attributes)                      |
-| `t-call`                       | [Rendering sub templates](#rendering-sub-templates)            |
-| `t-debug`, `t-log`             | [Debugging](#debugging)                                        |
-| `t-translation`                | [Disabling the translation of a node](#translations)           |
-| `t-name`                       | [Defining a template (not really a directive)](qweb_engine.md) |
+| Name                           | Description                                                     |
+| ------------------------------ | --------------------------------------------------------------- |
+| `t-esc`                        | [Outputting safely a value](#outputting-data)                   |
+| `t-out`                        | [Outputting value, possibly without escaping](#outputting-data) |
+| `t-set`, `t-value`             | [Setting variables](#setting-variables)                         |
+| `t-if`, `t-elif`, `t-else`,    | [conditionally rendering](#conditionals)                        |
+| `t-foreach`, `t-as`            | [Loops](#loops)                                                 |
+| `t-att`, `t-attf-*`, `t-att-*` | [Dynamic attributes](#dynamic-attributes)                       |
+| `t-call`                       | [Rendering sub templates](#sub-templates)                       |
+| `t-debug`, `t-log`             | [Debugging](#debugging)                                         |
+| `t-translation`                | [Disabling the translation of a node](translations.md)          |
 
 The component system in Owl requires additional directives, to express various
 needs. Here is a list of all Owl specific directives:
 
-| Name                     | Description                                                                     |
-| ------------------------ | ------------------------------------------------------------------------------- |
-| `t-component`, `t-props` | [Defining a sub component](component.md#composition)                            |
-| `t-ref`                  | [Setting a reference to a dom node or a sub component](component.md#references) |
-| `t-key`                  | [Defining a key (to help virtual dom reconciliation)](#loops)                   |
-| `t-on-*`                 | [Event handling](event_handling.md)                                             |
-| `t-transition`           | [Defining an animation](animations.md#css-transitions)                          |
-| `t-slot`                 | [Rendering a slot](slots.md)                                                    |
-| `t-model`                | [Form input bindings](component.md#form-input-bindings)                         |
-| `t-tag`                  | [Rendering nodes with dynamic tag name](#dynamic-tag-names)                     |
+| Name                                   | Description                                                     |
+| -------------------------------------- | --------------------------------------------------------------- |
+| `t-component`, `t-props`               | [Defining a sub component](component.md#sub-components)         |
+| `t-ref`                                | [Setting a reference to a dom node or a sub component](refs.md) |
+| `t-key`                                | [Defining a key (to help virtual dom reconciliation)](#loops)   |
+| `t-on-*`                               | [Event handling](event_handling.md)                             |
+| `t-portal`                             | [Portal](portal.md)                                             |
+| `t-slot`, `t-set-slot`, `t-slot-scope` | [Rendering a slot](slots.md)                                    |
+| `t-model`                              | [Form input bindings](input_bindings.md)                        |
+| `t-tag`                                | [Rendering nodes with dynamic tag name](#dynamic-tag-names)     |
 
-## Reference
+## QWeb Template Reference
 
 ### White Spaces
 
@@ -90,32 +91,6 @@ White spaces in a template are handled in a special way:
 - if a whitespace-only text node contains a linebreak, it is ignored
 - the previous rules do not apply if we are in a `<pre>` tag
 
-### Root Nodes
-
-For many reasons, Owl QWeb templates should have a single root node. More
-precisely, the result of a template rendering should have a single root node:
-
-```xml
-<!–– not ok: two root nodes ––>
-<t>
-    <div>foo</div>
-    <div>bar</div>
-</t>
-
-<!–– ok: result has one single root node ––>
-<t>
-    <div t-if="someCondition">foo</div>
-    <span t-else="">bar</span>
-</t>
-```
-
-Extra root nodes will actually be ignored (even though they will be rendered
-in memory).
-
-Note: this does not apply to subtemplates (see the `t-call` directive). In that
-case, they will be inlined in the main template, and can actually have many
-root nodes.
-
 ### Expression Evaluation
 
 QWeb expressions are strings that will be processed at compile time. Each variable in
@@ -140,7 +115,7 @@ It is useful to explain the various rules that apply on these expressions:
    <div><p t-if="console.log(1)">NOT valid</p></div>
    ```
 
-2. it can use anything in the rendering context (typically, the component):
+2. it can use anything in the rendering context (which typically contains the properties of the component):
 
    ```xml
    <p t-if="user.birthday === today()">Happy bithday!</p>
@@ -190,24 +165,29 @@ rendered with the value `value` set to `42` in the rendering context yields:
 <p>42</p>
 ```
 
-The `t-raw` directive is almost the same as `t-esc`, but without the escaping.
-This is mostly useful to inject a raw html string somewhere. Obviously, this
-is unsafe to do in general, and should only be used for strings known to be safe.
+The `t-out` directive is almost the same as `t-esc`, but possibly without the
+escaping. The difference is that the value received by the `t-out` directive
+will only be not-escaped if it has been marked as such, using the `markup`
+utility function:
 
-```xml
-<p><t t-raw="value"/></p>
+For example, in the following component:
+
+```js
+const { markup, Component, xml } = owl;
+
+class SomeComponent extends Component {
+  static template = xml`
+    <t t-out="value1"/>
+    <t t-out="value2"/>`;
+
+  value1 = "<div>some text 1</div>";
+  value2 = markup("<div>some text 2</div>");
+}
 ```
 
-rendered with the value `value` set to `<span>foo</span>` in the rendering context yields:
-
-```html
-<p><span>foo</span></p>
-```
-
-Note that since the content of the expression is not known beforehand, the `t-raw`
-directive has to parse the html (and convert it to a virtual dom structure) for
-each rendering. So, it will be much slower than a regular template. It is
-therefore advised to limit the use of `t-raw` whenever possible.
+The first `t-out` will act as a `t-esc` directive, which means that the content
+of `value1` will be escaped. However, since `value2` has been tagged as a markup,
+this will be injected as html.
 
 ### Setting Variables
 
@@ -310,10 +290,11 @@ If an expression evaluates to a falsy value, it will not be set at all:
 
 It is sometimes convenient to format an attribute with string interpolation. In
 that case, the `t-attf-` directive can be used. It is useful when we need to mix
-literal and dynamic elements, such as css classes.
+literal and dynamic elements, such as css classes. The dynamic elements can be
+specified with either `{{...}}` or `#{...}`:
 
 ```xml
-<div t-attf-foo="a {{value1}} is {{value2}} of {{value3}} ]"/>
+<div t-attf-foo="a {{value1}} is #{value2} of {{value3}} ]"/>
 <!-- result if values are set to 1,2 and 3: <div foo="a 0 is 1 of 2 ]"></div> -->
 ```
 
@@ -368,7 +349,7 @@ collection to iterate on, and a second parameter `t-as` providing the name to us
 for the current item of the iteration:
 
 ```xml
-<t t-foreach="[1, 2, 3]" t-as="i">
+<t t-foreach="[1, 2, 3]" t-as="i" t-key="i">
     <p><t t-esc="i"/></p>
 </t>
 ```
@@ -384,22 +365,27 @@ will be rendered as:
 Like conditions, `t-foreach` applies to the element bearing the directive’s attribute, and
 
 ```xml
-<p t-foreach="[1, 2, 3]" t-as="i">
+<p t-foreach="[1, 2, 3]" t-as="i" t-key="i">
     <t t-esc="i"/>
 </p>
 ```
 
 is equivalent to the previous example.
 
-`t-foreach` can iterate on an array (the current item will be the current value)
-or an object (the current item will be the current key).
+An important difference should be made with the usual `QWeb` behaviour: Owl
+requires the presence of a `t-key` directive, to be able to properly reconcile
+renderings.
 
-In addition to the name passed via t-as, `t-foreach` provides a few other
-variables for various data points (note: `$as` will be replaced with the name
-passed to `t-as`):
+`t-foreach` can iterate on any iterable, and also has special support for objects
+and maps, it will expose the key of the current iteration as the contents of the
+`t-as`, and the corresponding value with the same name and the suffix `_value`.
 
-- `$as_value`: the current iteration value, identical to `$as` for lists and
-  integers, but for objects, it provides the value (where `$as` provides the key)
+In addition to the name passed via t-as, `t-foreach` provides a few other useful
+variables (note: `$as` will be replaced with the name passed to `t-as`):
+
+- `$as_value`: the current iteration value, identical to `$as` for arrays and
+  other iterables, but for objects and maps, it provides the value (where `$as`
+  provides the key)
 - `$as_index`: the current iteration index (the first item of the iteration has index 0)
 - `$as_first`: whether the current item is the first of the iteration
   (equivalent to `$as_index == 0`)
@@ -416,7 +402,7 @@ into the global context.
 <t t-set="existing_variable" t-value="false"/>
 <!-- existing_variable now False -->
 
-<p t-foreach="Array(3)" t-as="i">
+<p t-foreach="Array(3)" t-as="i" t-key="i">
     <t t-set="existing_variable" t-value="true"/>
     <t t-set="new_variable" t-value="true"/>
     <!-- existing_variable and new_variable now true -->
@@ -430,17 +416,14 @@ Even though Owl tries to be as declarative as possible, the DOM does not fully
 expose its state declaratively in the DOM tree. For example, the scrolling state,
 the current user selection, the focused element or the state of an input are not
 set as attribute in the DOM tree. This is why we use a virtual dom
-algorithm to keep the actual DOM node as much as possible.
-
-However, in some situations, this is not enough, and we need to help Owl decide
-if an element is actually the same, or is a different element with the same
-properties.
+algorithm to make sure we keep the actual DOM node instead of replacing it with
+a new one.
 
 Consider the following situation: we have a list of two items `[{text: "a"}, {text: "b"}]`
 and we render them in this template:
 
 ```xml
-<p t-foreach="items" t-as="item"><t t-esc="item.text"/></p>
+<p t-foreach="items" t-as="item" t-key="item_index"><t t-esc="item.text"/></p>
 ```
 
 The result will be two `<p>` tags with text `a` and `b`. Now, if we swap them,
@@ -495,13 +478,13 @@ not work with other iterables, such as `Set`. However, it is only a matter of
 using the `...` javascript operator. For example:
 
 ```xml
-<t t-foreach="...items" t-as="item">...</t>
+<t t-foreach="[...items]" t-as="item">...</t>
 ```
 
 The `...` operator will convert the `Set` (or any other iterables) into a list,
 which will work with Owl QWeb.
 
-### Rendering Sub Templates
+### Sub Templates
 
 QWeb templates can be used for top level rendering, but they can also be used
 from within another template (to avoid duplication or give names to parts of
@@ -558,6 +541,14 @@ This can be used to define variables scoped to a sub template:
 <!-- "var" does not exist here -->
 ```
 
+Note: by default, the rendering context for a sub template is simply the current
+rendering context. However, it may be useful to be able to specify a specific
+object as context. This can be done by using the `t-call-context` directive:
+
+```xml
+<t t-call="other-template" t-call-context="obj"/>
+```
+
 ### Dynamic sub templates
 
 The `t-call` directive can also be used to dynamically call a sub template,
@@ -574,21 +565,6 @@ using string interpolation. For example:
 Here, the name of the template is obtained from the `template` value in the
 template rendering context.
 
-### Translations
-
-By default, QWeb specify that templates should be translated. If this behaviour
-is not wanted, there is a `t-translation` directive which can turn off
-translations (if it is set to the `off` value), with the following rules:
-
-- each text node will be replaced with its translation,
-- each of the following attribute values will be translated as well: `title`,
-  `placeholder`, `label` and `alt`,
-- translating text nodes can be disabled with the special attribute `t-translation`,
-  if its value is `off`.
-
-See [here](qweb_engine.md#translations) for more information on how to setup a
-translate function in Owl QWeb.
-
 ### Debugging
 
 The javascript QWeb implementation provides two useful debugging directives:
@@ -611,3 +587,117 @@ will stop execution if the browser dev tools are open.
 ```
 
 will print 42 to the console.
+
+## Fragments
+
+Owl 2 supports templates with an arbitrary number of root elements, or even just
+a text node. So, the following templates are all valid:
+
+```xml
+hello owl. This is just a text node!
+```
+
+```xml
+<div>hello</div>
+```
+
+```xml
+<div>hello</div>
+<div>ola</div>
+```
+
+```xml
+<div t-if="someCondition"><SomeChildComponent/></div>
+```
+
+```xml
+<t t-if="someCondition"><SomeChildComponent/></t>
+```
+
+## Inline templates
+
+Most real applications will define their templates in a XML file, to benefit
+from the XML ecosystem, and to do some additional processing, such as translating
+them. However, in some cases, it is convenient to be able to define a template
+inline. To do so, one can use the `xml` helper function:
+
+```js
+const { Component, xml } = owl;
+
+class MyComponent extends Component {
+  static template = xml`
+      <div>
+          <span t-if="somecondition">text</span>
+          <button t-on-click="someMethod">Click</button>
+      </div>
+  `;
+
+    ...
+}
+
+mount(MyComponent, document.body);
+```
+
+This function simply generates an unique string id, and register the template
+under that id in the internals of Owl, then return the id.
+
+## Rendering svg
+
+Owl components can be used to generate dynamic SVG graphs:
+
+```js
+class Node extends Component {
+  static template = xml`
+        <g>
+            <circle t-att-cx="props.x" t-att-cy="props.y" r="4" fill="black"/>
+            <text t-att-x="props.x - 5" t-att-y="props.y + 18"><t t-esc="props.node.label"/></text>
+            <t t-set="childx" t-value="props.x + 100"/>
+            <t t-set="height" t-value="props.height/(props.node.children || []).length"/>
+            <t t-foreach="props.node.children || []" t-as="child">
+                <t t-set="childy" t-value="props.y + child_index*height"/>
+                <line t-att-x1="props.x" t-att-y1="props.y" t-att-x2="childx" t-att-y2="childy" stroke="black" />
+                <Node x="childx" y="childy" node="child" height="height"/>
+            </t>
+        </g>
+    `;
+  static components = { Node };
+}
+
+class RootNode extends Component {
+  static template = xml`
+        <svg height="180">
+            <Node node="graph" x="10" y="20" height="180"/>
+        </svg>
+    `;
+  static components = { Node };
+  graph = {
+    label: "a",
+    children: [
+      { label: "b" },
+      { label: "c", children: [{ label: "d" }, { label: "e" }] },
+      { label: "f", children: [{ label: "g" }] },
+    ],
+  };
+}
+```
+
+This `RootNode` component will then display a live SVG representation of the
+graph described by the `graph` property. Note that there is a recursive structure
+here: the `Node` component uses itself as a subcomponent.
+
+**Important note:** Owl needs to properly set the namespace for each svg elements.
+Since Owl compile each template separately, it is not able to determine easily
+if a template is supposed to be included in a svg namespace or not. Therefore,
+Owl depends on a heuristic: if a tag is either `svg`, `g` or `path`, then it will
+be considered as svg. In practice, this means that each component or each sub
+templates (included with `t-call`) should have one of these tag as root tag.
+
+## Restrictions
+
+Note that Owl templates forbid the use of tag and or attributes starting with
+the `block-` string. This restriction prevents name collision with the internal
+code of Owl.
+
+```xml
+<div><block-1>this will not be accepted by Owl</block-1></div>
+```

doc/reference/translations.md

@@ -0,0 +1,70 @@
+# 🦉 Translations 🦉
+
+If properly setup, Owl can translate all rendered templates. To do
+so, it needs a translate function, which takes a string and returns a string.
+
+For example:
+
+```js
+const translations = {
+  hello: "bonjour",
+  yes: "oui",
+  no: "non",
+};
+const translateFn = (str) => translations[str] || str;
+
+const app = new App(Root, { templates, tranaslateFn });
+// ...
+```
+
+See the [app configuration page](app.md#configuration) for more info on how to
+configure an Owl application.
+
+Once setup, all rendered templates will be translated using `translateFn`:
+
+- each text node will be replaced with its translation,
+- each of the following attribute values will be translated as well: `title`,
+  `placeholder`, `label` and `alt`,
+- translating text nodes can be disabled with the special attribute `t-translation`,
+  if its value is `off`.
+
+So, with the above `translateFn`, the following templates:
+
+```xml
+<div>hello</div>
+<div t-translation="off">hello</div>
+<div>Are you sure?</div>
+<input placeholder="hello" other="yes"/>
+```
+
+will be rendered as:
+
+```xml
+<div>bonjour</div>
+<div>hello</div>
+<div>Are you sure?</div>
+<input placeholder="bonjour" other="yes"/>
+```
+
+Note that the translation is done during the compilation of the template, not
+when it is rendered.
+
+In some case, it is useful to be able to extend the list of translatable attributes.
+For example, one may want to also translate `data-title` attributes. To do that,
+we can define additional attributes with the `translatableAttributes` option:
+
+```js
+const app = new App(Root, { templates, tranaslateFn, translatableAttributes: ["data-title"] });
+// ...
+```
+
+It is also possible to remove an attribute from the default list by prefixing it with `-`:
+
+```js
+const app = new App(Root, {
+  templates,
+  tranaslateFn,
+  translatableAttributes: ["data-title", "-title"],
+});
+// data-title attribute will be translated, but not title attribute...
+```

doc/reference/utils.md

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

doc/tools/devtools.md

@@ -0,0 +1,56 @@
+# Owl Devtools Browser extension
+
+The owl devtools browser extension is an extension available on chrome or firefox which adds an owl tab
+to the browser devtools in order to inspect all owl apps that are present on any web page, their components
+and allows to interract with their data to a certain extend. There is also a profiler available to visualize
+the components' lifecycle and be able to trace their origin.
+
+See the [`devtools doc`](devtools_guide.md) for more information.
+
+## Install the extension manually (for devs)
+
+In the owl root folder:
+
+```bash
+npm install
+```
+
+For chrome:
+
+```bash
+npm run build:devtools-chrome
+```
+
+For firefox:
+
+```bash
+npm run build:devtools-firefox
+```
+
+You can also run:
+
+```bash
+npm run dev:devtools-chrome
+```
+
+or
+
+```bash
+npm run dev:devtools-firefox
+```
+
+to avoid recompiling owl and gain time if it has already been done.
+
+To run the extension:
+
+In google chrome: go to your chrome extensions admin panel, activate developer mode and click on `Load unpacked`.
+Select the output folder (dist/devtools) and that's it, your extension is active!
+There is a convenient refresh button on the extension card (still on the same admin page) to update your code.
+Do note that if you got some problems, you may need to completly remove and reload the extension to completly refresh the extension.
+
+In firefox: go to the address about:debugging#/runtime/this-firefox and click on `Load temporary Add-on...`.
+Select any file of the output folder (dist/devtools) and that's it, your extension is active!
+Here, you can use the reload button to refresh the extension.
+
+Note that you may have to open another window or reload your tab to see the extension working.
+Also note that the extension will only be active on pages that have a sufficient version of owl.

doc/tools/devtools_guide.md

@@ -0,0 +1,155 @@
+# Owl Devtools Guide
+
+## Information popup
+
+After having installed the extension, a new icon will be added to your extension bar.
+If you don't see it, you can pin the extension using the extensions popup.
+
+<img src="screenshots/extensions.png"/>
+
+Clicking on the owl icon will open the information popup. This popup is useful
+to know in advance whether owl is loaded in the tab or not. This is also indicated
+by the icon itself: if it is flipped upside-down, it means that owl is not loaded in the
+active tab. Do note that old versions of owl are not supported by the extension and will
+therefore be indicated either as obsolete or absent by the extension popup.
+
+<img src="screenshots/popup.png"/>
+
+## First steps
+
+When you are on a page where owl is detected, you can open your devtools either with
+right-click -> Inspect or using F12. In the devtools menu, you can search for the Owl
+tab which is added by the extension. It will be present by default at the end of the list but
+you can drag and drop it at the position you want for easier navigation in the future.
+
+<img src="screenshots/find_owl_tab.png"/>
+
+When you open the tab, you arrive on the Components view by default which is one of the
+two available tabs at the top. Here is an example of the devtools on the Odoo CRM app:
+
+<img src="screenshots/crm.png"/>
+
+## Components tab
+
+The components tab is separated into two sub windows: the components tree in the left and
+the component details in the right. The components tree will display all the different
+components that are present in the tab in the form of a tree. The root of this tree is
+actually the app which is not a component but can still be inspected by the devtools like
+one. There can also be multiple apps loaded in the page like in website:
+
+<img src="screenshots/multi_apps.png"/>
+
+There is a convenient search bar at the top of the components tree which will help finding
+the components tou want in the tree and also, an element picker can be used to directly select
+the component you want to focus on in the page which is especially useful when 1trying to find
+what you want. Just click on the elements picker icon and click on the element you want to focus
+on in the page and it will be selected in the devtools accordingly. Hovering any element in the
+page in this mode will highlight it and the same happens anytime in the components tree.
+
+<img src="screenshots/picker.png"/>
+
+In the tree itself, the navigation is quite simple and is similar to the one in the Elements tab
+of the browser's devtools. It is possible to navigate with the keyboard using the arrow keys and
+multiple shortcuts are available in a custom menu when right-clicking on a component. This menu
+allows to expand/fold all the children nodes of a component, fold its direct children only, inspect
+the source code of the component, send it as a global variable in the console, go to the Elements tab
+and focus on its content, force a rerender of the component, send its observed states to the console
+as a global variable, inspect its compiled template in the Sources tab or send its raw template
+to the console.
+
+<img src="screenshots/menu.png"/>
+
+The component details window in the right will show the component that is currently selected as well
+as its env, props, observed states and all the other variables that are present on its instance.
+While the props and the env are already present on the actual instance of the component and are
+pretty explicit by themselves, the observed state value is a bit more complicated to grasp.
+
+The observed state is actually information about which variables are being observed by the component:
+when any property of a reactive object is being read by the component, the component will subscribe
+to this property which means it will listen to any change that can occur on the property and render
+when such a change occurs. This can be visualized easily within the devtools inside of the observed
+state section: observed properties of the reactive object(s) are displayed in bold while the others
+are greyed out. Do keep in mind that a greyed out property in the observed state of one component
+may be observed by another and the other way around is also possible. Here is an example for some
+user Field component:
+
+<img src="screenshots/states.png"/>
+
+Navigation inside the properties is also similar to the one in console variables: properties have
+their prototype displayed and getters will get their value when clicked on (...). It is also possible to
+send any property to the console using the right-click context menu on it and functions can be inspected
+in the sources tab as well.
+
+<img src="screenshots/function_menu.png"/>
+
+There are several icons available to perform several of the actions described before in the components
+tree context menu and all these actions are also available by opening the menu by right-clicking on the
+component's name. Using the left click on the component's name will focus it in the components tree.
+
+It is also possible to edit any of the leaf node properties. To do so, you must double click on the
+property's value and modify it using the freshly created input then press enter to apply the changes.
+Do note that the modified values should be written in JSON format in order to be valid (examples:
+89, "yes", undefined, null, \["hello", 15\], {"a": 1}, true, ...). Editing any value will produce a
+manual render of the component (or the root component of the application in the case of env values).
+Whether the edition has an impact on the component or not and whether it produces an error is the
+responsability of the user.
+
+<img src="screenshots/edit.png"/>
+
+## Profiler
+
+The profiler tab is the other tab of the owl devtools. It consists in an actions bar at the top and
+a tree/list of events related to the owl components' renders. Here is an example of the events launched
+when entering the Odoo Crm app.
+
+<img src="screenshots/profiler.png"/>
+
+In the initial state, no event is displayed. You need to activate the recording of events before they
+are intercepted by the devtools using the record button.
+
+<img src="screenshots/record.png"/>
+
+The second button is used to clear all the events that have been recorded. The select can be used to
+switch between the tree view (which shows the causality between renders) and the events log view which
+simply displays the events in the exact order they were triggered. In this view, you can expand the create,
+update and destroy events which reveals the component that initiated the event. Also, a transition line will
+appear each time a new animation frame has been loaded between events.
+
+<img src="screenshots/events_log.png"/>
+
+The third button is only visible in tree view and allows to fold all the render events that were recorded.
+Some actions are also available when using the right-click on any event of the tree view for navigation
+purpose in a similar fashion as in the components tree.
+
+<img src="screenshots/tree_actions.png"/>
+
+There is also the Trace Renderings and Trace Subscriptions features. These features are independant of the
+recording of events and have no effect on the profiler tab. The Trace Renderings option is used to log in
+the console all the render events and allows to show their traceback information. Similarly, the Trace
+Subscriptions option logs all the properties that caused a render event and also allows to see the traceback
+of the modification.
+
+<img src="screenshots/trace_rendering.png"/>
+<img src="screenshots/trace_subscriptions.png"/>
+
+The Owl Devtools also allow to inspect iframes coded in Owl: when an Owl iframe is detected in the page,
+the iframe selector will appear next to the tabs. This allows to switch from an iframe to another easily.
+Be aware that switching iframes will clear all record events from the profiler tab. Iframes detection is
+currently not working in the firefox version, we are aware of this issue and will try to address it in the
+future.
+
+<img src="screenshots/iframes.png"/>
+
+## Options
+
+The owl devtools extension has a dark mode feature which defaults to your general devtools settings and can
+be toggled using the sun/moon icon at the top-right corner of the tab. There is also a refresh button to
+completely reset the owl devtools.
+
+<img src="screenshots/darkmode.png"/>
+
+## Troubleshooting
+
+If the feedback from the page to the devtools seems to be cut, you can first try to use the refresh
+button mentioned above but if it still doesn't seem to work, just close the devtools and refresh the page.
+This will eventually happen any time a tab stays opened for too long without being refreshed.

docs/assets/highlight.tomorrow.css

@@ -0,0 +1,72 @@
+/* http://jmblog.github.com/color-themes-for-google-code-highlightjs */
+
+/* Tomorrow Comment */
+.hljs-comment,
+.hljs-quote {
+  color: #8e908c;
+}
+
+/* Tomorrow Red */
+.hljs-variable,
+.hljs-template-variable,
+.hljs-tag,
+.hljs-name,
+.hljs-selector-id,
+.hljs-selector-class,
+.hljs-regexp,
+.hljs-deletion {
+  color: #c82829;
+}
+
+/* Tomorrow Orange */
+.hljs-number,
+.hljs-built_in,
+.hljs-builtin-name,
+.hljs-literal,
+.hljs-type,
+.hljs-params,
+.hljs-meta,
+.hljs-link {
+  color: #f5871f;
+}
+
+/* Tomorrow Yellow */
+.hljs-attribute {
+  color: #eab700;
+}
+
+/* Tomorrow Green */
+.hljs-string,
+.hljs-symbol,
+.hljs-bullet,
+.hljs-addition {
+  color: #718c00;
+}
+
+/* Tomorrow Blue */
+.hljs-title,
+.hljs-section {
+  color: #4271ae;
+}
+
+/* Tomorrow Purple */
+.hljs-keyword,
+.hljs-selector-tag {
+  color: #8959a8;
+}
+
+.hljs {
+  display: block;
+  overflow-x: auto;
+  background: white;
+  color: #4d4d4c;
+  padding: 0.5em;
+}
+
+.hljs-emphasis {
+  font-style: italic;
+}
+
+.hljs-strong {
+  font-weight: bold;
+}

docs/assets/main.css

@@ -0,0 +1,116 @@
+html, body {
+  background-color: #fefefe;
+  font-family: Roboto, -apple-system, BlinkMacSystemFont, "Segoe UI", Oxygen, Ubuntu, Cantarell, "Open Sans", "Helvetica Neue", sans-serif;
+  height: 100%;
+  margin: 0;
+  text-rendering: optimizeLegibility;
+}
+
+body {
+  display: grid;
+  grid-gap: 3rem;
+  grid-template-areas: "header" "nav" "main" "footer";
+  grid-template-columns: 1fr;
+  height: 100%;
+  grid-template-rows: 1fr 3rem 1fr 3rem;
+}
+
+@media screen and (max-width: 800px) {
+  body {
+    grid-template-rows: 1fr 3rem 1fr 5rem;
+  }
+}
+
+a {
+  color: #00A09D;
+  text-decoration: none;
+}
+
+a:hover, a:active, a:visited {
+  text-decoration: underline;
+}
+
+header {
+  grid-area: header;
+  display: flex;
+  align-items: center;
+  flex-direction: column;
+  justify-content: flex-end;
+  text-align: center;
+  padding-top: 3rem !important;
+}
+
+hgroup > p {
+  margin-bottom: auto;
+}
+
+nav {
+  grid-area: nav;
+}
+
+main {
+  grid-area: main;
+  /*justify-self: center;*/
+  grid-column: 1 / -1;
+  /*max-width: 80rem !important;*/
+  /*margin: 3rem 0;*/
+}
+
+footer {
+  grid-area: footer;
+  padding-bottom: 3rem !important;
+}
+
+header, nav, footer {
+  text-align: center;
+}
+
+article {
+  padding: 3rem 0;
+}
+
+article h3 {
+  font-size: 2rem;
+  font-weight: 700;
+}
+
+article.brand {
+  align-items: center;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  text-align: center;
+}
+
+article.design {
+  background-color: #875A7B;
+  color: #f0eeee;
+}
+
+header .homepage-logo {
+  margin-bottom: 2rem;
+}
+
+@media (min-width: 40rem) {
+  .row {
+    flex-direction: column;
+    margin-left: initial;
+    width: 100%;
+  }
+
+  .row .column {
+    margin-bottom: initial;
+    padding: initial;
+  }
+}
+@media (min-width: 60rem) {
+  .row {
+    flex-direction: row;
+    margin-left: -1.0rem;
+    width: calc(100% + 2.0rem);
+  }
+  .row .column {
+    margin-bottom: inherit;
+    padding: 0 1.0rem;
+  }
+}

docs/assets/milligram.css

@@ -0,0 +1,602 @@
+/*!
+ * Milligram v1.3.0
+ * https://milligram.github.io
+ *
+ * Copyright (c) 2017 CJ Patoilo
+ * Licensed under the MIT license
+ */
+
+*,
+*:after,
+*:before {
+  box-sizing: inherit;
+}
+
+html {
+  box-sizing: border-box;
+  font-size: 62.5%;
+}
+
+body {
+  color: #606c76;
+  font-family: 'Roboto', 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif;
+  font-size: 1.6em;
+  font-weight: 300;
+  letter-spacing: .01em;
+  line-height: 1.6;
+}
+
+blockquote {
+  border-left: 0.3rem solid #d1d1d1;
+  margin-left: 0;
+  margin-right: 0;
+  padding: 1rem 1.5rem;
+}
+
+blockquote *:last-child {
+  margin-bottom: 0;
+}
+
+.button,
+button,
+input[type='button'],
+input[type='reset'],
+input[type='submit'] {
+  background-color: #9b4dca;
+  border: 0.1rem solid #9b4dca;
+  border-radius: .4rem;
+  color: #fff;
+  cursor: pointer;
+  display: inline-block;
+  font-size: 1.1rem;
+  font-weight: 700;
+  height: 3.8rem;
+  letter-spacing: .1rem;
+  line-height: 3.8rem;
+  padding: 0 3.0rem;
+  text-align: center;
+  text-decoration: none;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+
+.button:focus, .button:hover,
+button:focus,
+button:hover,
+input[type='button']:focus,
+input[type='button']:hover,
+input[type='reset']:focus,
+input[type='reset']:hover,
+input[type='submit']:focus,
+input[type='submit']:hover {
+  background-color: #606c76;
+  border-color: #606c76;
+  color: #fff;
+  outline: 0;
+}
+
+.button[disabled],
+button[disabled],
+input[type='button'][disabled],
+input[type='reset'][disabled],
+input[type='submit'][disabled] {
+  cursor: default;
+  opacity: .5;
+}
+
+.button[disabled]:focus, .button[disabled]:hover,
+button[disabled]:focus,
+button[disabled]:hover,
+input[type='button'][disabled]:focus,
+input[type='button'][disabled]:hover,
+input[type='reset'][disabled]:focus,
+input[type='reset'][disabled]:hover,
+input[type='submit'][disabled]:focus,
+input[type='submit'][disabled]:hover {
+  background-color: #9b4dca;
+  border-color: #9b4dca;
+}
+
+.button.button-outline,
+button.button-outline,
+input[type='button'].button-outline,
+input[type='reset'].button-outline,
+input[type='submit'].button-outline {
+  background-color: transparent;
+  color: #9b4dca;
+}
+
+.button.button-outline:focus, .button.button-outline:hover,
+button.button-outline:focus,
+button.button-outline:hover,
+input[type='button'].button-outline:focus,
+input[type='button'].button-outline:hover,
+input[type='reset'].button-outline:focus,
+input[type='reset'].button-outline:hover,
+input[type='submit'].button-outline:focus,
+input[type='submit'].button-outline:hover {
+  background-color: transparent;
+  border-color: #606c76;
+  color: #606c76;
+}
+
+.button.button-outline[disabled]:focus, .button.button-outline[disabled]:hover,
+button.button-outline[disabled]:focus,
+button.button-outline[disabled]:hover,
+input[type='button'].button-outline[disabled]:focus,
+input[type='button'].button-outline[disabled]:hover,
+input[type='reset'].button-outline[disabled]:focus,
+input[type='reset'].button-outline[disabled]:hover,
+input[type='submit'].button-outline[disabled]:focus,
+input[type='submit'].button-outline[disabled]:hover {
+  border-color: inherit;
+  color: #9b4dca;
+}
+
+.button.button-clear,
+button.button-clear,
+input[type='button'].button-clear,
+input[type='reset'].button-clear,
+input[type='submit'].button-clear {
+  background-color: transparent;
+  border-color: transparent;
+  color: #9b4dca;
+}
+
+.button.button-clear:focus, .button.button-clear:hover,
+button.button-clear:focus,
+button.button-clear:hover,
+input[type='button'].button-clear:focus,
+input[type='button'].button-clear:hover,
+input[type='reset'].button-clear:focus,
+input[type='reset'].button-clear:hover,
+input[type='submit'].button-clear:focus,
+input[type='submit'].button-clear:hover {
+  background-color: transparent;
+  border-color: transparent;
+  color: #606c76;
+}
+
+.button.button-clear[disabled]:focus, .button.button-clear[disabled]:hover,
+button.button-clear[disabled]:focus,
+button.button-clear[disabled]:hover,
+input[type='button'].button-clear[disabled]:focus,
+input[type='button'].button-clear[disabled]:hover,
+input[type='reset'].button-clear[disabled]:focus,
+input[type='reset'].button-clear[disabled]:hover,
+input[type='submit'].button-clear[disabled]:focus,
+input[type='submit'].button-clear[disabled]:hover {
+  color: #9b4dca;
+}
+
+code {
+  background: #f4f5f6;
+  border-radius: .4rem;
+  font-size: 86%;
+  margin: 0 .2rem;
+  padding: .2rem .5rem;
+  white-space: nowrap;
+}
+
+pre {
+  background: #f4f5f6;
+  border-left: 0.3rem solid #9b4dca;
+  overflow-y: hidden;
+}
+
+pre > code {
+  border-radius: 0;
+  display: block;
+  padding: 1rem 1.5rem;
+  white-space: pre;
+}
+
+hr {
+  border: 0;
+  border-top: 0.1rem solid #f4f5f6;
+  margin: 3.0rem 0;
+}
+
+input[type='email'],
+input[type='number'],
+input[type='password'],
+input[type='search'],
+input[type='tel'],
+input[type='text'],
+input[type='url'],
+textarea,
+select {
+  -webkit-appearance: none;
+     -moz-appearance: none;
+          appearance: none;
+  background-color: transparent;
+  border: 0.1rem solid #d1d1d1;
+  border-radius: .4rem;
+  box-shadow: none;
+  box-sizing: inherit;
+  height: 3.8rem;
+  padding: .6rem 1.0rem;
+  width: 100%;
+}
+
+input[type='email']:focus,
+input[type='number']:focus,
+input[type='password']:focus,
+input[type='search']:focus,
+input[type='tel']:focus,
+input[type='text']:focus,
+input[type='url']:focus,
+textarea:focus,
+select:focus {
+  border-color: #9b4dca;
+  outline: 0;
+}
+
+select {
+  background: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" height="14" viewBox="0 0 29 14" width="29"><path fill="#d1d1d1" d="M9.37727 3.625l5.08154 6.93523L19.54036 3.625"/></svg>') center right no-repeat;
+  padding-right: 3.0rem;
+}
+
+select:focus {
+  background-image: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" height="14" viewBox="0 0 29 14" width="29"><path fill="#9b4dca" d="M9.37727 3.625l5.08154 6.93523L19.54036 3.625"/></svg>');
+}
+
+textarea {
+  min-height: 6.5rem;
+}
+
+label,
+legend {
+  display: block;
+  font-size: 1.6rem;
+  font-weight: 700;
+  margin-bottom: .5rem;
+}
+
+fieldset {
+  border-width: 0;
+  padding: 0;
+}
+
+input[type='checkbox'],
+input[type='radio'] {
+  display: inline;
+}
+
+.label-inline {
+  display: inline-block;
+  font-weight: normal;
+  margin-left: .5rem;
+}
+
+.container {
+  margin: 0 auto;
+  max-width: 112.0rem;
+  padding: 0 2.0rem;
+  position: relative;
+  width: 100%;
+}
+
+.row {
+  display: flex;
+  flex-direction: column;
+  padding: 0;
+  width: 100%;
+}
+
+.row.row-no-padding {
+  padding: 0;
+}
+
+.row.row-no-padding > .column {
+  padding: 0;
+}
+
+.row.row-wrap {
+  flex-wrap: wrap;
+}
+
+.row.row-top {
+  align-items: flex-start;
+}
+
+.row.row-bottom {
+  align-items: flex-end;
+}
+
+.row.row-center {
+  align-items: center;
+}
+
+.row.row-stretch {
+  align-items: stretch;
+}
+
+.row.row-baseline {
+  align-items: baseline;
+}
+
+.row .column {
+  display: block;
+  flex: 1 1 auto;
+  margin-left: 0;
+  max-width: 100%;
+  width: 100%;
+}
+
+.row .column.column-offset-10 {
+  margin-left: 10%;
+}
+
+.row .column.column-offset-20 {
+  margin-left: 20%;
+}
+
+.row .column.column-offset-25 {
+  margin-left: 25%;
+}
+
+.row .column.column-offset-33, .row .column.column-offset-34 {
+  margin-left: 33.3333%;
+}
+
+.row .column.column-offset-50 {
+  margin-left: 50%;
+}
+
+.row .column.column-offset-66, .row .column.column-offset-67 {
+  margin-left: 66.6666%;
+}
+
+.row .column.column-offset-75 {
+  margin-left: 75%;
+}
+
+.row .column.column-offset-80 {
+  margin-left: 80%;
+}
+
+.row .column.column-offset-90 {
+  margin-left: 90%;
+}
+
+.row .column.column-10 {
+  flex: 0 0 10%;
+  max-width: 10%;
+}
+
+.row .column.column-20 {
+  flex: 0 0 20%;
+  max-width: 20%;
+}
+
+.row .column.column-25 {
+  flex: 0 0 25%;
+  max-width: 25%;
+}
+
+.row .column.column-33, .row .column.column-34 {
+  flex: 0 0 33.3333%;
+  max-width: 33.3333%;
+}
+
+.row .column.column-40 {
+  flex: 0 0 40%;
+  max-width: 40%;
+}
+
+.row .column.column-50 {
+  flex: 0 0 50%;
+  max-width: 50%;
+}
+
+.row .column.column-60 {
+  flex: 0 0 60%;
+  max-width: 60%;
+}
+
+.row .column.column-66, .row .column.column-67 {
+  flex: 0 0 66.6666%;
+  max-width: 66.6666%;
+}
+
+.row .column.column-75 {
+  flex: 0 0 75%;
+  max-width: 75%;
+}
+
+.row .column.column-80 {
+  flex: 0 0 80%;
+  max-width: 80%;
+}
+
+.row .column.column-90 {
+  flex: 0 0 90%;
+  max-width: 90%;
+}
+
+.row .column .column-top {
+  align-self: flex-start;
+}
+
+.row .column .column-bottom {
+  align-self: flex-end;
+}
+
+.row .column .column-center {
+  -ms-grid-row-align: center;
+      align-self: center;
+}
+
+@media (min-width: 40rem) {
+  .row {
+    flex-direction: row;
+    margin-left: -1.0rem;
+    width: calc(100% + 2.0rem);
+  }
+  .row .column {
+    margin-bottom: inherit;
+    padding: 0 1.0rem;
+  }
+}
+
+a {
+  color: #9b4dca;
+  text-decoration: none;
+}
+
+a:focus, a:hover {
+  color: #606c76;
+}
+
+dl,
+ol,
+ul {
+  list-style: none;
+  margin-top: 0;
+  padding-left: 0;
+}
+
+dl dl,
+dl ol,
+dl ul,
+ol dl,
+ol ol,
+ol ul,
+ul dl,
+ul ol,
+ul ul {
+  font-size: 90%;
+  margin: 1.5rem 0 1.5rem 3.0rem;
+}
+
+ol {
+  list-style: decimal inside;
+}
+
+ul {
+  list-style: circle inside;
+}
+
+.button,
+button,
+dd,
+dt,
+li {
+  margin-bottom: 1.0rem;
+}
+
+fieldset,
+input,
+select,
+textarea {
+  margin-bottom: 1.5rem;
+}
+
+blockquote,
+dl,
+figure,
+form,
+ol,
+p,
+pre,
+table,
+ul {
+  margin-bottom: 2.5rem;
+}
+
+table {
+  border-spacing: 0;
+  width: 100%;
+}
+
+td,
+th {
+  border-bottom: 0.1rem solid #e1e1e1;
+  padding: 1.2rem 1.5rem;
+  text-align: left;
+}
+
+td:first-child,
+th:first-child {
+  padding-left: 0;
+}
+
+td:last-child,
+th:last-child {
+  padding-right: 0;
+}
+
+b,
+strong {
+  font-weight: bold;
+}
+
+p {
+  margin-top: 0;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  font-weight: 300;
+  letter-spacing: -.1rem;
+  margin-bottom: 2.0rem;
+  margin-top: 0;
+}
+
+h1 {
+  font-size: 4.6rem;
+  line-height: 1.2;
+}
+
+h2 {
+  font-size: 3.6rem;
+  line-height: 1.25;
+}
+
+h3 {
+  font-size: 2.8rem;
+  line-height: 1.3;
+}
+
+h4 {
+  font-size: 2.2rem;
+  letter-spacing: -.08rem;
+  line-height: 1.35;
+}
+
+h5 {
+  font-size: 1.8rem;
+  letter-spacing: -.05rem;
+  line-height: 1.5;
+}
+
+h6 {
+  font-size: 1.6rem;
+  letter-spacing: 0;
+  line-height: 1.4;
+}
+
+img {
+  max-width: 100%;
+}
+
+.clearfix:after {
+  clear: both;
+  content: ' ';
+  display: table;
+}
+
+.float-left {
+  float: left;
+}
+
+.float-right {
+  float: right;
+}
+
+/*# sourceMappingURL=milligram.css.map */

docs/assets/normalize.css

@@ -0,0 +1,349 @@
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
+
+/* Document
+   ========================================================================== */
+
+/**
+ * 1. Correct the line height in all browsers.
+ * 2. Prevent adjustments of font size after orientation changes in iOS.
+ */
+
+html {
+  line-height: 1.15; /* 1 */
+  -webkit-text-size-adjust: 100%; /* 2 */
+}
+
+/* Sections
+   ========================================================================== */
+
+/**
+ * Remove the margin in all browsers.
+ */
+
+body {
+  margin: 0;
+}
+
+/**
+ * Render the `main` element consistently in IE.
+ */
+
+main {
+  display: block;
+}
+
+/**
+ * Correct the font size and margin on `h1` elements within `section` and
+ * `article` contexts in Chrome, Firefox, and Safari.
+ */
+
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/* Grouping content
+   ========================================================================== */
+
+/**
+ * 1. Add the correct box sizing in Firefox.
+ * 2. Show the overflow in Edge and IE.
+ */
+
+hr {
+  box-sizing: content-box; /* 1 */
+  height: 0; /* 1 */
+  overflow: visible; /* 2 */
+}
+
+/**
+ * 1. Correct the inheritance and scaling of font size in all browsers.
+ * 2. Correct the odd `em` font sizing in all browsers.
+ */
+
+pre {
+  font-family: monospace, monospace; /* 1 */
+  font-size: 1em; /* 2 */
+}
+
+/* Text-level semantics
+   ========================================================================== */
+
+/**
+ * Remove the gray background on active links in IE 10.
+ */
+
+a {
+  background-color: transparent;
+}
+
+/**
+ * 1. Remove the bottom border in Chrome 57-
+ * 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+ */
+
+abbr[title] {
+  border-bottom: none; /* 1 */
+  text-decoration: underline; /* 2 */
+  text-decoration: underline dotted; /* 2 */
+}
+
+/**
+ * Add the correct font weight in Chrome, Edge, and Safari.
+ */
+
+b,
+strong {
+  font-weight: bolder;
+}
+
+/**
+ * 1. Correct the inheritance and scaling of font size in all browsers.
+ * 2. Correct the odd `em` font sizing in all browsers.
+ */
+
+code,
+kbd,
+samp {
+  font-family: monospace, monospace; /* 1 */
+  font-size: 1em; /* 2 */
+}
+
+/**
+ * Add the correct font size in all browsers.
+ */
+
+small {
+  font-size: 80%;
+}
+
+/**
+ * Prevent `sub` and `sup` elements from affecting the line height in
+ * all browsers.
+ */
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+sup {
+  top: -0.5em;
+}
+
+/* Embedded content
+   ========================================================================== */
+
+/**
+ * Remove the border on images inside links in IE 10.
+ */
+
+img {
+  border-style: none;
+}
+
+/* Forms
+   ========================================================================== */
+
+/**
+ * 1. Change the font styles in all browsers.
+ * 2. Remove the margin in Firefox and Safari.
+ */
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  font-family: inherit; /* 1 */
+  font-size: 100%; /* 1 */
+  line-height: 1.15; /* 1 */
+  margin: 0; /* 2 */
+}
+
+/**
+ * Show the overflow in IE.
+ * 1. Show the overflow in Edge.
+ */
+
+button,
+input { /* 1 */
+  overflow: visible;
+}
+
+/**
+ * Remove the inheritance of text transform in Edge, Firefox, and IE.
+ * 1. Remove the inheritance of text transform in Firefox.
+ */
+
+button,
+select { /* 1 */
+  text-transform: none;
+}
+
+/**
+ * Correct the inability to style clickable types in iOS and Safari.
+ */
+
+button,
+[type="button"],
+[type="reset"],
+[type="submit"] {
+  -webkit-appearance: button;
+}
+
+/**
+ * Remove the inner border and padding in Firefox.
+ */
+
+button::-moz-focus-inner,
+[type="button"]::-moz-focus-inner,
+[type="reset"]::-moz-focus-inner,
+[type="submit"]::-moz-focus-inner {
+  border-style: none;
+  padding: 0;
+}
+
+/**
+ * Restore the focus styles unset by the previous rule.
+ */
+
+button:-moz-focusring,
+[type="button"]:-moz-focusring,
+[type="reset"]:-moz-focusring,
+[type="submit"]:-moz-focusring {
+  outline: 1px dotted ButtonText;
+}
+
+/**
+ * Correct the padding in Firefox.
+ */
+
+fieldset {
+  padding: 0.35em 0.75em 0.625em;
+}
+
+/**
+ * 1. Correct the text wrapping in Edge and IE.
+ * 2. Correct the color inheritance from `fieldset` elements in IE.
+ * 3. Remove the padding so developers are not caught out when they zero out
+ *    `fieldset` elements in all browsers.
+ */
+
+legend {
+  box-sizing: border-box; /* 1 */
+  color: inherit; /* 2 */
+  display: table; /* 1 */
+  max-width: 100%; /* 1 */
+  padding: 0; /* 3 */
+  white-space: normal; /* 1 */
+}
+
+/**
+ * Add the correct vertical alignment in Chrome, Firefox, and Opera.
+ */
+
+progress {
+  vertical-align: baseline;
+}
+
+/**
+ * Remove the default vertical scrollbar in IE 10+.
+ */
+
+textarea {
+  overflow: auto;
+}
+
+/**
+ * 1. Add the correct box sizing in IE 10.
+ * 2. Remove the padding in IE 10.
+ */
+
+[type="checkbox"],
+[type="radio"] {
+  box-sizing: border-box; /* 1 */
+  padding: 0; /* 2 */
+}
+
+/**
+ * Correct the cursor style of increment and decrement buttons in Chrome.
+ */
+
+[type="number"]::-webkit-inner-spin-button,
+[type="number"]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+ * 1. Correct the odd appearance in Chrome and Safari.
+ * 2. Correct the outline style in Safari.
+ */
+
+[type="search"] {
+  -webkit-appearance: textfield; /* 1 */
+  outline-offset: -2px; /* 2 */
+}
+
+/**
+ * Remove the inner padding in Chrome and Safari on macOS.
+ */
+
+[type="search"]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+ * 1. Correct the inability to style clickable types in iOS and Safari.
+ * 2. Change font properties to `inherit` in Safari.
+ */
+
+::-webkit-file-upload-button {
+  -webkit-appearance: button; /* 1 */
+  font: inherit; /* 2 */
+}
+
+/* Interactive
+   ========================================================================== */
+
+/*
+ * Add the correct display in Edge, IE 10+, and Firefox.
+ */
+
+details {
+  display: block;
+}
+
+/*
+ * Add the correct display in all browsers.
+ */
+
+summary {
+  display: list-item;
+}
+
+/* Misc
+   ========================================================================== */
+
+/**
+ * Add the correct display in IE 10+.
+ */
+
+template {
+  display: none;
+}
+
+/**
+ * Add the correct display in IE 10.
+ */
+
+[hidden] {
+  display: none;
+}

docs/counter.js

@@ -0,0 +1,15 @@
+import { mount, Component, useState, loadFile } from "@odoo/owl";
+
+class Counter extends Component {
+  static template = "Counter";
+  setup() {
+    this.state = useState({ value: 0 });
+  }
+
+  increment() {
+    this.state.value++;
+  }
+}
+const templates = await loadFile("./counter.xml");
+
+mount(Counter, document.getElementById("app-container"), { templates });

docs/counter.xml

@@ -0,0 +1,7 @@
+<templates>
+  <t t-name="Counter">
+    <button t-on-click="increment">
+      Click Me! [<t t-esc="state.value"/>]
+    </button>
+  </t>
+</templates>

docs/display_code.js

@@ -0,0 +1,9 @@
+import { loadFile } from "@odoo/owl";
+
+for (const [className, type] of [["xml", "xml"], ["javascript", "js"]]) {
+    loadFile(`./counter.${type}`).then(code => {
+        const el = document.querySelector(`code.${className}`);
+        el.textContent = code;
+        hljs.highlightBlock(el);
+    })
+}

docs/index.html

@@ -0,0 +1,74 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>OWL Framework</title>
+  <link rel="icon" href="data:,">
+  <link rel="stylesheet" href="//fonts.googleapis.com/css?family=Roboto:300,300italic,700,700italic">
+  <link rel="stylesheet" href="assets/normalize.css">
+  <link rel="stylesheet" href="assets/milligram.css">
+  <link rel="stylesheet" href="assets/highlight.tomorrow.css">
+  <link rel="stylesheet" href="assets/main.css">
+  <script type="importmap">{ "imports": { "@odoo/owl": "./owl.js" } }</script>
+</head>
+<body>
+  <header class="container">
+    <img class="homepage-logo" src="assets/owl_1f989.png" alt="OWL Logo">
+    <hgroup>
+      <h1>OWL Framework</h1>
+      <p>Mysterious OWL: A web framework for structured, dynamic and maintainable applications</p>
+    </hgroup>
+  </header>
+  <nav class="container">
+    <p>
+      <a href="https://github.com/odoo/owl" title="https://github.com/odoo/owl">Github</a>
+      &bull;
+      <a href="https://github.com/odoo/owl/blob/master/doc/readme.md">Documentation</a>
+      &bull;
+      <a href="playground/">Playground</a>
+    </p>
+  </nav>
+  <main>
+    <article class="design">
+      <div class="container">
+        <h2>Why OWL?</h2>
+        <div class="row">
+          <section class="column">
+            <h3>XML based</h3>
+            <p>Templates are based on the XML format, which allows interesting applications. For example, they could be stored in a database and modified dynamically with <tt>xpaths</tt>.</p>
+          </section>
+          <section class="column">
+            <h3>Templates compiled in the browser</h3>
+            <p>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.</p>
+          </section>
+          <section class="column">
+            <h3>No toolchain required</h3>
+            <p>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 <tt>npm</tt>.</p>
+          </section>
+        </div>
+      </div>
+    </article>
+    <article class="example">
+      <div class="container">
+        <h2>Example</h2>
+        <div class="row">
+          <section class="column">
+            <pre><code class="javascript"></code></pre>
+          </section>
+          <section class="column">
+            <pre><code class="xml"></code></pre>
+            <div id="app-container"></div>
+          </section>
+        </div>
+      </div>
+    </article>
+  </main>
+  <footer>
+    <p><a href=".">OWL</a> is licensed under LGPLv3.<br>Logo from <a href="https://github.com/googlefonts/noto-emoji">Google Noto Emoji Font</a>, licensed under Apache License 2.0</p>
+  </footer>
+  <script src="assets/highlight.pack.js"></script>
+  <script type="module" src="display_code.js"></script>
+  <script type="module" src="counter.js"></script>
+</body>
+</html>

docs/playground/index.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <title>OWL Playground</title>
+    <link rel="icon" href="data:,">
+
+    <script src="libs/ace.js" type="text/javascript" charset="utf-8"></script>
+    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.1/css/solid.css" integrity="sha384-QokYePQSOwpBDuhlHOsX0ymF6R/vLk/UQVz3WHa6wygxI5oGTmDTv8wahFOSspdm" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.8.1/css/fontawesome.css" integrity="sha384-vd1e11sR28tEK9YANUtpIOdjGW14pS87bUBuOIoBILVWLFnS+MCX9T6MMf0VdPGq" crossorigin="anonymous">
+    
+    <!-- Application JS/CSS -->
+    <link rel="stylesheet" href="playground.css">
+    <script type="module" src="playground.js"></script>
+  </head>
+  <body>
+  </body>
+</html>

docs/playground/playground.css

@@ -20,7 +20,7 @@ body {
   display: grid;
   height: 100%;
   width: 100%;
-  grid-template-columns: auto 8px 100%;
+  grid-template-columns: auto 8px 1fr;
 }
 
 /* LEFT BAR ****************************************/
@@ -79,6 +79,19 @@ body {
   margin: 5px;
 }
 
+.share-code {
+  position: relative;
+}
+
+.copied-notification {
+  font-size: x-small;
+  position: absolute;
+  bottom: -5px;
+  white-space: nowrap;
+  left: 50%;
+  transform: translateX(-50%);
+}
+
 /* TABBED EDITOR ****************************************/
 
 .tabbed-editor {

docs/playground/playground.js

@@ -0,0 +1,404 @@
+import { debounce, loadJS } from "./utils.js";
+import {
+  App,
+  Component,
+  useState,
+  useRef,
+  onMounted,
+  onWillUnmount,
+  onPatched,
+  onWillUpdateProps,
+  loadFile as _loadFile,
+  whenReady,
+  __info__,
+  useEffect,
+  onWillStart,
+} from "../owl.js";
+
+//------------------------------------------------------------------------------
+// Constants, helpers, utils
+//------------------------------------------------------------------------------
+
+const MODES = {
+  js: "ace/mode/javascript",
+  css: "ace/mode/css",
+  xml: "ace/mode/xml"
+};
+
+const DEFAULT_XML = `<templates>
+</templates>`;
+
+// Memoize loadFile so that samples aren't reloaded whenever a sample is selected
+const fileCache = {};
+const loadFile = (path) => {
+  if (!(path in fileCache)) {
+    fileCache[path] = _loadFile(path);
+  }
+  return fileCache[path];
+}
+
+/**
+ * Make an iframe, with all the js, css and xml properly injected.
+ */
+function makeCodeIframe(js, css, xml) {
+  // escape backticks in the xml so they don't close the template string
+  const escapedXml = xml.replace(/`/g, '\\\`');
+
+  const iframe = document.createElement("iframe");
+  iframe.onload = () => {
+    const doc = iframe.contentDocument;
+
+    const importMap = doc.createElement("script");
+    importMap.type = "importmap";
+    importMap.textContent = `{ "imports": { "@odoo/owl": "../owl.js" } }`;
+    doc.head.appendChild(importMap);
+
+    const script = doc.createElement("script");
+    script.type = "module";
+    script.textContent = `const TEMPLATES = \`${escapedXml}\`\n${js}`;
+    doc.body.appendChild(script);
+
+    const style = document.createElement("style");
+    style.innerText = css;
+    doc.head.appendChild(style);
+  };
+  return iframe;
+}
+
+//------------------------------------------------------------------------------
+// SAMPLES
+//------------------------------------------------------------------------------
+
+const SAMPLES = [
+  {
+    description: "Components",
+    folder: "components",
+    code: ["js", "xml", "css"],
+  },
+  {
+    description: "Form Input Bindings",
+    folder: "form",
+    code: ["js", "xml"],
+  },
+  {
+    description: "Inline templates",
+    folder: "single_file_component",
+    code: ["js"],
+  },
+  {
+    description: "Lifecycle demo",
+    folder: "lifecycle_demo",
+    code: ["js", "xml", "css"],
+  },
+  {
+    description: "Customized hook",
+    folder: "custom_hooks",
+    code: ["js", "xml", "css"],
+  },
+  {
+    description: "Todo List App (with reactivity)",
+    folder: "todo_app",
+    code: ["js", "xml", "css"],
+  },
+  {
+    description: "Responsive app",
+    folder: "responsive_app",
+    code: ["js", "xml", "css"],
+  },
+  {
+    description: "Slots And Generic Components",
+    folder: "slots",
+    code: ["js", "xml", "css"],
+  },
+  {
+    description: "Window Management System",
+    folder: "window_manager",
+    code: ["js", "xml", "css"],
+  },
+  {
+    description: "Benchmark example",
+    folder: "benchmark",
+    code: ["js", "xml", "css"],
+  },
+]
+
+function loadSamples() {
+  const result = SAMPLES.map(({ description, folder, code }) => ({
+    description,
+    code: async () => Object.fromEntries(
+      await Promise.all(
+        code.map(async (type) => [type, await loadFile(`./samples/${folder}/${folder}.${type}`)])
+      )
+    ),
+  }));
+  const localSample = localStorage.getItem("owl-playground-local-sample");
+  if (localSample) {
+    const { js, css, xml } = JSON.parse(localSample);
+    result.unshift({
+      description: "Local Storage Code",
+      code: () => Promise.resolve({ js, xml, css }),
+    });
+  }
+  return result;
+}
+
+//------------------------------------------------------------------------------
+// Tabbed editor
+//------------------------------------------------------------------------------
+class TabbedEditor extends Component {
+  setup() {
+    const props = this.props;
+    this.state = useState({
+      currentTab: props.js !== false ? "js" : props.xml ? "xml" : "css"
+    });
+    this.setTab = debounce(this.setTab.bind(this), 250, true);
+
+    this.sessions = {};
+    this._setupSessions(props);
+    this.editorNode = useRef("editor");
+    this._updateCode = this._updateCode.bind(this);
+
+    onMounted(() => {
+      this.editor = this.editor || ace.edit(this.editorNode.el);
+
+      this.editor.setValue(this.props[this.state.currentTab], -1);
+      this.editor.setFontSize("12px");
+      this.editor.setTheme("ace/theme/monokai");
+      this.editor.setSession(this.sessions[this.state.currentTab]);
+      const tabSize = this.state.currentTab === "xml" ? 2 : 4;
+      this.editor.session.setOption("tabSize", tabSize);
+      this.editor.on("blur", this._updateCode);
+      this.interval = setInterval(this._updateCode, 3000);
+    });
+
+    onPatched(() => {
+      const session = this.sessions[this.state.currentTab];
+      let content = this.props[this.state.currentTab];
+      if (content === false) {
+        const tab = this.props.js !== false ? "js" : this.props.xml ? "xml" : "css";
+        content = this.props[tab];
+        this.state.currentTab = tab;
+      }
+      if (this.editor.getValue() !== content) {
+        session.setValue(content, -1);
+        this.editor.setSession(session);
+        this.editor.resize();
+      }
+    });
+
+    onWillUpdateProps((nextProps) => this._setupSessions(nextProps));
+
+    onWillUnmount(() => {
+      clearInterval(this.interval);
+      this.editor.off("blur", this._updateCode);
+    });
+  }
+
+  setTab(tab) {
+    if (this.state.currentTab !== tab) {
+      this.state.currentTab = tab;
+      const session = this.sessions[this.state.currentTab];
+      session.doc.setValue(this.props[tab], -1);
+      this.editor.setSession(session);
+    }
+  }
+
+  onMouseDown(ev) {
+    if (ev.target.tagName === "DIV") {
+      let y = ev.clientY;
+      const resizer = ev => {
+        const delta = ev.clientY - y;
+        y = ev.clientY;
+        this.props.updatePanelHeight({ delta });
+      };
+      document.body.addEventListener("mousemove", resizer);
+      document.body.addEventListener("mouseup", () => {
+        document.body.removeEventListener("mousemove", resizer);
+      });
+    }
+  }
+
+  _setupSessions(props) {
+    for (let tab of ["js", "xml", "css"]) {
+      if (props[tab] !== false && !this.sessions[tab]) {
+        this.sessions[tab] = new ace.EditSession(props[tab], MODES[tab]);
+        this.sessions[tab].setOption("useWorker", false);
+        const tabSize = tab === "xml" ? 2 : 4;
+        this.sessions[tab].setOption("tabSize", tabSize);
+        this.sessions[tab].setUndoManager(new ace.UndoManager());
+      }
+    }
+  }
+
+  _updateCode() {
+    const editorValue = this.editor.getValue();
+    const propsValue = this.props[this.state.currentTab];
+    if (editorValue !== propsValue) {
+      this.props.updateCode({
+        type: this.state.currentTab,
+        value: editorValue
+      });
+    }
+  }
+}
+TabbedEditor.template = "TabbedEditor";
+
+//------------------------------------------------------------------------------
+// MAIN APP
+//------------------------------------------------------------------------------
+class Playground extends Component {
+  static template = "Playground";
+  static components = { TabbedEditor };
+  setup() {
+    this.version = __info__.version;
+
+    this.isDirty = false;
+    this.state = useState({
+      js: "",
+      css: "",
+      xml: DEFAULT_XML,
+      displayWelcome: true,
+      splitLayout: true,
+      leftPaneWidth: Math.ceil(window.innerWidth / 2),
+      topPanelHeight: null
+    });
+
+    this.samples = loadSamples();
+    if (window.location.hash) {
+      try {
+        const { js, css, xml } = JSON.parse(atob(decodeURIComponent(window.location.hash.slice(1))));
+        if ([js, css, xml].every(item => typeof item === "string")) {
+          Object.assign(this.state, { js, css, xml });
+        }
+      } catch {}
+    }
+    onWillStart(async () => {
+      if (!this.state.js) {
+        this.setSample(await this.samples[0].code());
+      }
+    })
+    useEffect(() => {
+      const interval = setInterval(() => {
+        if (this.isDirty) {
+          const { js, css, xml } = this.state;
+          const str = JSON.stringify({ js, css, xml });
+          localStorage.setItem("owl-playground-local-sample", str);
+        }
+      }, 1000);
+      return () => clearInterval(interval);
+    }, () => []);
+
+    this.toggleLayout = debounce(this.toggleLayout, 250, true);
+    this.runCode = debounce(this.runCode, 250, true);
+    this.exportStandaloneApp = debounce(this.exportStandaloneApp, 250, true);
+    this.content = useRef("content");
+    this.updateCode = this.updateCode.bind(this);
+  }
+
+  runCode() {
+    this.content.el.innerHTML = "";
+    this.state.displayWelcome = false;
+
+    const { js, css, xml } = this.state;
+    const subiframe = makeCodeIframe(js, css, xml);
+    this.content.el.appendChild(subiframe);
+  }
+
+  shareCode() {
+    const state = btoa(JSON.stringify({ js: this.state.js, css: this.state.css, xml: this.state.xml }));
+    const link = new URL(window.location.href);
+    link.hash = state;
+    if (navigator.clipboard) {
+      navigator.clipboard.writeText(link.href);
+      clearTimeout(this.state.copied)
+      this.state.copied = setTimeout(() => this.state.copied = null, 2000);
+    }
+    window.location.href = link.href;
+  }
+
+  setSample(sample) {
+    this.state.js = sample.js;
+    this.state.css = sample.css || "";
+    this.state.xml = sample.xml || DEFAULT_XML;
+    localStorage.removeItem("owl-playground-local-sample");
+    this.isDirty = false;
+  }
+
+  get leftPaneStyle() {
+    return `width:${this.state.leftPaneWidth}px`;
+  }
+
+  get topEditorStyle() {
+    return `flex: 0 0 ${this.state.topPanelHeight}px`;
+  }
+
+  async onSampleChange(ev) {
+    this.setSample(await this.samples.find(s => s.description === ev.target.value).code());
+  }
+
+  onMouseDown() {
+    const resizer = ev => {
+      this.state.leftPaneWidth = ev.clientX;
+    };
+
+    document.body.addEventListener("mousemove", resizer);
+    for (let iframe of document.getElementsByTagName("iframe")) {
+      iframe.classList.add("disabled");
+    }
+
+    document.body.addEventListener("mouseup", () => {
+      document.body.removeEventListener("mousemove", resizer);
+      for (let iframe of document.getElementsByTagName("iframe")) {
+        iframe.classList.remove("disabled");
+      }
+    });
+  }
+  updateCode({type, value}) {
+    if (this.state[type] !== value) {
+      this.state[type] = value;
+      this.isDirty = true;
+    }
+  }
+  toggleLayout() {
+    this.state.splitLayout = !this.state.splitLayout;
+  }
+  updatePanelHeight({ delta }) {
+    let height = this.state.topPanelHeight || document.querySelector(".tabbed-editor").clientHeight;
+    this.state.topPanelHeight = height + delta;
+  }
+
+  async exportStandaloneApp() {
+    const { js, css, xml } = this.state;
+
+    await loadJS("libs/jszip.min.js");
+    const zip = new JSZip();
+    zip.file("app.py", await loadFile("./standalone_app/app.py"));
+    zip.file("index.html", await loadFile("./standalone_app/index.html"));
+    zip.file("owl.js", await loadFile("../owl.js"));
+    zip.file("app.js", `const TEMPLATES = await (await fetch('app.xml')).text();\n${js}`);
+    zip.file("app.css", css);
+    zip.file("app.xml", xml);
+
+    await loadJS("libs/FileSaver.min.js");
+    saveAs(await zip.generateAsync({ type: "blob" }), "app.zip");
+  }
+}
+
+//------------------------------------------------------------------------------
+// Application initialization
+//------------------------------------------------------------------------------
+async function start() {
+  document.title = `${document.title} (v${__info__.version})`;
+  const commit = `https://github.com/odoo/owl/commit/${__info__.hash}`;
+  console.info(`This application is using Owl built with the following commit:`, commit);
+  const [templates] = await Promise.all([
+    loadFile("templates.xml"),
+    whenReady()
+  ]);
+  const rootApp = new App(Playground, { name: "Owl Playground" });
+  rootApp.addTemplates(templates);
+
+  await  rootApp.mount(document.body);
+}
+
+start();

docs/playground/samples/benchmark/benchmark.css

@@ -0,0 +1,11 @@
+tr.danger {
+  font-weight: bold;
+}
+
+.remove:hover {
+  font-weight: bold;
+}
+.remove {
+  cursor: pointer;
+}
+  

docs/playground/samples/benchmark/benchmark.js

@@ -0,0 +1,124 @@
+import { Component, mount, useState, onPatched} from "@odoo/owl";
+
+// -----------------------------------------------------------------------------
+// Data generation
+// -----------------------------------------------------------------------------
+
+let idCounter = 1;
+const adjectives = [
+    "pretty", "large", "big", "small", "tall", "short", "long", "handsome", "plain",
+    "quaint", "clean", "elegant", "easy", "angry", "crazy", "helpful", "mushy", "odd",
+    "unsightly", "adorable", "important", "inexpensive", "cheap", "expensive", "fancy"];
+const colours = ["red", "yellow", "blue", "green", "pink", "brown", "purple", "brown", "white", "black", "orange"];
+const nouns = ["table", "chair", "house", "bbq", "desk", "car", "pony", "cookie", "sandwich", "burger", "pizza", "mouse", "keyboard"];
+
+function _random (max) { return Math.round(Math.random() * 1000) % max; };
+
+function buildData(count) {
+    const data = new Array(count);
+    for (let i = 0; i < count; i++) {
+        const label = `${adjectives[_random(adjectives.length)]} ${colours[_random(colours.length)]} ${nouns[_random(nouns.length)]}`;
+        data[i] = {
+            id: idCounter++,
+            label,
+        };
+    }
+    return data;
+}
+
+// -----------------------------------------------------------------------------
+// Components
+// -----------------------------------------------------------------------------
+class Button extends Component {
+  static template = "Button";
+}
+
+
+class Row extends Component {
+  static template = "Row";
+}
+
+class Root extends Component {
+  static template = "Root";
+  static components = { Button, Row };
+
+  setup() {
+      this.state = useState({
+          rows: [],
+          selectedRowId: null
+      });
+      this.benchmarking = false;
+      onPatched(() => {
+          if (this.benchmarking) {
+              this.stop();
+          }
+      });
+    }
+    
+    start(descr) {
+        this.benchmarking = `[${descr}]`;
+        console.time(this.benchmarking);
+    }
+    stop() {
+        console.timeEnd(this.benchmarking);
+        this.benchmarking = false;  
+    }
+
+    run() {
+        this.start('add1000');
+        this.state.rows = buildData(1000);
+        this.state.selectedRowId = null;
+    }
+    
+    runLots() {
+        this.start('add10_000');
+        this.state.rows = buildData(10_000);
+        this.state.selectedRowId = null;
+    }
+    
+    add() {
+        this.start('append1000');
+        this.state.rows = this.state.rows.concat(buildData(1000));
+    }
+    
+    update() {
+        this.start('update1/10th');
+        let index = 0;
+        const rows = this.state.rows;
+        while (index < rows.length) {
+            rows[index].label = rows[index].label + " !!!";
+            index += 10;
+        }
+    }
+    
+    clear() {
+        this.start('clear');
+        this.state.rows = [];
+        this.state.selectedRowId = null;
+    }
+    
+    swapRows() {
+        this.start('swap');
+        const rows = this.state.rows;
+        if (rows.length > 998) {
+            let tmp = rows[1];
+            rows[1] = rows[998];
+            rows[998] = tmp;
+        }
+    }
+    
+    selectRow(id) {
+        this.start('select');
+        this.state.selectedRowId = id;
+    }
+    
+    removeRow(id) {
+        this.start('remove1');
+        const rows = this.state.rows;
+        rows.splice(rows.findIndex(row => row.id === id), 1);
+    }
+}
+
+
+// dev=false for benchmarking. we don't want to benchmark dev code!
+mount(Root, document.body, { templates: TEMPLATES, dev: false });

docs/playground/samples/benchmark/benchmark.xml

@@ -0,0 +1,52 @@
+<templates>
+    <t t-name="Button">
+        <div class='col-sm-6 smallpad'>
+            <button t-att-id="props.id" class='btn btn-primary btn-block' type='button' t-on-click="props.onClick">
+                <t t-esc="props.text"/>
+            </button>
+        </div>
+    </t>
+    <t t-name="Row">
+        <tr t-att-class="props.isSelected ? 'danger' : ''">
+            <td class="col-md-1" t-esc="props.row.id" />
+            <td class="col-md-4">
+                <a t-on-click="() => props.onSelect(props.row.id)" t-esc="props.row.label" />
+            </td>
+            <td class="col-md-1">
+                <a t-on-click="() =>  props.onRemove(props.row.id)" class="remove">[x]
+                    <span class='glyphicon glyphicon-remove' aria-hidden="true" />
+                </a>
+            </td>
+            <td class='col-md-6'/>
+        </tr>
+    </t>
+    <t t-name="Root">
+        <div class='container'>
+            <div class='jumbotron'>
+                <div class='row'>
+                    <div class='col-md-6'>
+                        <h1>Owl Keyed</h1>
+                    </div>
+                    <div class='col-md-6'>
+                        <div class='row'>
+                            <Button id="'run'" onClick.bind="run" text="'Create 1,000 rows'" />
+                            <Button id="'runlots'" onClick.bind="runLots" text="'Create 10,000 rows'" />
+                            <Button id="'add'" onClick.bind="add" text="'Append 1,000 rows'" />
+                            <Button id="'update'" onClick.bind="update" text="'Update every 10th row'" />
+                            <Button id="'clear'" onClick.bind="clear" text="'Clear'" />
+                            <Button id="'swaprows'" onClick.bind="swapRows" text="'Swap Rows'" />
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <table class='table table-hover table-striped test-data'>
+                <tbody>
+                    <t t-foreach="state.rows" t-as="row" t-key="row.id">
+                        <Row row="row" isSelected="row.id === state.selectedRowId" onSelect.bind="selectRow" onRemove.bind="removeRow"/>
+                    </t>
+                </tbody>
+            </table>
+            <span class='preloadicon glyphicon glyphicon-remove' aria-hidden="true" />
+        </div>
+    </t>
+</templates>

docs/playground/samples/components/components.css

@@ -0,0 +1,10 @@
+.greeter {
+    font-size: 20px;
+    width: 300px;
+    height: 100px;
+    margin: 5px;
+    text-align: center;
+    line-height: 100px;
+    background-color: #eeeeee;
+    user-select: none;
+}

docs/playground/samples/components/components.js

@@ -0,0 +1,26 @@
+// In this example, we show how components can be defined and created.
+import { Component, useState, mount } from "@odoo/owl";
+
+class Greeter extends Component {
+    static template = "Greeter";
+    
+    setup() {
+        this.state = useState({ word: 'Hello' });
+    }
+
+    toggle() {
+        this.state.word = this.state.word === 'Hi' ? 'Hello' : 'Hi';
+    }
+}
+
+// Main root component
+class Root extends Component {
+    static components = { Greeter };
+    static template = "Root"
+
+    setup() {
+        this.state = useState({ name: 'World'});
+    }
+}
+
+mount(Root, document.body, { templates: TEMPLATES, dev: true });

docs/playground/samples/components/components.xml

@@ -0,0 +1,9 @@
+<templates>
+  <div t-name="Greeter" class="greeter" t-on-click="toggle">
+    <t t-esc="state.word"/>, <t t-esc="props.name"/>
+  </div>
+
+  <t t-name="Root">
+    <Greeter name="state.name"/>
+  </t>
+</templates>

docs/playground/samples/custom_hooks/custom_hooks.css

@@ -0,0 +1,6 @@
+
+button {
+    width: 120px;
+    height: 35px;
+    font-size: 16px;
+}

docs/playground/samples/custom_hooks/custom_hooks.js

@@ -0,0 +1,40 @@
+// In this example, we show how hooks can be used or defined.
+import { Component, mount, useState, onWillDestroy } from "@odoo/owl";
+
+// We define here a custom behaviour: this hook tracks the state of the mouse
+// position
+function useMouse() {
+    const position = useState({x:0, y: 0});
+
+    function update(e) {
+      position.x = e.clientX;
+      position.y = e.clientY;
+    }
+    window.addEventListener('mousemove', update);
+    onWillDestroy(() => {
+        window.removeEventListener('mousemove', update);
+    });
+
+    return position;
+}
+
+
+// Main root component
+class Root extends Component {
+    static template = "Root";
+
+    setup() {
+        // simple state hook (reactive object)
+        this.counter = useState({ value: 0 });
+
+        // this hooks is bound to the 'mouse' property.
+        this.mouse = useMouse();
+    }
+
+    increment() {
+        this.counter.value++;
+    }
+}
+
+// Application setup
+mount(Root, document.body, { templates: TEMPLATES, dev: true });

docs/playground/samples/custom_hooks/custom_hooks.xml

@@ -0,0 +1,7 @@
+
+<templates>
+  <div t-name="Root">
+    <button t-on-click="increment">Click! <t t-esc="counter.value"/></button>
+    <div>Mouse: <t t-esc="mouse.x"/>, <t t-esc="mouse.y"/></div>
+  </div>
+</templates>

docs/playground/samples/form/form.js

@@ -0,0 +1,22 @@
+// This example illustrate how the t-model directive can be used to synchronize
+// data between html inputs (and select/textareas) and the state of a component.
+// Note that there are two controls with t-model="color": they are totally
+// synchronized.
+import { Component, useState, mount } from "@odoo/owl";
+
+class Form extends Component {
+  static template = "Form";
+
+  setup() {
+    this.state = useState({
+      text: "",
+      othertext: "",
+      number: 11,
+      color: "",
+      bool: false
+    });
+  }
+}
+
+// Application setup
+mount(Form, document.body, { templates: TEMPLATES, dev: true });