[IMP] playground: add a new sample

.github/workflows/deploy.yml

@@ -14,7 +14,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [20.x, 22.x]
+        node-version: [12.x, 14.x, 16.x]
 
     steps:
     - uses: actions/checkout@v2

doc/reference/app.md

@@ -6,7 +6,6 @@
 - [API](#api)
 - [Configuration](#configuration)
 - [`mount` helper](#mount-helper)
-- [Roots](#roots)
 - [Loading templates](#loading-templates)
 
 ## Overview
@@ -66,9 +65,6 @@ The `config` object is an object with some of the following keys:
   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).
-- **`customDirectives (object)`**: if given, the corresponding function on the object will be called
-  on the template custom directives: `t-custom-*` (see [Custom Directives](templates.md#custom-directives)).
-- **`globalValues (object)`**: Global object of elements available at compilations.
 
 ## `mount` helper
 
@@ -96,33 +92,6 @@ 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.
 
-## Roots
-
-An application can have multiple roots. It is sometimes useful to instantiate
-sub components in places that are not managed by Owl, such as an html editor
-with dynamic content (the Knowledge application in Odoo).
-
-To create a root, one can use the `createRoot` method, which takes two arguments:
-
-- **`Component`**: a component class (Root component of the app)
-- **`config (optional)`**: a config object that may contain a `props` object or a
-  `env` object.
-
-The `createRoot` method returns an object with a `mount` method (same API as
-the `App.mount` method), and a `destroy` method.
-
-```js
-const root = app.createRoot(MyComponent, { props: { someProps: true } });
-await root.mount(targetElement);
-
-// later
-root.destroy();
-```
-
-Note that, like with owl `App`, it is the responsibility of the code that created
-the root to properly destroy it (before it has been removed from the DOM!). Owl
-has no way of doing it itself.
-
 ## Loading templates
 
 Most applications will need to load templates whenever they start. Here is

doc/reference/templates.md

@@ -18,7 +18,6 @@
   - [Sub Templates](#sub-templates)
   - [Dynamic Sub Templates](#dynamic-sub-templates)
   - [Debugging](#debugging)
-  - [Custom Directives](#custom-directives)
 - [Fragments](#fragments)
 - [Inline templates](#inline-templates)
 - [Rendering svg](#rendering-svg)
@@ -81,7 +80,6 @@ needs. Here is a list of all Owl specific directives:
 | `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)     |
-| `t-custom-*`                           | [Rendering nodes with custom directives](#custom-directives)    |
 
 ## QWeb Template Reference
 
@@ -590,35 +588,6 @@ will stop execution if the browser dev tools are open.
 
 will print 42 to the console.
 
-### Custom Directives
-
-Owl 2 supports the declaration of custom directives. To use them, an Object of functions needs to be configured on the owl APP:
-
-```js
- new App(..., {
-    customDirectives: {
-     test_directive: function (el, value) {
-            el.setAttribute("t-on-click", value);
-       }
-   }
-  });
-```
-
-The functions will be called when a custom directive with the name of the
-function is found. The original element will be replaced with the one
-modified by the function.
-This :
-
-```xml
-<div t-custom-test_directive="click" />
-```
-
-will be replaced by :
-
-```xml
-<div t-on-click="value"/>
-```
-
 ## Fragments
 
 Owl 2 supports templates with an arbitrary number of root elements, or even just

docs/owl.js

@@ -2270,12 +2270,6 @@ function collectionsProxyHandler(target, callback, targetRawType) {
 }
 
 let currentNode = null;
-function saveCurrent() {
-    let n = currentNode;
-    return () => {
-        currentNode = n;
-    };
-}
 function getCurrent() {
     if (!currentNode) {
         throw new OwlError("No active component (a hook function should only be called in 'setup')");
@@ -2604,47 +2598,42 @@ class ComponentNode {
 }
 
 const TIMEOUT = Symbol("timeout");
-const HOOK_TIMEOUT = {
-    onWillStart: 3000,
-    onWillUpdateProps: 3000,
-};
 function wrapError(fn, hookName) {
-    const error = new OwlError();
-    const timeoutError = new OwlError();
+    const error = new OwlError(`The following error occurred in ${hookName}: `);
+    const timeoutError = new OwlError(`${hookName}'s promise hasn't resolved after 3 seconds`);
     const node = getCurrent();
     return (...args) => {
         const onError = (cause) => {
             error.cause = cause;
-            error.message =
-                cause instanceof Error
-                    ? `The following error occurred in ${hookName}: "${cause.message}"`
-                    : `Something that is not an Error was thrown in ${hookName} (see this Error's "cause" property)`;
+            if (cause instanceof Error) {
+                error.message += `"${cause.message}"`;
+            }
+            else {
+                error.message = `Something that is not an Error was thrown in ${hookName} (see this Error's "cause" property)`;
+            }
             throw error;
         };
-        let result;
         try {
-            result = fn(...args);
+            const result = fn(...args);
+            if (result instanceof Promise) {
+                if (hookName === "onWillStart" || hookName === "onWillUpdateProps") {
+                    const fiber = node.fiber;
+                    Promise.race([
+                        result.catch(() => { }),
+                        new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), 3000)),
+                    ]).then((res) => {
+                        if (res === TIMEOUT && node.fiber === fiber && node.status <= 2) {
+                            console.warn(timeoutError);
+                        }
+                    });
+                }
+                return result.catch(onError);
+            }
+            return result;
         }
         catch (cause) {
             onError(cause);
         }
-        if (!(result instanceof Promise)) {
-            return result;
-        }
-        const timeout = HOOK_TIMEOUT[hookName];
-        if (timeout) {
-            const fiber = node.fiber;
-            Promise.race([
-                result.catch(() => { }),
-                new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), timeout)),
-            ]).then((res) => {
-                if (res === TIMEOUT && node.fiber === fiber && node.status <= 2) {
-                    timeoutError.message = `${hookName}'s promise hasn't resolved after ${timeout / 1000} seconds`;
-                    console.log(timeoutError);
-                }
-            });
-        }
-        return result.catch(onError);
     };
 }
 // -----------------------------------------------------------------------------
@@ -3227,9 +3216,6 @@ class TemplateSet {
             }
         }
         this.getRawTemplate = config.getTemplate;
-        this.customDirectives = config.customDirectives || {};
-        this.runtimeUtils = { ...helpers, __globals__: config.globalValues || {} };
-        this.hasGlobalValues = Boolean(config.globalValues && Object.keys(config.globalValues).length);
     }
     static registerTemplate(name, fn) {
         globalTemplates[name] = fn;
@@ -3286,7 +3272,7 @@ class TemplateSet {
             this.templates[name] = function (context, parent) {
                 return templates[name].call(this, context, parent);
             };
-            const template = templateFn(this, bdom, this.runtimeUtils);
+            const template = templateFn(this, bdom, helpers);
             this.templates[name] = template;
         }
         return this.templates[name];
@@ -3337,7 +3323,7 @@ TemplateSet.registerTemplate("__portal__", portalTemplate);
 //------------------------------------------------------------------------------
 // Misc types, constants and helpers
 //------------------------------------------------------------------------------
-const RESERVED_WORDS = "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,eval,void,Math,RegExp,Array,Object,Date,__globals__".split(",");
+const RESERVED_WORDS = "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,eval,void,Math,RegExp,Array,Object,Date".split(",");
 const WORD_REPLACEMENT = Object.assign(Object.create(null), {
     and: "&&",
     or: "||",
@@ -3809,9 +3795,6 @@ class CodeGenerator {
         this.dev = options.dev || false;
         this.ast = ast;
         this.templateName = options.name;
-        if (options.hasGlobalValues) {
-            this.helpers.add("__globals__");
-        }
     }
     generateCode() {
         const ast = this.ast;
@@ -4850,33 +4833,29 @@ class CodeGenerator {
 // Parser
 // -----------------------------------------------------------------------------
 const cache = new WeakMap();
-function parse(xml, customDir) {
-    const ctx = {
-        inPreTag: false,
-        customDirectives: customDir,
-    };
+function parse(xml) {
     if (typeof xml === "string") {
         const elem = parseXML(`<t>${xml}</t>`).firstChild;
-        return _parse(elem, ctx);
+        return _parse(elem);
     }
     let ast = cache.get(xml);
     if (!ast) {
         // we clone here the xml to prevent modifying it in place
-        ast = _parse(xml.cloneNode(true), ctx);
+        ast = _parse(xml.cloneNode(true));
         cache.set(xml, ast);
     }
     return ast;
 }
-function _parse(xml, ctx) {
+function _parse(xml) {
     normalizeXML(xml);
+    const ctx = { inPreTag: false };
     return parseNode(xml, ctx) || { type: 0 /* Text */, value: "" };
 }
 function parseNode(node, ctx) {
     if (!(node instanceof Element)) {
         return parseTextCommentNode(node, ctx);
     }
-    return (parseTCustom(node, ctx) ||
-        parseTDebugLog(node, ctx) ||
+    return (parseTDebugLog(node, ctx) ||
         parseTForEach(node, ctx) ||
         parseTIf(node, ctx) ||
         parseTPortal(node, ctx) ||
@@ -4918,35 +4897,6 @@ function parseTextCommentNode(node, ctx) {
     }
     return null;
 }
-function parseTCustom(node, ctx) {
-    if (!ctx.customDirectives) {
-        return null;
-    }
-    const nodeAttrsNames = node.getAttributeNames();
-    for (let attr of nodeAttrsNames) {
-        if (attr === "t-custom" || attr === "t-custom-") {
-            throw new OwlError("Missing custom directive name with t-custom directive");
-        }
-        if (attr.startsWith("t-custom-")) {
-            const directiveName = attr.split(".")[0].slice(9);
-            const customDirective = ctx.customDirectives[directiveName];
-            if (!customDirective) {
-                throw new OwlError(`Custom directive "${directiveName}" is not defined`);
-            }
-            const value = node.getAttribute(attr);
-            const modifier = attr.split(".").length > 1 ? attr.split(".")[1] : undefined;
-            node.removeAttribute(attr);
-            try {
-                customDirective(node, value, modifier);
-            }
-            catch (error) {
-                throw new OwlError(`Custom directive "${directiveName}" throw the following error: ${error}`);
-            }
-            return parseNode(node, ctx);
-        }
-    }
-    return null;
-}
 // -----------------------------------------------------------------------------
 // debugging
 // -----------------------------------------------------------------------------
@@ -5578,11 +5528,9 @@ function normalizeXML(el) {
     normalizeTEscTOut(el);
 }
 
-function compile(template, options = {
-    hasGlobalValues: false,
-}) {
+function compile(template, options = {}) {
     // parsing
-    const ast = parse(template, options.customDirectives);
+    const ast = parse(template);
     // some work
     const hasSafeContext = template instanceof Node
         ? !(template instanceof Element) || template.querySelector("[t-set], [t-call]") === null
@@ -5604,7 +5552,7 @@ function compile(template, options = {
 }
 
 // do not modify manually. This file is generated by the release script.
-const version = "2.5.0";
+const version = "2.3.0";
 
 // -----------------------------------------------------------------------------
 //  Scheduler
@@ -5615,7 +5563,6 @@ class Scheduler {
         this.frame = 0;
         this.delayedRenders = [];
         this.cancelledNodes = new Set();
-        this.processing = false;
         this.requestAnimationFrame = Scheduler.requestAnimationFrame;
     }
     addFiber(fiber) {
@@ -5646,10 +5593,6 @@ class Scheduler {
         }
     }
     processTasks() {
-        if (this.processing) {
-            return;
-        }
-        this.processing = true;
         this.frame = 0;
         for (let node of this.cancelledNodes) {
             node._destroy();
@@ -5663,7 +5606,6 @@ class Scheduler {
                 this.tasks.delete(task);
             }
         }
-        this.processing = false;
     }
     processFiber(fiber) {
         if (fiber.root !== fiber) {
@@ -5683,14 +5625,7 @@ class Scheduler {
             if (!hasError) {
                 fiber.complete();
             }
-            // at this point, the fiber should have been applied to the DOM, so we can
-            // remove it from the task list. If it is not the case, it means that there
-            // was an error and an error handler triggered a new rendering that recycled
-            // the fiber, so in that case, we actually want to keep the fiber around,
-            // otherwise it will just be ignored.
-            if (fiber.appliedToDom) {
-                this.tasks.delete(fiber);
-            }
+            this.tasks.delete(fiber);
         }
     }
 }
@@ -5712,7 +5647,6 @@ class App extends TemplateSet {
     constructor(Root, config = {}) {
         super(config);
         this.scheduler = new Scheduler();
-        this.subRoots = new Set();
         this.root = null;
         this.name = config.name || "";
         this.Root = Root;
@@ -5731,44 +5665,14 @@ class App extends TemplateSet {
         this.props = config.props || {};
     }
     mount(target, options) {
-        const root = this.createRoot(this.Root, { props: this.props });
-        this.root = root.node;
-        this.subRoots.delete(root.node);
-        return root.mount(target, options);
-    }
-    createRoot(Root, config = {}) {
-        const props = config.props || {};
-        // hack to make sure the sub root get the sub env if necessary. for owl 3,
-        // would be nice to rethink the initialization process to make sure that
-        // we can create a ComponentNode and give it explicitely the env, instead
-        // of looking it up in the app
-        const env = this.env;
-        if (config.env) {
-            this.env = config.env;
+        App.validateTarget(target);
+        if (this.dev) {
+            validateProps(this.Root, this.props, { __owl__: { app: this } });
         }
-        const restore = saveCurrent();
-        const node = this.makeNode(Root, props);
-        restore();
-        if (config.env) {
-            this.env = env;
-        }
-        this.subRoots.add(node);
-        return {
-            node,
-            mount: (target, options) => {
-                App.validateTarget(target);
-                if (this.dev) {
-                    validateProps(Root, props, { __owl__: { app: this } });
-                }
-                const prom = this.mountNode(node, target, options);
-                return prom;
-            },
-            destroy: () => {
-                this.subRoots.delete(node);
-                node.destroy();
-                this.scheduler.processTasks();
-            },
-        };
+        const node = this.makeNode(this.Root, this.props);
+        const prom = this.mountNode(node, target, options);
+        this.root = node;
+        return prom;
     }
     makeNode(Component, props) {
         return new ComponentNode(Component, props, this, null, null);
@@ -5800,9 +5704,6 @@ class App extends TemplateSet {
     }
     destroy() {
         if (this.root) {
-            for (let subroot of this.subRoots) {
-                subroot.destroy();
-            }
             this.root.destroy();
             this.scheduler.processTasks();
         }
@@ -6074,14 +5975,12 @@ TemplateSet.prototype._compileTemplate = function _compileTemplate(name, templat
         dev: this.dev,
         translateFn: this.translateFn,
         translatableAttributes: this.translatableAttributes,
-        customDirectives: this.customDirectives,
-        hasGlobalValues: this.hasGlobalValues,
     });
 };
 
 export { App, Component, EventBus, OwlError, __info__, batched, blockDom, loadFile, markRaw, markup, mount, onError, onMounted, onPatched, onRendered, onWillDestroy, onWillPatch, onWillRender, onWillStart, onWillUnmount, onWillUpdateProps, reactive, status, toRaw, useChildSubEnv, useComponent, useEffect, useEnv, useExternalListener, useRef, useState, useSubEnv, validate, validateType, whenReady, xml };
 
 
-__info__.date = '2024-11-25T09:30:45.930Z';
-__info__.hash = '6b24864';
+__info__.date = '2024-07-25T13:13:44.371Z';
+__info__.hash = '0cde4b8';
 __info__.url = 'https://github.com/odoo/owl';

docs/playground/playground.js

@@ -99,6 +99,11 @@ const SAMPLES = [
     folder: "todo_app",
     code: ["js", "xml", "css"],
   },
+  {
+    description: "Tic-Tac-Toe (with reactivity)",
+    folder: "tic_tac_toe",
+    code: ["js", "xml", "css"],
+  },
   {
     description: "Responsive app",
     folder: "responsive_app",

docs/playground/samples/tic_tac_toe/tic_tac_toe.css

@@ -0,0 +1,32 @@
+.square {
+    background: #fff;
+    border: 1px solid #999;
+    float: left;
+    font-size: 24px;
+    font-weight: bold;
+    line-height: 34px;
+    height: 34px;
+    margin-right: -1px;
+    margin-top: -1px;
+    padding: 0;
+    text-align: center;
+    width: 34px;
+}
+
+.board-row:after {
+    clear: both;
+    content: '';
+    display: table;
+}
+
+.status {
+    margin-bottom: 10px;
+}
+.game {
+    display: flex;
+    flex-direction: row;
+}
+
+.game-info {
+    margin-left: 20px;
+}

docs/playground/samples/tic_tac_toe/tic_tac_toe.js

@@ -0,0 +1,105 @@
+// This example is an implementation of the Tic-Tac-Toe game, from
+// https://react.dev/learn/tutorial-tic-tac-toe.  This is an easy application to start learning owl
+// with some interesting user interactions.
+//
+// In this implementation, we use the owl reactivity mechanism.
+import { Component, useState, mount } from "@odoo/owl";
+
+
+class Square extends Component {
+    static template = "Square";
+}
+
+class Board extends Component {
+    static template = "Board"
+    static components = { Square };
+
+    handleClick(i) {
+        if (this.calculateWinner(this.props.squares) || this.props.squares[i]) {
+          return;
+        }
+        const nextSquares = this.props.squares.slice();
+        if (this.props.xIsNext) {
+          nextSquares[i] = 'X';
+        } else {
+          nextSquares[i] = 'O';
+        }
+        this.props.onPlay(nextSquares);
+    }
+
+    get status(){
+        const winner = this.calculateWinner(this.props.squares);
+        if (winner) {
+          return 'Winner: ' + winner;
+        } else {
+            if (Object.values(this.props.squares).filter((v) => v === null).length > 0)
+                return 'Next player: ' + (this.props.xIsNext ? 'X' : 'O');
+            else 
+                return 'Draw';
+        }
+    }
+
+    calculateWinner(squares) {
+        const lines = [
+          [0, 1, 2],
+          [3, 4, 5],
+          [6, 7, 8],
+          [0, 3, 6],
+          [1, 4, 7],
+          [2, 5, 8],
+          [0, 4, 8],
+          [2, 4, 6],
+        ];
+        for (let i = 0; i < lines.length; i++) {
+          const [a, b, c] = lines[i];
+          if (squares[a] && squares[a] === squares[b] && squares[a] === squares[c]) {
+            return squares[a];
+          }
+        }
+        return null;
+      }
+}  
+
+class Game extends Component {
+    static template = "Game"
+    static components = { Board };
+
+    setup() {
+        this.state = useState({
+            currentMove: 0,
+            history: [Array(9).fill(null)],
+        });
+    }
+
+    get currentSquares() {
+        return this.state.history[this.state.currentMove];
+    }
+
+    get xIsNext() {
+        return this.state.currentMove % 2 === 0;
+    }
+
+    jumpTo(nextMove) {
+        this.state.currentMove = nextMove;
+    }
+
+    handlePlay(nextSquares) {
+        const nextHistory = [...this.state.history.slice(0, this.state.currentMove + 1), nextSquares];
+        this.state.history = nextHistory;
+        this.state.currentMove = this.state.history.length - 1;
+    }
+
+    get moves() {
+        return this.state.history.map((_squares, move) => {
+            if (move > 0) {
+              return {id: move, description: 'Go to move #' + move};
+            } else {
+              return {id: move, description: 'Go to game start'};
+            }
+        });
+    }
+
+}
+
+// Application setup
+mount(Game, document.body, { templates: TEMPLATES, dev: true});

docs/playground/samples/tic_tac_toe/tic_tac_toe.xml

@@ -0,0 +1,43 @@
+<templates>
+    <button t-name="Square" class="square" t-on-click="props.onSquareClick">
+        <t t-esc="props.value"/>
+    </button>
+
+    <t t-name="Board">
+        <div class="status">
+            <t t-esc="status"/>
+        </div>
+        <div class="board-row">
+            <Square value="props.squares[0]" onSquareClick="() => this.handleClick(0)" />
+            <Square value="props.squares[1]" onSquareClick="() => this.handleClick(1)" />
+            <Square value="props.squares[2]" onSquareClick="() => this.handleClick(2)" />
+        </div>
+        <div class="board-row">
+            <Square value="props.squares[3]" onSquareClick="() => this.handleClick(3)" />
+            <Square value="props.squares[4]" onSquareClick="() => this.handleClick(4)" />
+            <Square value="props.squares[5]" onSquareClick="() => this.handleClick(5)" />
+        </div>
+        <div class="board-row">
+            <Square value="props.squares[6]" onSquareClick="() => this.handleClick(6)" />
+            <Square value="props.squares[7]" onSquareClick="() => this.handleClick(7)" />
+            <Square value="props.squares[8]" onSquareClick="() => this.handleClick(8)" />
+        </div>
+    </t>
+
+    <div t-name="Game" class="game">
+        <div class="game-board">
+            <Board xIsNext="xIsNext" squares="currentSquares" onPlay.bind="handlePlay" />
+        </div>
+        <div class="game-info">
+            <ol>
+                <t t-foreach="moves" t-as="move" t-key="move.id">
+                    <li>
+                        <button t-on-click="() => this.jumpTo(move.id)">
+                            <t t-esc="move.description"/>
+                        </button>
+                    </li>
+                </t>
+            </ol>
+        </div>
+    </div>
+</templates>

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "2.5.0",
+  "version": "2.3.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "2.5.0",
+  "version": "2.3.0",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "module": "dist/owl.es.js",
@@ -9,7 +9,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=12.18.3"
   },
   "scripts": {
     "build:bundle": "rollup -c --failAfterWarnings",

src/common/types.ts

@@ -1,4 +0,0 @@
-export type customDirectives = Record<
-  string,
-  (node: Element, value: string, modifier?: string) => void
->;

src/compiler/code_generator.ts

@@ -43,7 +43,6 @@ export interface Config {
 export interface CodeGenOptions extends Config {
   hasSafeContext?: boolean;
   name?: string;
-  hasGlobalValues: boolean;
 }
 
 // using a non-html document so that <inner/outer>HTML serializes as XML instead
@@ -287,9 +286,6 @@ export class CodeGenerator {
     this.dev = options.dev || false;
     this.ast = ast;
     this.templateName = options.name;
-    if (options.hasGlobalValues) {
-      this.helpers.add("__globals__");
-    }
   }
 
   generateCode(): string {

src/compiler/index.ts

@@ -1,4 +1,3 @@
-import type { customDirectives } from "../common/types";
 import type { TemplateSet } from "../runtime/template_set";
 import type { BDom } from "../runtime/blockdom";
 import { CodeGenerator, Config } from "./code_generator";
@@ -11,17 +10,13 @@ export type TemplateFunction = (app: TemplateSet, bdom: any, helpers: any) => Te
 
 interface CompileOptions extends Config {
   name?: string;
-  customDirectives?: customDirectives;
-  hasGlobalValues: boolean;
 }
 export function compile(
   template: string | Element,
-  options: CompileOptions = {
-    hasGlobalValues: false,
-  }
+  options: CompileOptions = {}
 ): TemplateFunction {
   // parsing
-  const ast = parse(template, options.customDirectives);
+  const ast = parse(template);
 
   // some work
   const hasSafeContext =

src/compiler/inline_expressions.ts

@@ -28,7 +28,7 @@ import { OwlError } from "../common/owl_error";
 //------------------------------------------------------------------------------
 
 const RESERVED_WORDS =
-  "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,eval,void,Math,RegExp,Array,Object,Date,__globals__".split(
+  "true,false,NaN,null,undefined,debugger,console,window,in,instanceof,new,function,return,eval,void,Math,RegExp,Array,Object,Date".split(
     ","
   );
 

src/compiler/parser.ts

@@ -1,5 +1,4 @@
 import { OwlError } from "../common/owl_error";
-import type { customDirectives } from "../common/types";
 import { parseXML } from "../common/utils";
 
 // -----------------------------------------------------------------------------
@@ -199,26 +198,23 @@ export type AST =
 // -----------------------------------------------------------------------------
 const cache: WeakMap<Element, AST> = new WeakMap();
 
-export function parse(xml: string | Element, customDir?: customDirectives): AST {
-  const ctx = {
-    inPreTag: false,
-    customDirectives: customDir,
-  };
+export function parse(xml: string | Element): AST {
   if (typeof xml === "string") {
     const elem = parseXML(`<t>${xml}</t>`).firstChild as Element;
-    return _parse(elem, ctx);
+    return _parse(elem);
   }
   let ast = cache.get(xml);
   if (!ast) {
     // we clone here the xml to prevent modifying it in place
-    ast = _parse(xml.cloneNode(true) as Element, ctx);
+    ast = _parse(xml.cloneNode(true) as Element);
     cache.set(xml, ast);
   }
   return ast;
 }
 
-function _parse(xml: Element, ctx: ParsingContext): AST {
+function _parse(xml: Element): AST {
   normalizeXML(xml);
+  const ctx = { inPreTag: false };
   return parseNode(xml, ctx) || { type: ASTType.Text, value: "" };
 }
 
@@ -226,7 +222,6 @@ interface ParsingContext {
   tModelInfo?: TModelInfo | null;
   nameSpace?: string;
   inPreTag: boolean;
-  customDirectives?: customDirectives;
 }
 
 function parseNode(node: Node, ctx: ParsingContext): AST | null {
@@ -234,7 +229,6 @@ function parseNode(node: Node, ctx: ParsingContext): AST | null {
     return parseTextCommentNode(node, ctx);
   }
   return (
-    parseTCustom(node, ctx) ||
     parseTDebugLog(node, ctx) ||
     parseTForEach(node, ctx) ||
     parseTIf(node, ctx) ||
@@ -283,37 +277,6 @@ function parseTextCommentNode(node: Node, ctx: ParsingContext): AST | null {
   return null;
 }
 
-function parseTCustom(node: Element, ctx: ParsingContext): AST | null {
-  if (!ctx.customDirectives) {
-    return null;
-  }
-  const nodeAttrsNames = node.getAttributeNames();
-  for (let attr of nodeAttrsNames) {
-    if (attr === "t-custom" || attr === "t-custom-") {
-      throw new OwlError("Missing custom directive name with t-custom directive");
-    }
-    if (attr.startsWith("t-custom-")) {
-      const directiveName = attr.split(".")[0].slice(9);
-      const customDirective = ctx.customDirectives[directiveName];
-      if (!customDirective) {
-        throw new OwlError(`Custom directive "${directiveName}" is not defined`);
-      }
-      const value = node.getAttribute(attr)!;
-      const modifier = attr.split(".").length > 1 ? attr.split(".")[1] : undefined;
-      node.removeAttribute(attr);
-      try {
-        customDirective(node, value, modifier);
-      } catch (error) {
-        throw new OwlError(
-          `Custom directive "${directiveName}" throw the following error: ${error}`
-        );
-      }
-      return parseNode(node, ctx);
-    }
-  }
-  return null;
-}
-
 // -----------------------------------------------------------------------------
 // debugging
 // -----------------------------------------------------------------------------

src/index.ts

@@ -12,7 +12,5 @@ TemplateSet.prototype._compileTemplate = function _compileTemplate(
     dev: this.dev,
     translateFn: this.translateFn,
     translatableAttributes: this.translatableAttributes,
-    customDirectives: this.customDirectives,
-    hasGlobalValues: this.hasGlobalValues,
   });
 };

src/runtime/app.ts

@@ -1,6 +1,6 @@
 import { version } from "../version";
 import { Component, ComponentConstructor, Props } from "./component";
-import { ComponentNode, saveCurrent } from "./component_node";
+import { ComponentNode } from "./component_node";
 import { nodeErrorHandlers, handleError } from "./error_handling";
 import { OwlError } from "../common/owl_error";
 import { Fiber, RootFiber, MountOptions } from "./fibers";
@@ -16,13 +16,10 @@ export interface Env {
   [key: string]: any;
 }
 
-export interface RootConfig<P, E> {
+export interface AppConfig<P, E> extends TemplateSetConfig {
+  name?: string;
   props?: P;
   env?: E;
-}
-
-export interface AppConfig<P, E> extends TemplateSetConfig, RootConfig<P, E> {
-  name?: string;
   test?: boolean;
   warnIfNoStaticProps?: boolean;
 }
@@ -52,12 +49,6 @@ declare global {
   }
 }
 
-interface Root<P extends Props, E> {
-  node: ComponentNode<P, E>;
-  mount(target: HTMLElement | ShadowRoot, options?: MountOptions): Promise<Component<P, E>>;
-  destroy(): void;
-}
-
 window.__OWL_DEVTOOLS__ ||= { apps, Fiber, RootFiber, toRaw, reactive };
 
 export class App<
@@ -74,7 +65,6 @@ export class App<
   props: P;
   env: E;
   scheduler = new Scheduler();
-  subRoots: Set<ComponentNode> = new Set();
   root: ComponentNode<P, E> | null = null;
   warnIfNoStaticProps: boolean;
 
@@ -101,49 +91,14 @@ export class App<
     target: HTMLElement | ShadowRoot,
     options?: MountOptions
   ): Promise<Component<P, E> & InstanceType<T>> {
-    const root = this.createRoot(this.Root, { props: this.props });
-    this.root = root.node;
-    this.subRoots.delete(root.node);
-    return root.mount(target, options) as any;
-  }
-
-  createRoot<Props extends object, SubEnv = any>(
-    Root: ComponentConstructor<Props, E>,
-    config: RootConfig<Props, SubEnv> = {}
-  ): Root<Props, SubEnv> {
-    const props = config.props || ({} as Props);
-    // hack to make sure the sub root get the sub env if necessary. for owl 3,
-    // would be nice to rethink the initialization process to make sure that
-    // we can create a ComponentNode and give it explicitely the env, instead
-    // of looking it up in the app
-    const env = this.env;
-    if (config.env) {
-      this.env = config.env as any;
+    App.validateTarget(target);
+    if (this.dev) {
+      validateProps(this.Root, this.props, { __owl__: { app: this } });
     }
-
-    const restore = saveCurrent();
-    const node = this.makeNode(Root, props);
-    restore();
-    if (config.env) {
-      this.env = env;
-    }
-    this.subRoots.add(node);
-    return {
-      node,
-      mount: (target: HTMLElement | ShadowRoot, options?: MountOptions) => {
-        App.validateTarget(target);
-        if (this.dev) {
-          validateProps(Root, props, { __owl__: { app: this } });
-        }
-        const prom = this.mountNode(node, target, options);
-        return prom;
-      },
-      destroy: () => {
-        this.subRoots.delete(node);
-        node.destroy();
-        this.scheduler.processTasks();
-      },
-    };
+    const node = this.makeNode(this.Root, this.props);
+    const prom = this.mountNode(node, target, options);
+    this.root = node;
+    return prom;
   }
 
   makeNode(Component: ComponentConstructor, props: any): ComponentNode {
@@ -179,9 +134,6 @@ export class App<
 
   destroy() {
     if (this.root) {
-      for (let subroot of this.subRoots) {
-        subroot.destroy();
-      }
       this.root.destroy();
       this.scheduler.processTasks();
     }

src/runtime/component_node.ts

@@ -10,13 +10,6 @@ import { batched, Callback } from "./utils";
 
 let currentNode: ComponentNode | null = null;
 
-export function saveCurrent() {
-  let n = currentNode;
-  return () => {
-    currentNode = n;
-  };
-}
-
 export function getCurrent(): ComponentNode {
   if (!currentNode) {
     throw new OwlError("No active component (a hook function should only be called in 'setup')");

src/runtime/lifecycle_hooks.ts

@@ -3,50 +3,42 @@ import { nodeErrorHandlers } from "./error_handling";
 import { OwlError } from "../common/owl_error";
 
 const TIMEOUT = Symbol("timeout");
-const HOOK_TIMEOUT: { [key: string]: number } = {
-  onWillStart: 3000,
-  onWillUpdateProps: 3000,
-};
 function wrapError(fn: (...args: any[]) => any, hookName: string) {
-  const error = new OwlError() as Error & {
+  const error = new OwlError(`The following error occurred in ${hookName}: `) as Error & {
     cause: any;
   };
-  const timeoutError = new OwlError();
+  const timeoutError = new OwlError(`${hookName}'s promise hasn't resolved after 3 seconds`);
   const node = getCurrent();
   return (...args: any[]) => {
     const onError = (cause: any) => {
       error.cause = cause;
-      error.message =
-        cause instanceof Error
-          ? `The following error occurred in ${hookName}: "${cause.message}"`
-          : `Something that is not an Error was thrown in ${hookName} (see this Error's "cause" property)`;
+      if (cause instanceof Error) {
+        error.message += `"${cause.message}"`;
+      } else {
+        error.message = `Something that is not an Error was thrown in ${hookName} (see this Error's "cause" property)`;
+      }
       throw error;
     };
-    let result;
     try {
-      result = fn(...args);
+      const result = fn(...args);
+      if (result instanceof Promise) {
+        if (hookName === "onWillStart" || hookName === "onWillUpdateProps") {
+          const fiber = node.fiber;
+          Promise.race([
+            result.catch(() => {}),
+            new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), 3000)),
+          ]).then((res) => {
+            if (res === TIMEOUT && node.fiber === fiber && node.status <= 2) {
+              console.warn(timeoutError);
+            }
+          });
+        }
+        return result.catch(onError);
+      }
+      return result;
     } catch (cause) {
       onError(cause);
     }
-    if (!(result instanceof Promise)) {
-      return result;
-    }
-    const timeout = HOOK_TIMEOUT[hookName];
-    if (timeout) {
-      const fiber = node.fiber;
-      Promise.race([
-        result.catch(() => {}),
-        new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), timeout)),
-      ]).then((res) => {
-        if (res === TIMEOUT && node.fiber === fiber && node.status <= 2) {
-          timeoutError.message = `${hookName}'s promise hasn't resolved after ${
-            timeout / 1000
-          } seconds`;
-          console.log(timeoutError);
-        }
-      });
-    }
-    return result.catch(onError);
   };
 }
 

src/runtime/scheduler.ts

@@ -16,7 +16,6 @@ export class Scheduler {
   frame: number = 0;
   delayedRenders: Fiber[] = [];
   cancelledNodes: Set<ComponentNode> = new Set();
-  processing = false;
 
   constructor() {
     this.requestAnimationFrame = Scheduler.requestAnimationFrame;
@@ -54,10 +53,6 @@ export class Scheduler {
   }
 
   processTasks() {
-    if (this.processing) {
-      return;
-    }
-    this.processing = true;
     this.frame = 0;
     for (let node of this.cancelledNodes) {
       node._destroy();
@@ -71,7 +66,6 @@ export class Scheduler {
         this.tasks.delete(task);
       }
     }
-    this.processing = false;
   }
 
   processFiber(fiber: RootFiber) {
@@ -93,14 +87,7 @@ export class Scheduler {
       if (!hasError) {
         fiber.complete();
       }
-      // at this point, the fiber should have been applied to the DOM, so we can
-      // remove it from the task list. If it is not the case, it means that there
-      // was an error and an error handler triggered a new rendering that recycled
-      // the fiber, so in that case, we actually want to keep the fiber around,
-      // otherwise it will just be ignored.
-      if (fiber.appliedToDom) {
-        this.tasks.delete(fiber);
-      }
+      this.tasks.delete(fiber);
     }
   }
 }

src/runtime/template_set.ts

@@ -5,7 +5,6 @@ import { Portal, portalTemplate } from "./portal";
 import { helpers } from "./template_helpers";
 import { OwlError } from "../common/owl_error";
 import { parseXML } from "../common/utils";
-import type { customDirectives } from "../common/types";
 
 const bdom = { text, createBlock, list, multi, html, toggler, comment };
 
@@ -15,8 +14,6 @@ export interface TemplateSetConfig {
   translateFn?: (s: string) => string;
   templates?: string | Document | Record<string, string>;
   getTemplate?: (s: string) => Element | Function | string | void;
-  customDirectives?: customDirectives;
-  globalValues?: object;
 }
 
 export class TemplateSet {
@@ -30,9 +27,6 @@ export class TemplateSet {
   translateFn?: (s: string) => string;
   translatableAttributes?: string[];
   Portal = Portal;
-  customDirectives: customDirectives;
-  runtimeUtils: object;
-  hasGlobalValues: boolean;
 
   constructor(config: TemplateSetConfig = {}) {
     this.dev = config.dev || false;
@@ -48,9 +42,6 @@ export class TemplateSet {
       }
     }
     this.getRawTemplate = config.getTemplate;
-    this.customDirectives = config.customDirectives || {};
-    this.runtimeUtils = { ...helpers, __globals__: config.globalValues || {} };
-    this.hasGlobalValues = Boolean(config.globalValues && Object.keys(config.globalValues).length);
   }
 
   addTemplate(name: string, template: string | Element) {
@@ -106,7 +97,7 @@ export class TemplateSet {
       this.templates[name] = function (context, parent) {
         return templates[name].call(this, context, parent);
       };
-      const template = templateFn(this, bdom, this.runtimeUtils);
+      const template = templateFn(this, bdom, helpers);
       this.templates[name] = template;
     }
     return this.templates[name];

src/version.ts

@@ -1,2 +1,2 @@
 // do not modify manually. This file is generated by the release script.
-export const version = "2.5.0";
+export const version = "2.3.0";

tests/app/__snapshots__/app.test.ts.snap

@@ -43,48 +43,6 @@ exports[`app app: clear scheduler tasks and destroy cancelled nodes immediately
 }"
 `;
 
-exports[`app can add functions to the bdom 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  let { __globals__ } = helpers;
-  
-  let block1 = createBlock(\`<div class=\\"my-div\\" block-handler-0=\\"click\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [()=>__globals__.plop('click'), ctx];
-    return block1([hdlr1]);
-  }
-}"
-`;
-
-exports[`app can call processTask twice in a row without crashing 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`Child\`, true, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`parent\`);
-    const b3 = comp1({}, key + \`__1\`, node, this, null);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`app can call processTask twice in a row without crashing 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`app can configure an app with props 1`] = `
 "function anonymous(app, bdom, helpers
 ) {

tests/app/__snapshots__/sub_root.test.ts.snap

@@ -1,210 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`destroy a subroot while another component is mounted in main app 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(\`ChildB\`, true, false, false, []);
-  const comp2 = app.createComponent(\`ChildA\`, true, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2, b3;
-    if (ctx['state'].flag) {
-      b2 = comp1({}, key + \`__1\`, node, this, null);
-    } else {
-      b3 = comp2({}, key + \`__2\`, node, this, null);
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`destroy a subroot while another component is mounted in main app 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block3 = createBlock(\`<div block-ref=\\"0\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`a\`);
-    let ref1 = (el) => this.__owl__.setRef((\`elem\`), el);
-    const b3 = block3([ref1]);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`destroy a subroot while another component is mounted in main app 3`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`c\`);
-  }
-}"
-`;
-
-exports[`destroy a subroot while another component is mounted in main app 4`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`b\`);
-  }
-}"
-`;
-
-exports[`subroot by default, env is the same in sub root 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot by default, env is the same in sub root 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot can create a root in a setup function, then use a hook 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`a\`);
-  }
-}"
-`;
-
-exports[`subroot can create a root in a setup function, then use a hook 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`c\`);
-  }
-}"
-`;
-
-exports[`subroot can mount subroot 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot can mount subroot 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot can mount subroot inside own dom 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot can mount subroot inside own dom 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot env can be specified for sub roots 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot env can be specified for sub roots 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot subcomponents can be destroyed, and it properly cleanup the subroots 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>main app</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`subroot subcomponents can be destroyed, and it properly cleanup the subroots 2`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>sub root</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;

tests/app/app.test.ts

@@ -1,4 +1,4 @@
-import { App, Component, mount, onWillPatch, onWillStart, useState, xml } from "../../src";
+import { App, Component, mount, onWillStart, useState, xml } from "../../src";
 import { status } from "../../src/runtime/status";
 import {
   makeTestFixture,
@@ -184,39 +184,4 @@ describe("app", () => {
     expect(Object.keys(app.templates)).toEqual(["hello"]);
     expect(Object.keys(app.rawTemplates)).toEqual(["hello", "world"]);
   });
-
-  test("can call processTask twice in a row without crashing", async () => {
-    class Child extends Component {
-      static template = xml`<div/>`;
-      setup() {
-        onWillPatch(() => app.scheduler.processTasks());
-      }
-    }
-    class SomeComponent extends Component {
-      static template = xml`parent<Child/>`;
-      static components = { Child };
-    }
-
-    const app = new App(SomeComponent);
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("parent<div></div>");
-  });
-
-  test("can add functions to the bdom", async () => {
-    const steps: string[] = [];
-    class SomeComponent extends Component {
-      static template = xml`<div t-on-click="() => __globals__.plop('click')" class="my-div"/>`;
-    }
-    const app = new App(SomeComponent, {
-      globalValues: {
-        plop: (string: any) => {
-          steps.push(string);
-        },
-      },
-    });
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe(`<div class="my-div"></div>`);
-    fixture.querySelector("div")!.click();
-    expect(steps).toEqual(["click"]);
-  });
 });

tests/app/sub_root.test.ts

@@ -1,176 +0,0 @@
-import { App, Component, onMounted, onWillDestroy, useRef, useState, xml } from "../../src";
-import { status } from "../../src/runtime/status";
-import { makeTestFixture, nextTick, snapshotEverything } from "../helpers";
-
-let fixture: HTMLElement;
-
-snapshotEverything();
-
-beforeEach(() => {
-  fixture = makeTestFixture();
-});
-
-class SomeComponent extends Component {
-  static template = xml`<div>main app</div>`;
-}
-
-class SubComponent extends Component {
-  static template = xml`<div>sub root</div>`;
-}
-
-describe("subroot", () => {
-  test("can mount subroot", async () => {
-    const app = new App(SomeComponent);
-    const comp = await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>main app</div>");
-    const subRoot = app.createRoot(SubComponent);
-    const subcomp = await subRoot.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>main app</div><div>sub root</div>");
-
-    app.destroy();
-    expect(fixture.innerHTML).toBe("");
-    expect(status(comp)).toBe("destroyed");
-    expect(status(subcomp)).toBe("destroyed");
-  });
-
-  test("can mount subroot inside own dom", async () => {
-    const app = new App(SomeComponent);
-    const comp = await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>main app</div>");
-    const subRoot = app.createRoot(SubComponent);
-    const subcomp = await subRoot.mount(fixture.querySelector("div")!);
-    expect(fixture.innerHTML).toBe("<div>main app<div>sub root</div></div>");
-
-    app.destroy();
-    expect(fixture.innerHTML).toBe("");
-    expect(status(comp)).toBe("destroyed");
-    expect(status(subcomp)).toBe("destroyed");
-  });
-
-  test("by default, env is the same in sub root", async () => {
-    let env, subenv;
-    class SC extends SomeComponent {
-      setup() {
-        env = this.env;
-      }
-    }
-    class Sub extends SubComponent {
-      setup() {
-        subenv = this.env;
-      }
-    }
-
-    const app = new App(SC);
-    await app.mount(fixture);
-    const subRoot = app.createRoot(Sub);
-    await subRoot.mount(fixture);
-
-    expect(env).toBeDefined();
-    expect(subenv).toBeDefined();
-    expect(env).toBe(subenv);
-  });
-
-  test("env can be specified for sub roots", async () => {
-    const env1 = { env1: true };
-    const env2 = {};
-    let someComponentEnv: any, subComponentEnv: any;
-    class SC extends SomeComponent {
-      setup() {
-        someComponentEnv = this.env;
-      }
-    }
-    class Sub extends SubComponent {
-      setup() {
-        subComponentEnv = this.env;
-      }
-    }
-
-    const app = new App(SC, { env: env1 });
-    await app.mount(fixture);
-    const subRoot = app.createRoot(Sub, { env: env2 });
-    await subRoot.mount(fixture);
-
-    // because env is different in app => it is given a sub object, frozen and all
-    // not sure it is a good idea, but it's the way owl 2 works. maybe we should
-    // avoid doing anything with the main env and let user code do it if they
-    // want. in that case, we can change the test here to assert that they are equal
-    expect(someComponentEnv).not.toBe(env1);
-    expect(someComponentEnv!.env1).toBe(true);
-    expect(subComponentEnv).toBe(env2);
-  });
-
-  test("subcomponents can be destroyed, and it properly cleanup the subroots", async () => {
-    const app = new App(SomeComponent);
-    const comp = await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("<div>main app</div>");
-    const root = app.createRoot(SubComponent);
-    const subcomp = await root.mount(fixture.querySelector("div")!);
-    expect(fixture.innerHTML).toBe("<div>main app<div>sub root</div></div>");
-
-    root.destroy();
-    expect(fixture.innerHTML).toBe("<div>main app</div>");
-    expect(status(comp)).not.toBe("destroyed");
-    expect(status(subcomp)).toBe("destroyed");
-  });
-
-  test("can create a root in a setup function, then use a hook", async () => {
-    class C extends Component {
-      static template = xml`c`;
-    }
-
-    class A extends Component {
-      static template = xml`a`;
-      state: any;
-      setup() {
-        app.createRoot(C);
-        this.state = useState({ value: 1 });
-      }
-    }
-
-    const app = new App(A);
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe("a");
-  });
-});
-
-test("destroy a subroot while another component is mounted in main app", async () => {
-  class C extends Component {
-    static template = xml`c`;
-  }
-
-  class ChildA extends Component {
-    static template = xml`a<div t-ref="elem"></div>`;
-    ref: any;
-    setup() {
-      this.ref = useRef("elem");
-      let root = app.createRoot(C);
-      onMounted(() => {
-        root.mount(this.ref.el);
-      });
-      onWillDestroy(() => {
-        root.destroy();
-      });
-    }
-  }
-  class ChildB extends Component {
-    static template = xml`b`;
-  }
-
-  class SomeComponent extends Component {
-    static template = xml`
-        <t t-if="state.flag"><ChildB/></t>
-        <t t-else=""><ChildA/></t>
-        `;
-    static components = { ChildA, ChildB };
-    state = useState({ flag: false });
-  }
-
-  const app = new App(SomeComponent);
-  const comp = await app.mount(fixture);
-  expect(fixture.innerHTML).toBe("a<div></div>");
-  await nextTick();
-  expect(fixture.innerHTML).toBe("a<div>c</div>");
-  comp.state.flag = true;
-  await nextTick();
-  expect(fixture.innerHTML).toBe("b");
-});

tests/compiler/__snapshots__/t_custom.test.ts.snap

@@ -1,29 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`t-custom can use t-custom directive on a node 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div class=\\"my-div\\" block-handler-0=\\"click\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['click'], ctx];
-    return block1([hdlr1]);
-  }
-}"
-`;
-
-exports[`t-custom can use t-custom directive with modifier on a node 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div class=\\"my-div\\" block-handler-0=\\"click\\"/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['click'], ctx];
-    return block1([hdlr1]);
-  }
-}"
-`;

tests/compiler/t_custom.test.ts

@@ -1,55 +0,0 @@
-import { App, Component, xml } from "../../src";
-import { makeTestFixture, snapshotEverything } from "../helpers";
-
-let fixture: HTMLElement;
-
-snapshotEverything();
-
-beforeEach(() => {
-  fixture = makeTestFixture();
-});
-
-describe("t-custom", () => {
-  test("can use t-custom directive on a node", async () => {
-    const steps: string[] = [];
-    class SomeComponent extends Component {
-      static template = xml`<div t-custom-plop="click" class="my-div"/>`;
-      click() {
-        steps.push("clicked");
-      }
-    }
-    const app = new App(SomeComponent, {
-      customDirectives: {
-        plop: (node, value) => {
-          node.setAttribute("t-on-click", value);
-        },
-      },
-    });
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe(`<div class="my-div"></div>`);
-    fixture.querySelector("div")!.click();
-    expect(steps).toEqual(["clicked"]);
-  });
-
-  test("can use t-custom directive with modifier on a node", async () => {
-    const steps: string[] = [];
-    class SomeComponent extends Component {
-      static template = xml`<div t-custom-plop.mouse="click" class="my-div"/>`;
-      click() {
-        steps.push("clicked");
-      }
-    }
-    const app = new App(SomeComponent, {
-      customDirectives: {
-        plop: (node, value, modifier) => {
-          node.setAttribute("t-on-click", value);
-          steps.push(modifier || "");
-        },
-      },
-    });
-    await app.mount(fixture);
-    expect(fixture.innerHTML).toBe(`<div class="my-div"></div>`);
-    fixture.querySelector("div")!.click();
-    expect(steps).toEqual(["mouse", "clicked"]);
-  });
-});

tests/compiler/validation.test.ts

@@ -48,7 +48,7 @@ describe("basic validation", () => {
   test("compilation error", () => {
     const template = `<div t-att-class="a b">test</div>`;
     expect(() => renderToString(template))
-      .toThrow(`Failed to compile anonymous template: Unexpected identifier 'ctx'
+      .toThrow(`Failed to compile anonymous template: Unexpected identifier
 
 generated code:
 function(app, bdom, helpers) {

tests/components/__snapshots__/basics.test.ts.snap

@@ -97,19 +97,6 @@ exports[`basics a component cannot be mounted in a detached node (even if node i
 }"
 `;
 
-exports[`basics a component cannot be mounted in a detached node 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`basics a component inside a component 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -274,19 +261,6 @@ exports[`basics can mount a simple component with props 1`] = `
 }"
 `;
 
-exports[`basics cannot mount on a documentFragment 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>content</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`basics child can be updated 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
@@ -1028,19 +1002,6 @@ exports[`basics three level of components with collapsing root nodes 3`] = `
 }"
 `;
 
-exports[`basics throws if mounting on target=null 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<span>simple vnode</span>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`basics two child components 1`] = `
 "function anonymous(app, bdom, helpers
 ) {

tests/components/__snapshots__/error_handling.test.ts.snap

@@ -320,50 +320,6 @@ exports[`can catch errors can catch an error in a component render function 3`]
 }"
 `;
 
-exports[`can catch errors can catch an error in onmounted 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  const comp1 = app.createComponent(null, false, false, false, []);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2, b3;
-    b2 = text(\`Main\`);
-    if (ctx['state'].ok) {
-      const Comp1 = ctx['component'];
-      b3 = toggler(Comp1, comp1({}, (Comp1).name + key + \`__1\`, node, this, Comp1));
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`can catch errors can catch an error in onmounted 3`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>Error!!!</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`can catch errors can catch an error in onmounted 4`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>perfect</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`can catch errors can catch an error in the constructor call of a component render function 1`] = `
 "function anonymous(app, bdom, helpers
 ) {

tests/components/__snapshots__/lifecycle.test.ts.snap

@@ -683,7 +683,7 @@ exports[`lifecycle hooks sub widget (inside sub node): hooks are correctly calle
 }"
 `;
 
-exports[`lifecycle hooks timeout in onWillStart doesn't emit a console log if app is destroyed 1`] = `
+exports[`lifecycle hooks timeout in onWillStart doesn't emit a warning if app is destroyed 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
@@ -696,7 +696,7 @@ exports[`lifecycle hooks timeout in onWillStart doesn't emit a console log if ap
 }"
 `;
 
-exports[`lifecycle hooks timeout in onWillStart emits a console log 1`] = `
+exports[`lifecycle hooks timeout in onWillStart emits a warning 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
@@ -709,7 +709,7 @@ exports[`lifecycle hooks timeout in onWillStart emits a console log 1`] = `
 }"
 `;
 
-exports[`lifecycle hooks timeout in onWillUpdateProps emits a console log 1`] = `
+exports[`lifecycle hooks timeout in onWillUpdateProps emits a warning 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
@@ -723,7 +723,7 @@ exports[`lifecycle hooks timeout in onWillUpdateProps emits a console log 1`] =
 }"
 `;
 
-exports[`lifecycle hooks timeout in onWillUpdateProps emits a console log 2`] = `
+exports[`lifecycle hooks timeout in onWillUpdateProps emits a warning 2`] = `
 "function anonymous(app, bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;

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

@@ -924,20 +924,6 @@ exports[`props validation props: list of strings 1`] = `
 }"
 `;
 
-exports[`props validation validate props for root component 1`] = `
-"function anonymous(app, bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
-  
-  let block1 = createBlock(\`<div><block-text-0/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['message'];
-    return block1([txt1]);
-  }
-}"
-`;
-
 exports[`props validation validate simple types 1`] = `
 "function anonymous(app, bdom, helpers
 ) {

tests/components/error_handling.test.ts

@@ -157,7 +157,7 @@ describe("basics", () => {
     } catch (e) {
       error = e as Error;
     }
-    const expectedErrorMessage = `Failed to compile anonymous template: Unexpected identifier 'ctx'
+    const expectedErrorMessage = `Failed to compile anonymous template: Unexpected identifier
 
 generated code:
 function(app, bdom, helpers) {
@@ -182,7 +182,7 @@ function(app, bdom, helpers) {
       static components = { Child };
       static template = xml`<Child/>`;
     }
-    const expectedErrorMessage = `Failed to compile anonymous template: Unexpected identifier 'ctx'
+    const expectedErrorMessage = `Failed to compile anonymous template: Unexpected identifier
 
 generated code:
 function(app, bdom, helpers) {
@@ -564,82 +564,6 @@ describe("can catch errors", () => {
     expect(mockConsoleWarn).toBeCalledTimes(0);
   });
 
-  test("can catch an error in onmounted", async () => {
-    class ErrorComponent extends Component {
-      static template = xml`<div>Error!!!</div>`;
-      setup() {
-        useLogLifecycle();
-        onMounted(() => {
-          throw new Error("error");
-        });
-      }
-    }
-    class PerfectComponent extends Component {
-      static template = xml`<div>perfect</div>`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-    class Main extends Component {
-      static template = xml`Main<t t-if="state.ok" t-component="component"/>`;
-      component: any;
-      state: any;
-      setup() {
-        this.state = useState({ ok: false });
-        useLogLifecycle();
-        this.component = ErrorComponent;
-        onError(() => {
-          this.component = PerfectComponent;
-          this.render();
-        });
-      }
-    }
-
-    const app = await mount(Main, fixture);
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "Main:setup",
-        "Main:willStart",
-        "Main:willRender",
-        "Main:rendered",
-        "Main:mounted",
-      ]
-    `);
-    expect(fixture.innerHTML).toBe("Main");
-    (app as any).state.ok = true;
-    await nextTick();
-    expect(fixture.innerHTML).toBe("Main<div>Error!!!</div>");
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "Main:willRender",
-        "ErrorComponent:setup",
-        "ErrorComponent:willStart",
-        "Main:rendered",
-        "ErrorComponent:willRender",
-        "ErrorComponent:rendered",
-        "Main:willPatch",
-        "ErrorComponent:mounted",
-        "Main:willRender",
-        "PerfectComponent:setup",
-        "PerfectComponent:willStart",
-        "Main:rendered",
-      ]
-    `);
-    await nextTick();
-    expect(steps.splice(0)).toMatchInlineSnapshot(`
-      Array [
-        "PerfectComponent:willRender",
-        "PerfectComponent:rendered",
-        "Main:willPatch",
-        "ErrorComponent:willUnmount",
-        "ErrorComponent:willDestroy",
-        "PerfectComponent:mounted",
-        "Main:patched",
-      ]
-    `);
-    expect(fixture.innerHTML).toBe("Main<div>perfect</div>");
-  });
-
   test("calling a hook outside setup should crash", async () => {
     class Root extends Component {
       static template = xml`<t t-esc="state.value"/>`;

tests/components/lifecycle.test.ts

@@ -112,10 +112,10 @@ describe("lifecycle hooks", () => {
     await mount(Test, fixture);
   });
 
-  test("timeout in onWillStart emits a console log", async () => {
-    const { log } = console;
-    let logArgs: any[];
-    console.log = jest.fn((...args) => (logArgs = args));
+  test("timeout in onWillStart emits a warning", async () => {
+    const { warn } = console;
+    let warnArgs: any[];
+    console.warn = jest.fn((...args) => (warnArgs = args));
     const { setTimeout } = window;
     let timeoutCbs: any = {};
     let timeoutId = 0;
@@ -138,17 +138,17 @@ describe("lifecycle hooks", () => {
       }
       await nextMicroTick();
       await nextMicroTick();
-      expect(console.log).toHaveBeenCalledTimes(1);
-      expect(logArgs![0]!.message).toBe("onWillStart's promise hasn't resolved after 3 seconds");
+      expect(console.warn).toHaveBeenCalledTimes(1);
+      expect(warnArgs![0]!.message).toBe("onWillStart's promise hasn't resolved after 3 seconds");
     } finally {
-      console.log = log;
+      console.warn = warn;
       window.setTimeout = setTimeout;
     }
   });
 
-  test("timeout in onWillStart doesn't emit a console log if app is destroyed", async () => {
-    const { log } = console;
-    console.log = jest.fn();
+  test("timeout in onWillStart doesn't emit a warning if app is destroyed", async () => {
+    const { warn } = console;
+    console.warn = jest.fn();
     const { setTimeout } = window;
     let timeoutCbs: any = {};
     let timeoutId = 0;
@@ -172,14 +172,14 @@ describe("lifecycle hooks", () => {
       }
       await nextMicroTick();
       await nextMicroTick();
-      expect(console.log).toHaveBeenCalledTimes(0);
+      expect(console.warn).toHaveBeenCalledTimes(0);
     } finally {
-      console.log = log;
+      console.warn = warn;
       window.setTimeout = setTimeout;
     }
   });
 
-  test("timeout in onWillUpdateProps emits a console log", async () => {
+  test("timeout in onWillUpdateProps emits a warning", async () => {
     class Child extends Component {
       static template = xml``;
       setup() {
@@ -193,9 +193,9 @@ describe("lifecycle hooks", () => {
     }
     const parent = await mount(Parent, fixture, { test: true });
 
-    const { log } = console;
-    let logArgs: any[];
-    console.log = jest.fn((...args) => (logArgs = args));
+    const { warn } = console;
+    let warnArgs: any[];
+    console.warn = jest.fn((...args) => (warnArgs = args));
     const { setTimeout } = window;
     let timeoutCbs: any = {};
     let timeoutId = 0;
@@ -218,12 +218,12 @@ describe("lifecycle hooks", () => {
         delete timeoutCbs[id];
       }
       await tick;
-      expect(console.log).toHaveBeenCalledTimes(1);
-      expect(logArgs![0]!.message).toBe(
+      expect(console.warn).toHaveBeenCalledTimes(1);
+      expect(warnArgs![0]!.message).toBe(
         "onWillUpdateProps's promise hasn't resolved after 3 seconds"
       );
     } finally {
-      console.log = log;
+      console.warn = warn;
       window.setTimeout = setTimeout;
     }
   });

tools/devtools/manifest-chrome.json

@@ -14,7 +14,7 @@
     "default_popup": "popup_app/popup.html"
   },
   "permissions": ["scripting", "storage"],
-  "host_permissions": ["http://*/*", "https://*/*", "file://*"],
+  "host_permissions": ["http://*/*", "https://*/*"],
   "content_security_policy": {
     "script-src": "self",
     "object-src": "self"

tools/devtools/src/page_scripts/owl_devtools_global_hook.js

@@ -109,34 +109,23 @@
         object(obj) {
           const result = [];
           let length = 0;
-          if (obj instanceof String) {
-            result[0] = `'${obj.toString()}'`;
-          } else if (obj instanceof Array) {
-            return `${obj.constructor.name} ${this.array([...obj])}`;
-          } else if (obj instanceof Number) {
-            result[0] = obj.toString();
-          } else {
-            for (const [key, value] of Object.entries(obj)) {
-              if (length > 25) {
-                result.push("...");
-                break;
-              }
-              const element = key + ": " + this.serializeItem(value);
-              length += element.length;
-              result.push(element);
-            }
-            for (const key of Object.getOwnPropertySymbols(obj)) {
-              if (length > 25) {
-                result.push("...");
-                break;
-              }
-              const element = key.toString() + ": " + this.serializeItem(obj[key]);
-              length += element.length;
-              result.push(element);
+          for (const [key, value] of Object.entries(obj)) {
+            if (length > 25) {
+              result.push("...");
+              break;
             }
+            const element = key + ": " + this.serializeItem(value);
+            length += element.length;
+            result.push(element);
           }
-          if (obj.constructor.name !== "Object") {
-            return obj.constructor.name + " {" + result.join(", ") + "}";
+          for (const key of Object.getOwnPropertySymbols(obj)) {
+            if (length > 25) {
+              result.push("...");
+              break;
+            }
+            const element = key.toString() + ": " + this.serializeItem(obj[key]);
+            length += element.length;
+            result.push(element);
           }
           return "{" + result.join(", ") + "}";
         },
@@ -834,7 +823,7 @@
               child.contentType = "set";
               child.hasChildren = true;
               break;
-            case obj.constructor.name === "Array":
+            case obj instanceof Array:
               child.contentType = "array";
               child.hasChildren = obj.length > 0;
               break;
@@ -845,9 +834,7 @@
             case obj instanceof Object:
               child.contentType = "object";
               child.hasChildren =
-                Object.keys(obj).length ||
-                Object.getOwnPropertySymbols(obj).length ||
-                obj.constructor.name !== "Object";
+                Object.keys(obj).length || Object.getOwnPropertySymbols(obj).length;
               break;
             default:
               child.contentType = typeof obj;

tools/release.js

@@ -140,6 +140,7 @@ async function startRelease() {
   }
 
   // ---------------------------------------------------------------------------
+
   log(`Step ${step++}/${STEPS}: Creating the release...`);
   const relaseResult = await execCommand(`gh release create v${next} dist/*.js dist/*.zip ${draft} -F ${file}`);
   if (relaseResult !== 0) {