PROTOTYPE: batch renders in animation frame instead of microtick

CHANGELOG.md

@@ -31,7 +31,6 @@ All changes are documented here in no particular order.
 - 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))
 
 
 
@@ -44,6 +43,7 @@ All changes are documented here in no particular order.
 - 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))
+- breaking: `t-on` does not work on components any more ([details](#12-t-on-does-not-work-on-components-any-more))
 - 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
@@ -80,6 +80,7 @@ All changes are documented here in no particular order.
 - 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 `Memo` component
 - 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))
@@ -247,12 +248,35 @@ 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.
+a much more powerful reactivity system.
 
-Migration code: remove the `shouldUpdate` methods, and it should work as well
-as before.
+Migration code: remove the `shouldUpdate` methods. Then, maybe the following
+ideas may help:
+
+- try to organize the state/architecture to minimize the number of state updates
+- take advantage of the finer reactivity system. For example, if we have a list
+  of items, with a component for each item, we can write this:
+
+  ```js
+  class Item extends Component {
+      setup() {
+          this.item = useState(this.props.item); // and only use this, not props.item
+      }
+  }
+  ```
+  Doing so will make it that each `Item` component will register itself as an
+  observer of its own item, and will be the only component being rerendered when
+  its item object is updated.
+- use the `Memo` component to wrap some piece of template. `Memo` memoize its
+  content, and only update itself if its props are different (shallow comparison):
+  
+  ```xml
+    <Memo a="state.a" b="state.b"> 
+        <t t-esc="state.a"/>
+        <t t-esc="state.b"/>
+        <t t-esc="state.c"/>
+    </Memo>
+  ```
 
 ### 9. component.el is removed
 
@@ -312,6 +336,41 @@ Documentation:
 - [Mounting a component](doc/reference/app.md#mount-helper)
 
 
+### 12. `t-on` does not work on components any more
+
+In owl 1, it was possible to bind an event listener on a component tag in a
+template:
+
+```xml
+<SomeComponent t-on-some-event="doSomething"/>
+```
+
+This does not work any more.
+
+Rationale: with the support of fragments, there is no longer a canonical html
+element that we can refer. So, this makes it difficult to implement correctly
+and efficiently. Also, we noticed in practice that the event system was an issue
+in some cases, when components need to communicate before they are mounted. In
+those cases, the better solution is to directly use a callback.  Also, another
+conceptual issue with this is that it kind of breaks the component encapsulation.
+The child component kind of leak its own implementation to the outside world.
+
+Migration: a quick fix that may work in some cases is to simply bind the event
+handler on a parent htmlelement. A better way to do it, if possible, is to change
+the component API to accept explicitely a callback as props. 
+
+```xml
+<SomeComponent onSomeEvent="doSomething"/>
+<!-- or alternatively: -->
+<SomeComponent onSomeEvent.bind="doSomething"/>
+```
+
+Note that one of the example above uses the `.bind` suffix, to bind the function
+prop to the component.  Most of the time, binding the function is necessary, and
+using the `.bind` suffix is very helpful in that case.
+
+Documentation: [Binding function props](doc/reference/props.md#binding-function-props)
+
 ### 13. Portal does no longer transfer DOM events
 
 In Owl 1, a Portal component would listen to events emitted on its portalled
@@ -739,28 +798,4 @@ 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.
-
+or to use native browser function (and then, just mock them directly).

README.md

@@ -82,7 +82,6 @@ Are you new to Owl? This is the place to start!
 - [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)
@@ -111,7 +110,6 @@ Are you new to Owl? This is the place to start!
 - [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)
 
 ## Installing Owl
 

doc/learning/tutorial_todoapp.md

@@ -240,7 +240,7 @@ 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"/>
-      <span><t t-esc="props.task.text"/></span>
+      <span><t t-esc="props.task.title"/></span>
     </div>`;
   static props = ["task"];
 }
@@ -743,7 +743,7 @@ the user experience.
 ```xml
 <input type="checkbox" t-att-checked="props.task.isCompleted"
     t-att-id="props.task.id"
-    t-on-click="() => store.toggleTask(props.task)"/>
+    t-on-click="dispatch('toggleTask', props.task.id)"/>
 <label t-att-for="props.task.id"><t t-esc="props.task.text"/></label>
 ```
 

doc/miscellaneous/compiled_template.md

@@ -1,98 +0,0 @@
-# 🦉 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/reference/app.md

@@ -51,10 +51,11 @@ 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);
+- **`dev (boolean, default=false)`**: if `true`, the application is rendered in `dev`
+  mode, which activates some additional checks (in particular, the props validation
+  code is only performed in 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.
+  that Owll 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
@@ -109,13 +110,3 @@ const { loadFile, mount } = owl;
   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/component.md

@@ -68,16 +68,12 @@ The `Component` class has a very small API.
   component will go through the following lifecycle methods: `willUpdateProps`,
   `willPatch` and `patched`.
 
-* **`render(deep[=false])`**: calling this method directly will cause a rerender. Note
+* **`render()`**: calling this method directly will cause a rerender. Note
   that with the reactivity system, this should be rare to have to do it manually.
   Also, the rendering operation is asynchronous, so the DOM will only be updated
   slightly later (at the next animation frame, if no component delays the
   rendering)
 
-  By default, the render initiated by this method will stop at each child
-  component if their props are (shallow) equal. To force a render to update
-  all child components, one can use the optional `deep` argument.
-
 ## Static Properties
 
 - **`template (string)`**: this is the name of the template that

doc/reference/event_handling.md

@@ -5,7 +5,6 @@
 - [Event Handling](#event-handling)
 - [Modifiers](#modifiers)
 - [Synthetic Events](#synthetic-events)
-- [On Components](#on-components)
 
 ## Event Handling
 
@@ -101,19 +100,3 @@ To enable it, one can just use the `.synthetic` suffix:
     </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/reactivity.md

@@ -25,11 +25,6 @@ To solve this issue, Owl provides two reactivity primitives:
 
 Most of the time, the `useState` hook is the best solution.
 
-Since version 2.0, Owl applies the fine grained reactivity at the component
-level: props are automatically turned into reactive object, so Owl can track
-which part of these props are consumed by each component, and is therefore able
-to only rerender the impacted components.
-
 ## `useState`
 
 Let us start by an example of how `useState` could be used:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odoo/owl",
-  "version": "2.0.0-beta-4",
+  "version": "2.0.0-alpha.2",
   "description": "Odoo Web Library (OWL)",
   "main": "dist/owl.cjs.js",
   "browser": "dist/owl.iife.js",

src/app/app.ts

@@ -18,8 +18,6 @@ export interface AppConfig<P, E> extends TemplateSetConfig {
   test?: boolean;
 }
 
-let hasBeenLogged = false;
-
 export const DEV_MSG = () => {
   const hash = (window as any).owl ? (window as any).owl.__info__.hash : "master";
 
@@ -31,7 +29,7 @@ See https://github.com/odoo/owl/blob/${hash}/doc/reference/app.md#configuration
 
 export class App<
   T extends abstract new (...args: any) => any = any,
-  P extends object = any,
+  P = any,
   E = any
 > extends TemplateSet {
   static validateTarget = validateTarget;
@@ -48,13 +46,11 @@ export class App<
     if (config.test) {
       this.dev = true;
     }
-    if (this.dev && !config.test && !hasBeenLogged) {
+    if (this.dev && !config.test) {
       console.info(DEV_MSG());
-      hasBeenLogged = true;
     }
-    const env = config.env || {};
-    const descrs = Object.getOwnPropertyDescriptors(env);
-    this.env = Object.freeze(Object.create(Object.getPrototypeOf(env), descrs));
+    const descrs = Object.getOwnPropertyDescriptors(config.env || {});
+    this.env = Object.freeze(Object.defineProperties({}, descrs)) as E;
     this.props = config.props || ({} as P);
   }
 
@@ -101,17 +97,12 @@ export class App<
 
   destroy() {
     if (this.root) {
-      this.scheduler.flush();
       this.root.destroy();
     }
   }
 }
 
-export async function mount<
-  T extends abstract new (...args: any) => any = any,
-  P extends object = any,
-  E = any
->(
+export async function mount<T extends abstract new (...args: any) => any = any, P = any, E = any>(
   C: T & ComponentConstructor<P, E>,
   target: HTMLElement,
   config: AppConfig<P, E> & MountOptions = {}

src/app/template_helpers.ts

@@ -1,9 +1,7 @@
-import { BDom, multi, text, toggler, createCatcher } from "../blockdom";
+import { BDom, multi, text, toggler } from "../blockdom";
 import { validateProps } from "../component/props_validation";
 import { Markup } from "../utils";
 import { html } from "../blockdom/index";
-import { TARGET } from "../reactivity";
-
 /**
  * This file contains utility functions that will be injected in each template,
  * to perform various useful tasks in the compiled code.
@@ -23,11 +21,11 @@ function callSlot(
   defaultContent?: (ctx: any, node: any, key: string) => BDom
 ): BDom {
   key = key + "__slot_" + name;
-  const slots = ctx.props[TARGET].slots || {};
+  const slots = (ctx.props && ctx.props.slots) || {};
   const { __render, __ctx, __scope } = slots[name] || {};
   const slotScope = Object.create(__ctx || {});
   if (__scope) {
-    slotScope[__scope] = extra;
+    slotScope[__scope] = extra || {};
   }
   const slotBDom = __render ? __render.call(__ctx.__owl__.component, slotScope, parent, key) : null;
   if (defaultContent) {
@@ -183,7 +181,7 @@ function multiRefSetter(refs: RefMap, name: string): RefSetter {
   };
 }
 
-export const helpers = {
+export const UTILS = {
   withDefault,
   zero: Symbol("zero"),
   isBoundary,
@@ -199,5 +197,4 @@ export const helpers = {
   LazyValue,
   safeOutput,
   bind,
-  createCatcher,
 };

src/app/template_set.ts

@@ -1,13 +1,12 @@
 import { createBlock, html, list, multi, text, toggler, comment } from "../blockdom";
 import { compile, Template } from "../compiler";
-import { markRaw } from "../reactivity";
-import { Portal } from "../portal";
 import { component, getCurrent } from "../component/component_node";
-import { helpers } from "./template_helpers";
-import { globalTemplates } from "../utils";
+import { UTILS } from "./template_helpers";
 
 const bdom = { text, createBlock, list, multi, html, toggler, component, comment };
 
+export const globalTemplates: { [key: string]: string | Element } = {};
+
 function parseXML(xml: string): Document {
   const parser = new DOMParser();
 
@@ -38,22 +37,6 @@ function parseXML(xml: string): Document {
   return doc;
 }
 
-/**
- * Returns the helpers object that will be injected in each template closure
- * function
- */
-function makeHelpers(getTemplate: (name: string) => Template): any {
-  return Object.assign({}, helpers, {
-    Portal,
-    markRaw,
-    getTemplate,
-    call: (owner: any, subTemplate: string, ctx: any, parent: any, key: any) => {
-      const template = getTemplate(subTemplate);
-      return toggler(subTemplate, template.call(owner, ctx, parent, key));
-    },
-  });
-}
-
 export interface TemplateSetConfig {
   dev?: boolean;
   translatableAttributes?: string[];
@@ -67,7 +50,13 @@ export class TemplateSet {
   templates: { [name: string]: Template } = {};
   translateFn?: (s: string) => string;
   translatableAttributes?: string[];
-  helpers: any;
+  utils: typeof UTILS = Object.assign({}, UTILS, {
+    call: (owner: any, subTemplate: string, ctx: any, parent: any, key: any) => {
+      const template = this.getTemplate(subTemplate);
+      return toggler(subTemplate, template.call(owner, ctx, parent, key));
+    },
+    getTemplate: (name: string) => this.getTemplate(name),
+  });
 
   constructor(config: TemplateSetConfig = {}) {
     this.dev = config.dev || false;
@@ -76,7 +65,6 @@ export class TemplateSet {
     if (config.templates) {
       this.addTemplates(config.templates);
     }
-    this.helpers = makeHelpers(this.getTemplate.bind(this));
   }
 
   addTemplate(
@@ -120,7 +108,7 @@ export class TemplateSet {
       this.templates[name] = function (context, parent) {
         return templates[name].call(this, context, parent);
       };
-      const template = templateFn(bdom, this.helpers);
+      const template = templateFn(bdom, this.utils);
       this.templates[name] = template;
     }
     return this.templates[name];
@@ -135,3 +123,15 @@ export class TemplateSet {
     });
   }
 }
+
+// -----------------------------------------------------------------------------
+//  xml tag helper
+// -----------------------------------------------------------------------------
+export function xml(...args: Parameters<typeof String.raw>) {
+  const name = `__template__${xml.nextId++}`;
+  const value = String.raw(...args);
+  globalTemplates[name] = value;
+  return name;
+}
+
+xml.nextId = 1;

src/blockdom/attributes.ts

@@ -139,8 +139,7 @@ export function updateClass(this: HTMLElement, val: any, oldVal: any) {
 
 export function makePropSetter(name: string): Setter<HTMLElement> {
   return function setProp(this: HTMLElement, value: any) {
-    // support 0, fallback to empty string for other falsy values
-    (this as any)[name] = value === 0 ? 0 : value || "";
+    (this as any)[name] = value || "";
   };
 }
 

src/blockdom/event_catcher.ts

@@ -1,89 +0,0 @@
-import { createEventHandler } from "./events";
-import type { VNode } from "./index";
-
-type EventsSpec = { [name: string]: number };
-
-type Catcher = (child: VNode, handlers: any[]) => VNode;
-
-export function createCatcher(eventsSpec: EventsSpec): Catcher {
-  let setupFns: any[] = [];
-  let removeFns: any[] = [];
-  for (let name in eventsSpec) {
-    let index = eventsSpec[name];
-    let { setup, remove } = createEventHandler(name);
-    setupFns[index] = setup;
-    removeFns[index] = remove;
-  }
-  let n = setupFns.length;
-
-  class VCatcher {
-    child: VNode;
-    handlers: any[];
-
-    parentEl?: HTMLElement | undefined;
-    afterNode: Node | null = null;
-
-    constructor(child: VNode, handlers: any[]) {
-      this.child = child;
-      this.handlers = handlers;
-    }
-
-    mount(parent: HTMLElement, afterNode: Node | null) {
-      this.parentEl = parent;
-      this.afterNode = afterNode;
-      this.child.mount(parent, afterNode);
-      for (let i = 0; i < n; i++) {
-        let origFn = this.handlers[i][0];
-        const self = this;
-        this.handlers[i][0] = function (ev: any) {
-          const target = ev.target;
-          let currentNode: any = self.child.firstNode();
-          const afterNode = self.afterNode;
-          while (currentNode !== afterNode) {
-            if (currentNode.contains(target)) {
-              return origFn.call(this, ev);
-            }
-            currentNode = currentNode.nextSibling;
-          }
-        };
-        setupFns[i].call(parent, this.handlers[i]);
-      }
-    }
-
-    moveBefore(other: VCatcher | null, afterNode: Node | null) {
-      this.afterNode = null;
-      this.child.moveBefore(other ? other.child : null, afterNode);
-    }
-
-    patch(other: VCatcher, withBeforeRemove: boolean) {
-      if (this === other) {
-        return;
-      }
-      this.handlers = other.handlers;
-      this.child.patch(other.child, withBeforeRemove);
-    }
-
-    beforeRemove() {
-      this.child.beforeRemove();
-    }
-
-    remove() {
-      for (let i = 0; i < n; i++) {
-        removeFns[i].call(this.parentEl!);
-      }
-      this.child.remove();
-    }
-
-    firstNode(): Node | undefined {
-      return this.child.firstNode();
-    }
-
-    toString(): string {
-      return this.child.toString();
-    }
-  }
-
-  return function (child: VNode, handlers: any[]): VNode<VCatcher> {
-    return new VCatcher(child, handlers);
-  };
-}

src/blockdom/events.ts

@@ -5,7 +5,6 @@ type EventHandlerSetter = (this: HTMLElement, data: any) => void;
 interface EventHandlerCreator {
   setup: EventHandlerSetter;
   update: EventHandlerSetter;
-  remove: (this: HTMLElement) => void;
 }
 
 export function createEventHandler(rawEvent: string): EventHandlerCreator {
@@ -39,15 +38,11 @@ function createElementHandler(evName: string, capture: boolean = false): EventHa
     this.addEventListener(evName, listener, { capture });
   }
 
-  function remove(this: HTMLElement) {
-    delete (this as any)[eventKey];
-    this.removeEventListener(evName, listener, { capture });
-  }
   function update(this: HTMLElement, data: any) {
     (this as any)[eventKey] = data;
   }
 
-  return { setup, update, remove };
+  return { setup, update };
 }
 
 // Synthetic handler: a form of event delegation that allows placing only one
@@ -65,12 +60,7 @@ function createSyntheticHandler(evName: string, capture: boolean = false): Event
     _data[currentId] = data;
     (this as any)[eventKey] = _data;
   }
-
-  function remove(this: HTMLElement) {
-    delete (this as any)[eventKey];
-  }
-
-  return { setup, update: setup, remove };
+  return { setup, update: setup };
 }
 
 function nativeToSyntheticEvent(eventKey: string, event: Event) {

src/blockdom/index.ts

@@ -6,7 +6,6 @@ export { list } from "./list";
 export { multi } from "./multi";
 export { text, comment } from "./text";
 export { html } from "./html";
-export { createCatcher } from "./event_catcher";
 
 export interface VNode<T = any> {
   mount(parent: HTMLElement, afterNode: Node | null): void;

src/compiler/code_generator.ts

@@ -20,8 +20,6 @@ import {
   ASTTranslation,
   ASTType,
   ASTTPortal,
-  EventHandlers,
-  Attrs,
 } from "./parser";
 
 type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
@@ -159,11 +157,9 @@ class CodeTarget {
   // maps ref name to [id, expr]
   refInfo: { [name: string]: [string, string] } = {};
   shouldProtectScope: boolean = false;
-  on: EventHandlers | null;
 
-  constructor(name: string, on?: EventHandlers | null) {
+  constructor(name: string) {
     this.name = name;
-    this.on = on || null;
   }
 
   addLine(line: string, idx?: number) {
@@ -220,7 +216,7 @@ export class CodeGenerator {
   translateFn: (s: string) => string;
   translatableAttributes: string[] = TRANSLATABLE_ATTRS;
   ast: AST;
-  staticDefs: { id: string; expr: string }[] = [];
+  staticCalls: { id: string; template: string }[] = [];
   helpers: Set<string> = new Set();
 
   constructor(ast: AST, options: CodeGenOptions) {
@@ -266,8 +262,8 @@ export class CodeGenerator {
       mainCode.push(`// Template name: "${this.templateName}"`);
     }
 
-    for (let { id, expr } of this.staticDefs) {
-      mainCode.push(`const ${id} = ${expr};`);
+    for (let { id, template } of this.staticCalls) {
+      mainCode.push(`const ${id} = getTemplate(${template});`);
     }
 
     // define all blocks
@@ -307,23 +303,20 @@ export class CodeGenerator {
     return code;
   }
 
-  compileInNewTarget(prefix: string, ast: AST, ctx: Context, on?: EventHandlers | null): string {
+  compileInNewTarget(prefix: string, ast: AST, ctx: Context): string {
     const name = this.generateId(prefix);
     const initialTarget = this.target;
-    const target = new CodeTarget(name, on);
+    const target = new CodeTarget(name);
     this.targets.push(target);
     this.target = target;
-    this.compileAST(ast, createContext(ctx));
+    const subCtx: Context = createContext(ctx);
+    this.compileAST(ast, subCtx);
     this.target = initialTarget;
     return name;
   }
 
-  addLine(line: string, idx?: number) {
-    this.target.addLine(line, idx);
-  }
-
-  define(varName: string, expr: string) {
-    this.addLine(`const ${varName} = ${expr};`);
+  addLine(line: string) {
+    this.target.addLine(line);
   }
 
   generateId(prefix: string = ""): string {
@@ -375,12 +368,9 @@ export class CodeGenerator {
     }
 
     if (block.isRoot && !ctx.preventRoot) {
-      if (this.target.on) {
-        blockExpr = this.wrapWithEventCatcher(blockExpr, this.target.on);
-      }
       this.addLine(`return ${blockExpr};`);
     } else {
-      this.define(block.varName, blockExpr);
+      this.addLine(`let ${block.varName} = ${blockExpr};`);
     }
   }
 
@@ -409,7 +399,7 @@ export class CodeGenerator {
           if (!mapping.has(tok.varName)) {
             const varId = this.generateId("v");
             mapping.set(tok.varName, varId);
-            this.define(varId, tok.value);
+            this.addLine(`const ${varId} = ${tok.value};`);
           }
           tok.value = mapping.get(tok.varName)!;
         }
@@ -554,12 +544,12 @@ export class CodeGenerator {
       this.blocks.push(block);
       if (ast.dynamicTag) {
         const tagExpr = this.generateId("tag");
-        this.define(tagExpr, compileExpr(ast.dynamicTag));
+        this.addLine(`let ${tagExpr} = ${compileExpr(ast.dynamicTag)};`);
         block.dynamicTagName = tagExpr;
       }
     }
     // attributes
-    const attrs: Attrs = {};
+    const attrs: { [key: string]: string } = {};
     const nameSpace = ast.ns || ctx.nameSpace;
     if (nameSpace && isNewBlock) {
       // specific namespace uri
@@ -649,11 +639,11 @@ export class CodeGenerator {
 
       const baseExpression = compileExpr(baseExpr);
       const bExprId = this.generateId("bExpr");
-      this.define(bExprId, baseExpression);
+      this.addLine(`const ${bExprId} = ${baseExpression};`);
 
       const expression = compileExpr(expr);
       const exprId = this.generateId("expr");
-      this.define(exprId, expression);
+      this.addLine(`const ${exprId} = ${expression};`);
 
       const fullExpression = `${bExprId}[${exprId}]`;
 
@@ -664,7 +654,7 @@ export class CodeGenerator {
       } else if (hasDynamicChildren) {
         const bValueId = this.generateId("bValue");
         tModelSelectedExpr = `${bValueId}`;
-        this.define(tModelSelectedExpr, fullExpression);
+        this.addLine(`let ${tModelSelectedExpr} = ${fullExpression}`);
       } else {
         idx = block!.insertData(`${fullExpression}`, "attr");
         attrs[`block-attribute-${idx}`] = targetAttr;
@@ -714,13 +704,13 @@ export class CodeGenerator {
         const children = block!.children.slice();
         let current = children.shift();
         for (let i = codeIdx; i < code.length; i++) {
-          if (code[i].trimStart().startsWith(`const ${current!.varName} `)) {
-            code[i] = code[i].replace(`const ${current!.varName}`, current!.varName);
+          if (code[i].trimStart().startsWith(`let ${current!.varName} `)) {
+            code[i] = code[i].replace(`let ${current!.varName}`, current!.varName);
             current = children.shift();
             if (!current) break;
           }
         }
-        this.addLine(`let ${block!.children.map((c) => c.varName)};`, codeIdx);
+        this.target.addLine(`let ${block!.children.map((c) => c.varName)};`, codeIdx);
       }
     }
   }
@@ -809,13 +799,13 @@ export class CodeGenerator {
         const children = block!.children.slice();
         let current = children.shift();
         for (let i = codeIdx; i < code.length; i++) {
-          if (code[i].trimStart().startsWith(`const ${current!.varName} `)) {
-            code[i] = code[i].replace(`const ${current!.varName}`, current!.varName);
+          if (code[i].trimStart().startsWith(`let ${current!.varName} `)) {
+            code[i] = code[i].replace(`let ${current!.varName}`, current!.varName);
             current = children.shift();
             if (!current) break;
           }
         }
-        this.addLine(`let ${block!.children.map((c) => c.varName)};`, codeIdx);
+        this.target.addLine(`let ${block!.children.map((c) => c.varName)};`, codeIdx);
       }
 
       // note: this part is duplicated from end of compilemulti:
@@ -838,10 +828,12 @@ export class CodeGenerator {
     const l = `l_block${block.id}`;
     const c = `c_block${block.id}`;
     this.helpers.add("prepareList");
-    this.define(`[${keys}, ${vals}, ${l}, ${c}]`, `prepareList(${compileExpr(ast.collection)});`);
+    this.addLine(
+      `const [${keys}, ${vals}, ${l}, ${c}] = prepareList(${compileExpr(ast.collection)});`
+    );
     // Throw errors on duplicate keys in dev mode
     if (this.dev) {
-      this.define(`keys${block.id}`, `new Set()`);
+      this.addLine(`const keys${block.id} = new Set();`);
     }
     this.addLine(`for (let ${loopVar} = 0; ${loopVar} < ${l}; ${loopVar}++) {`);
     this.target.indentLevel++;
@@ -858,7 +850,7 @@ export class CodeGenerator {
     if (!ast.hasNoValue) {
       this.addLine(`ctx[\`${ast.elem}_value\`] = ${keys}[${loopVar}];`);
     }
-    this.define(`key${this.target.loopLevel}`, ast.key ? compileExpr(ast.key) : loopVar);
+    this.addLine(`let key${this.target.loopLevel} = ${ast.key ? compileExpr(ast.key) : loopVar};`);
     if (this.dev) {
       // Throw error on duplicate keys in dev mode
       this.addLine(
@@ -870,8 +862,8 @@ export class CodeGenerator {
     if (ast.memo) {
       this.target.hasCache = true;
       id = this.generateId();
-      this.define(`memo${id}`, compileExpr(ast.memo));
-      this.define(`vnode${id}`, `cache[key${this.target.loopLevel}];`);
+      this.addLine(`let memo${id} = ${compileExpr(ast.memo)}`);
+      this.addLine(`let vnode${id} = cache[key${this.target.loopLevel}];`);
       this.addLine(`if (vnode${id}) {`);
       this.target.indentLevel++;
       this.addLine(`if (shallowEqual(vnode${id}.memo, memo${id})) {`);
@@ -905,7 +897,7 @@ export class CodeGenerator {
 
   compileTKey(ast: ASTTKey, ctx: Context) {
     const tKeyExpr = this.generateId("tKey_");
-    this.define(tKeyExpr, compileExpr(ast.expr));
+    this.addLine(`const ${tKeyExpr} = ${compileExpr(ast.expr)};`);
     ctx = createContext(ctx, {
       tKeyExpr,
       block: ctx.block,
@@ -951,13 +943,13 @@ export class CodeGenerator {
           const children = block!.children.slice();
           let current = children.shift();
           for (let i = codeIdx; i < code.length; i++) {
-            if (code[i].trimStart().startsWith(`const ${current!.varName} `)) {
-              code[i] = code[i].replace(`const ${current!.varName}`, current!.varName);
+            if (code[i].trimStart().startsWith(`let ${current!.varName} `)) {
+              code[i] = code[i].replace(`let ${current!.varName}`, current!.varName);
               current = children.shift();
               if (!current) break;
             }
           }
-          this.addLine(`let ${block!.children.map((c) => c.varName)};`, codeIdx);
+          this.target.addLine(`let ${block!.children.map((c) => c.varName)};`, codeIdx);
         }
       }
 
@@ -990,7 +982,7 @@ export class CodeGenerator {
     const key = `key + \`${this.generateComponentKey()}\``;
     if (isDynamic) {
       const templateVar = this.generateId("template");
-      this.define(templateVar, subTemplate);
+      this.addLine(`const ${templateVar} = ${subTemplate};`);
       block = this.createBlock(block, "multi", ctx);
       this.helpers.add("call");
       this.insertBlock(`call(this, ${templateVar}, ctx, node, ${key})`, block!, {
@@ -1000,7 +992,7 @@ export class CodeGenerator {
     } else {
       const id = this.generateId(`callTemplate_`);
       this.helpers.add("getTemplate");
-      this.staticDefs.push({ id, expr: `getTemplate(${subTemplate})` });
+      this.staticCalls.push({ id, template: subTemplate });
       block = this.createBlock(block, "multi", ctx);
       this.insertBlock(`${id}.call(this, ctx, node, ${key})`, block!, {
         ...ctx,
@@ -1095,31 +1087,30 @@ export class CodeGenerator {
 
   compileComponent(ast: ASTComponent, ctx: Context) {
     let { block } = ctx;
+
     // props
-    const hasSlotsProp = "slots" in (ast.props || {});
+    const hasSlotsProp = "slots" in ast.props;
     const props: string[] = [];
-    const propExpr = this.formatPropObject(ast.props || {});
+    const propExpr = this.formatPropObject(ast.props);
     if (propExpr) {
       props.push(propExpr);
     }
 
     // slots
+    const hasSlot = !!Object.keys(ast.slots).length;
     let slotDef: string = "";
-    if (ast.slots) {
+    if (hasSlot) {
       let ctxStr = "ctx";
       if (this.target.loopLevel || !this.hasSafeContext) {
         ctxStr = this.generateId("ctx");
         this.helpers.add("capture");
-        this.define(ctxStr, `capture(ctx)`);
+        this.addLine(`const ${ctxStr} = capture(ctx);`);
       }
       let slotStr: string[] = [];
       for (let slotName in ast.slots) {
-        const slotAst = ast.slots[slotName];
-        const params = [];
-        if (slotAst.content) {
-          const name = this.compileInNewTarget("slot", slotAst.content, ctx, slotAst.on);
-          params.push(`__render: ${name}, __ctx: ${ctxStr}`);
-        }
+        const slotAst = ast.slots[slotName].content;
+        const name = this.compileInNewTarget("slot", slotAst, ctx);
+        const params = [`__render: ${name}, __ctx: ${ctxStr}`];
         const scope = ast.slots[slotName].scope;
         if (scope) {
           params.push(`__scope: "${scope}"`);
@@ -1134,29 +1125,29 @@ export class CodeGenerator {
     }
 
     if (slotDef && !(ast.dynamicProps || hasSlotsProp)) {
-      this.helpers.add("markRaw");
-      props.push(`slots: markRaw(${slotDef})`);
+      props.push(`slots: ${slotDef}`);
     }
 
     const propStr = `{${props.join(",")}}`;
 
     let propString = propStr;
     if (ast.dynamicProps) {
-      propString = `Object.assign({}, ${compileExpr(ast.dynamicProps)}${
-        props.length ? ", " + propStr : ""
-      })`;
+      if (!props.length) {
+        propString = `Object.assign({}, ${compileExpr(ast.dynamicProps)})`;
+      } else {
+        propString = `Object.assign({}, ${compileExpr(ast.dynamicProps)}, ${propStr})`;
+      }
     }
 
     let propVar: string;
     if ((slotDef && (ast.dynamicProps || hasSlotsProp)) || this.dev) {
       propVar = this.generateId("props");
-      this.define(propVar!, propString);
+      this.addLine(`const ${propVar!} = ${propString};`);
       propString = propVar!;
     }
 
     if (slotDef && (ast.dynamicProps || hasSlotsProp)) {
-      this.helpers.add("markRaw");
-      this.addLine(`${propVar!}.slots = markRaw(Object.assign(${slotDef}, ${propVar!}.slots))`);
+      this.addLine(`${propVar!}.slots = Object.assign(${slotDef}, ${propVar!}.slots)`);
     }
 
     // cmap key
@@ -1164,7 +1155,7 @@ export class CodeGenerator {
     let expr: string;
     if (ast.isDynamic) {
       expr = this.generateId("Comp");
-      this.define(expr, compileExpr(ast.name));
+      this.addLine(`let ${expr} = ${compileExpr(ast.name)};`);
     } else {
       expr = `\`${ast.name}\``;
     }
@@ -1187,32 +1178,10 @@ export class CodeGenerator {
     if (ast.isDynamic) {
       blockExpr = `toggler(${expr}, ${blockExpr})`;
     }
-
-    // event handling
-    if (ast.on) {
-      blockExpr = this.wrapWithEventCatcher(blockExpr, ast.on);
-    }
-
     block = this.createBlock(block, "multi", ctx);
     this.insertBlock(blockExpr, block, ctx);
   }
 
-  wrapWithEventCatcher(expr: string, on: EventHandlers): string {
-    this.helpers.add("createCatcher");
-    let name = this.generateId("catcher");
-    let spec: any = {};
-    let handlers: any[] = [];
-    for (let ev in on) {
-      let handlerId = this.generateId("hdlr");
-      let idx = handlers.push(handlerId) - 1;
-      spec[ev] = idx;
-      const handler = this.generateHandlerCode(ev, on[ev]);
-      this.define(handlerId, handler);
-    }
-    this.staticDefs.push({ id: name, expr: `createCatcher(${JSON.stringify(spec)})` });
-    return `${name}(${expr}, [${handlers.join(",")}])`;
-  }
-
   compileTSlot(ast: ASTSlot, ctx: Context) {
     this.helpers.add("callSlot");
     let { block } = ctx;
@@ -1233,17 +1202,12 @@ export class CodeGenerator {
     } else {
       if (dynamic) {
         let name = this.generateId("slot");
-        this.define(name, slotName);
+        this.addLine(`const ${name} = ${slotName};`);
         blockString = `toggler(${name}, callSlot(ctx, node, key, ${name}), ${dynamic}, ${scope})`;
       } else {
         blockString = `callSlot(ctx, node, key, ${slotName}, ${dynamic}, ${scope})`;
       }
     }
-    // event handling
-    if (ast.on) {
-      blockString = this.wrapWithEventCatcher(blockString, ast.on);
-    }
-
     if (block) {
       this.insertAnchor(block);
     }
@@ -1266,7 +1230,7 @@ export class CodeGenerator {
     if (this.target.loopLevel || !this.hasSafeContext) {
       ctxStr = this.generateId("ctx");
       this.helpers.add("capture");
-      this.define(ctxStr, `capture(ctx);`);
+      this.addLine(`const ${ctxStr} = capture(ctx);`);
     }
     const blockString = `component(Portal, {target: ${ast.target},slots: {'default': {__render: ${name}, __ctx: ${ctxStr}}}}, key + \`${key}\`, node, ctx)`;
     if (block) {

src/compiler/inline_expressions.ts

@@ -199,30 +199,24 @@ const TOKENIZERS = [
 export function tokenize(expr: string): Token[] {
   const result: Token[] = [];
   let token: boolean | Token = true;
-  let error: any;
-  let current = expr;
 
-  try {
-    while (token) {
-      current = current.trim();
-      if (current) {
-        for (let tokenizer of TOKENIZERS) {
-          token = tokenizer(current);
-          if (token) {
-            result.push(token);
-            current = current.slice(token.size || token.value.length);
-            break;
-          }
+  while (token) {
+    expr = expr.trim();
+    if (expr) {
+      for (let tokenizer of TOKENIZERS) {
+        token = tokenizer(expr);
+        if (token) {
+          result.push(token);
+          expr = expr.slice(token.size || token.value.length);
+          break;
         }
-      } else {
-        token = false;
       }
+    } else {
+      token = false;
     }
-  } catch (e) {
-    error = e; // Silence all errors and throw a generic error below
   }
-  if (current.length || error) {
-    throw new Error(`Tokenizer error: could not tokenize \`${expr}\``);
+  if (expr.length) {
+    throw new Error(`Tokenizer error: could not tokenize "${expr}"`);
   }
   return result;
 }

src/compiler/parser.ts

@@ -2,9 +2,6 @@
 // AST Type definition
 // -----------------------------------------------------------------------------
 
-export type EventHandlers = { [eventName: string]: string };
-export type Attrs = { [attrs: string]: string };
-
 export const enum ASTType {
   Text,
   Comment,
@@ -37,25 +34,25 @@ export interface ASTComment {
 }
 
 interface TModelInfo {
+  hasDynamicChildren?: boolean;
   baseExpr: string;
   expr: string;
   targetAttr: string;
+  specialInitTargetAttr: string | null;
   eventType: "change" | "click" | "input";
   shouldTrim: boolean;
   shouldNumberize: boolean;
-  hasDynamicChildren: boolean;
-  specialInitTargetAttr: string | null;
 }
 
 export interface ASTDomNode {
   type: ASTType.DomNode;
   tag: string;
-  content: AST[];
-  attrs: Attrs | null;
-  ref: string | null;
-  on: EventHandlers | null;
-  model: TModelInfo | null;
   dynamicTag: string | null;
+  attrs: { [key: string]: string };
+  content: AST[];
+  ref: string | null;
+  on: { [key: string]: string };
+  model?: TModelInfo | null;
   ns: string | null;
 }
 
@@ -96,13 +93,13 @@ export interface ASTTForEach {
   type: ASTType.TForEach;
   collection: string;
   elem: string;
+  key: string | null;
   body: AST;
   memo: string;
   hasNoFirst: boolean;
   hasNoLast: boolean;
   hasNoIndex: boolean;
   hasNoValue: boolean;
-  key: string | null;
 }
 
 export interface ASTTKey {
@@ -117,28 +114,19 @@ export interface ASTTCall {
   body: AST[] | null;
 }
 
-interface SlotDefinition {
-  content: AST | null;
-  scope: string | null;
-  on: EventHandlers | null;
-  attrs: Attrs | null;
-}
-
 export interface ASTComponent {
   type: ASTType.TComponent;
   name: string;
   isDynamic: boolean;
   dynamicProps: string | null;
-  on: EventHandlers | null;
-  props: { [name: string]: string } | null;
-  slots: { [name: string]: SlotDefinition } | null;
+  props: { [name: string]: string };
+  slots: { [name: string]: { content: AST; attrs?: { [key: string]: string }; scope?: string } };
 }
 
 export interface ASTSlot {
   type: ASTType.TSlot;
   name: string;
-  attrs: Attrs | null;
-  on: EventHandlers | null;
+  attrs: { [key: string]: string };
   defaultContent: AST | null;
 }
 
@@ -331,8 +319,8 @@ function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
   node.removeAttribute("t-ref");
 
   const nodeAttrsNames = node.getAttributeNames();
-  let attrs: ASTDomNode["attrs"] = null;
-  let on: EventHandlers | null = null;
+  const attrs: ASTDomNode["attrs"] = {};
+  const on: ASTDomNode["on"] = {};
   let model: TModelInfo | null = null;
 
   for (let attr of nodeAttrsNames) {
@@ -341,7 +329,6 @@ function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
       if (attr === "t-on") {
         throw new Error("Missing event name with t-on directive");
       }
-      on = on || {};
       on[attr.slice(5)] = value;
     } else if (attr.startsWith("t-model")) {
       if (!["input", "select", "textarea"].includes(tagName)) {
@@ -379,7 +366,6 @@ function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
         targetAttr: isCheckboxInput ? "checked" : "value",
         specialInitTargetAttr: isRadioInput ? "checked" : null,
         eventType,
-        hasDynamicChildren: false,
         shouldTrim: hasTrimMod && (isOtherInput || isTextarea),
         shouldNumberize: hasNumberMod && (isOtherInput || isTextarea),
       };
@@ -398,7 +384,6 @@ function parseDOMNode(node: Element, ctx: ParsingContext): AST | null {
       if (tModel && ["t-att-value", "t-attf-value"].includes(attr)) {
         tModel.hasDynamicChildren = true;
       }
-      attrs = attrs || {};
       attrs[attr] = value;
     }
   }
@@ -569,7 +554,7 @@ function parseTCall(node: Element, ctx: ParsingContext): AST | null {
     if (ast && ast.type === ASTType.TComponent) {
       return {
         ...ast,
-        slots: { default: { content: tcall, scope: null, on: null, attrs: null } },
+        slots: { default: { content: tcall } },
       };
     }
   }
@@ -665,6 +650,7 @@ function parseTSetNode(node: Element, ctx: ParsingContext): AST | null {
 
 // Error messages when trying to use an unsupported directive on a component
 const directiveErrorMap = new Map([
+  ["t-on", "t-on is no longer supported on components. Consider passing a callback in props."],
   [
     "t-ref",
     "t-ref is no longer supported on components. Consider exposing only the public part of the component's API through a callback prop.",
@@ -698,26 +684,19 @@ function parseComponent(node: Element, ctx: ParsingContext): AST | null {
 
   const defaultSlotScope = node.getAttribute("t-slot-scope");
   node.removeAttribute("t-slot-scope");
-  let on: ASTComponent["on"] = null;
 
-  let props: ASTComponent["props"] = null;
+  const props: ASTComponent["props"] = {};
   for (let name of node.getAttributeNames()) {
     const value = node.getAttribute(name)!;
     if (name.startsWith("t-")) {
-      if (name.startsWith("t-on-")) {
-        on = on || {};
-        on[name.slice(5)] = value;
-      } else {
-        const message = directiveErrorMap.get(name.split("-").slice(0, 2).join("-"));
-        throw new Error(message || `unsupported directive on Component: ${name}`);
-      }
+      const message = directiveErrorMap.get(name.split("-").slice(0, 2).join("-"));
+      throw new Error(message || `unsupported directive on Component: ${name}`);
     } else {
-      props = props || {};
       props[name] = value;
     }
   }
 
-  let slots: ASTComponent["slots"] | null = null;
+  const slots: ASTComponent["slots"] = {};
   if (node.hasChildNodes()) {
     const clone = <Element>node.cloneNode(true);
 
@@ -749,34 +728,34 @@ function parseComponent(node: Element, ctx: ParsingContext): AST | null {
       slotNode.removeAttribute("t-set-slot");
       slotNode.remove();
       const slotAst = parseNode(slotNode, ctx);
-      let on: SlotDefinition["on"] = null;
-      let attrs: Attrs | null = null;
-      let scope: string | null = null;
-      for (let attributeName of slotNode.getAttributeNames()) {
-        const value = slotNode.getAttribute(attributeName)!;
-        if (attributeName === "t-slot-scope") {
-          scope = value;
-          continue;
-        } else if (attributeName.startsWith("t-on-")) {
-          on = on || {};
-          on[attributeName.slice(5)] = value;
-        } else {
-          attrs = attrs || {};
+      if (slotAst) {
+        const slotInfo: any = { content: slotAst };
+        const attrs: { [key: string]: string } = {};
+        for (let attributeName of slotNode.getAttributeNames()) {
+          const value = slotNode.getAttribute(attributeName)!;
+          if (attributeName === "t-slot-scope") {
+            slotInfo.scope = value;
+            continue;
+          }
           attrs[attributeName] = value;
         }
+        if (Object.keys(attrs).length) {
+          slotInfo.attrs = attrs;
+        }
+        slots[name] = slotInfo;
       }
-      slots = slots || {};
-      slots[name] = { content: slotAst, on, attrs, scope };
     }
 
     // default slot
     const defaultContent = parseChildNodes(clone, ctx);
     if (defaultContent) {
-      slots = slots || {};
-      slots.default = { content: defaultContent, on, attrs: null, scope: defaultSlotScope };
+      slots.default = { content: defaultContent };
+      if (defaultSlotScope) {
+        slots.default.scope = defaultSlotScope;
+      }
     }
   }
-  return { type: ASTType.TComponent, name, isDynamic, dynamicProps, props, slots, on };
+  return { type: ASTType.TComponent, name, isDynamic, dynamicProps, props, slots };
 }
 
 // -----------------------------------------------------------------------------
@@ -789,23 +768,15 @@ function parseTSlot(node: Element, ctx: ParsingContext): AST | null {
   }
   const name = node.getAttribute("t-slot")!;
   node.removeAttribute("t-slot");
-  let attrs: Attrs | null = null;
-  let on: ASTComponent["on"] = null;
+  const attrs: { [key: string]: string } = {};
   for (let attributeName of node.getAttributeNames()) {
     const value = node.getAttribute(attributeName)!;
-    if (attributeName.startsWith("t-on-")) {
-      on = on || {};
-      on[attributeName.slice(5)] = value;
-    } else {
-      attrs = attrs || {};
-      attrs[attributeName] = value;
-    }
+    attrs[attributeName] = value;
   }
   return {
     type: ASTType.TSlot,
     name,
     attrs,
-    on,
     defaultContent: parseChildNodes(node, ctx),
   };
 }

src/component/component.ts

@@ -36,7 +36,7 @@ export class Component<Props = any, Env = any> {
 
   setup() {}
 
-  render(deep: boolean = false) {
-    this.__owl__.render(deep);
+  render() {
+    this.__owl__.render();
   }
 }

src/component/component_node.ts

@@ -1,17 +1,15 @@
 import type { App, Env } from "../app/app";
 import { BDom, VNode } from "../blockdom";
-import {
-  clearReactivesForCallback,
-  getSubscriptions,
-  NonReactive,
-  Reactive,
-  reactive,
-  TARGET,
-} from "../reactivity";
-import { batched, Callback } from "../utils";
 import { Component, ComponentConstructor } from "./component";
-import { fibersInError, handleError } from "./error_handling";
-import { Fiber, makeChildFiber, makeRootFiber, MountFiber, MountOptions } from "./fibers";
+import {
+  Fiber,
+  makeChildFiber,
+  makeRootFiber,
+  MountFiber,
+  MountOptions,
+  RootFiber,
+} from "./fibers";
+import { handleError, fibersInError } from "./error_handling";
 import { applyDefaultProps } from "./props_validation";
 import { STATUS } from "./status";
 
@@ -28,54 +26,13 @@ export function useComponent(): Component {
   return currentNode!.component;
 }
 
-// -----------------------------------------------------------------------------
-// Integration with reactivity system (useState)
-// -----------------------------------------------------------------------------
-
-const batchedRenderFunctions = new WeakMap<ComponentNode, Callback>();
-/**
- * Creates a reactive object that will be observed by the current component.
- * Reading data from the returned object (eg during rendering) will cause the
- * component to subscribe to that data and be rerendered when it changes.
- *
- * @param state the state to observe
- * @returns a reactive object that will cause the component to re-render on
- *  relevant changes
- * @see reactive
- */
-export function useState<T extends object>(state: T): Reactive<T> | NonReactive<T> {
-  const node = getCurrent();
-  let render = batchedRenderFunctions.get(node)!;
-  if (!render) {
-    render = batched(node.render.bind(node));
-    batchedRenderFunctions.set(node, render);
-    // manual implementation of onWillDestroy to break cyclic dependency
-    node.willDestroy.push(clearReactivesForCallback.bind(null, render));
-  }
-  return reactive(state, render);
-}
-
-// -----------------------------------------------------------------------------
-// component function (used in compiled template code)
-// -----------------------------------------------------------------------------
-type Props = { [key: string]: any };
-
-function arePropsDifferent(props1: Props, props2: Props): boolean {
-  for (let k in props1) {
-    if (props1[k] !== props2[k]) {
-      return true;
-    }
-  }
-  return Object.keys(props1).length !== Object.keys(props2).length;
-}
-
-export function component<P extends object>(
-  name: string | ComponentConstructor<P>,
-  props: P,
+export function component(
+  name: string | typeof Component,
+  props: any,
   key: string,
   ctx: ComponentNode,
   parent: any
-): ComponentNode<P> {
+): ComponentNode {
   let node: any = ctx.children[key];
   let isDynamic = typeof name !== "string";
 
@@ -93,16 +50,7 @@ export function component<P extends object>(
 
   const parentFiber = ctx.fiber!;
   if (node) {
-    let shouldRender = node.forceNextRender;
-    if (shouldRender) {
-      node.forceNextRender = false;
-    } else {
-      const currentProps = node.component.props[TARGET];
-      shouldRender = parentFiber.deep || arePropsDifferent(currentProps, props);
-    }
-    if (shouldRender) {
-      node.updateAndRender(props, parentFiber);
-    }
+    node.updateAndRender(props, parentFiber);
   } else {
     // new component
     let C;
@@ -117,26 +65,25 @@ export function component<P extends object>(
     node = new ComponentNode(C, props, ctx.app, ctx);
     ctx.children[key] = node;
 
-    node.initiateRender(makeChildFiber(node, parentFiber));
+    const fiber = makeChildFiber(node, parentFiber);
+    node.initiateRender(fiber);
   }
-  parentFiber.root!.reachedChildren.add(node);
   return node;
 }
 
 // -----------------------------------------------------------------------------
-//  Component VNode class
+//  Component VNode
 // -----------------------------------------------------------------------------
 
 type LifecycleHook = Function;
 
-export class ComponentNode<P extends object = any, E = any> implements VNode<ComponentNode<P, E>> {
+export class ComponentNode<P = any, E = any> implements VNode<ComponentNode<P, E>> {
   el?: HTMLElement | Text | undefined;
   app: App;
   fiber: Fiber | null = null;
   component: Component<P, E>;
   bdom: BDom | null = null;
   status: STATUS = STATUS.NEW;
-  forceNextRender: boolean = false;
 
   renderFn: Function;
   parent: ComponentNode | null;
@@ -161,7 +108,6 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
     applyDefaultProps(props, C);
     const env = (parent && parent.childEnv) || app.env;
     this.childEnv = env;
-    props = useState(props);
     this.component = new C(props, env, this) as any;
     this.renderFn = app.getTemplate(C.template).bind(this.component, this.component, this);
     this.component.setup();
@@ -174,65 +120,78 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
     this.initiateRender(fiber);
   }
 
-  async initiateRender(fiber: Fiber | MountFiber) {
+  initiateRender(fiber: Fiber | MountFiber) {
     this.fiber = fiber;
     if (this.mounted.length) {
       fiber.root!.mounted.push(fiber);
     }
     const component = this.component;
+    const finish = () => {
+      if (this.status === STATUS.NEW && this.fiber === fiber) {
+        this._render(fiber);
+      }
+    }
+    let willStartResults;
     try {
-      await Promise.all(this.willStart.map((f) => f.call(component)));
+      willStartResults = this.willStart.map((f) => f.call(component));
     } catch (e) {
       handleError({ node: this, error: e });
       return;
     }
-    if (this.status === STATUS.NEW && this.fiber === fiber) {
-      fiber.render();
+    if (willStartResults.some(result => result instanceof Promise)) {
+      Promise.all(willStartResults)
+        .then(finish)
+        .catch(e => handleError({ node: this, error: e }));
+    } else {
+      finish();
     }
   }
 
-  async render(deep: boolean = false) {
+  async render() {
     let current = this.fiber;
     if (current && current.root!.locked) {
       await Promise.resolve();
       // situation may have changed after the microtask tick
       current = this.fiber;
     }
-    if (current) {
-      if (!current.bdom && !fibersInError.has(current)) {
-        if (deep) {
-          // we want the render from this point on to be with deep=true
-          current.deep = deep;
-        }
-        return;
-      }
-      // if current rendering was with deep=true, we want this one to be the same
-      deep = deep || current.deep;
-    } else if (!this.bdom) {
+    if (current && !current.bdom && !fibersInError.has(current)) {
+      return;
+    }
+    if (!this.bdom && !current) {
       return;
     }
 
     const fiber = makeRootFiber(this);
-    fiber.deep = deep;
     this.fiber = fiber;
+    debugger;
+    window.requestAnimationFrame(() => {
+      if (this.status === STATUS.DESTROYED) {
+        return;
+      }
+      // We only want to actually render the component if the following two
+      // conditions are true:
+      // * this.fiber: it could be null, in which case the render has been cancelled
+      // * (current || !fiber.parent): if current is not null, this means that the
+      //   render function was called when a render was already occurring. In this
+      //   case, the pending rendering was cancelled, and the fiber needs to be
+      //   rendered to complete the work.  If current is null, we check that the
+      //   fiber has no parent.  If that is the case, the fiber was downgraded from
+      //   a root fiber to a child fiber in the previous microtick, because it was
+      //   embedded in a rendering coming from above, so the fiber will be rendered
+      //   in the next microtick anyway, so we should not render it again.
+      if (this.fiber === fiber && (current || !fiber.parent)) {
+        this._render(fiber);
+      }
+    });
     this.app.scheduler.addFiber(fiber);
-    await Promise.resolve();
-    if (this.status === STATUS.DESTROYED) {
-      return;
-    }
-    // We only want to actually render the component if the following two
-    // conditions are true:
-    // * this.fiber: it could be null, in which case the render has been cancelled
-    // * (current || !fiber.parent): if current is not null, this means that the
-    //   render function was called when a render was already occurring. In this
-    //   case, the pending rendering was cancelled, and the fiber needs to be
-    //   rendered to complete the work.  If current is null, we check that the
-    //   fiber has no parent.  If that is the case, the fiber was downgraded from
-    //   a root fiber to a child fiber in the previous microtick, because it was
-    //   embedded in a rendering coming from above, so the fiber will be rendered
-    //   in the next microtick anyway, so we should not render it again.
-    if (this.fiber === fiber && (current || !fiber.parent)) {
-      fiber.render();
+  }
+
+  _render(fiber: Fiber | RootFiber) {
+    try {
+      fiber.bdom = this.renderFn();
+      fiber.root!.counter--;
+    } catch (e) {
+      handleError({ node: this, error: e });
     }
   }
 
@@ -260,29 +219,32 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
     this.status = STATUS.DESTROYED;
   }
 
-  async updateAndRender(props: any, parentFiber: Fiber) {
+  updateAndRender(props: any, parentFiber: Fiber) {
     // update
     const fiber = makeChildFiber(this, parentFiber);
     this.fiber = fiber;
     const component = this.component;
     applyDefaultProps(props, component.constructor as any);
 
-    currentNode = this;
-    props = useState(props);
-    currentNode = null;
-    const prom = Promise.all(this.willUpdateProps.map((f) => f.call(component, props)));
-    await prom;
-    if (fiber !== this.fiber) {
-      return;
+    const finish = () => {
+      if (fiber !== this.fiber) {
+        return;
+      }
+      component.props = props;
+      this._render(fiber);
+      const parentRoot = parentFiber.root!;
+      if (this.willPatch.length) {
+        parentRoot.willPatch.push(fiber);
+      }
+      if (this.patched.length) {
+        parentRoot.patched.push(fiber);
+      }
     }
-    component.props = props;
-    fiber.render();
-    const parentRoot = parentFiber.root!;
-    if (this.willPatch.length) {
-      parentRoot.willPatch.push(fiber);
-    }
-    if (this.patched.length) {
-      parentRoot.patched.push(fiber);
+    const willUpdatePropsResults = this.willUpdateProps.map((f) => f.call(component, props));
+    if (willUpdatePropsResults.some(res => res instanceof Promise)) {
+      Promise.all(willUpdatePropsResults).then(finish);
+    } else {
+      finish();
     }
   }
 
@@ -334,15 +296,6 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
   }
 
   patch() {
-    debugger
-    if (this.fiber && this.fiber.parent) {
-      // we only patch here renderings coming from above. renderings initiated
-      // by the component will be patched independently in the appropriate
-      // fiber.complete
-      this._patch();
-    }
-  }
-  _patch() {
     const hasChildren = Object.keys(this.children).length > 0;
     this.bdom!.patch(this!.fiber!.bdom!, hasChildren);
     if (hasChildren) {
@@ -373,16 +326,4 @@ export class ComponentNode<P extends object = any, E = any> implements VNode<Com
       }
     }
   }
-
-  // ---------------------------------------------------------------------------
-  // Some debug helpers
-  // ---------------------------------------------------------------------------
-  get name(): string {
-    return this.component.constructor.name;
-  }
-
-  get subscriptions(): ReturnType<typeof getSubscriptions> {
-    const render = batchedRenderFunctions.get(this);
-    return render ? getSubscriptions(render) : [];
-  }
 }

src/component/error_handling.ts

@@ -30,8 +30,7 @@ function _handleError(node: ComponentNode | null, error: any, isFirstRound = fal
 
     if (stopped) {
       if (isFirstRound && fiber && fiber.node.fiber) {
-        const root = fiber.root!;
-        root.setCounter(root.counter - 1);
+        fiber.root!.counter--;
       }
       return true;
     }

src/component/fibers.ts

@@ -1,6 +1,6 @@
 import { BDom, mount } from "../blockdom";
 import type { ComponentNode } from "./component_node";
-import { handleError } from "./error_handling";
+import { fibersInError, handleError } from "./error_handling";
 import { STATUS } from "./status";
 
 export function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber {
@@ -9,78 +9,32 @@ export function makeChildFiber(node: ComponentNode, parent: Fiber): Fiber {
     cancelFibers(current.children);
     current.root = null;
   }
-  let fiber = new Fiber(node);
-  fiber.deep = parent.deep;
-  const root = parent.root!;
-  fiber.root = root;
-  parent.children.push(fiber);
-  fiber.parent = parent;
-  root.setCounter(root.counter + 1);
-  return fiber;
+  return new Fiber(node, parent);
 }
 
 export function makeRootFiber(node: ComponentNode): Fiber {
   let current = node.fiber;
   if (current) {
-    debugger;
-    let parent = current.parent;
-    let n = cancelFibers(current.children);
-    current.root = null;
-    // current.bdom = null;
-    if (parent) {
-      let fiber = new Fiber(node);
-      fiber.deep = parent.deep;
-      const root = parent.root!;
-      fiber.root = root;
-      let index = parent.children.indexOf(current);
-      parent.children[index] = fiber;
-      // parent.children.push(fiber);
-      fiber.parent = parent;
-      // node.fiber = 
-      root.setCounter(root.counter + 1 - n);
-      if (node.willPatch.length) {
-        let index = root.willPatch.indexOf(current);
-        if (index >= 0) {
-          root.willPatch[index] = fiber;
-        }
-      }
-      if (node.patched.length) {
-        let index = root.patched.indexOf(current);
-        if (index >= 0) {
-          root.patched[index] = fiber;
-        }
-      }
-    
-      return fiber;
+    let root = current.root!;
+    root.counter -= cancelFibers(current.children);
+    current.children = [];
+    root.counter++;
+    current.bdom = null;
+    if (fibersInError.has(current)) {
+      fibersInError.delete(current);
+      fibersInError.delete(root);
+      current.appliedToDom = false;
     }
-    // let parent = current.parent;
-    // let fiber = new Fiber(node);
-    // return fiber;
-
-    // cancelFibers(current.children);
-    // current.root = null;
-    // let root = current.root!;
-    // root.setCounter(root.counter + 1 - cancelFibers(current.children));
-    // current.children = [];
-    // current.bdom = null;
-    // if (current === root) {
-    //   root.reachedChildren = new WeakSet();
-    // }
-    // if (fibersInError.has(current)) {
-    //   fibersInError.delete(current);
-    //   fibersInError.delete(root);
-    //   current.appliedToDom = false;
-    // }
-    // return current;
+    return current;
   }
-  const fiber = new RootFiber(node);
-  fiber.root = fiber;
+  const fiber = new RootFiber(node, null);
   if (node.willPatch.length) {
     fiber.willPatch.push(fiber);
   }
   if (node.patched.length) {
     fiber.patched.push(fiber);
   }
+
   return fiber;
 }
 
@@ -91,15 +45,7 @@ function cancelFibers(fibers: Fiber[]): number {
   let result = 0;
   for (let fiber of fibers) {
     fiber.node.fiber = null;
-    if (fiber.bdom) {
-      // if fiber has been rendered, this means that the component props have
-      // been updated. however, this fiber will not be patched to the dom, so
-      // it could happen that the next render compare the current props with
-      // the same props, and skip the render completely. With the next line,
-      // we kindly request the component code to force a render, so it works as
-      // expected.
-      fiber.node.forceNextRender = true;
-    } else {
+    if (!fiber.bdom) {
       result++;
     }
     result += cancelFibers(fiber.children);
@@ -107,60 +53,24 @@ function cancelFibers(fibers: Fiber[]): number {
   return result;
 }
 
-(window as any).fibers = [];
-
 export class Fiber {
   node: ComponentNode;
   bdom: BDom | null = null;
-  root: RootFiber | null = null; // A Fiber that has been replaced by another has no root
-  parent: Fiber | null = null;
+  root: RootFiber | null; // A Fiber that has been replaced by another has no root
+  parent: Fiber | null;
   children: Fiber[] = [];
   appliedToDom = false;
-  deep: boolean = false;
 
-  constructor(node: ComponentNode) {
+  constructor(node: ComponentNode, parent: Fiber | null) {
     this.node = node;
-    (window as any).fibers.push(this);
-  }
-
-  render() {
-    // if some parent has a fiber => register in followup
-    let prev = this.root!.node;
-    let scheduler = prev.app.scheduler;
-    let current = prev.parent;
-    while (current) {
-      if (current.fiber) {
-        let root = current.fiber.root!;
-        if (root.counter) {
-          scheduler.delayedRenders.push(this);
-          return;
-        } else {
-          if (!root.reachedChildren.has(prev)) {
-            // is dead. but we keep the render around just in case
-            scheduler.delayedRenders.push(this);
-            return;
-          }
-          current = root.node;
-        }
-      }
-      prev = current;
-      current = current.parent;
-    }
-
-    // there are no current rendering from above => we can render
-    this._render();
-  }
-
-  _render() {
-    const node = this.node;
-    const root = this.root;
-    if (root) {
-      try {
-        this.bdom = node.renderFn();
-        root.setCounter(root.counter - 1);
-      } catch (e) {
-        handleError({ node, error: e });
-      }
+    this.parent = parent;
+    if (parent) {
+      const root = parent.root!;
+      root.counter++;
+      this.root = root;
+      parent.children.push(this);
+    } else {
+      this.root = this as any;
     }
   }
 }
@@ -176,8 +86,6 @@ export class RootFiber extends Fiber {
   // i.e.: render triggered in onWillUnmount or in willPatch will be delayed
   locked: boolean = false;
 
-  reachedChildren: WeakSet<ComponentNode> = new WeakSet();
-
   complete() {
     const node = this.node;
     this.locked = true;
@@ -199,7 +107,7 @@ export class RootFiber extends Fiber {
       current = undefined;
 
       // Step 2: patching the dom
-      node._patch();
+      node.patch();
       this.locked = false;
 
       // Step 4: calling all mounted lifecycle hooks
@@ -228,14 +136,6 @@ export class RootFiber extends Fiber {
       handleError({ fiber: current || this, error: e });
     }
   }
-
-  setCounter(newValue: number) {
-    debugger;
-    this.counter = newValue;
-    if (newValue === 0) {
-      this.node.app.scheduler.flush();
-    }
-  }
 }
 
 type Position = "first-child" | "last-child";
@@ -249,9 +149,8 @@ export class MountFiber extends RootFiber {
   position: Position;
 
   constructor(node: ComponentNode, target: HTMLElement, options: MountOptions = {}) {
-    super(node);
+    super(node, null);
     this.target = target;
-    this.root = this;
     this.position = options.position || "last-child";
   }
   complete() {

src/component/lifecycle_hooks.ts

@@ -1,28 +1,14 @@
 import { getCurrent } from "./component_node";
 import { nodeErrorHandlers } from "./error_handling";
 
-const TIMEOUT = Symbol("timeout");
 function wrapError(fn: (...args: any[]) => any, hookName: string) {
   const error = new Error(`The following error occurred in ${hookName}: `) as Error & {
     cause: any;
   };
-  const timeoutError = new Error(`${hookName}'s promise hasn't resolved after 3 seconds`);
-  const node = getCurrent();
   return (...args: any[]) => {
     try {
       const result = fn(...args);
       if (result instanceof Promise) {
-        if (hookName === "onWillStart" || hookName === "onWillUpdateProps") {
-          const fiber = node.fiber;
-          Promise.race([
-            result,
-            new Promise((resolve) => setTimeout(() => resolve(TIMEOUT), 3000)),
-          ]).then((res) => {
-            if (res === TIMEOUT && node.fiber === fiber) {
-              console.warn(timeoutError);
-            }
-          });
-        }
         return result.catch((cause) => {
           error.cause = cause;
           if (cause instanceof Error) {
@@ -91,23 +77,21 @@ export function onWillRender(fn: () => void | any) {
   const node = getCurrent();
   const renderFn = node.renderFn;
   const decorate = node.app.dev ? wrapError : (fn: any) => fn;
-  fn = decorate(fn.bind(node.component), "onWillRender");
-  node.renderFn = () => {
-    fn();
+  node.renderFn = decorate(() => {
+    fn.call(node.component);
     return renderFn();
-  };
+  }, "onWillRender");
 }
 
 export function onRendered(fn: () => void | any) {
   const node = getCurrent();
   const renderFn = node.renderFn;
   const decorate = node.app.dev ? wrapError : (fn: any) => fn;
-  fn = decorate(fn.bind(node.component), "onRendered");
-  node.renderFn = () => {
+  node.renderFn = decorate(() => {
     const result = renderFn();
-    fn();
+    fn.call(node.component);
     return result;
-  };
+  }, "onRendered");
 }
 
 type OnErrorCallback = (error: any) => void | any;

src/component/scheduler.ts

@@ -11,16 +11,27 @@ export class Scheduler {
   // interactions with other code, such as test frameworks that override them
   static requestAnimationFrame = window.requestAnimationFrame.bind(window);
   tasks: Set<RootFiber> = new Set();
+  isRunning: boolean = false;
   requestAnimationFrame: Window["requestAnimationFrame"];
-  frame: number = 0;
-  delayedRenders: Fiber[] = [];
 
   constructor() {
     this.requestAnimationFrame = Scheduler.requestAnimationFrame;
   }
 
+  start() {
+    this.isRunning = true;
+    this.scheduleTasks();
+  }
+
+  stop() {
+    this.isRunning = false;
+  }
+
   addFiber(fiber: Fiber) {
     this.tasks.add(fiber.root!);
+    if (!this.isRunning) {
+      this.start();
+    }
   }
 
   /**
@@ -28,49 +39,39 @@ export class Scheduler {
    * Other tasks are left unchanged.
    */
   flush() {
-    if (this.delayedRenders.length) {
-      let renders = this.delayedRenders;
-      this.delayedRenders = [];
-      for (let f of renders) {
-        if (f.root) {
-          f.render();
-        }
+    this.tasks.forEach((fiber) => {
+      if (fiber.root !== fiber) {
+        this.tasks.delete(fiber);
+        return;
+      }
+      const hasError = fibersInError.has(fiber);
+      if (hasError && fiber.counter !== 0) {
+        this.tasks.delete(fiber);
+        return;
+      }
+      if (fiber.node.status === STATUS.DESTROYED) {
+        this.tasks.delete(fiber);
+        return;
       }
-    }
 
-    if (this.frame === 0) {
-      this.frame = this.requestAnimationFrame(() => {
-        this.frame = 0;
-        this.tasks.forEach((fiber) => this.processFiber(fiber));
-        for (let task of this.tasks) {
-          if (task.node.status === STATUS.DESTROYED) {
-            this.tasks.delete(task);
-          }
+      if (fiber.counter === 0) {
+        if (!hasError) {
+          fiber.complete();
         }
-      });
+        this.tasks.delete(fiber);
+      }
+    });
+    if (this.tasks.size === 0) {
+      this.stop();
     }
   }
 
-  processFiber(fiber: RootFiber) {
-    if (fiber.root !== fiber) {
-      this.tasks.delete(fiber);
-      return;
-    }
-    const hasError = fibersInError.has(fiber);
-    if (hasError && fiber.counter !== 0) {
-      this.tasks.delete(fiber);
-      return;
-    }
-    if (fiber.node.status === STATUS.DESTROYED) {
-      this.tasks.delete(fiber);
-      return;
-    }
-
-    if (fiber.counter === 0) {
-      if (!hasError) {
-        fiber.complete();
+  scheduleTasks() {
+    this.requestAnimationFrame(() => {
+      this.flush();
+      if (this.isRunning) {
+        this.scheduleTasks();
       }
-      this.tasks.delete(fiber);
-    }
+    });
   }
 }

src/hooks.ts

@@ -57,6 +57,7 @@ export function useChildSubEnv(envExtension: Env) {
 // useEffect
 // -----------------------------------------------------------------------------
 
+const NO_OP = () => {};
 /**
  * @param {...any} dependencies the dependencies computed by computeDependencies
  * @returns {void|(()=>void)} a cleanup function that reverses the side
@@ -77,11 +78,11 @@ type Effect = (...dependencies: any[]) => void | (() => void);
  *      NaN !== NaN, which will cause the effect to rerun on every patch.
  */
 export function useEffect(effect: Effect, computeDependencies: () => any[] = () => [NaN]) {
-  let cleanup: (() => void) | void;
+  let cleanup: () => void;
   let dependencies: any[];
   onMounted(() => {
     dependencies = computeDependencies();
-    cleanup = effect(...dependencies);
+    cleanup = effect(...dependencies) || NO_OP;
   });
 
   onPatched(() => {
@@ -89,14 +90,12 @@ export function useEffect(effect: Effect, computeDependencies: () => any[] = ()
     const shouldReapply = newDeps.some((val, i) => val !== dependencies[i]);
     if (shouldReapply) {
       dependencies = newDeps;
-      if (cleanup) {
-        cleanup();
-      }
-      cleanup = effect(...dependencies);
+      cleanup();
+      cleanup = effect(...dependencies) || NO_OP;
     }
   });
 
-  onWillUnmount(() => cleanup && cleanup());
+  onWillUnmount(() => cleanup());
 }
 
 // -----------------------------------------------------------------------------

src/index.ts

@@ -1,3 +1,4 @@
+import { UTILS } from "./app/template_helpers";
 import {
   config,
   createBlock,
@@ -12,10 +13,12 @@ import {
   comment,
 } from "./blockdom";
 import { mainEventHandler } from "./component/handler";
+import { Portal } from "./portal";
 export type { Reactive } from "./reactivity";
 
 config.shouldNormalizeDom = false;
 config.mainEventHandler = mainEventHandler;
+(UTILS as any).Portal = Portal;
 
 export const blockDom = {
   config,
@@ -35,11 +38,13 @@ export const blockDom = {
 
 export { App, mount } from "./app/app";
 export { Component } from "./component/component";
-export { useComponent, useState } from "./component/component_node";
+export { useComponent } from "./component/component_node";
 export { status } from "./component/status";
-export { reactive, markRaw, toRaw } from "./reactivity";
+export { Memo } from "./memo";
+export { xml } from "./app/template_set";
+export { useState, reactive, markRaw, toRaw } from "./reactivity";
 export { useEffect, useEnv, useExternalListener, useRef, useChildSubEnv, useSubEnv } from "./hooks";
-export { EventBus, whenReady, loadFile, markup, xml } from "./utils";
+export { EventBus, whenReady, loadFile, markup } from "./utils";
 export {
   onWillStart,
   onMounted,

src/memo.ts

@@ -0,0 +1,47 @@
+import { Component } from "./component/component";
+import type { ComponentNode } from "./component/component_node";
+import { xml } from "./app/template_set";
+import { Fiber } from "./component/fibers";
+
+export class Memo extends Component {
+  static template = xml`<t t-slot="default"/>`;
+
+  constructor(props: any, env: any, node: ComponentNode) {
+    super(props, env, node);
+
+    // prevent patching process conditionally
+    let applyPatch = false;
+    const patchFn = node.patch;
+    node.patch = () => {
+      if (applyPatch) {
+        patchFn.call(node);
+        applyPatch = false;
+      }
+    };
+
+    // check props change, and render/apply patch if it changed
+    let prevProps = props;
+    const updateAndRender = node.updateAndRender;
+    node.updateAndRender = function (props: any, parentFiber: Fiber) {
+      const shouldUpdate = !shallowEqual(prevProps, props);
+      if (shouldUpdate) {
+        prevProps = props;
+        updateAndRender.call(node, props, parentFiber);
+        applyPatch = true;
+      }
+      return Promise.resolve();
+    };
+  }
+}
+
+/**
+ * we assume that each object have the same set of keys
+ */
+function shallowEqual(p1: any, p2: any): boolean {
+  for (let k in p1) {
+    if (k !== "slots" && p1[k] !== p2[k]) {
+      return false;
+    }
+  }
+  return true;
+}

src/portal.ts

@@ -1,5 +1,5 @@
 import { onWillUnmount } from "./component/lifecycle_hooks";
-import { xml } from "./utils";
+import { xml } from "./app/template_set";
 import { BDom, text, VNode } from "./blockdom";
 import { Component } from "./component/component";
 

src/reactivity.ts

@@ -1,42 +1,27 @@
-import { Callback } from "./utils";
+import { onWillDestroy } from "./component/lifecycle_hooks";
+import { ComponentNode, getCurrent } from "./component/component_node";
+import { batched, Callback } from "./utils";
 
 // Allows to get the target of a Reactive (used for making a new Reactive from the underlying object)
-export const TARGET = Symbol("Target");
+const TARGET = Symbol("Target");
 // Escape hatch to prevent reactivity system to turn something into a reactive
 const SKIP = Symbol("Skip");
 // Special key to subscribe to, to be notified of key creation/deletion
 const KEYCHANGES = Symbol("Key changes");
 
+type ObjectKey = string | number | symbol;
+
 type Target = object;
-type Collection = Set<any> | Map<any, any> | WeakMap<any, any>;
-type CollectionRawType = "Set" | "Map" | "WeakMap";
 
 export type Reactive<T extends Target = Target> = T & {
   [TARGET]: any;
 };
 
-export type NonReactive<T extends Target = Target> = T & {
+type NonReactive<T extends Target = Target> = T & {
   [SKIP]: any;
 };
-
 const objectToString = Object.prototype.toString;
-const objectHasOwnProperty = Object.prototype.hasOwnProperty;
 
-const SUPPORTED_RAW_TYPES = new Set(["Object", "Array", "Set", "Map", "WeakMap"]);
-const COLLECTION_RAWTYPES = new Set(["Set", "Map", "WeakMap"]);
-
-/**
- * extract "RawType" from strings like "[object RawType]" => this lets us ignore
- * many native objects such as Promise (whose toString is [object Promise])
- * or Date ([object Date]), while also supporting collections without using
- * instanceof in a loop
- *
- * @param obj the object to check
- * @returns the raw type of the object
- */
-function rawType(obj: any) {
-  return objectToString.call(obj).slice(8, -1);
-}
 /**
  * Checks whether a given value can be made into a reactive object.
  *
@@ -47,17 +32,11 @@ function canBeMadeReactive(value: any): boolean {
   if (typeof value !== "object") {
     return false;
   }
-  return SUPPORTED_RAW_TYPES.has(rawType(value));
-}
-/**
- * Creates a reactive from the given object/callback if possible and returns it,
- * returns the original object otherwise.
- *
- * @param value the value make reactive
- * @returns a reactive for the given object when possible, the original otherwise
- */
-function possiblyReactive(val: any, cb: Callback) {
-  return canBeMadeReactive(val) ? reactive(val, cb) : val;
+  // extract "RawType" from strings like "[object RawType]" => this lets us
+  // ignore many native objects such as Promise (whose toString is [object Promise])
+  // or Date ([object Date]).
+  const rawType = objectToString.call(value).slice(8, -1);
+  return rawType === "Object" || rawType === "Array";
 }
 
 /**
@@ -81,7 +60,7 @@ export function toRaw<T extends object>(value: Reactive<T>): T {
   return value[TARGET] || value;
 }
 
-const targetToKeysToCallbacks = new WeakMap<Target, Map<PropertyKey, Set<Callback>>>();
+const targetToKeysToCallbacks = new WeakMap<Target, Map<ObjectKey, Set<Callback>>>();
 /**
  * Observes a given key on a target with an callback. The callback will be
  * called when the given key changes on the target.
@@ -91,7 +70,7 @@ const targetToKeysToCallbacks = new WeakMap<Target, Map<PropertyKey, Set<Callbac
  *  or deletion)
  * @param callback the function to call when the key changes
  */
-function observeTargetKey(target: Target, key: PropertyKey, callback: Callback): void {
+function observeTargetKey(target: Target, key: ObjectKey, callback: Callback): void {
   if (!targetToKeysToCallbacks.get(target)) {
     targetToKeysToCallbacks.set(target, new Map());
   }
@@ -114,7 +93,7 @@ function observeTargetKey(target: Target, key: PropertyKey, callback: Callback):
  * @param key the key that changed (or Symbol `KEYCHANGES` if a key was created
  *   or deleted)
  */
-function notifyReactives(target: Target, key: PropertyKey): void {
+function notifyReactives(target: Target, key: ObjectKey): void {
   const keyToCallbacks = targetToKeysToCallbacks.get(target);
   if (!keyToCallbacks) {
     return;
@@ -136,7 +115,7 @@ const callbacksToTargets = new WeakMap<Callback, Set<Target>>();
  *
  * @param callback the callback for which the reactives need to be cleared
  */
-export function clearReactivesForCallback(callback: Callback): void {
+function clearReactivesForCallback(callback: Callback): void {
   const targetsToClear = callbacksToTargets.get(callback);
   if (!targetsToClear) {
     return;
@@ -153,17 +132,6 @@ export function clearReactivesForCallback(callback: Callback): void {
   targetsToClear.clear();
 }
 
-export function getSubscriptions(callback: Callback) {
-  const targets = callbacksToTargets.get(callback) || [];
-  return [...targets].map((target) => {
-    const keysToCallbacks = targetToKeysToCallbacks.get(target);
-    return {
-      target,
-      keys: keysToCallbacks ? [...keysToCallbacks.keys()] : [],
-    };
-  });
-}
-
 const reactiveCache = new WeakMap<Target, WeakMap<Callback, Reactive>>();
 /**
  * Creates a reactive proxy for an object. Reading data on the reactive object
@@ -211,247 +179,75 @@ export function reactive<T extends Target>(
   }
   const reactivesForTarget = reactiveCache.get(target)!;
   if (!reactivesForTarget.has(callback)) {
-    const targetRawType = rawType(target);
-    const handler = COLLECTION_RAWTYPES.has(targetRawType)
-      ? collectionsProxyHandler(target as Collection, callback, targetRawType as CollectionRawType)
-      : basicProxyHandler<T>(callback);
-    const proxy = new Proxy(target, handler as ProxyHandler<T>) as Reactive<T>;
+    const proxy = new Proxy(target, {
+      get(target: any, key: ObjectKey, proxy: Reactive<T>) {
+        if (key === TARGET) {
+          return target;
+        }
+        observeTargetKey(target, key, callback);
+        const value = Reflect.get(target, key, proxy);
+        if (!canBeMadeReactive(value)) {
+          return value;
+        }
+        return reactive(value, callback);
+      },
+      set(target, key, value, proxy) {
+        const isNewKey = !Object.hasOwnProperty.call(target, key);
+        const originalValue = Reflect.get(target, key, proxy);
+        const ret = Reflect.set(target, key, value, proxy);
+        if (isNewKey) {
+          notifyReactives(target, KEYCHANGES);
+        }
+        // While Array length may trigger the set trap, it's not actually set by this
+        // method but is updated behind the scenes, and the trap is not called with the
+        // new value. We disable the "same-value-optimization" for it because of that.
+        if (originalValue !== value || (Array.isArray(target) && key === "length")) {
+          notifyReactives(target, key);
+        }
+        return ret;
+      },
+      deleteProperty(target, key) {
+        const ret = Reflect.deleteProperty(target, key);
+        notifyReactives(target, KEYCHANGES);
+        notifyReactives(target, key);
+        return ret;
+      },
+      ownKeys(target) {
+        observeTargetKey(target, KEYCHANGES, callback);
+        return Reflect.ownKeys(target);
+      },
+      has(target, key) {
+        // TODO: this observes all key changes instead of only the presence of the argument key
+        observeTargetKey(target, KEYCHANGES, callback);
+        return Reflect.has(target, key);
+      },
+    });
     reactivesForTarget.set(callback, proxy);
   }
   return reactivesForTarget.get(callback) as Reactive<T>;
 }
+
+const batchedRenderFunctions = new WeakMap<ComponentNode, Callback>();
 /**
- * Creates a basic proxy handler for regular objects and arrays.
+ * Creates a reactive object that will be observed by the current component.
+ * Reading data from the returned object (eg during rendering) will cause the
+ * component to subscribe to that data and be rerendered when it changes.
  *
- * @param callback @see reactive
- * @returns a proxy handler object
+ * @param state the state to observe
+ * @returns a reactive object that will cause the component to re-render on
+ *  relevant changes
+ * @see reactive
  */
-function basicProxyHandler<T extends Target>(callback: Callback): ProxyHandler<T> {
-  return {
-    get(target: any, key: PropertyKey, proxy: Reactive<T>) {
-      if (key === TARGET) {
-        return target;
-      }
-      // non-writable non-configurable properties cannot be made reactive
-      const desc = Object.getOwnPropertyDescriptor(target, key);
-      if (desc && !desc.writable && !desc.configurable) {
-        return Reflect.get(target, key, proxy);
-      }
-      observeTargetKey(target, key, callback);
-      return possiblyReactive(Reflect.get(target, key, proxy), callback);
-    },
-    set(target, key, value, proxy) {
-      const isNewKey = !objectHasOwnProperty.call(target, key);
-      const originalValue = Reflect.get(target, key, proxy);
-      const ret = Reflect.set(target, key, value, proxy);
-      if (isNewKey) {
-        notifyReactives(target, KEYCHANGES);
-      }
-      // While Array length may trigger the set trap, it's not actually set by this
-      // method but is updated behind the scenes, and the trap is not called with the
-      // new value. We disable the "same-value-optimization" for it because of that.
-      if (originalValue !== value || (Array.isArray(target) && key === "length")) {
-        notifyReactives(target, key);
-      }
-      return ret;
-    },
-    deleteProperty(target, key) {
-      const ret = Reflect.deleteProperty(target, key);
-      // TODO: only notify when something was actually deleted
-      notifyReactives(target, KEYCHANGES);
-      notifyReactives(target, key);
-      return ret;
-    },
-    ownKeys(target) {
-      observeTargetKey(target, KEYCHANGES, callback);
-      return Reflect.ownKeys(target);
-    },
-    has(target, key) {
-      // TODO: this observes all key changes instead of only the presence of the argument key
-      // observing the key itself would observe value changes instead of presence changes
-      // so we may need a finer grained system to distinguish observing value vs presence.
-      observeTargetKey(target, KEYCHANGES, callback);
-      return Reflect.has(target, key);
-    },
-  } as ProxyHandler<T>;
-}
-/**
- * Creates a function that will observe the key that is passed to it when called
- * and delegates to the underlying method.
- *
- * @param methodName name of the method to delegate to
- * @param target @see reactive
- * @param callback @see reactive
- */
-function makeKeyObserver(methodName: "has" | "get", target: any, callback: Callback) {
-  return (key: any) => {
-    key = toRaw(key);
-    observeTargetKey(target, key, callback);
-    return possiblyReactive(target[methodName](key), callback);
-  };
-}
-/**
- * Creates an iterable that will delegate to the underlying iteration method and
- * observe keys as necessary.
- *
- * @param methodName name of the method to delegate to
- * @param target @see reactive
- * @param callback @see reactive
- */
-function makeIteratorObserver(
-  methodName: "keys" | "values" | "entries" | typeof Symbol.iterator,
-  target: any,
-  callback: Callback
-) {
-  return function* () {
-    observeTargetKey(target, KEYCHANGES, callback);
-    const keys = target.keys();
-    for (const item of target[methodName]()) {
-      const key = keys.next().value;
-      observeTargetKey(target, key, callback);
-      yield possiblyReactive(item, callback);
-    }
-  };
-}
-/**
- * Creates a forEach function that will delegate to forEach on the underlying
- * collection while observing key changes, and keys as they're iterated over,
- * and making the passed keys/values reactive.
- *
- * @param target @see reactive
- * @param callback @see reactive
- */
-function makeForEachObserver(target: any, callback: Callback) {
-  return function forEach(forEachCb: (val: any, key: any, target: any) => void, thisArg: any) {
-    observeTargetKey(target, KEYCHANGES, callback);
-    target.forEach(function (val: any, key: any, targetObj: any) {
-      observeTargetKey(target, key, callback);
-      forEachCb.call(
-        thisArg,
-        possiblyReactive(val, callback),
-        possiblyReactive(key, callback),
-        possiblyReactive(targetObj, callback)
-      );
-    }, thisArg);
-  };
-}
-/**
- * Creates a function that will delegate to an underlying method, and check if
- * that method has modified the presence or value of a key, and notify the
- * reactives appropriately.
- *
- * @param setterName name of the method to delegate to
- * @param getterName name of the method which should be used to retrieve the
- *  value before calling the delegate method for comparison purposes
- * @param target @see reactive
- */
-function delegateAndNotify(
-  setterName: "set" | "add" | "delete",
-  getterName: "has" | "get",
-  target: any
-) {
-  return (key: any, value: any) => {
-    key = toRaw(key);
-    const hadKey = target.has(key);
-    const originalValue = target[getterName](key);
-    const ret = target[setterName](key, value);
-    const hasKey = target.has(key);
-    if (hadKey !== hasKey) {
-      notifyReactives(target, KEYCHANGES);
-    }
-    if (originalValue !== value) {
-      notifyReactives(target, key);
-    }
-    return ret;
-  };
-}
-/**
- * Creates a function that will clear the underlying collection and notify that
- * the keys of the collection have changed.
- *
- * @param target @see reactive
- */
-function makeClearNotifier(target: Map<any, any> | Set<any>) {
-  return () => {
-    const allKeys = [...target.keys()];
-    target.clear();
-    notifyReactives(target, KEYCHANGES);
-    for (const key of allKeys) {
-      notifyReactives(target, key);
-    }
-  };
-}
-/**
- * Maps raw type of an object to an object containing functions that can be used
- * to build an appropritate proxy handler for that raw type. Eg: when making a
- * reactive set, calling the has method should mark the key that is being
- * retrieved as observed, and calling the add or delete method should notify the
- * reactives that the key which is being added or deleted has been modified.
- */
-const rawTypeToFuncHandlers = {
-  Set: (target: any, callback: Callback) => ({
-    has: makeKeyObserver("has", target, callback),
-    add: delegateAndNotify("add", "has", target),
-    delete: delegateAndNotify("delete", "has", target),
-    keys: makeIteratorObserver("keys", target, callback),
-    values: makeIteratorObserver("values", target, callback),
-    entries: makeIteratorObserver("entries", target, callback),
-    [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
-    forEach: makeForEachObserver(target, callback),
-    clear: makeClearNotifier(target),
-    get size() {
-      observeTargetKey(target, KEYCHANGES, callback);
-      return target.size;
-    },
-  }),
-  Map: (target: any, callback: Callback) => ({
-    has: makeKeyObserver("has", target, callback),
-    get: makeKeyObserver("get", target, callback),
-    set: delegateAndNotify("set", "get", target),
-    delete: delegateAndNotify("delete", "has", target),
-    keys: makeIteratorObserver("keys", target, callback),
-    values: makeIteratorObserver("values", target, callback),
-    entries: makeIteratorObserver("entries", target, callback),
-    [Symbol.iterator]: makeIteratorObserver(Symbol.iterator, target, callback),
-    forEach: makeForEachObserver(target, callback),
-    clear: makeClearNotifier(target),
-    get size() {
-      observeTargetKey(target, KEYCHANGES, callback);
-      return target.size;
-    },
-  }),
-  WeakMap: (target: any, callback: Callback) => ({
-    has: makeKeyObserver("has", target, callback),
-    get: makeKeyObserver("get", target, callback),
-    set: delegateAndNotify("set", "get", target),
-    delete: delegateAndNotify("delete", "has", target),
-  }),
-};
-/**
- * Creates a proxy handler for collections (Set/Map/WeakMap)
- *
- * @param callback @see reactive
- * @param target @see reactive
- * @returns a proxy handler object
- */
-function collectionsProxyHandler<T extends Collection>(
-  target: T,
-  callback: Callback,
-  targetRawType: CollectionRawType
-): ProxyHandler<T> {
-  // TODO: if performance is an issue we can create the special handlers lazily when each
-  // property is read.
-  const specialHandlers = rawTypeToFuncHandlers[targetRawType](target, callback);
-  return Object.assign(basicProxyHandler(callback), {
-    get(target: any, key: PropertyKey) {
-      if (key === TARGET) {
-        return target;
-      }
-      if (objectHasOwnProperty.call(specialHandlers, key)) {
-        return (specialHandlers as any)[key];
-      }
-      observeTargetKey(target, key, callback);
-      return possiblyReactive(target[key], callback);
-    },
-  }) as ProxyHandler<T>;
+export function useState<T extends object>(state: T): Reactive<T> | NonReactive<T> {
+  const node = getCurrent();
+  if (!batchedRenderFunctions.has(node)) {
+    batchedRenderFunctions.set(
+      node,
+      batched(() => node.render())
+    );
+    onWillDestroy(() => clearReactivesForCallback(render));
+  }
+  const render = batchedRenderFunctions.get(node)!;
+  const reactiveState = reactive(state, render);
+  return reactiveState;
 }

src/utils.ts

@@ -15,13 +15,11 @@ export function batched(callback: Callback): Callback {
     await Promise.resolve();
     if (!called) {
       called = true;
-      // wait for all calls in this microtick to fall through before resetting "called"
-      // so that only the first call to the batched function calls the original callback.
-      // Schedule this before calling the callback so that calls to the batched function
-      // within the callback will proceed only after resetting called to false, and have
-      // a chance to execute the callback again
-      Promise.resolve().then(() => (called = false));
       callback();
+      // wait for all calls in this microtick to fall through before resetting "called"
+      // so that only the first call to the batched function calls the original callback
+      await Promise.resolve();
+      called = false;
     }
   };
 }
@@ -73,17 +71,3 @@ export class Markup extends String {}
 export function markup(value: any) {
   return new Markup(value);
 }
-
-// -----------------------------------------------------------------------------
-//  xml tag helper
-// -----------------------------------------------------------------------------
-export const globalTemplates: { [key: string]: string | Element } = {};
-
-export function xml(...args: Parameters<typeof String.raw>) {
-  const name = `__template__${xml.nextId++}`;
-  const value = String.raw(...args);
-  globalTemplates[name] = value;
-  return name;
-}
-
-xml.nextId = 1;

tests/__snapshots__/reactivity.test.ts.snap

@@ -131,7 +131,7 @@ exports[`Reactivity: useState parent and children subscribed to same context 1`]
   let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     let txt1 = ctx['contextObj'].b;
     return block1([txt1], [b2]);
   }
@@ -223,8 +223,8 @@ exports[`Reactivity: useState two components are updated in parallel 1`] = `
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    const b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -252,8 +252,8 @@ exports[`Reactivity: useState two components can subscribe to same context 1`] =
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    const b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -281,8 +281,8 @@ exports[`Reactivity: useState two independent components on different levels are
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    const b3 = component(\`Parent\`, {}, key + \`__2\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b3 = component(\`Parent\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -310,7 +310,7 @@ exports[`Reactivity: useState two independent components on different levels are
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -340,14 +340,14 @@ exports[`Reactivity: useState useless atoms should be deleted 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Object.keys(ctx['state']));;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Object.keys(ctx['state']));
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`id\`] = v_block2[i1];
-      const key1 = ctx['id'];
+      let key1 = ctx['id'];
       c_block2[i1] = withKey(component(\`Quantity\`, {id: ctx['id']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     ctx = ctx.__proto__;
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     let txt1 = ctx['total'];
     let txt2 = Object.keys(ctx['state']).length;
     return block1([txt1, txt2], [b2]);

tests/blockdom/block_attributes.test.ts

@@ -169,25 +169,13 @@ describe("properties", () => {
     expect(input.value).toBe("potato");
   });
 
-  test("input with value attribute, and falsy value given", () => {
+  test("input with value attribute, and undefined given", () => {
     const block = createBlock(`<input block-attribute-0="value"/>`);
 
     const tree = block([undefined]);
     mount(tree, fixture);
     const input = fixture.querySelector("input")!;
     expect(input.value).toBe("");
-
-    patch(tree, block([null]));
-    expect(input.value).toBe("");
-
-    patch(tree, block([0]));
-    expect(input.value).toBe("0");
-
-    patch(tree, block([""]));
-    expect(input.value).toBe("");
-
-    patch(tree, block([false]));
-    expect(input.value).toBe("");
   });
 
   test("input type=checkbox with checked attribute", () => {

tests/blockdom/event_catcher.test.ts

@@ -1,54 +0,0 @@
-import { config, createBlock, createCatcher, mount } from "../../src/blockdom";
-import { makeTestFixture } from "./helpers";
-import { mainEventHandler } from "../../src/component/handler";
-
-//------------------------------------------------------------------------------
-// Setup and helpers
-//------------------------------------------------------------------------------
-
-let fixture: HTMLElement;
-config.mainEventHandler = mainEventHandler;
-
-beforeEach(() => {
-  fixture = makeTestFixture();
-});
-
-afterEach(() => {
-  fixture.remove();
-});
-
-test("simple event catcher", async () => {
-  const catcher = createCatcher({ click: 0 });
-  const block = createBlock("<div></div>");
-  let n = 0;
-  let ctx = {};
-  let handler = [() => n++, ctx];
-  const tree = catcher(block(), [handler]);
-
-  mount(tree, fixture);
-  expect(fixture.innerHTML).toBe("<div></div>");
-
-  expect(fixture.firstChild).toBeInstanceOf(HTMLDivElement);
-  expect(n).toBe(0);
-  (fixture.firstChild as HTMLDivElement).click();
-  expect(n).toBe(1);
-});
-
-test("do not catch events outside of itself", async () => {
-  const catcher = createCatcher({ click: 0 });
-  const childBlock = createBlock("<div></div>");
-  const parentBlock = createBlock("<button><block-child-0/></button>");
-  let n = 0;
-  let ctx = {};
-  let handler = [() => n++, ctx];
-  const tree = parentBlock([], [catcher(childBlock(), [handler])]);
-
-  mount(tree, fixture);
-  expect(fixture.innerHTML).toBe("<button><div></div></button>");
-
-  expect(n).toBe(0);
-  fixture.querySelector("div")!.click();
-  expect(n).toBe(1);
-  fixture.querySelector("button")!.click();
-  expect(n).toBe(1);
-});

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

@@ -70,17 +70,17 @@ exports[`t-on can bind handlers with empty object (with non empty inner string)
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['someval']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['someval']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`action\`] = v_block2[i1];
       ctx[\`action_index\`] = i1;
-      const key1 = ctx['action_index'];
+      let key1 = ctx['action_index'];
       const v1 = ctx['activate'];
       const v2 = ctx['action'];
       let hdlr1 = [()=>v1(v2), ctx];
       c_block2[i1] = withKey(block3([hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -140,10 +140,10 @@ exports[`t-on handler is bound to proper owner, part 2 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList([1]);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList([1]);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`value\`] = v_block1[i1];
-      const key1 = ctx['value'];
+      let key1 = ctx['value'];
       let hdlr1 = [ctx['add'], ctx];
       c_block1[i1] = withKey(block2([hdlr1]), key1);
     }
@@ -188,14 +188,14 @@ exports[`t-on handler is bound to proper owner, part 4 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList([1]);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList([1]);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`value\`] = v_block1[i1];
       ctx[\`value_first\`] = i1 === 0;
       ctx[\`value_last\`] = i1 === v_block1.length - 1;
       ctx[\`value_index\`] = i1;
       ctx[\`value_value\`] = k_block1[i1];
-      const key1 = ctx['value'];
+      let key1 = ctx['value'];
       c_block1[i1] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
     }
     return list(c_block1);
@@ -271,7 +271,7 @@ exports[`t-on t-on modifiers (native listener) t-on combined with t-out 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let hdlr1 = [ctx['onClick'], ctx];
-    const b2 = safeOutput(ctx['html']);
+    let b2 = safeOutput(ctx['html']);
     return block1([hdlr1], [b2]);
   }
 }"
@@ -347,17 +347,17 @@ exports[`t-on t-on modifiers (native listener) t-on with prevent modifier in t-f
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['projects']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['projects']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`project\`] = v_block2[i1];
-      const key1 = ctx['project'];
+      let key1 = ctx['project'];
       const v1 = ctx['onEdit'];
       const v2 = ctx['project'];
       let hdlr1 = [\\"prevent\\", _ev=>v1(v2.id,_ev), ctx];
       let txt1 = ctx['project'].name;
       c_block2[i1] = withKey(block3([hdlr1, txt1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -478,7 +478,7 @@ exports[`t-on t-on with t-call 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -508,7 +508,7 @@ exports[`t-on t-on, with arguments and t-call 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"

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

@@ -30,28 +30,28 @@ exports[`misc complex template 1`] = `
       b3 = block3();
     }
     ctx = Object.create(ctx);
-    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['batch'].slot_ids.filter(_slot=>_slot.build_id.id&&!_slot.trigger_id.manual&&(ctx['options'].trigger_display[_slot.trigger_id.id])));;
+    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['batch'].slot_ids.filter(_slot=>_slot.build_id.id&&!_slot.trigger_id.manual&&(ctx['options'].trigger_display[_slot.trigger_id.id])));
     for (let i1 = 0; i1 < l_block4; i1++) {
       ctx[\`slot\`] = v_block4[i1];
-      const key1 = ctx['slot'].id;
+      let key1 = ctx['slot'].id;
       c_block4[i1] = withKey(component(\`SlotButton\`, {class: ctx['slot_container'], slot: ctx['slot']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     ctx = ctx.__proto__;
     b4 = list(c_block4);
     ctx = Object.create(ctx);
-    const [k_block6, v_block6, l_block6, c_block6] = prepareList([1,2,3,4]);;
+    const [k_block6, v_block6, l_block6, c_block6] = prepareList([1,2,3,4]);
     for (let i1 = 0; i1 < l_block6; i1++) {
       ctx[\`x\`] = v_block6[i1];
-      const key1 = ctx['x'];
+      let key1 = ctx['x'];
       c_block6[i1] = withKey(block7(), key1);
     }
     ctx = ctx.__proto__;
     b6 = list(c_block6);
     ctx = Object.create(ctx);
-    const [k_block8, v_block8, l_block8, c_block8] = prepareList(ctx['commit_links']);;
+    const [k_block8, v_block8, l_block8, c_block8] = prepareList(ctx['commit_links']);
     for (let i1 = 0; i1 < l_block8; i1++) {
       ctx[\`commit_link\`] = v_block8[i1];
-      const key1 = ctx['commit_link'].id;
+      let key1 = ctx['commit_link'].id;
       let b10,b11,b12,b13;
       let attr5 = \`/runbot/commit/\${ctx['commit_link'].commit_id}\`;
       let attr6 = \`badge badge-light batch_commit match_type_\${ctx['commit_link'].match_type}\`;
@@ -96,35 +96,35 @@ exports[`misc global 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList([4,5,6]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([4,5,6]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`value\`] = v_block2[i1];
       ctx[\`value_first\`] = i1 === 0;
       ctx[\`value_last\`] = i1 === v_block2.length - 1;
       ctx[\`value_index\`] = i1;
       ctx[\`value_value\`] = k_block2[i1];
-      const key1 = ctx['value'];
+      let key1 = ctx['value'];
       let txt1 = ctx['value'];
-      const b4 = block4([txt1]);
+      let b4 = block4([txt1]);
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
       setContextValue(ctx, \\"foo\\", 'aaa');
-      const b6 = callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`);
+      let b6 = callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`);
       ctx = ctx.__proto__;
-      const b7 = callTemplate_2.call(this, ctx, node, key + \`__2__\${key1}\`);
+      let b7 = callTemplate_2.call(this, ctx, node, key + \`__2__\${key1}\`);
       setContextValue(ctx, \\"foo\\", 'bbb');
-      const b8 = callTemplate_3.call(this, ctx, node, key + \`__3__\${key1}\`);
-      const b5 = multi([b6, b7, b8]);
+      let b8 = callTemplate_3.call(this, ctx, node, key + \`__3__\${key1}\`);
+      let b5 = multi([b6, b7, b8]);
       ctx[zero] = b5;
-      const b9 = callTemplate_4.call(this, ctx, node, key + \`__4__\${key1}\`);
+      let b9 = callTemplate_4.call(this, ctx, node, key + \`__4__\${key1}\`);
       ctx = ctx.__proto__;
       c_block2[i1] = withKey(multi([b4, b9]), key1);
     }
     ctx = ctx.__proto__;
-    const b2 = list(c_block2);
-    const b10 = callTemplate_5.call(this, ctx, node, key + \`__5\`);
+    let b2 = list(c_block2);
+    let b10 = callTemplate_5.call(this, ctx, node, key + \`__5\`);
     return block1([], [b2, b10]);
   }
 }"
@@ -155,7 +155,7 @@ exports[`misc global 3`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let attr1 = 'agüero';
-    const b2 = ctx[zero];
+    let b2 = ctx[zero];
     return block1([attr1], [b2]);
   }
 }"
@@ -170,8 +170,8 @@ exports[`misc global 4`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = text(\`toto default\`);
-    const b2 = withDefault(safeOutput(ctx['toto']), b3);
+    let b3 = text(\`toto default\`);
+    let b2 = withDefault(safeOutput(ctx['toto']), b3);
     return block1([], [b2]);
   }
 }"
@@ -221,10 +221,10 @@ exports[`misc other complex template 1`] = `
     let attr1 = \`/runbot/\${ctx['project'].slug}\`;
     let txt1 = ctx['project'].name;
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['projects']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['projects']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`project\`] = v_block2[i1];
-      const key1 = ctx['project'].id;
+      let key1 = ctx['project'].id;
       let hdlr1 = [ctx['selectProject'](ctx['project']), ctx];
       let txt2 = ctx['project'].name;
       c_block2[i1] = withKey(block3([hdlr1, txt2]), key1);
@@ -241,12 +241,12 @@ exports[`misc other complex template 1`] = `
         if (ctx['nb_assigned_errors']&&ctx['nb_assigned_errors']>0) {
           let attr3 = \`You have \${ctx['nb_assigned_errors']} random bug assigned\`;
           let txt3 = ctx['nb_assigned_errors'];
-          const b8 = block8([attr3, txt3]);
-          const b9 = block9();
+          let b8 = block8([attr3, txt3]);
+          let b9 = block9();
           b7 = multi([b8, b9]);
         } else if (ctx['nb_build_errors']&&ctx['nb_build_errors']>0) {
-          const b11 = block11();
-          const b12 = block12();
+          let b11 = block11();
+          let b12 = block12();
           b10 = multi([b11, b12]);
         }
         let txt4 = ctx['user'].name.length>25?ctx['user'].namesubstring(0,23)+'...':ctx['user'].name;
@@ -261,17 +261,17 @@ exports[`misc other complex template 1`] = `
     let hdlr3 = [ctx['toggleMore'], ctx];
     if (ctx['categories']&&ctx['categories'].length>1) {
       ctx = Object.create(ctx);
-      const [k_block15, v_block15, l_block15, c_block15] = prepareList(ctx['categories']);;
+      const [k_block15, v_block15, l_block15, c_block15] = prepareList(ctx['categories']);
       for (let i1 = 0; i1 < l_block15; i1++) {
         ctx[\`category\`] = v_block15[i1];
-        const key1 = ctx['category'].id;
+        let key1 = ctx['category'].id;
         let attr6 = ctx['category'].id;
         let attr7 = ctx['category'].id==ctx['options'].active_category_id;
         let txt5 = ctx['category'].name;
         c_block15[i1] = withKey(block16([attr6, attr7, txt5]), key1);
       }
       ctx = ctx.__proto__;
-      const b15 = list(c_block15);
+      let b15 = list(c_block15);
       b14 = block14([], [b15]);
     }
     let attr8 = ctx['search'].value;
@@ -280,10 +280,10 @@ exports[`misc other complex template 1`] = `
     let hdlr6 = [ctx['clearSearch'], ctx];
     if (ctx['triggers']) {
       ctx = Object.create(ctx);
-      const [k_block18, v_block18, l_block18, c_block18] = prepareList(ctx['triggers']);;
+      const [k_block18, v_block18, l_block18, c_block18] = prepareList(ctx['triggers']);
       for (let i1 = 0; i1 < l_block18; i1++) {
         ctx[\`trigger\`] = v_block18[i1];
-        const key1 = ctx['trigger'].id;
+        let key1 = ctx['trigger'].id;
         let b20;
         if (!ctx['trigger'].manual&&ctx['trigger'].project_id===ctx['project'].id&&ctx['trigger'].category_id===ctx['options'].active_category_id) {
           let attr9 = \`trigger_\${ctx['trigger'].id}\`;
@@ -298,12 +298,12 @@ exports[`misc other complex template 1`] = `
         c_block18[i1] = withKey(multi([b20]), key1);
       }
       ctx = ctx.__proto__;
-      const b18 = list(c_block18);
+      let b18 = list(c_block18);
       let hdlr8 = [ctx['triggerAll'], ctx];
       let hdlr9 = [ctx['triggerNone'], ctx];
       let hdlr10 = [ctx['triggerDefault'], ctx];
       let hdlr11 = [ctx['toggleSettingsMenu'], ctx];
-      const b21 = block21([hdlr8, hdlr9, hdlr10, hdlr11]);
+      let b21 = block21([hdlr8, hdlr9, hdlr10, hdlr11]);
       b17 = multi([b18, b21]);
     }
     if (ctx['load_infos']) {
@@ -316,8 +316,8 @@ exports[`misc other complex template 1`] = `
     if (!ctx['project']) {
       b24 = block24();
     } else {
-      const b26 = component(\`BundlesList\`, {bundles: ctx['bundles'].sticky, category_custom_views: ctx['category_custom_views'], search: ctx['search']}, key + \`__2\`, node, ctx);
-      const b27 = component(\`BundlesList\`, {bundles: ctx['bundles'].dev, search: ctx['search']}, key + \`__3\`, node, ctx);
+      let b26 = component(\`BundlesList\`, {bundles: ctx['bundles'].sticky, category_custom_views: ctx['category_custom_views'], search: ctx['search']}, key + \`__2\`, node, ctx);
+      let b27 = component(\`BundlesList\`, {bundles: ctx['bundles'].dev, search: ctx['search']}, key + \`__3\`, node, ctx);
       b25 = block25([], [b26, b27]);
     }
     return block1([attr1, txt1, hdlr2, hdlr3, attr8, hdlr4, hdlr5, ref1, hdlr6, ref2], [b2, b4, b14, b17, b22, b23, b24, b25]);

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

@@ -10,14 +10,14 @@ exports[`memory t-foreach does not leak stuff in global scope 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList([3,2,1]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([3,2,1]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
       ctx[\`item_index\`] = i1;
-      const key1 = ctx['item_index'];
+      let key1 = ctx['item_index'];
       c_block2[i1] = withKey(text(ctx['item']), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"

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

@@ -211,8 +211,8 @@ exports[`simple templates, mostly static multiple root nodes 1`] = `
   let block3 = createBlock(\`<span>hey</span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
-    const b3 = block3();
+    let b2 = block2();
+    let b3 = block3();
     return multi([b2, b3]);
   }
 }"
@@ -246,8 +246,8 @@ exports[`simple templates, mostly static static text and dynamic text (no t tag)
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`hello \`);
-    const b3 = text(ctx['text']);
+    let b2 = text(\`hello \`);
+    let b3 = text(ctx['text']);
     return multi([b2, b3]);
   }
 }"
@@ -259,8 +259,8 @@ exports[`simple templates, mostly static static text and dynamic text 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`hello \`);
-    const b3 = text(ctx['text']);
+    let b2 = text(\`hello \`);
+    let b3 = text(ctx['text']);
     return multi([b2, b3]);
   }
 }"
@@ -347,8 +347,8 @@ exports[`simple templates, mostly static two t-escs next to each other 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['text1']);
-    const b3 = text(ctx['text2']);
+    let b2 = text(ctx['text1']);
+    let b3 = text(ctx['text2']);
     return multi([b2, b3]);
   }
 }"
@@ -360,8 +360,8 @@ exports[`simple templates, mostly static two t-escs next to each other 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['text1']);
-    const b3 = text(ctx['text2']);
+    let b2 = text(ctx['text1']);
+    let b3 = text(ctx['text2']);
     return multi([b2, b3]);
   }
 }"

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

@@ -66,7 +66,7 @@ exports[`properly support svg svg creates new block if it is within html -- 2 1`
     if (ctx['hasPath']) {
       b3 = block3();
     }
-    const b2 = block2([], [b3]);
+    let b2 = block2([], [b3]);
     return block1([], [b2]);
   }
 }"
@@ -81,7 +81,7 @@ exports[`properly support svg svg creates new block if it is within html 1`] = `
   let block2 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><polygon fill=\\"#000000\\" points=\\"0 0 4 4 8 0\\" transform=\\"translate(5 7)\\"/></svg>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
+    let b2 = block2();
     return block1([], [b2]);
   }
 }"
@@ -97,7 +97,7 @@ exports[`properly support svg svg namespace added to sub templates if root tag i
   let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><block-child-0/></svg>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"

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

@@ -10,7 +10,7 @@ exports[`t-call (template calling) basic caller 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -69,12 +69,12 @@ exports[`t-call (template calling) call with several sub nodes on same line 1`]
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b3 = block3();
-    const b4 = text(\` \`);
-    const b5 = block5();
-    const b2 = multi([b3, b4, b5]);
+    let b3 = block3();
+    let b4 = text(\` \`);
+    let b5 = block5();
+    let b2 = multi([b3, b4, b5]);
     ctx[zero] = b2;
-    const b6 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b6 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b6]);
   }
 }"
@@ -89,7 +89,7 @@ exports[`t-call (template calling) call with several sub nodes on same line 2`]
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
+    let b2 = ctx[zero];
     return block1([], [b2]);
   }
 }"
@@ -109,12 +109,12 @@ exports[`t-call (template calling) cascading t-call t-out='0' 1`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b3 = block3();
-    const b4 = text(\` \`);
-    const b5 = block5();
-    const b2 = multi([b3, b4, b5]);
+    let b3 = block3();
+    let b4 = text(\` \`);
+    let b5 = block5();
+    let b2 = multi([b3, b4, b5]);
     ctx[zero] = b2;
-    const b6 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b6 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b6]);
   }
 }"
@@ -133,11 +133,11 @@ exports[`t-call (template calling) cascading t-call t-out='0' 2`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b3 = block3();
-    const b4 = ctx[zero];
-    const b2 = multi([b3, b4]);
+    let b3 = block3();
+    let b4 = ctx[zero];
+    let b2 = multi([b3, b4]);
     ctx[zero] = b2;
-    const b5 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b5 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b5]);
   }
 }"
@@ -156,11 +156,11 @@ exports[`t-call (template calling) cascading t-call t-out='0' 3`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b3 = block3();
-    const b4 = ctx[zero];
-    const b2 = multi([b3, b4]);
+    let b3 = block3();
+    let b4 = ctx[zero];
+    let b2 = multi([b3, b4]);
     ctx[zero] = b2;
-    const b5 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b5 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b5]);
   }
 }"
@@ -175,7 +175,7 @@ exports[`t-call (template calling) cascading t-call t-out='0' 4`] = `
   let block1 = createBlock(\`<div><span>cascade 2</span><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
+    let b2 = ctx[zero];
     return block1([], [b2]);
   }
 }"
@@ -194,10 +194,10 @@ exports[`t-call (template calling) cascading t-call t-out='0', without external
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b2 = block2();
-    const b3 = text(\` \`);
-    const b4 = block4();
-    const b1 = multi([b2, b3, b4]);
+    let b2 = block2();
+    let b3 = text(\` \`);
+    let b4 = block4();
+    let b1 = multi([b2, b3, b4]);
     ctx[zero] = b1;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
@@ -216,9 +216,9 @@ exports[`t-call (template calling) cascading t-call t-out='0', without external
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b2 = block2();
-    const b3 = ctx[zero];
-    const b1 = multi([b2, b3]);
+    let b2 = block2();
+    let b3 = ctx[zero];
+    let b1 = multi([b2, b3]);
     ctx[zero] = b1;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
@@ -237,9 +237,9 @@ exports[`t-call (template calling) cascading t-call t-out='0', without external
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b2 = block2();
-    const b3 = ctx[zero];
-    const b1 = multi([b2, b3]);
+    let b2 = block2();
+    let b3 = ctx[zero];
+    let b1 = multi([b2, b3]);
     ctx[zero] = b1;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
@@ -255,8 +255,8 @@ exports[`t-call (template calling) cascading t-call t-out='0', without external
   let block2 = createBlock(\`<span>cascade 2</span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
-    const b3 = ctx[zero];
+    let b2 = block2();
+    let b3 = ctx[zero];
     return multi([b2, b3]);
   }
 }"
@@ -272,7 +272,7 @@ exports[`t-call (template calling) dynamic t-call 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const template1 = (ctx['template']);
-    const b2 = call(this, template1, ctx, node, key + \`__1\`);
+    let b2 = call(this, template1, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -319,7 +319,7 @@ exports[`t-call (template calling) inherit context 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"foo\\", 1);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -370,7 +370,7 @@ exports[`t-call (template calling) recursive template, part 2 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"node\\", ctx['root']);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -390,21 +390,21 @@ exports[`t-call (template calling) recursive template, part 2 2`] = `
     ctx[isBoundary] = 1
     let txt1 = ctx['node'].val;
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`subtree\`] = v_block2[i1];
       ctx[\`subtree_first\`] = i1 === 0;
       ctx[\`subtree_last\`] = i1 === v_block2.length - 1;
       ctx[\`subtree_index\`] = i1;
       ctx[\`subtree_value\`] = k_block2[i1];
-      const key1 = ctx['subtree_index'];
+      let key1 = ctx['subtree_index'];
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
       setContextValue(ctx, \\"node\\", ctx['subtree']);
       c_block2[i1] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
       ctx = ctx.__proto__;
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([txt1], [b2]);
   }
 }"
@@ -425,7 +425,7 @@ exports[`t-call (template calling) recursive template, part 3 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"node\\", ctx['root']);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -445,21 +445,21 @@ exports[`t-call (template calling) recursive template, part 3 2`] = `
     ctx[isBoundary] = 1
     let txt1 = ctx['node'].val;
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`subtree\`] = v_block2[i1];
       ctx[\`subtree_first\`] = i1 === 0;
       ctx[\`subtree_last\`] = i1 === v_block2.length - 1;
       ctx[\`subtree_index\`] = i1;
       ctx[\`subtree_value\`] = k_block2[i1];
-      const key1 = ctx['subtree_index'];
+      let key1 = ctx['subtree_index'];
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
       setContextValue(ctx, \\"node\\", ctx['subtree']);
       c_block2[i1] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
       ctx = ctx.__proto__;
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([txt1], [b2]);
   }
 }"
@@ -481,7 +481,7 @@ exports[`t-call (template calling) recursive template, part 4: with t-set recurs
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"recursive_idx\\", 1);
     setContextValue(ctx, \\"node\\", ctx['root']);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -503,21 +503,21 @@ exports[`t-call (template calling) recursive template, part 4: with t-set recurs
     let txt1 = ctx['node'].val;
     let txt2 = ctx['recursive_idx'];
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`subtree\`] = v_block2[i1];
       ctx[\`subtree_first\`] = i1 === 0;
       ctx[\`subtree_last\`] = i1 === v_block2.length - 1;
       ctx[\`subtree_index\`] = i1;
       ctx[\`subtree_value\`] = k_block2[i1];
-      const key1 = ctx['subtree_index'];
+      let key1 = ctx['subtree_index'];
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
       setContextValue(ctx, \\"node\\", ctx['subtree']);
       c_block2[i1] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
       ctx = ctx.__proto__;
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([txt1, txt2], [b2]);
   }
 }"
@@ -538,7 +538,7 @@ exports[`t-call (template calling) scoped parameters 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"foo\\", 42);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     ctx = ctx.__proto__;
     let txt1 = ctx['foo'];
     return block1([txt1], [b2]);
@@ -573,7 +573,7 @@ exports[`t-call (template calling) scoped parameters, part 2 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"foo\\", 42);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     ctx = ctx.__proto__;
     let txt1 = ctx['foo'];
     return block1([txt1], [b2]);
@@ -602,7 +602,7 @@ exports[`t-call (template calling) t-call allowed on a non t node 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -633,7 +633,7 @@ exports[`t-call (template calling) t-call with body content as root of a templat
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b1 = block1();
+    let b1 = block1();
     ctx[zero] = b1;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
@@ -649,7 +649,7 @@ exports[`t-call (template calling) t-call with body content as root of a templat
   let block1 = createBlock(\`<foo><block-child-0/></foo>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
+    let b2 = ctx[zero];
     return block1([], [b2]);
   }
 }"
@@ -702,7 +702,7 @@ exports[`t-call (template calling) t-call with t-set inside and body text conten
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"val\\", \`yip yip\`);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -735,14 +735,14 @@ exports[`t-call (template calling) t-call with t-set inside and outside 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['list']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['list']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`v\`] = v_block2[i1];
       ctx[\`v_first\`] = i1 === 0;
       ctx[\`v_last\`] = i1 === v_block2.length - 1;
       ctx[\`v_index\`] = i1;
       ctx[\`v_value\`] = k_block2[i1];
-      const key1 = ctx['v_index'];
+      let key1 = ctx['v_index'];
       setContextValue(ctx, \\"val\\", ctx['v'].val);
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
@@ -750,7 +750,7 @@ exports[`t-call (template calling) t-call with t-set inside and outside 1`] = `
       c_block2[i1] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
       ctx = ctx.__proto__;
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -783,7 +783,7 @@ exports[`t-call (template calling) t-call with t-set inside and outside. 2 1`] =
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"w\\", 'fromwrapper');
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -802,14 +802,14 @@ exports[`t-call (template calling) t-call with t-set inside and outside. 2 2`] =
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['list']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['list']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`v\`] = v_block2[i1];
       ctx[\`v_first\`] = i1 === 0;
       ctx[\`v_last\`] = i1 === v_block2.length - 1;
       ctx[\`v_index\`] = i1;
       ctx[\`v_value\`] = k_block2[i1];
-      const key1 = ctx['v_index'];
+      let key1 = ctx['v_index'];
       setContextValue(ctx, \\"val\\", ctx['v'].val);
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
@@ -817,7 +817,7 @@ exports[`t-call (template calling) t-call with t-set inside and outside. 2 2`] =
       c_block2[i1] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
       ctx = ctx.__proto__;
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -832,8 +832,8 @@ exports[`t-call (template calling) t-call with t-set inside and outside. 2 3`] =
   
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['val3'];
-    const b2 = block2([txt1]);
-    const b3 = text(ctx['w']);
+    let b2 = block2([txt1]);
+    let b3 = text(ctx['w']);
     return multi([b2, b3]);
   }
 }"
@@ -908,7 +908,7 @@ exports[`t-call (template calling) t-esc inside t-call, with t-set outside 1`] =
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"v\\", \`Hi\`);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -938,7 +938,7 @@ exports[`t-call (template calling) with unused body 1`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b1 = text(\`WHEEE\`);
+    let b1 = text(\`WHEEE\`);
     ctx[zero] = b1;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
@@ -999,7 +999,7 @@ exports[`t-call (template calling) with used body 1`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b1 = text(\`ok\`);
+    let b1 = text(\`ok\`);
     ctx[zero] = b1;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
@@ -1036,7 +1036,7 @@ exports[`t-call (template calling) with used setbody 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"foo\\", 'ok');
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"

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

@@ -44,7 +44,7 @@ exports[`debugging t-debug on sub template 2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"

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

@@ -82,15 +82,15 @@ exports[`t-esc falsy values in text nodes 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['v1']);
-    const b3 = text(\`:\`);
-    const b4 = text(ctx['v2']);
-    const b5 = text(\`:\`);
-    const b6 = text(ctx['v3']);
-    const b7 = text(\`:\`);
-    const b8 = text(ctx['v4']);
-    const b9 = text(\`:\`);
-    const b10 = text(ctx['v5']);
+    let b2 = text(ctx['v1']);
+    let b3 = text(\`:\`);
+    let b4 = text(ctx['v2']);
+    let b5 = text(\`:\`);
+    let b6 = text(ctx['v3']);
+    let b7 = text(\`:\`);
+    let b8 = text(ctx['v4']);
+    let b9 = text(\`:\`);
+    let b10 = text(ctx['v5']);
     return multi([b2, b3, b4, b5, b6, b7, b8, b9, b10]);
   }
 }"
@@ -160,9 +160,9 @@ exports[`t-esc t-esc=0 is escaped 1`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b2 = block2();
+    let b2 = block2();
     ctx[zero] = b2;
-    const b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b3]);
   }
 }"

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

@@ -10,13 +10,13 @@ exports[`t-foreach does not pollute the rendering context 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList([1]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([1]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       c_block2[i1] = withKey(text(ctx['item']), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -33,14 +33,14 @@ exports[`t-foreach iterate on items (on a element node) 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList([1,2]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([1,2]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       let txt1 = ctx['item'];
       c_block2[i1] = withKey(block3([txt1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -56,22 +56,22 @@ exports[`t-foreach iterate on items 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList([3,2,1]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([3,2,1]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
       ctx[\`item_index\`] = i1;
       ctx[\`item_value\`] = k_block2[i1];
-      const key1 = ctx['item'];
-      const b4 = text(\` [\`);
-      const b5 = text(ctx['item_index']);
-      const b6 = text(\`: \`);
-      const b7 = text(ctx['item']);
-      const b8 = text(\` \`);
-      const b9 = text(ctx['item_value']);
-      const b10 = text(\`] \`);
+      let key1 = ctx['item'];
+      let b4 = text(\` [\`);
+      let b5 = text(ctx['item_index']);
+      let b6 = text(\`: \`);
+      let b7 = text(ctx['item']);
+      let b8 = text(\` \`);
+      let b9 = text(ctx['item_value']);
+      let b10 = text(\`] \`);
       c_block2[i1] = withKey(multi([b4, b5, b6, b7, b8, b9, b10]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -87,22 +87,22 @@ exports[`t-foreach iterate, dict param 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['value']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['value']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
       ctx[\`item_index\`] = i1;
       ctx[\`item_value\`] = k_block2[i1];
-      const key1 = ctx['item_index'];
-      const b4 = text(\` [\`);
-      const b5 = text(ctx['item_index']);
-      const b6 = text(\`: \`);
-      const b7 = text(ctx['item']);
-      const b8 = text(\` \`);
-      const b9 = text(ctx['item_value']);
-      const b10 = text(\`] \`);
+      let key1 = ctx['item_index'];
+      let b4 = text(\` [\`);
+      let b5 = text(ctx['item_index']);
+      let b6 = text(\`: \`);
+      let b7 = text(ctx['item']);
+      let b8 = text(\` \`);
+      let b9 = text(ctx['item_value']);
+      let b10 = text(\`] \`);
       c_block2[i1] = withKey(multi([b4, b5, b6, b7, b8, b9, b10]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -118,13 +118,13 @@ exports[`t-foreach iterate, position 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Array(5));;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Array(5));
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`elem\`] = v_block2[i1];
       ctx[\`elem_first\`] = i1 === 0;
       ctx[\`elem_last\`] = i1 === v_block2.length - 1;
       ctx[\`elem_index\`] = i1;
-      const key1 = ctx['elem'];
+      let key1 = ctx['elem'];
       let b4,b5,b6,b7,b8,b9;
       b4 = text(\` -\`);
       if (ctx['elem_first']) {
@@ -138,7 +138,7 @@ exports[`t-foreach iterate, position 1`] = `
       b9 = text(\`) \`);
       c_block2[i1] = withKey(multi([b4, b5, b6, b7, b8, b9]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -154,13 +154,13 @@ exports[`t-foreach simple iteration (in a node) 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList([3,2,1]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([3,2,1]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       c_block2[i1] = withKey(text(ctx['item']), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -174,10 +174,10 @@ exports[`t-foreach simple iteration 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList([3,2,1]);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList([3,2,1]);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`item\`] = v_block1[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       c_block1[i1] = withKey(text(ctx['item']), key1);
     }
     return list(c_block1);
@@ -196,14 +196,14 @@ exports[`t-foreach simple iteration with two nodes inside 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList([3,2,1]);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList([3,2,1]);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`item\`] = v_block1[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       let txt1 = ctx['item'];
-      const b3 = block3([txt1]);
+      let b3 = block3([txt1]);
       let txt2 = ctx['item'];
-      const b4 = block4([txt2]);
+      let b4 = block4([txt2]);
       c_block1[i1] = withKey(multi([b3, b4]), key1);
     }
     return list(c_block1);
@@ -225,23 +225,23 @@ exports[`t-foreach t-call with body in t-foreach in t-foreach 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['numbers']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['numbers']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`a\`] = v_block2[i1];
       ctx[\`a_first\`] = i1 === 0;
       ctx[\`a_last\`] = i1 === v_block2.length - 1;
       ctx[\`a_index\`] = i1;
       ctx[\`a_value\`] = k_block2[i1];
-      const key1 = ctx['a'];
+      let key1 = ctx['a'];
       ctx = Object.create(ctx);
-      const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['letters']);;
+      const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['letters']);
       for (let i2 = 0; i2 < l_block4; i2++) {
         ctx[\`b\`] = v_block4[i2];
         ctx[\`b_first\`] = i2 === 0;
         ctx[\`b_last\`] = i2 === v_block4.length - 1;
         ctx[\`b_index\`] = i2;
         ctx[\`b_value\`] = k_block4[i2];
-        const key2 = ctx['b'];
+        let key2 = ctx['b'];
         ctx = Object.create(ctx);
         ctx[isBoundary] = 1;
         setContextValue(ctx, \\"c\\", 'x'+'_'+ctx['a']+'_'+ctx['b']);
@@ -249,13 +249,13 @@ exports[`t-foreach t-call with body in t-foreach in t-foreach 1`] = `
         ctx = ctx.__proto__;
       }
       ctx = ctx.__proto__;
-      const b4 = list(c_block4);
+      let b4 = list(c_block4);
       let txt1 = ctx['c'];
-      const b6 = block6([txt1]);
+      let b6 = block6([txt1]);
       c_block2[i1] = withKey(multi([b4, b6]), key1);
     }
     ctx = ctx.__proto__;
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     let txt2 = ctx['a'];
     let txt3 = ctx['b'];
     let txt4 = ctx['c'];
@@ -270,13 +270,13 @@ exports[`t-foreach t-call with body in t-foreach in t-foreach 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\` [\`);
-    const b3 = text(ctx['a']);
-    const b4 = text(\`] [\`);
-    const b5 = text(ctx['b']);
-    const b6 = text(\`] [\`);
-    const b7 = text(ctx['c']);
-    const b8 = text(\`] \`);
+    let b2 = text(\` [\`);
+    let b3 = text(ctx['a']);
+    let b4 = text(\`] [\`);
+    let b5 = text(ctx['b']);
+    let b6 = text(\`] [\`);
+    let b7 = text(ctx['c']);
+    let b8 = text(\`] \`);
     return multi([b2, b3, b4, b5, b6, b7, b8]);
   }
 }"
@@ -294,33 +294,33 @@ exports[`t-foreach t-call without body in t-foreach in t-foreach 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['numbers']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['numbers']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`a\`] = v_block2[i1];
       ctx[\`a_first\`] = i1 === 0;
       ctx[\`a_last\`] = i1 === v_block2.length - 1;
       ctx[\`a_index\`] = i1;
       ctx[\`a_value\`] = k_block2[i1];
-      const key1 = ctx['a'];
+      let key1 = ctx['a'];
       ctx = Object.create(ctx);
-      const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['letters']);;
+      const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['letters']);
       for (let i2 = 0; i2 < l_block4; i2++) {
         ctx[\`b\`] = v_block4[i2];
         ctx[\`b_first\`] = i2 === 0;
         ctx[\`b_last\`] = i2 === v_block4.length - 1;
         ctx[\`b_index\`] = i2;
         ctx[\`b_value\`] = k_block4[i2];
-        const key2 = ctx['b'];
+        let key2 = ctx['b'];
         c_block4[i2] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}__\${key2}\`), key2);
       }
       ctx = ctx.__proto__;
-      const b4 = list(c_block4);
+      let b4 = list(c_block4);
       let txt1 = ctx['c'];
-      const b6 = block6([txt1]);
+      let b6 = block6([txt1]);
       c_block2[i1] = withKey(multi([b4, b6]), key1);
     }
     ctx = ctx.__proto__;
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     let txt2 = ctx['a'];
     let txt3 = ctx['b'];
     let txt4 = ctx['c'];
@@ -339,13 +339,13 @@ exports[`t-foreach t-call without body in t-foreach in t-foreach 2`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"c\\", 'x'+'_'+ctx['a']+'_'+ctx['b']);
-    const b2 = text(\` [\`);
-    const b3 = text(ctx['a']);
-    const b4 = text(\`] [\`);
-    const b5 = text(ctx['b']);
-    const b6 = text(\`] [\`);
-    const b7 = text(ctx['c']);
-    const b8 = text(\`] \`);
+    let b2 = text(\` [\`);
+    let b3 = text(ctx['a']);
+    let b4 = text(\`] [\`);
+    let b5 = text(ctx['b']);
+    let b6 = text(\`] [\`);
+    let b7 = text(ctx['c']);
+    let b8 = text(\`] \`);
     return multi([b2, b3, b4, b5, b6, b7, b8]);
   }
 }"
@@ -361,25 +361,25 @@ exports[`t-foreach t-foreach in t-foreach 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['numbers']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['numbers']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`number\`] = v_block2[i1];
-      const key1 = ctx['number'];
+      let key1 = ctx['number'];
       ctx = Object.create(ctx);
-      const [k_block3, v_block3, l_block3, c_block3] = prepareList(ctx['letters']);;
+      const [k_block3, v_block3, l_block3, c_block3] = prepareList(ctx['letters']);
       for (let i2 = 0; i2 < l_block3; i2++) {
         ctx[\`letter\`] = v_block3[i2];
-        const key2 = ctx['letter'];
-        const b5 = text(\` [\`);
-        const b6 = text(ctx['number']);
-        const b7 = text(ctx['letter']);
-        const b8 = text(\`] \`);
+        let key2 = ctx['letter'];
+        let b5 = text(\` [\`);
+        let b6 = text(ctx['number']);
+        let b7 = text(ctx['letter']);
+        let b8 = text(\`] \`);
         c_block3[i2] = withKey(multi([b5, b6, b7, b8]), key2);
       }
       ctx = ctx.__proto__;
       c_block2[i1] = withKey(list(c_block3), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -395,10 +395,10 @@ exports[`t-foreach t-foreach with t-if inside (no external node) 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['elems']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['elems']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`elem\`] = v_block1[i1];
-      const key1 = ctx['elem'].id;
+      let key1 = ctx['elem'].id;
       let b3;
       if (ctx['elem'].id<3) {
         let txt1 = ctx['elem'].text;
@@ -422,10 +422,10 @@ exports[`t-foreach t-foreach with t-if inside 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['elems']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['elems']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`elem\`] = v_block2[i1];
-      const key1 = ctx['elem'].id;
+      let key1 = ctx['elem'].id;
       let b4;
       if (ctx['elem'].id<3) {
         let txt1 = ctx['elem'].text;
@@ -433,7 +433,7 @@ exports[`t-foreach t-foreach with t-if inside 1`] = `
       }
       c_block2[i1] = withKey(multi([b4]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -450,13 +450,13 @@ exports[`t-foreach t-key on t-foreach 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['things']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['things']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`thing\`] = v_block2[i1];
-      const key1 = ctx['thing'];
+      let key1 = ctx['thing'];
       c_block2[i1] = withKey(block3(), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -473,15 +473,15 @@ exports[`t-foreach throws error if invalid loop expression 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['abc']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['abc']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
       ctx[\`item_index\`] = i1;
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       const tKey_1 = ctx['item_index'];
       c_block2[i1] = withKey(block3(), tKey_1 + key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -500,12 +500,12 @@ exports[`t-foreach with t-memo 1`] = `
     let cache = ctx.cache || {};
     let nextCache = ctx.cache = {};
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = ctx['item'].id;
-      const memo1 = [ctx['item'].x];
-      const vnode1 = cache[key1];;
+      let key1 = ctx['item'].id;
+      let memo1 = [ctx['item'].x]
+      let vnode1 = cache[key1];
       if (vnode1) {
         if (shallowEqual(vnode1.memo, memo1)) {
           c_block2[i1] = vnode1;
@@ -518,7 +518,7 @@ exports[`t-foreach with t-memo 1`] = `
       c_block2[i1] = withKey(block3([txt1, txt2]), key1);
       nextCache[key1] = Object.assign(c_block2[i1], {memo: memo1});
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"

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

@@ -29,8 +29,8 @@ exports[`t-if a t-if with two inner nodes 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['condition']) {
-      const b3 = block3();
-      const b4 = block4();
+      let b3 = block3();
+      let b4 = block4();
       b2 = multi([b3, b4]);
     }
     return multi([b2]);
@@ -187,8 +187,8 @@ exports[`t-if div containing a t-if with two inner nodes 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['condition']) {
-      const b3 = block3();
-      const b4 = block4();
+      let b3 = block3();
+      let b4 = block4();
       b2 = multi([b3, b4]);
     }
     return block1([], [b2]);
@@ -208,8 +208,8 @@ exports[`t-if dynamic content after t-if with two children nodes 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['condition']) {
-      const b3 = block3();
-      const b4 = block4();
+      let b3 = block3();
+      let b4 = block4();
       b2 = multi([b3, b4]);
     }
     let txt1 = ctx['text'];
@@ -318,8 +318,8 @@ exports[`t-if t-if and t-else with two nodes 1`] = `
     if (ctx['condition']) {
       b2 = text(\`1\`);
     } else {
-      const b4 = block4();
-      const b5 = block5();
+      let b4 = block4();
+      let b5 = block5();
       b3 = multi([b4, b5]);
     }
     return multi([b2, b3]);
@@ -526,8 +526,8 @@ exports[`t-if two t-ifs next to each other 1`] = `
       b2 = block2([txt1]);
     }
     if (ctx['condition']) {
-      const b4 = block4();
-      const b5 = block5();
+      let b4 = block4();
+      let b5 = block5();
       b3 = multi([b4, b5]);
     }
     return block1([], [b2, b3]);

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

@@ -56,14 +56,14 @@ exports[`t-key t-key directive in a list 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['beers']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['beers']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`beer\`] = v_block2[i1];
-      const key1 = ctx['beer'].id;
+      let key1 = ctx['beer'].id;
       let txt1 = ctx['beer'].name;
       c_block2[i1] = withKey(block3([txt1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"

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

@@ -9,7 +9,7 @@ exports[`t-out literal 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput('ok');
+    let b2 = safeOutput('ok');
     return block1([], [b2]);
   }
 }"
@@ -40,9 +40,9 @@ exports[`t-out multiple calls to t-out 1`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b2 = block2();
+    let b2 = block2();
     ctx[zero] = b2;
-    const b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b3]);
   }
 }"
@@ -57,8 +57,8 @@ exports[`t-out multiple calls to t-out 2`] = `
   let block1 = createBlock(\`<div><block-child-0/><div>Greeter</div><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
-    const b3 = ctx[zero];
+    let b2 = ctx[zero];
+    let b3 = ctx[zero];
     return block1([], [b2, b3]);
   }
 }"
@@ -73,7 +73,7 @@ exports[`t-out not escaping 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -92,9 +92,9 @@ exports[`t-out t-out 0 1`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b2 = block2();
+    let b2 = block2();
     ctx[zero] = b2;
-    const b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b3 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b3]);
   }
 }"
@@ -109,7 +109,7 @@ exports[`t-out t-out 0 2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
+    let b2 = ctx[zero];
     return block1([], [b2]);
   }
 }"
@@ -124,7 +124,7 @@ exports[`t-out t-out and another sibling node 1`] = `
   let block1 = createBlock(\`<span><span>hello</span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -147,7 +147,7 @@ exports[`t-out t-out bdom 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx[\`var\`] = new LazyValue(value1, ctx, node);
-    const b3 = safeOutput(ctx['var']);
+    let b3 = safeOutput(ctx['var']);
     return block1([], [b3]);
   }
 }"
@@ -162,7 +162,7 @@ exports[`t-out t-out block 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['bdom']);
+    let b2 = safeOutput(ctx['bdom']);
     return block1([], [b2]);
   }
 }"
@@ -177,7 +177,7 @@ exports[`t-out t-out escaped 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -192,7 +192,7 @@ exports[`t-out t-out markedup 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -207,8 +207,8 @@ exports[`t-out t-out on a node with a body, as a default 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = text(\`nope\`);
-    const b2 = withDefault(safeOutput(ctx['var']), b3);
+    let b3 = text(\`nope\`);
+    let b2 = withDefault(safeOutput(ctx['var']), b3);
     return block1([], [b2]);
   }
 }"
@@ -224,8 +224,8 @@ exports[`t-out t-out on a node with a dom node in body, as a default 1`] = `
   let block3 = createBlock(\`<div>nope</div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = block3();
-    const b2 = withDefault(safeOutput(ctx['var']), b3);
+    let b3 = block3();
+    let b2 = withDefault(safeOutput(ctx['var']), b3);
     return block1([], [b2]);
   }
 }"
@@ -240,7 +240,7 @@ exports[`t-out t-out switch escaped 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -255,7 +255,7 @@ exports[`t-out t-out switch escaped on markup 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -270,7 +270,7 @@ exports[`t-out t-out switch markup 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -297,10 +297,10 @@ exports[`t-out t-out switch markup on bdom 1`] = `
     let b3,b5;
     ctx[\`bdom\`] = new LazyValue(value1, ctx, node);
     if (ctx['hasBdom']) {
-      const b4 = safeOutput(ctx['bdom']);
+      let b4 = safeOutput(ctx['bdom']);
       b3 = block3([], [b4]);
     } else {
-      const b6 = safeOutput(ctx['var']);
+      let b6 = safeOutput(ctx['var']);
       b5 = block5([], [b6]);
     }
     return block1([], [b3, b5]);
@@ -317,7 +317,7 @@ exports[`t-out t-out switch markup on escaped 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -344,7 +344,7 @@ exports[`t-out t-out with arbitrary object 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -359,7 +359,7 @@ exports[`t-out t-out with arbitrary object 2 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -374,7 +374,7 @@ exports[`t-out t-out with comment 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -401,7 +401,7 @@ exports[`t-out variable 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -416,7 +416,7 @@ exports[`t-out with a String class 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -431,7 +431,7 @@ exports[`t-out with an extended String class 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -446,7 +446,7 @@ exports[`t-raw is deprecated should warn 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"
@@ -461,7 +461,7 @@ exports[`t-raw is deprecated t-out is actually called in t-raw's place 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['var']);
+    let b2 = safeOutput(ctx['var']);
     return block1([], [b2]);
   }
 }"

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

@@ -41,7 +41,7 @@ exports[`t-ref ref in a t-call 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -94,17 +94,17 @@ exports[`t-ref refs in a loop 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const refs = ctx.__owl__.refs;
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       const tKey_1 = ctx['item'];
       const v1 = ctx['item'];
       let ref1 = (el) => refs[\`\${v1}\`] = el;
       let txt1 = ctx['item'];
       c_block2[i1] = withKey(block3([ref1, txt1]), tKey_1 + key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"

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

@@ -208,7 +208,7 @@ exports[`t-set t-set body is evaluated immediately 1`] = `
     setContextValue(ctx, \\"v1\\", 'before');
     ctx[\`v2\`] = new LazyValue(value1, ctx, node);
     setContextValue(ctx, \\"v1\\", 'after');
-    const b3 = safeOutput(ctx['v2']);
+    let b3 = safeOutput(ctx['v2']);
     return block1([], [b3]);
   }
 }"
@@ -228,7 +228,7 @@ exports[`t-set t-set can't alter from within callee 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"iter\\", 'source');
     let txt1 = ctx['iter'];
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     let txt2 = ctx['iter'];
     return block1([txt1, txt2], [b2]);
   }
@@ -271,7 +271,7 @@ exports[`t-set t-set can't alter in t-call body 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"iter\\", 'inCall');
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     ctx = ctx.__proto__;
     let txt2 = ctx['iter'];
     return block1([txt1, txt2], [b2]);
@@ -349,16 +349,16 @@ exports[`t-set t-set outside modified in t-foreach 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"iter\\", 0);
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['a','b']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['a','b']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
-      const key1 = ctx['val'];
+      let key1 = ctx['val'];
       let txt1 = ctx['iter'];
       c_block2[i1] = withKey(block3([txt1]), key1);
       setContextValue(ctx, \\"iter\\", ctx['iter']+1);
     }
     ctx = ctx.__proto__;
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     let txt2 = ctx['iter'];
     return block1([txt2], [b2]);
   }
@@ -379,16 +379,16 @@ exports[`t-set t-set outside modified in t-foreach increment-after operator 1`]
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"iter\\", 0);
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['a','b']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['a','b']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
-      const key1 = ctx['val'];
+      let key1 = ctx['val'];
       let txt1 = ctx['iter'];
       c_block2[i1] = withKey(block3([txt1]), key1);
       setContextValue(ctx, \\"iter\\", ctx['iter']++);
     }
     ctx = ctx.__proto__;
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     let txt2 = ctx['iter'];
     return block1([txt2], [b2]);
   }
@@ -409,16 +409,16 @@ exports[`t-set t-set outside modified in t-foreach increment-before operator 1`]
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"iter\\", 0);
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['a','b']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['a','b']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
-      const key1 = ctx['val'];
+      let key1 = ctx['val'];
       let txt1 = ctx['iter'];
       c_block2[i1] = withKey(block3([txt1]), key1);
       setContextValue(ctx, \\"iter\\", ++ctx['iter']);
     }
     ctx = ctx.__proto__;
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     let txt2 = ctx['iter'];
     return block1([txt2], [b2]);
   }
@@ -439,16 +439,16 @@ exports[`t-set t-set should reuse variable if possible 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"v\\", 1);
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['list']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['list']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`elem\`] = v_block2[i1];
       ctx[\`elem_index\`] = i1;
-      const key1 = ctx['elem_index'];
+      let key1 = ctx['elem_index'];
       let txt1 = ctx['v'];
       setContextValue(ctx, \\"v\\", ctx['elem']);
       c_block2[i1] = withKey(block3([txt1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -463,8 +463,8 @@ exports[`t-set t-set with content and sub t-esc 1`] = `
   let block1 = createBlock(\`<div><block-text-0/></div>\`);
   
   function value1(ctx, node, key = \\"\\") {
-    const b3 = text(ctx['beep']);
-    const b4 = text(\` boop\`);
+    let b3 = text(ctx['beep']);
+    let b4 = text(\` boop\`);
     return multi([b3, b4]);
   }
   
@@ -500,7 +500,7 @@ exports[`t-set t-set with t-value (falsy) and body 1`] = `
     ctx[\`v2\`] = withDefault(ctx['v3'], new LazyValue(value1, ctx, node));
     setContextValue(ctx, \\"v1\\", 'after');
     setContextValue(ctx, \\"v3\\", true);
-    const b3 = safeOutput(ctx['v2']);
+    let b3 = safeOutput(ctx['v2']);
     return block1([], [b3]);
   }
 }"
@@ -528,7 +528,7 @@ exports[`t-set t-set with t-value (truthy) and body 1`] = `
     ctx[\`v2\`] = withDefault(ctx['v3'], new LazyValue(value1, ctx, node));
     setContextValue(ctx, \\"v1\\", 'after');
     setContextValue(ctx, \\"v3\\", false);
-    const b3 = safeOutput(ctx['v2']);
+    let b3 = safeOutput(ctx['v2']);
     return block1([], [b3]);
   }
 }"

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

@@ -8,7 +8,7 @@ exports[`qweb t-tag can fallback if falsy tag 1`] = `
   let block1 = tag => createBlock(\`<\${tag || 'fallback'}/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const tag1 = ctx['tag'];
+    let tag1 = ctx['tag'];
     return toggler(tag1, block1(tag1)());
   }
 }"
@@ -22,7 +22,7 @@ exports[`qweb t-tag can update 1`] = `
   let block1 = tag => createBlock(\`<\${tag || 't'}/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const tag1 = ctx['tag'];
+    let tag1 = ctx['tag'];
     return toggler(tag1, block1(tag1)());
   }
 }"
@@ -36,7 +36,7 @@ exports[`qweb t-tag simple usecases 1`] = `
   let block1 = tag => createBlock(\`<\${tag || 't'}/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const tag1 = 'div';
+    let tag1 = 'div';
     return toggler(tag1, block1(tag1)());
   }
 }"
@@ -50,7 +50,7 @@ exports[`qweb t-tag simple usecases 2`] = `
   let block1 = tag => createBlock(\`<\${tag || 't'}>text</\${tag || 't'}>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const tag1 = ctx['tag'];
+    let tag1 = ctx['tag'];
     return toggler(tag1, block1(tag1)());
   }
 }"
@@ -64,7 +64,7 @@ exports[`qweb t-tag with multiple attributes 1`] = `
   let block1 = tag => createBlock(\`<\${tag || 't'} class=\\"blueberry\\" taste=\\"raspberry\\">gooseberry</\${tag || 't'}>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const tag1 = ctx['tag'];
+    let tag1 = ctx['tag'];
     return toggler(tag1, block1(tag1)());
   }
 }"
@@ -78,7 +78,7 @@ exports[`qweb t-tag with multiple child nodes 1`] = `
   let block1 = tag => createBlock(\`<\${tag || 't'}> pear <span>apple</span> strawberry </\${tag || 't'}>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const tag1 = ctx['tag'];
+    let tag1 = ctx['tag'];
     return toggler(tag1, block1(tag1)());
   }
 }"
@@ -93,9 +93,9 @@ exports[`qweb t-tag with multiple t-tag in same template 1`] = `
   let block2 = tag => createBlock(\`<\${tag || 't'}>baz</\${tag || 't'}>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const tag1 = ctx['outer'];
-    const tag2 = ctx['inner'];
-    const b2 = toggler(tag2, block2(tag2)());
+    let tag1 = ctx['outer'];
+    let tag2 = ctx['inner'];
+    let b2 = toggler(tag2, block2(tag2)());
     return toggler(tag1, block1(tag1)([], [b2]));
   }
 }"
@@ -110,10 +110,10 @@ exports[`qweb t-tag with multiple t-tag in same template, part 2 1`] = `
   let block3 = tag => createBlock(\`<\${tag || 't'}>baz</\${tag || 't'}>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const tag1 = ctx['brother'];
-    const b2 = toggler(tag1, block2(tag1)());
-    const tag2 = ctx['brother'];
-    const b3 = toggler(tag2, block3(tag2)());
+    let tag1 = ctx['brother'];
+    let b2 = toggler(tag1, block2(tag1)());
+    let tag2 = ctx['brother'];
+    let b3 = toggler(tag2, block3(tag2)());
     return multi([b2, b3]);
   }
 }"

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

@@ -50,7 +50,7 @@ exports[`loading templates can load a few templates from a xml string 1`] = `
   let block1 = createBlock(\`<ul><block-child-0/></ul>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -65,8 +65,8 @@ exports[`loading templates can load a few templates from a xml string 2`] = `
   let block3 = createBlock(\`<li>foo</li>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
-    const b3 = block3();
+    let b2 = block2();
+    let b3 = block3();
     return multi([b2, b3]);
   }
 }"
@@ -82,7 +82,7 @@ exports[`loading templates can load a few templates from an XMLDocument 1`] = `
   let block1 = createBlock(\`<ul><block-child-0/></ul>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -97,8 +97,8 @@ exports[`loading templates can load a few templates from an XMLDocument 2`] = `
   let block3 = createBlock(\`<li>foo</li>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
-    const b3 = block3();
+    let b2 = block2();
+    let b3 = block3();
     return multi([b2, b3]);
   }
 }"

tests/compiler/inline_expressions.test.ts

@@ -65,14 +65,14 @@ describe("tokenizer", () => {
   });
 
   test("strings", () => {
-    expect(() => tokenize("'")).toThrow("Tokenizer error: could not tokenize `'`");
-    expect(() => tokenize("'\\")).toThrow("Tokenizer error: could not tokenize `'\\`");
-    expect(() => tokenize("'\\'")).toThrow("Tokenizer error: could not tokenize `'\\'`");
+    expect(() => tokenize("'")).toThrow("Invalid expression");
+    expect(() => tokenize("'\\")).toThrow("Invalid expression");
+    expect(() => tokenize("'\\'")).toThrow("Invalid expression");
     expect(tokenize("'hello ged'")).toEqual([{ type: "VALUE", value: "'hello ged'" }]);
     expect(tokenize("'hello \\'ged\\''")).toEqual([{ type: "VALUE", value: "'hello \\'ged\\''" }]);
 
-    expect(() => tokenize('"')).toThrow('Tokenizer error: could not tokenize `"`');
-    expect(() => tokenize('"\\"')).toThrow('Tokenizer error: could not tokenize `"\\"`');
+    expect(() => tokenize('"')).toThrow("Invalid expression");
+    expect(() => tokenize('"\\"')).toThrow("Invalid expression");
     expect(tokenize('"hello ged"')).toEqual([{ type: "VALUE", value: '"hello ged"' }]);
     expect(tokenize('"hello ged"}')).toEqual([
       { type: "VALUE", value: '"hello ged"' },

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

@@ -6,7 +6,7 @@ exports[`basics GrandChild display is controlled by its GrandParent 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const Comp1 = ctx['myComp'];
+    let Comp1 = ctx['myComp'];
     return toggler(Comp1, component(Comp1, {displayGrandChild: ctx['displayGrandChild']}, key + \`__1\`, node, ctx));
   }
 }"
@@ -49,9 +49,9 @@ exports[`basics Multi root component 1`] = `
   let block4 = createBlock(\`<span>2</span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
-    const b3 = text(\`text\`);
-    const b4 = block4();
+    let b2 = block2();
+    let b3 = text(\`text\`);
+    let b4 = block4();
     return multi([b2, b3, b4]);
   }
 }"
@@ -102,7 +102,7 @@ exports[`basics a component inside a component 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -145,7 +145,7 @@ exports[`basics can handle empty props 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {val: undefined}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {val: undefined}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -236,8 +236,8 @@ exports[`basics can mount a simple component with multiple roots 1`] = `
   let block3 = createBlock(\`<div/>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
-    const b3 = block3();
+    let b2 = block2();
+    let b3 = block3();
     return multi([b2, b3]);
   }
 }"
@@ -477,15 +477,15 @@ exports[`basics list of two sub components inside other nodes 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].blips);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].blips);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`blip\`] = v_block2[i1];
-      const key1 = ctx['blip'].id;
-      const b4 = component(\`SubWidget\`, {}, key + \`__1__\${key1}\`, node, ctx);
-      const b5 = component(\`SubWidget\`, {}, key + \`__2__\${key1}\`, node, ctx);
+      let key1 = ctx['blip'].id;
+      let b4 = component(\`SubWidget\`, {}, key + \`__1__\${key1}\`, node, ctx);
+      let b5 = component(\`SubWidget\`, {}, key + \`__2__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([], [b4, b5]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -560,9 +560,9 @@ exports[`basics reconciliation alg is not confused in some specific situation 1`
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     const tKey_1 = 4;
-    const b3 = toggler(tKey_1, component(\`Child\`, {}, tKey_1 + key + \`__2\`, node, ctx));
+    let b3 = toggler(tKey_1, component(\`Child\`, {}, tKey_1 + key + \`__2\`, node, ctx));
     return block1([], [b2, b3]);
   }
 }"
@@ -617,9 +617,9 @@ exports[`basics same t-keys in two different places 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = 1;
-    const b2 = toggler(tKey_1, component(\`Child\`, {blip: '1'}, tKey_1 + key + \`__1\`, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, {blip: '1'}, tKey_1 + key + \`__1\`, node, ctx));
     const tKey_2 = 1;
-    const b3 = toggler(tKey_2, component(\`Child\`, {blip: '2'}, tKey_2 + key + \`__2\`, node, ctx));
+    let b3 = toggler(tKey_2, component(\`Child\`, {blip: '2'}, tKey_2 + key + \`__2\`, node, ctx));
     return block1([], [b2, b3]);
   }
 }"
@@ -952,8 +952,8 @@ exports[`basics two child components 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    const b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b3 = component(\`Child\`, {}, key + \`__2\`, node, ctx);
     return multi([b2, b3]);
   }
 }"
@@ -981,7 +981,7 @@ exports[`basics update props of component without concrete own node 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['childProps'].key;
-    const b2 = toggler(tKey_1, component(\`Child\`, Object.assign({}, ctx['childProps']), tKey_1 + key + \`__1\`, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, Object.assign({}, ctx['childProps']), tKey_1 + key + \`__1\`, node, ctx));
     return block1([], [b2]);
   }
 }"
@@ -1022,10 +1022,10 @@ exports[`basics updating a component with t-foreach as root 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['items']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['items']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`item\`] = v_block1[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       c_block1[i1] = withKey(text(ctx['item']), key1);
     }
     return list(c_block1);
@@ -1071,16 +1071,16 @@ exports[`basics widget after a t-foreach 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Array(2));;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Array(2));
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`elem\`] = v_block2[i1];
       ctx[\`elem_index\`] = i1;
-      const key1 = ctx['elem_index'];
+      let key1 = ctx['elem_index'];
       c_block2[i1] = withKey(text(\`txt\`), key1);
     }
     ctx = ctx.__proto__;
-    const b2 = list(c_block2);
-    const b4 = component(\`SomeComponent\`, {}, key + \`__1\`, node, ctx);
+    let b2 = list(c_block2);
+    let b4 = component(\`SomeComponent\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2, b4]);
   }
 }"
@@ -1187,7 +1187,7 @@ exports[`support svg components add proper namespace to svg 1`] = `
   let block1 = createBlock(\`<svg block-ns=\\"http://www.w3.org/2000/svg\\"><block-child-0/></svg>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`GComp\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`GComp\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1216,15 +1216,15 @@ exports[`t-out in components can render list of t-out  1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].items);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].items);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = ctx['item'];
-      const b4 = text(ctx['item']);
-      const b5 = safeOutput(ctx['item']);
+      let key1 = ctx['item'];
+      let b4 = text(ctx['item']);
+      let b5 = safeOutput(ctx['item']);
       c_block2[i1] = withKey(multi([b4, b5]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -1237,8 +1237,8 @@ exports[`t-out in components can switch the contents of two t-out repeatedly 1`]
   let { safeOutput } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['state'].a);
-    const b3 = safeOutput(ctx['state'].b);
+    let b2 = safeOutput(ctx['state'].a);
+    let b3 = safeOutput(ctx['state'].b);
     return multi([b2, b3]);
   }
 }"
@@ -1253,7 +1253,7 @@ exports[`t-out in components update properly on state changes 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = safeOutput(ctx['state'].value);
+    let b2 = safeOutput(ctx['state'].value);
     return block1([], [b2]);
   }
 }"

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

@@ -7,16 +7,16 @@ exports[`Cascading renders after microtaskTick 1`] = `
   let { prepareList, withKey } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    const b3 = text(\` _ \`);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b3 = text(\` _ \`);
     ctx = Object.create(ctx);
-    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['state']);;
+    const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['state']);
     for (let i1 = 0; i1 < l_block4; i1++) {
       ctx[\`elem\`] = v_block4[i1];
-      const key1 = ctx['elem'].id;
+      let key1 = ctx['elem'].id;
       c_block4[i1] = withKey(text(ctx['elem'].id), key1);
     }
-    const b4 = list(c_block4);
+    let b4 = list(c_block4);
     return multi([b2, b3, b4]);
   }
 }"
@@ -30,10 +30,10 @@ exports[`Cascading renders after microtaskTick 2`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['state']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['state']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`elem\`] = v_block1[i1];
-      const key1 = ctx['elem'].id;
+      let key1 = ctx['elem'].id;
       c_block1[i1] = withKey(component(\`Element\`, {id: ctx['elem'].id}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
@@ -52,50 +52,6 @@ exports[`Cascading renders after microtaskTick 3`] = `
 }"
 `;
 
-exports[`another scenario with delayed rendering 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2,b3;
-    b2 = text(\`A\`);
-    if (ctx['state'].value<15) {
-      b3 = component(\`B\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`another scenario with delayed rendering 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['props'].value);
-    const b3 = component(\`C\`, {}, key + \`__1\`, node, ctx);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`another scenario with delayed rendering 3`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<button block-handler-0=\\"click\\"><block-text-1/></button>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['increment'], ctx];
-    let txt1 = ctx['state'].val;
-    return block1([hdlr1, txt1]);
-  }
-}"
-`;
-
 exports[`async rendering destroying a widget before start is over 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -213,7 +169,7 @@ exports[`concurrent renderings scenario 1 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -227,7 +183,7 @@ exports[`concurrent renderings scenario 1 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -257,7 +213,7 @@ exports[`concurrent renderings scenario 2 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].fromA;
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([txt1], [b2]);
   }
 }"
@@ -271,7 +227,7 @@ exports[`concurrent renderings scenario 2 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -300,7 +256,7 @@ exports[`concurrent renderings scenario 2bis 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -314,7 +270,7 @@ exports[`concurrent renderings scenario 2bis 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA, fromB: ctx['state'].fromB}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -343,7 +299,7 @@ exports[`concurrent renderings scenario 3 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -357,7 +313,7 @@ exports[`concurrent renderings scenario 3 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -371,7 +327,7 @@ exports[`concurrent renderings scenario 3 3`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -400,7 +356,7 @@ exports[`concurrent renderings scenario 4 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -414,7 +370,7 @@ exports[`concurrent renderings scenario 4 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentC\`, {fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -428,7 +384,7 @@ exports[`concurrent renderings scenario 4 3`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -457,7 +413,7 @@ exports[`concurrent renderings scenario 5 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -485,7 +441,7 @@ exports[`concurrent renderings scenario 6 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -513,7 +469,7 @@ exports[`concurrent renderings scenario 7 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -542,7 +498,7 @@ exports[`concurrent renderings scenario 8 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -572,8 +528,8 @@ exports[`concurrent renderings scenario 9 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].fromA;
-    const b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
-    const b3 = component(\`ComponentC\`, {fromA: ctx['state'].fromA}, key + \`__2\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b3 = component(\`ComponentC\`, {fromA: ctx['state'].fromA}, key + \`__2\`, node, ctx);
     return block1([txt1], [b2, b3]);
   }
 }"
@@ -601,7 +557,7 @@ exports[`concurrent renderings scenario 9 3`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentD\`, {fromA: ctx['props'].fromA, fromC: ctx['state'].fromC}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -630,7 +586,7 @@ exports[`concurrent renderings scenario 10 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -675,7 +631,7 @@ exports[`concurrent renderings scenario 11 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -704,7 +660,7 @@ exports[`concurrent renderings scenario 12 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -764,7 +720,7 @@ exports[`concurrent renderings scenario 14 1`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -778,7 +734,7 @@ exports[`concurrent renderings scenario 14 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`C\`, {fromB: ctx['state'].fromB, fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`C\`, {fromB: ctx['state'].fromB, fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -808,7 +764,7 @@ exports[`concurrent renderings scenario 15 1`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`B\`, {fromA: ctx['state'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -822,7 +778,7 @@ exports[`concurrent renderings scenario 15 2`] = `
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`C\`, {fromB: ctx['state'].fromB, fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`C\`, {fromB: ctx['state'].fromB, fromA: ctx['props'].fromA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1052,9 +1008,9 @@ exports[`delay willUpdateProps 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['props'].value);
-    const b3 = text(\`_\`);
-    const b4 = text(ctx['state'].int);
+    let b2 = text(ctx['props'].value);
+    let b3 = text(\`_\`);
+    let b4 = text(ctx['state'].int);
     return multi([b2, b3, b4]);
   }
 }"
@@ -1077,8 +1033,8 @@ exports[`delay willUpdateProps with rendering grandchild 2`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`DelayedChild\`, {value: ctx['props'].state.value}, key + \`__1\`, node, ctx);
-    const b3 = component(\`ReactiveChild\`, {}, key + \`__2\`, node, ctx);
+    let b2 = component(\`DelayedChild\`, {value: ctx['props'].state.value}, key + \`__1\`, node, ctx);
+    let b3 = component(\`ReactiveChild\`, {}, key + \`__2\`, node, ctx);
     return multi([b2, b3]);
   }
 }"
@@ -1090,9 +1046,9 @@ exports[`delay willUpdateProps with rendering grandchild 3`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['props'].value);
-    const b3 = text(\`_\`);
-    const b4 = text(ctx['state'].int);
+    let b2 = text(ctx['props'].value);
+    let b3 = text(\`_\`);
+    let b4 = text(ctx['state'].int);
     return multi([b2, b3, b4]);
   }
 }"
@@ -1111,211 +1067,6 @@ exports[`delay willUpdateProps with rendering grandchild 4`] = `
 }"
 `;
 
-exports[`delayed rendering, but then initial rendering is cancelled by yet another render 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`B\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`delayed rendering, but then initial rendering is cancelled by yet another render 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`C\`, {value: ctx['state'].someValue+ctx['props'].value}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`delayed rendering, but then initial rendering is cancelled by yet another render 3`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block3 = createBlock(\`<p><block-text-0/></p>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`D\`, {}, key + \`__1\`, node, ctx);
-    let txt1 = ctx['props'].value;
-    const b3 = block3([txt1]);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`delayed rendering, but then initial rendering is cancelled by yet another render 4`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<button block-handler-0=\\"click\\"><block-text-1/></button>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['increment'], ctx];
-    let txt1 = ctx['state'].val;
-    return block1([hdlr1, txt1]);
-  }
-}"
-`;
-
-exports[`delayed rendering, reusing fiber and stuff 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`B\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`delayed rendering, reusing fiber and stuff 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['props'].value);
-    const b3 = component(\`C\`, {}, key + \`__1\`, node, ctx);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`delayed rendering, reusing fiber and stuff 3`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<button block-handler-0=\\"click\\"><block-text-1/></button>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['increment'], ctx];
-    let txt1 = ctx['state'].val;
-    return block1([hdlr1, txt1]);
-  }
-}"
-`;
-
-exports[`delayed rendering, reusing fiber then component is destroyed and  stuff 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2,b3;
-    b2 = text(\`A\`);
-    if (ctx['state'].value<15) {
-      b3 = component(\`B\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`delayed rendering, reusing fiber then component is destroyed and  stuff 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['props'].value);
-    const b3 = component(\`C\`, {}, key + \`__1\`, node, ctx);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`delayed rendering, reusing fiber then component is destroyed and  stuff 3`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<button block-handler-0=\\"click\\"><block-text-1/></button>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['increment'], ctx];
-    let txt1 = ctx['state'].val;
-    return block1([hdlr1, txt1]);
-  }
-}"
-`;
-
-exports[`delayed rendering, then component is destroyed and  stuff 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`B\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`delayed rendering, then component is destroyed and  stuff 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2,b3;
-    b2 = text(ctx['props'].value);
-    if (ctx['props'].value<10) {
-      b3 = component(\`C\`, {}, key + \`__1\`, node, ctx);
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`delayed rendering, then component is destroyed and  stuff 3`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<button block-handler-0=\\"click\\"><block-text-1/></button>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let hdlr1 = [ctx['increment'], ctx];
-    let txt1 = ctx['state'].val;
-    return block1([hdlr1, txt1]);
-  }
-}"
-`;
-
-exports[`destroying/recreating a subcomponent, other scenario 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2,b3;
-    b2 = text(\`parent\`);
-    if (ctx['state'].hasChild) {
-      b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    }
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`destroying/recreating a subcomponent, other scenario 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`child\`);
-  }
-}"
-`;
-
 exports[`destroying/recreating a subwidget with different props (if start is not over) 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -1394,7 +1145,7 @@ exports[`properly behave when destroyed/unmounted while rendering  2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`SubChild\`, {val: ctx['props'].val}, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubChild\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1444,28 +1195,6 @@ exports[`rendering component again in next microtick 2`] = `
 }"
 `;
 
-exports[`rendering parent twice, with different props on child and stuff 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`rendering parent twice, with different props on child and stuff 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].value);
-  }
-}"
-`;
-
 exports[`t-foreach with dynamic async component 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -1474,14 +1203,14 @@ exports[`t-foreach with dynamic async component 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['list']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['list']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`arr\`] = v_block1[i1];
       ctx[\`arr_index\`] = i1;
-      const key1 = ctx['arr_index'];
+      let key1 = ctx['arr_index'];
       let b3;
       if (ctx['arr']) {
-        const Comp1 = ctx['myComp'];
+        let Comp1 = ctx['myComp'];
         b3 = toggler(Comp1, component(Comp1, {key: ctx['arr'][0]}, key + \`__1__\${key1}\`, node, ctx));
       }
       c_block1[i1] = withKey(multi([b3]), key1);
@@ -1514,8 +1243,8 @@ exports[`t-key on dom node having a component 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key'];
-    const Comp1 = ctx['myComp'];
-    const b2 = toggler(tKey_1, toggler(Comp1, component(Comp1, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx)));
+    let Comp1 = ctx['myComp'];
+    let b2 = toggler(tKey_1, toggler(Comp1, component(Comp1, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx)));
     return toggler(tKey_1, block1([], [b2]));
   }
 }"
@@ -1539,7 +1268,7 @@ exports[`t-key on dynamic async component (toggler is never patched) 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key'];
-    const Comp1 = ctx['myComp'];
+    let Comp1 = ctx['myComp'];
     return toggler(tKey_1, toggler(Comp1, component(Comp1, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx)));
   }
 }"
@@ -1622,7 +1351,7 @@ exports[`update a sub-component twice in the same frame 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1650,7 +1379,7 @@ exports[`update a sub-component twice in the same frame, 2 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ChildA\`, {val: ctx['state'].valA}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

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

@@ -32,7 +32,7 @@ exports[`basics no component catching error lead to full app destruction 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ErrorComponent\`, {flag: ctx['state'].flag}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ErrorComponent\`, {flag: ctx['state'].flag}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -100,7 +100,6 @@ exports[`can catch errors can catch an error in a component render function 1`]
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -109,7 +108,7 @@ exports[`can catch errors can catch an error in a component render function 1`]
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -128,7 +127,7 @@ exports[`can catch errors can catch an error in a component render function 2`]
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -153,7 +152,6 @@ exports[`can catch errors can catch an error in the constructor call of a compon
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -162,7 +160,7 @@ exports[`can catch errors can catch an error in the constructor call of a compon
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -181,7 +179,7 @@ exports[`can catch errors can catch an error in the constructor call of a compon
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -192,18 +190,17 @@ exports[`can catch errors can catch an error in the constructor call of a compon
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    const b3 = component(\`ClassicCompoent\`, {}, key + \`__1\`, node, ctx);
-    const b4 = component(\`ErrorComponent\`, {}, key + \`__2\`, node, ctx);
+    let b3 = component(\`ClassicCompoent\`, {}, key + \`__1\`, node, ctx);
+    let b4 = component(\`ErrorComponent\`, {}, key + \`__2\`, node, ctx);
     return multi([b3, b4]);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b5 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__3\`, node, ctx);
+    let b5 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -222,7 +219,7 @@ exports[`can catch errors can catch an error in the constructor call of a compon
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -272,7 +269,6 @@ exports[`can catch errors can catch an error in the initial call of a component
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -281,7 +277,7 @@ exports[`can catch errors can catch an error in the initial call of a component
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -300,7 +296,7 @@ exports[`can catch errors can catch an error in the initial call of a component
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -325,7 +321,6 @@ exports[`can catch errors can catch an error in the initial call of a component
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -336,7 +331,7 @@ exports[`can catch errors can catch an error in the initial call of a component
   return function template(ctx, node, key = \\"\\") {
     let b3;
     if (ctx['state'].flag) {
-      b3 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
+      b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     }
     return block1([], [b3]);
   }
@@ -356,7 +351,7 @@ exports[`can catch errors can catch an error in the initial call of a component
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -396,7 +391,7 @@ exports[`can catch errors can catch an error in the mounted call (in child of ch
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`C\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`C\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -470,7 +465,6 @@ exports[`can catch errors can catch an error in the mounted call 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -479,7 +473,7 @@ exports[`can catch errors can catch an error in the mounted call 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -498,7 +492,7 @@ exports[`can catch errors can catch an error in the mounted call 2`] = `
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -522,7 +516,6 @@ exports[`can catch errors can catch an error in the willPatch call 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><span><block-text-0/></span><block-child-0/></div>\`);
   
@@ -532,7 +525,7 @@ exports[`can catch errors can catch an error in the willPatch call 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].message;
-    const b3 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([txt1], [b3]);
   }
 }"
@@ -551,7 +544,7 @@ exports[`can catch errors can catch an error in the willPatch call 2`] = `
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -576,7 +569,6 @@ exports[`can catch errors can catch an error in the willStart call 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -585,7 +577,7 @@ exports[`can catch errors can catch an error in the willStart call 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
+    let b3 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -604,7 +596,7 @@ exports[`can catch errors can catch an error in the willStart call 2`] = `
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -628,18 +620,17 @@ exports[`can catch errors can catch an error origination from a child's willStar
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    const b3 = component(\`ClassicCompoent\`, {}, key + \`__1\`, node, ctx);
-    const b4 = component(\`ErrorComponent\`, {}, key + \`__2\`, node, ctx);
+    let b3 = component(\`ClassicCompoent\`, {}, key + \`__1\`, node, ctx);
+    let b4 = component(\`ErrorComponent\`, {}, key + \`__2\`, node, ctx);
     return multi([b3, b4]);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b5 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__3\`, node, ctx);
+    let b5 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -658,7 +649,7 @@ exports[`can catch errors can catch an error origination from a child's willStar
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -718,7 +709,7 @@ exports[`can catch errors catchError in catchError 2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Boom\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Boom\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -742,22 +733,22 @@ exports[`can catch errors catching error, rethrow, render parent  -- a main comp
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { prepareList, capture, markRaw, withKey } = helpers;
+  let { prepareList, capture, withKey } = helpers;
   
   function slot1(ctx, node, key = \\"\\") {
-    const Comp1 = ctx['cp'].Comp;
+    let Comp1 = ctx['cp'].Comp;
     return toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
   }
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(Object.values(ctx['state'].cps));;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(Object.values(ctx['state'].cps));
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`cp\`] = v_block1[i1];
-      const key1 = ctx['cp'].id;
+      let key1 = ctx['cp'].id;
       const v1 = ctx['cp'];
       const ctx1 = capture(ctx);
-      c_block1[i1] = withKey(component(\`ErrorHandler\`, {onError: ()=>this.cleanUp(v1.id),slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2__\${key1}\`, node, ctx), key1);
+      c_block1[i1] = withKey(component(\`ErrorHandler\`, {onError: ()=>this.cleanUp(v1.id),slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
   }
@@ -771,7 +762,7 @@ exports[`can catch errors catching error, rethrow, render parent  -- a main comp
   let { callSlot } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    return callSlot(ctx, node, key, 'default', false, null);
+    return callSlot(ctx, node, key, 'default', false, {});
   }
 }"
 `;
@@ -817,22 +808,22 @@ exports[`can catch errors catching in child makes parent render 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { prepareList, capture, markRaw, withKey } = helpers;
+  let { prepareList, capture, withKey } = helpers;
   
   function slot1(ctx, node, key = \\"\\") {
-    const Comp1 = ctx['elem'][1];
+    let Comp1 = ctx['elem'][1];
     return toggler(Comp1, component(Comp1, {id: ctx['elem'][0]}, key + \`__1\`, node, ctx));
   }
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(Object.entries(this.elements));;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(Object.entries(this.elements));
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`elem\`] = v_block1[i1];
-      const key1 = ctx['elem'][0];
+      let key1 = ctx['elem'][0];
       const v1 = ctx['elem'];
       const ctx1 = capture(ctx);
-      c_block1[i1] = withKey(component(\`Catch\`, {onError: (_error)=>this.onError(v1[0],_error),slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2__\${key1}\`, node, ctx), key1);
+      c_block1[i1] = withKey(component(\`Catch\`, {onError: (_error)=>this.onError(v1[0],_error),slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
   }
@@ -846,7 +837,7 @@ exports[`can catch errors catching in child makes parent render 2`] = `
   let { callSlot } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    return callSlot(ctx, node, key, 'default', false, null);
+    return callSlot(ctx, node, key, 'default', false, {});
   }
 }"
 `;
@@ -882,7 +873,6 @@ exports[`can catch errors error in mounted on a component with a sibling (proper
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
   
@@ -891,8 +881,8 @@ exports[`can catch errors error in mounted on a component with a sibling (proper
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`OK\`, {}, key + \`__1\`, node, ctx);
-    const b4 = component(\`ErrorBoundary\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__3\`, node, ctx);
+    let b2 = component(\`OK\`, {}, key + \`__1\`, node, ctx);
+    let b4 = component(\`ErrorBoundary\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
     return block1([], [b2, b4]);
   }
 }"
@@ -922,7 +912,7 @@ exports[`can catch errors error in mounted on a component with a sibling (proper
     if (ctx['state'].error) {
       b2 = text(\`Error handled\`);
     } else {
-      b3 = callSlot(ctx, node, key, 'default', false, null);
+      b3 = callSlot(ctx, node, key, 'default', false, {});
     }
     return block1([], [b2, b3]);
   }
@@ -1010,7 +1000,7 @@ exports[`errors and promises a rendering error in a sub component will reject th
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1052,7 +1042,7 @@ exports[`errors and promises a rendering error will reject the render promise (w
   let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     let txt1 = ctx['x'].y;
     return block1([txt1], [b2]);
   }
@@ -1156,19 +1146,6 @@ exports[`errors and promises errors in mounted and in willUnmount 1`] = `
 }"
 `;
 
-exports[`errors and promises errors in onWillRender/onRender aren't wrapped more than once 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div>abc</div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`errors and promises errors in rerender 1`] = `
 "function anonymous(bdom, helpers
 ) {

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

@@ -37,7 +37,7 @@ exports[`event handling handler receive the event as argument 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let hdlr1 = [ctx['inc'], ctx];
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     let txt1 = ctx['state'].value;
     return block1([hdlr1, txt1], [b2]);
   }
@@ -99,16 +99,16 @@ exports[`event handling objects from scope are properly captured by t-on 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       const v1 = ctx['onClick'];
       const v2 = ctx['item'];
       let hdlr1 = [_ev=>v1(v2.val,_ev), ctx];
       c_block2[i1] = withKey(block3([hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -140,16 +140,16 @@ exports[`event handling t-on with handler bound to dynamic argument on a t-forea
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = ctx['item'];
+      let key1 = ctx['item'];
       const v1 = ctx['onClick'];
       const v2 = ctx['item'];
       let hdlr1 = [_ev=>v1(v2,_ev), ctx];
       c_block2[i1] = withKey(block3([hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"

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

@@ -147,7 +147,7 @@ exports[`basics top level sub widget with a parent 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ComponentB\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ComponentB\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

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

@@ -109,8 +109,8 @@ exports[`hooks parent and child env (with useChildSubEnv then useSubEnv) 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['env'].val);
-    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = text(ctx['env'].val);
+    let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return multi([b2, b3]);
   }
 }"
@@ -140,8 +140,8 @@ exports[`hooks parent and child env (with useChildSubEnv) 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['env'].val);
-    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = text(ctx['env'].val);
+    let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return multi([b2, b3]);
   }
 }"
@@ -167,8 +167,8 @@ exports[`hooks parent and child env (with useSubEnv) 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['env'].val);
-    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = text(ctx['env'].val);
+    let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return multi([b2, b3]);
   }
 }"
@@ -301,19 +301,6 @@ exports[`hooks useEffect hook effect with empty dependency list never reruns 1`]
 }"
 `;
 
-exports[`hooks useEffect hook properly behaves when the effect function throws 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
 exports[`hooks useExternalListener 1`] = `
 "function anonymous(bdom, helpers
 ) {

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

@@ -21,8 +21,8 @@ exports[`lifecycle hooks component semantics 1`] = `
   let block1 = createBlock(\`<div>A<block-child-0/><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`B\`, {}, key + \`__1\`, node, ctx);
-    const b3 = component(\`C\`, {}, key + \`__2\`, node, ctx);
+    let b2 = component(\`B\`, {}, key + \`__1\`, node, ctx);
+    let b3 = component(\`C\`, {}, key + \`__2\`, node, ctx);
     return block1([], [b2, b3]);
   }
 }"
@@ -110,7 +110,7 @@ exports[`lifecycle hooks components are unmounted and destroyed if no longer in
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].flag) {
-      const b3 = component(\`Child\`, {n: ctx['state'].n}, key + \`__1\`, node, ctx);
+      let b3 = component(\`Child\`, {n: ctx['state'].n}, key + \`__1\`, node, ctx);
       b2 = block2([], [b3]);
     }
     return multi([b2]);
@@ -196,7 +196,7 @@ exports[`lifecycle hooks hooks are called in proper order in widget creation/des
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -245,7 +245,7 @@ exports[`lifecycle hooks lifecycle semantics 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {a: ctx['state'].a}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {a: ctx['state'].a}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -458,7 +458,7 @@ exports[`lifecycle hooks mounted hook is called on subcomponents, in proper orde
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -502,7 +502,7 @@ exports[`lifecycle hooks mounted hook is called on subsubcomponents, in proper o
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ChildChild\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ChildChild\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -527,7 +527,7 @@ exports[`lifecycle hooks onWillRender 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {someValue: ctx['state'].value}, key + \`__1\`, node, ctx);
+    return component(\`Child\`, {}, key + \`__1\`, node, ctx);
   }
 }"
 `;
@@ -555,7 +555,7 @@ exports[`lifecycle hooks patched hook is called after updateProps 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {a: ctx['state'].a}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {a: ctx['state'].a}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -658,43 +658,6 @@ exports[`lifecycle hooks sub widget (inside sub node): hooks are correctly calle
 }"
 `;
 
-exports[`lifecycle hooks timeout in onWillStart emits a warning 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<span/>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    return block1();
-  }
-}"
-`;
-
-exports[`lifecycle hooks timeout in onWillUpdateProps emits a warning 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const props1 = {prop: ctx['state'].prop};
-    helpers.validateProps(\`Child\`, props1, ctx);
-    return component(\`Child\`, props1, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`lifecycle hooks timeout in onWillUpdateProps emits a warning 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`\`);
-  }
-}"
-`;
-
 exports[`lifecycle hooks willPatch, patched hook are called on subsubcomponents, in proper order 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -703,7 +666,7 @@ exports[`lifecycle hooks willPatch, patched hook are called on subsubcomponents,
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {n: ctx['state'].n}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {n: ctx['state'].n}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -717,7 +680,7 @@ exports[`lifecycle hooks willPatch, patched hook are called on subsubcomponents,
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`ChildChild\`, {n: ctx['props'].n}, key + \`__1\`, node, ctx);
+    let b2 = component(\`ChildChild\`, {n: ctx['props'].n}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

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

@@ -8,7 +8,7 @@ exports[`basics accept ES6-like syntax for props (with getters) 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {greetings: ctx['greetings']}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {greetings: ctx['greetings']}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -36,10 +36,10 @@ exports[`basics arrow functions as prop correctly capture their scope 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['items']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['items']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`item\`] = v_block1[i1];
-      const key1 = ctx['item'].val;
+      let key1 = ctx['item'].val;
       const v1 = ctx['onClick'];
       const v2 = ctx['item'];
       c_block1[i1] = withKey(component(\`Child\`, {onClick: _ev=>v1(v2.val,_ev)}, key + \`__1__\${key1}\`, node, ctx), key1);
@@ -71,7 +71,7 @@ exports[`basics explicit object prop 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {value: ctx['state'].val}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {value: ctx['state'].val}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -158,7 +158,7 @@ exports[`basics t-set with a body expression can be passed in props, and then t-
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx[\`abc\`] = new LazyValue(value1, ctx, node);
-    const b3 = component(\`Child\`, {val: ctx['abc']}, key + \`__1\`, node, ctx);
+    let b3 = component(\`Child\`, {val: ctx['abc']}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -174,7 +174,7 @@ exports[`basics t-set with a body expression can be passed in props, and then t-
   
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['props'].val;
-    const b2 = safeOutput(ctx['props'].val);
+    let b2 = safeOutput(ctx['props'].val);
     return block1([txt1], [b2]);
   }
 }"
@@ -192,7 +192,7 @@ exports[`basics t-set with a body expression can be used as textual prop 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"abc\\", \`42\`);
-    const b2 = component(\`Child\`, {val: ctx['abc']}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {val: ctx['abc']}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -224,7 +224,7 @@ exports[`basics t-set works  1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"val\\", 42);
-    const b2 = component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {val: ctx['val']}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

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

@@ -23,7 +23,7 @@ exports[`default props can set default boolean values 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -59,7 +59,7 @@ exports[`default props can set default values 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -89,7 +89,7 @@ exports[`default props default values are also set whenever component is updated
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['state'].p};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -171,7 +171,7 @@ exports[`props validation can validate a prop with multiple types 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -200,7 +200,7 @@ exports[`props validation can validate a prop with multiple types 3`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -229,7 +229,7 @@ exports[`props validation can validate a prop with multiple types 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -245,7 +245,7 @@ exports[`props validation can validate an array with given primitive type 1`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -274,7 +274,7 @@ exports[`props validation can validate an array with given primitive type 3`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -303,7 +303,7 @@ exports[`props validation can validate an array with given primitive type 5`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -319,7 +319,7 @@ exports[`props validation can validate an array with given primitive type 6`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -335,7 +335,7 @@ exports[`props validation can validate an array with multiple sub element types
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -364,7 +364,7 @@ exports[`props validation can validate an array with multiple sub element types
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -393,7 +393,7 @@ exports[`props validation can validate an array with multiple sub element types
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -422,7 +422,7 @@ exports[`props validation can validate an array with multiple sub element types
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -438,7 +438,7 @@ exports[`props validation can validate an object with simple shape 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -467,7 +467,7 @@ exports[`props validation can validate an object with simple shape 3`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -483,7 +483,7 @@ exports[`props validation can validate an object with simple shape 4`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -499,7 +499,7 @@ exports[`props validation can validate an object with simple shape 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -515,7 +515,7 @@ exports[`props validation can validate an optional props 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -544,7 +544,7 @@ exports[`props validation can validate an optional props 3`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -573,7 +573,7 @@ exports[`props validation can validate an optional props 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -589,7 +589,7 @@ exports[`props validation can validate recursively complicated prop def 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -618,7 +618,7 @@ exports[`props validation can validate recursively complicated prop def 3`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -647,7 +647,7 @@ exports[`props validation can validate recursively complicated prop def 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -663,7 +663,7 @@ exports[`props validation default values are applied before validating props at
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['state'].p};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -693,7 +693,7 @@ exports[`props validation missing required boolean prop causes an error 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -709,7 +709,7 @@ exports[`props validation mix of optional and mandatory 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {};
     helpers.validateProps(\`Child\`, props1, ctx);
-    const b2 = component(\`Child\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -725,7 +725,7 @@ exports[`props validation props are validated in dev mode (code snapshot) 1`] =
   return function template(ctx, node, key = \\"\\") {
     const props1 = {message: 1};
     helpers.validateProps(\`Child\`, props1, ctx);
-    const b2 = component(\`Child\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -755,7 +755,7 @@ exports[`props validation props are validated whenever component is updated 1`]
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['state'].p};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -785,7 +785,7 @@ exports[`props validation props: list of strings 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -801,7 +801,7 @@ exports[`props validation validate simple types 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -817,7 +817,7 @@ exports[`props validation validate simple types 2`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -846,7 +846,7 @@ exports[`props validation validate simple types 4`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -862,7 +862,7 @@ exports[`props validation validate simple types 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -878,7 +878,7 @@ exports[`props validation validate simple types 6`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -907,7 +907,7 @@ exports[`props validation validate simple types 8`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -923,7 +923,7 @@ exports[`props validation validate simple types 9`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -939,7 +939,7 @@ exports[`props validation validate simple types 10`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -968,7 +968,7 @@ exports[`props validation validate simple types 12`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -984,7 +984,7 @@ exports[`props validation validate simple types 13`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1000,7 +1000,7 @@ exports[`props validation validate simple types 14`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1029,7 +1029,7 @@ exports[`props validation validate simple types 16`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1045,7 +1045,7 @@ exports[`props validation validate simple types 17`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1061,7 +1061,7 @@ exports[`props validation validate simple types 18`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1090,7 +1090,7 @@ exports[`props validation validate simple types 20`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1106,7 +1106,7 @@ exports[`props validation validate simple types 21`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1122,7 +1122,7 @@ exports[`props validation validate simple types 22`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1151,7 +1151,7 @@ exports[`props validation validate simple types 24`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1167,7 +1167,7 @@ exports[`props validation validate simple types, alternate form 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1183,7 +1183,7 @@ exports[`props validation validate simple types, alternate form 2`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1212,7 +1212,7 @@ exports[`props validation validate simple types, alternate form 4`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1228,7 +1228,7 @@ exports[`props validation validate simple types, alternate form 5`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1244,7 +1244,7 @@ exports[`props validation validate simple types, alternate form 6`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1273,7 +1273,7 @@ exports[`props validation validate simple types, alternate form 8`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1289,7 +1289,7 @@ exports[`props validation validate simple types, alternate form 9`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1305,7 +1305,7 @@ exports[`props validation validate simple types, alternate form 10`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1334,7 +1334,7 @@ exports[`props validation validate simple types, alternate form 12`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1350,7 +1350,7 @@ exports[`props validation validate simple types, alternate form 13`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1366,7 +1366,7 @@ exports[`props validation validate simple types, alternate form 14`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1395,7 +1395,7 @@ exports[`props validation validate simple types, alternate form 16`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1411,7 +1411,7 @@ exports[`props validation validate simple types, alternate form 17`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1427,7 +1427,7 @@ exports[`props validation validate simple types, alternate form 18`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1456,7 +1456,7 @@ exports[`props validation validate simple types, alternate form 20`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1472,7 +1472,7 @@ exports[`props validation validate simple types, alternate form 21`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1488,7 +1488,7 @@ exports[`props validation validate simple types, alternate form 22`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1517,7 +1517,7 @@ exports[`props validation validate simple types, alternate form 24`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {p: ctx['p']};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1533,7 +1533,7 @@ exports[`props validation validation is only done in dev mode 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const props1 = {};
     helpers.validateProps(\`SubComp\`, props1, ctx);
-    const b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, props1, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -1547,7 +1547,7 @@ exports[`props validation validation is only done in dev mode 2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`SubComp\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`SubComp\`, {}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

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

@@ -1,31 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`reactivity in lifecycle Child component doesn't render when state they depend on changes but their parent is about to unmount them 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    let b2;
-    if (ctx['state'].renderChild) {
-      b2 = component(\`Child\`, {state: ctx['state']}, key + \`__1\`, node, ctx);
-    }
-    return multi([b2]);
-  }
-}"
-`;
-
-exports[`reactivity in lifecycle Child component doesn't render when state they depend on changes but their parent is about to unmount them 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].state.content.a);
-  }
-}"
-`;
-
 exports[`reactivity in lifecycle can use a state hook 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -54,20 +28,6 @@ exports[`reactivity in lifecycle can use a state hook 2 1`] = `
 }"
 `;
 
-exports[`reactivity in lifecycle can use a state hook on Map 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<div><block-text-0/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['counter'].get('value');
-    return block1([txt1]);
-  }
-}"
-`;
-
 exports[`reactivity in lifecycle change state while mounting component 1`] = `
 "function anonymous(bdom, helpers
 ) {

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

@@ -62,7 +62,7 @@ exports[`refs refs are properly bound in slots 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { capture, markRaw } = helpers;
+  let { capture } = helpers;
   
   let block1 = createBlock(\`<div><span class=\\"counter\\"><block-text-0/></span><block-child-0/></div>\`);
   let block2 = createBlock(\`<button block-handler-0=\\"click\\" block-ref=\\"1\\">do something</button>\`);
@@ -77,7 +77,7 @@ exports[`refs refs are properly bound in slots 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let txt1 = ctx['state'].val;
     const ctx1 = capture(ctx);
-    const b3 = component(\`Dialog\`, {slots: markRaw({'footer': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
+    let b3 = component(\`Dialog\`, {slots: {'footer': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     return block1([txt1], [b3]);
   }
 }"
@@ -92,7 +92,7 @@ exports[`refs refs are properly bound in slots 2`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callSlot(ctx, node, key, 'footer', false, null);
+    let b2 = callSlot(ctx, node, key, 'footer', false, {});
     return block1([], [b2]);
   }
 }"
@@ -110,8 +110,8 @@ exports[`refs throws if there are 2 same refs at the same time 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const refs = ctx.__owl__.refs;
     const ref1 = multiRefSetter(refs, \`coucou\`);
-    const b2 = block2([ref1]);
-    const b3 = block3([ref1]);
+    let b2 = block2([ref1]);
+    let b3 = block3([ref1]);
     return multi([b2, b3]);
   }
 }"

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

@@ -1,212 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`force render in case of existing render 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`B\`, {val: ctx['state'].val}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`force render in case of existing render 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`C\`, {}, key + \`__1\`, node, ctx);
-    const b3 = text(ctx['props'].val);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`force render in case of existing render 3`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`C\`);
-  }
-}"
-`;
-
-exports[`rendering semantics can force a render to update sub tree 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['state'].value);
-    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`rendering semantics can force a render to update sub tree 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`child\`);
-  }
-}"
-`;
-
-exports[`rendering semantics can render a parent without rendering child 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['state'].value);
-    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`rendering semantics can render a parent without rendering child 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(\`child\`);
-  }
-}"
-`;
-
-exports[`rendering semantics props are reactive (nested prop) 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {a: ctx['state']}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`rendering semantics props are reactive (nested prop) 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].a.b.c);
-  }
-}"
-`;
-
-exports[`rendering semantics props are reactive 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {a: ctx['state']}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`rendering semantics props are reactive 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].a.b);
-  }
-}"
-`;
-
-exports[`rendering semantics render with deep=true followed by render with deep=false work as expected 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`parent\`);
-    const b3 = text(ctx['state'].value);
-    const b4 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    return multi([b2, b3, b4]);
-  }
-}"
-`;
-
-exports[`rendering semantics render with deep=true followed by render with deep=false work as expected 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`child\`);
-    const b3 = text(ctx['env'].getValue());
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`rendering semantics rendering is atomic (for one subtree) 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(ctx['state'].obj.val);
-    const b3 = component(\`B\`, {obj: ctx['state'].obj}, key + \`__1\`, node, ctx);
-    return multi([b2, b3]);
-  }
-}"
-`;
-
-exports[`rendering semantics rendering is atomic (for one subtree) 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`C\`, {obj: ctx['props'].obj}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`rendering semantics rendering is atomic (for one subtree) 3`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(ctx['props'].obj.val);
-  }
-}"
-`;
-
-exports[`rendering semantics works as expected for dynamic number of props 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, Object.assign({}, ctx['state']), key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`rendering semantics works as expected for dynamic number of props 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return text(Object.keys(ctx['props']).length);
-  }
-}"
-`;

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

@@ -20,9 +20,9 @@ exports[`style and class handling can set class on multi root component 2`] = `
   let block3 = createBlock(\`<span block-attribute-0=\\"class\\">b</span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
+    let b2 = block2();
     let attr1 = ctx['props'].class;
-    const b3 = block3([attr1]);
+    let b3 = block3([attr1]);
     return multi([b2, b3]);
   }
 }"
@@ -205,7 +205,7 @@ exports[`style and class handling class with extra whitespaces (variation) 1`] =
   let block1 = createBlock(\`<p><block-child-0/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {class: 'a  b c   d'}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {class: 'a  b c   d'}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -310,7 +310,7 @@ exports[`style and class handling empty class attribute is not added on widget r
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {class: undefined}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {class: undefined}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -438,7 +438,7 @@ exports[`style and class handling t-att-class is properly added/removed on widge
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {class: {b:ctx['state'].b}}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {class: {b:ctx['state'].b}}, key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

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

@@ -9,7 +9,7 @@ exports[`t-call dynamic t-call 1`] = `
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
-    const b1 = text(\` owl \`);
+    let b1 = text(\` owl \`);
     ctx[zero] = b1;
     const template1 = (ctx['current'].template);
     return call(this, template1, ctx, node, key + \`__1\`);
@@ -48,9 +48,9 @@ exports[`t-call dynamic t-call: key is propagated 1`] = `
   let { call } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
     const template1 = (ctx['sub']);
-    const b3 = call(this, template1, ctx, node, key + \`__2\`);
+    let b3 = call(this, template1, ctx, node, key + \`__2\`);
     return multi([b2, b3]);
   }
 }"
@@ -91,7 +91,7 @@ exports[`t-call handlers are properly bound through a dynamic t-call 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const template1 = ('__template__999');
-    const b2 = call(this, template1, ctx, node, key + \`__1\`);
+    let b2 = call(this, template1, ctx, node, key + \`__1\`);
     let txt1 = ctx['counter'];
     return block1([txt1], [b2]);
   }
@@ -122,7 +122,7 @@ exports[`t-call handlers are properly bound through a t-call 1`] = `
   let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     let txt1 = ctx['counter'];
     return block1([txt1], [b2]);
   }
@@ -153,7 +153,7 @@ exports[`t-call handlers with arguments are properly bound through a t-call 1`]
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -184,7 +184,7 @@ exports[`t-call parent is set within t-call 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -266,7 +266,7 @@ exports[`t-call recursive t-call binding this -- static t-call 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"level\\", 0);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -288,11 +288,11 @@ exports[`t-call recursive t-call binding this -- static t-call 2`] = `
     if (ctx['level']<2) {
       let hdlr1 = [\\"stop\\", ctx['onClicked'].bind(this), ctx];
       let txt1 = ctx['level'];
-      const b3 = block3([hdlr1, txt1]);
+      let b3 = block3([hdlr1, txt1]);
       ctx = Object.create(ctx);
       ctx[isBoundary] = 1;
       setContextValue(ctx, \\"level\\", ctx['level']+1);
-      const b4 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+      let b4 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
       ctx = ctx.__proto__;
       b2 = multi([b3, b4]);
     }
@@ -316,7 +316,7 @@ exports[`t-call sub components in two t-calls 1`] = `
     if (ctx['state'].val===1) {
       b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     } else {
-      const b4 = callTemplate_2.call(this, ctx, node, key + \`__2\`);
+      let b4 = callTemplate_2.call(this, ctx, node, key + \`__2\`);
       b3 = block3([], [b4]);
     }
     return multi([b2, b3]);
@@ -360,17 +360,17 @@ exports[`t-call t-call in t-foreach and children component 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['a','b','c']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(['a','b','c']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
       ctx[\`val_first\`] = i1 === 0;
       ctx[\`val_last\`] = i1 === v_block2.length - 1;
       ctx[\`val_index\`] = i1;
       ctx[\`val_value\`] = k_block2[i1];
-      const key1 = ctx['val'];
+      let key1 = ctx['val'];
       c_block2[i1] = withKey(callTemplate_1.call(this, ctx, node, key + \`__1__\${key1}\`), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"

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

@@ -8,7 +8,7 @@ exports[`t-call-block simple t-call-block with static text 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx['myBlock']();
+    let b2 = ctx['myBlock']();
     return block1([], [b2]);
   }
 }"

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

@@ -8,8 +8,8 @@ exports[`t-component can switch between dynamic components without the need for
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const Comp1 = ctx['constructor'].components[ctx['state'].child];
-    const b2 = toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
+    let Comp1 = ctx['constructor'].components[ctx['state'].child];
+    let b2 = toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
     return block1([], [b2]);
   }
 }"
@@ -48,7 +48,7 @@ exports[`t-component can use dynamic components (the class) if given (with diffe
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['state'].child;
-    const Comp1 = ctx['myComponent'];
+    let Comp1 = ctx['myComponent'];
     return toggler(tKey_1, toggler(Comp1, component(Comp1, {}, tKey_1 + key + \`__1\`, node, ctx)));
   }
 }"
@@ -87,7 +87,7 @@ exports[`t-component can use dynamic components (the class) if given 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['state'].child;
-    const Comp1 = ctx['myComponent'];
+    let Comp1 = ctx['myComponent'];
     return toggler(tKey_1, toggler(Comp1, component(Comp1, {}, tKey_1 + key + \`__1\`, node, ctx)));
   }
 }"
@@ -127,8 +127,8 @@ exports[`t-component modifying a sub widget 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const Comp1 = ctx['Counter'];
-    const b2 = toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
+    let Comp1 = ctx['Counter'];
+    let b2 = toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
     return block1([], [b2]);
   }
 }"
@@ -156,7 +156,7 @@ exports[`t-component switching dynamic component 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const Comp1 = ctx['Child'];
+    let Comp1 = ctx['Child'];
     return toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
   }
 }"
@@ -192,7 +192,7 @@ exports[`t-component t-component works in simple case 1`] = `
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
   
   return function template(ctx, node, key = \\"\\") {
-    const Comp1 = ctx['Child'];
+    let Comp1 = ctx['Child'];
     return toggler(Comp1, component(Comp1, {}, key + \`__1\`, node, ctx));
   }
 }"

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

@@ -11,14 +11,14 @@ exports[`list of components components in a node in a t-foreach  1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['items']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`item\`] = v_block2[i1];
-      const key1 = 'li_'+ctx['item'];
-      const b4 = component(\`Child\`, {item: ctx['item']}, key + \`__1__\${key1}\`, node, ctx);
+      let key1 = 'li_'+ctx['item'];
+      let b4 = component(\`Child\`, {item: ctx['item']}, key + \`__1__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([], [b4]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -46,11 +46,11 @@ exports[`list of components crash on duplicate key in dev mode 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList([1,2]);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList([1,2]);
     const keys1 = new Set();
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`item\`] = v_block1[i1];
-      const key1 = 'child';
+      let key1 = 'child';
       if (keys1.has(key1)) { throw new Error(\`Got duplicate key in t-foreach: \${key1}\`)}
       keys1.add(key1);
       const props1 = {};
@@ -84,14 +84,14 @@ exports[`list of components list of sub components inside other nodes 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].blips);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].blips);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`blip\`] = v_block2[i1];
-      const key1 = ctx['blip'].id;
-      const b4 = component(\`SubComponent\`, {}, key + \`__1__\${key1}\`, node, ctx);
+      let key1 = ctx['blip'].id;
+      let b4 = component(\`SubComponent\`, {}, key + \`__1__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([], [b4]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -120,23 +120,23 @@ exports[`list of components reconciliation alg works for t-foreach in t-foreach
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].s);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].s);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`section\`] = v_block2[i1];
       ctx[\`section_index\`] = i1;
-      const key1 = ctx['section_index'];
+      let key1 = ctx['section_index'];
       ctx = Object.create(ctx);
-      const [k_block3, v_block3, l_block3, c_block3] = prepareList(ctx['section'].blips);;
+      const [k_block3, v_block3, l_block3, c_block3] = prepareList(ctx['section'].blips);
       for (let i2 = 0; i2 < l_block3; i2++) {
         ctx[\`blip\`] = v_block3[i2];
         ctx[\`blip_index\`] = i2;
-        const key2 = ctx['blip_index'];
+        let key2 = ctx['blip_index'];
         c_block3[i2] = withKey(component(\`Child\`, {blip: ctx['blip']}, key + \`__1__\${key1}__\${key2}\`, node, ctx), key2);
       }
       ctx = ctx.__proto__;
       c_block2[i1] = withKey(list(c_block3), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -168,23 +168,23 @@ exports[`list of components reconciliation alg works for t-foreach in t-foreach,
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].rows);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].rows);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`row\`] = v_block2[i1];
-      const key1 = ctx['row'];
+      let key1 = ctx['row'];
       ctx = Object.create(ctx);
-      const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['state'].cols);;
+      const [k_block4, v_block4, l_block4, c_block4] = prepareList(ctx['state'].cols);
       for (let i2 = 0; i2 < l_block4; i2++) {
         ctx[\`col\`] = v_block4[i2];
-        const key2 = ctx['col'];
-        const b6 = component(\`Child\`, {row: ctx['row'], col: ctx['col']}, key + \`__1__\${key1}__\${key2}\`, node, ctx);
+        let key2 = ctx['col'];
+        let b6 = component(\`Child\`, {row: ctx['row'], col: ctx['col']}, key + \`__1__\${key1}__\${key2}\`, node, ctx);
         c_block4[i2] = withKey(block5([], [b6]), key2);
       }
       ctx = ctx.__proto__;
-      const b4 = list(c_block4);
+      let b4 = list(c_block4);
       c_block2[i1] = withKey(block3([], [b4]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -212,10 +212,10 @@ exports[`list of components simple list 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['state'].elems);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['state'].elems);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`elem\`] = v_block1[i1];
-      const key1 = ctx['elem'].id;
+      let key1 = ctx['elem'].id;
       c_block1[i1] = withKey(component(\`Child\`, {value: ctx['elem'].value}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
@@ -247,13 +247,13 @@ exports[`list of components sub components rendered in a loop 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].numbers);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].numbers);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`number\`] = v_block2[i1];
-      const key1 = ctx['number'];
+      let key1 = ctx['number'];
       c_block2[i1] = withKey(component(\`Child\`, {n: ctx['number']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -283,13 +283,13 @@ exports[`list of components sub components with some state rendered in a loop 1`
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].numbers);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].numbers);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`number\`] = v_block2[i1];
-      const key1 = ctx['number'];
+      let key1 = ctx['number'];
       c_block2[i1] = withKey(component(\`Child\`, {}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -319,13 +319,13 @@ exports[`list of components switch component position 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['clist']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['clist']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`c\`] = v_block2[i1];
-      const key1 = ctx['c'];
+      let key1 = ctx['c'];
       c_block2[i1] = withKey(component(\`Child\`, {key: ctx['c']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -355,14 +355,14 @@ exports[`list of components t-foreach with t-component, and update 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Array(2));;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(Array(2));
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`n\`] = v_block2[i1];
       ctx[\`n_index\`] = i1;
-      const key1 = ctx['n_index'];
+      let key1 = ctx['n_index'];
       c_block2[i1] = withKey(component(\`Child\`, {val: ctx['n_index']}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"

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

@@ -10,14 +10,14 @@ exports[`t-key t-foreach with t-key switch component position 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['clist']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['clist']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`c\`] = v_block2[i1];
-      const key1 = ctx['c'];
+      let key1 = ctx['c'];
       const tKey_1 = ctx['key1'];
       c_block2[i1] = withKey(component(\`Child\`, {key: ctx['c']+ctx['key1']}, tKey_1 + key + \`__1__\${key1}\`, node, ctx), tKey_1 + key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -72,7 +72,7 @@ exports[`t-key t-key on Component as a function 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key'];
-    const b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key']}, tKey_1 + key + \`__1\`, node, ctx));
     return block1([], [b2]);
   }
 }"
@@ -101,9 +101,9 @@ exports[`t-key t-key on multiple Components 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key1'];
-    const b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key1']}, tKey_1 + key + \`__1\`, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key1']}, tKey_1 + key + \`__1\`, node, ctx));
     const tKey_2 = ctx['key2'];
-    const b3 = toggler(tKey_2, component(\`Child\`, {key: ctx['key2']}, tKey_2 + key + \`__2\`, node, ctx));
+    let b3 = toggler(tKey_2, component(\`Child\`, {key: ctx['key2']}, tKey_2 + key + \`__2\`, node, ctx));
     return block1([], [b2, b3]);
   }
 }"
@@ -139,12 +139,12 @@ exports[`t-key t-key on multiple Components with t-call 1 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"key\\", ctx['key1']);
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     ctx = ctx.__proto__;
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     setContextValue(ctx, \\"key\\", ctx['key2']);
-    const b3 = callTemplate_2.call(this, ctx, node, key + \`__2\`);
+    let b3 = callTemplate_2.call(this, ctx, node, key + \`__2\`);
     return block1([], [b2, b3]);
   }
 }"
@@ -186,7 +186,7 @@ exports[`t-key t-key on multiple Components with t-call 2 1`] = `
   let block1 = createBlock(\`<span><block-child-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    let b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
 }"
@@ -199,9 +199,9 @@ exports[`t-key t-key on multiple Components with t-call 2 2`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const tKey_1 = ctx['key1'];
-    const b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key1']}, tKey_1 + key + \`__1\`, node, ctx));
+    let b2 = toggler(tKey_1, component(\`Child\`, {key: ctx['key1']}, tKey_1 + key + \`__1\`, node, ctx));
     const tKey_2 = ctx['key2'];
-    const b3 = toggler(tKey_2, component(\`Child\`, {key: ctx['key2']}, tKey_2 + key + \`__2\`, node, ctx));
+    let b3 = toggler(tKey_2, component(\`Child\`, {key: ctx['key2']}, tKey_2 + key + \`__2\`, node, ctx));
     return multi([b2, b3]);
   }
 }"

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

@@ -194,17 +194,17 @@ exports[`t-model directive in a t-foreach 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`thing\`] = v_block2[i1];
-      const key1 = ctx['thing'].id;
+      let key1 = ctx['thing'].id;
       const bExpr1 = ctx['thing'];
       const expr1 = 'f';
       let attr1 = bExpr1[expr1];
       let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.checked; }];
       c_block2[i1] = withKey(block3([attr1, hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -221,18 +221,18 @@ exports[`t-model directive in a t-foreach, part 2 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`thing\`] = v_block2[i1];
       ctx[\`thing_index\`] = i1;
-      const key1 = ctx['thing_index'];
+      let key1 = ctx['thing_index'];
       const bExpr1 = ctx['state'];
       const expr1 = ctx['thing_index'];
       let attr1 = bExpr1[expr1];
       let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
       c_block2[i1] = withKey(block3([attr1, hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -249,18 +249,18 @@ exports[`t-model directive in a t-foreach, part 3 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['names']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['names']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`name\`] = v_block2[i1];
       ctx[\`name_index\`] = i1;
-      const key1 = ctx['name_index'];
+      let key1 = ctx['name_index'];
       const bExpr1 = ctx['state'].values;
       const expr1 = ctx['name'];
       let attr1 = bExpr1[expr1];
       let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
       c_block2[i1] = withKey(block3([attr1, hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -460,7 +460,7 @@ exports[`t-model directive t-model with dynamic values on select options -- 2 1`
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'model';
-    const bValue1 = bExpr1[expr1];
+    let bValue1 = bExpr1[expr1]
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let attr1 = ctx['options'][0];
     let attr2 = bValue1 === ctx['options'][0];
@@ -484,7 +484,7 @@ exports[`t-model directive t-model with dynamic values on select options -- 3 1`
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'model';
-    const bValue1 = bExpr1[expr1];
+    let bValue1 = bExpr1[expr1]
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let attr1 = ctx['options'][0];
     let attr2 = bValue1 === ctx['options'][0];
@@ -507,7 +507,7 @@ exports[`t-model directive t-model with dynamic values on select options 1`] = `
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'model';
-    const bValue1 = bExpr1[expr1];
+    let bValue1 = bExpr1[expr1]
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     let attr1 = ctx['options'][0];
     let attr2 = bValue1 === ctx['options'][0];
@@ -532,19 +532,19 @@ exports[`t-model directive t-model with dynamic values on select options in fore
   return function template(ctx, node, key = \\"\\") {
     const bExpr1 = ctx['state'];
     const expr1 = 'model';
-    const bValue1 = bExpr1[expr1];
+    let bValue1 = bExpr1[expr1]
     let hdlr1 = [(ev) => { bExpr1[expr1] = ev.target.value; }];
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['options']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['options']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`v\`] = v_block2[i1];
-      const key1 = ctx['v'];
+      let key1 = ctx['v'];
       let attr1 = ctx['v'];
       let attr2 = bValue1 === ctx['v'];
       let txt1 = ctx['v'];
       c_block2[i1] = withKey(block3([attr1, attr2, txt1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([hdlr1], [b2]);
   }
 }"

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

@@ -14,17 +14,17 @@ exports[`t-on t-on expression captured in t-foreach 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"iter\\", 0);
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['arr']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['arr']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
-      const key1 = ctx['val'];
+      let key1 = ctx['val'];
       const v1 = ctx['otherState'];
       const v2 = ctx['iter'];
       let hdlr1 = [()=>v1.vals.push(v2+'_'+v2), ctx];
       setContextValue(ctx, \\"iter\\", ctx['iter']+1);
       c_block2[i1] = withKey(block3([hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -41,11 +41,11 @@ exports[`t-on t-on expression in t-foreach 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].values);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].values);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
       ctx[\`val_index\`] = i1;
-      const key1 = ctx['val'];
+      let key1 = ctx['val'];
       let txt1 = ctx['val_index'];
       let txt2 = ctx['val']+'';
       const v1 = ctx['otherState'];
@@ -53,7 +53,7 @@ exports[`t-on t-on expression in t-foreach 1`] = `
       let hdlr1 = [()=>v1.vals.push(v2), ctx];
       c_block2[i1] = withKey(block3([txt1, txt2, hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -73,11 +73,11 @@ exports[`t-on t-on expression in t-foreach with t-set 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"bossa\\", 'nova');
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].values);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].values);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
       ctx[\`val_index\`] = i1;
-      const key1 = ctx['val'];
+      let key1 = ctx['val'];
       setContextValue(ctx, \\"bossa\\", ctx['bossa']+'_'+ctx['val_index']);
       let txt1 = ctx['val_index'];
       let txt2 = ctx['val']+'';
@@ -87,7 +87,7 @@ exports[`t-on t-on expression in t-foreach with t-set 1`] = `
       let hdlr1 = [()=>v1.vals.push(v2+'_'+v3), ctx];
       c_block2[i1] = withKey(block3([txt1, txt2, hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -104,82 +104,23 @@ exports[`t-on t-on method call in t-foreach 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].values);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['state'].values);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`val\`] = v_block2[i1];
       ctx[\`val_index\`] = i1;
-      const key1 = ctx['val'];
+      let key1 = ctx['val'];
       let txt1 = ctx['val_index'];
       let txt2 = ctx['val']+'';
       const v1 = ctx['val'];
       let hdlr1 = [()=>this.addVal(v1), ctx];
       c_block2[i1] = withKey(block3([txt1, txt2, hdlr1]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
 `;
 
-exports[`t-on t-on on components 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { createCatcher } = helpers;
-  const catcher1 = createCatcher({\\"click\\":0});
-  
-  return function template(ctx, node, key = \\"\\") {
-    const hdlr1 = [ctx['increment'], ctx];
-    return catcher1(component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx), [hdlr1]);
-  }
-}"
-`;
-
-exports[`t-on t-on on components 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<button><block-text-0/></button>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['props'].value;
-    return block1([txt1]);
-  }
-}"
-`;
-
-exports[`t-on t-on on components, variation 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { createCatcher } = helpers;
-  const catcher1 = createCatcher({\\"click\\":0});
-  
-  let block1 = createBlock(\`<div><span/><block-child-0/><p/></div>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    const hdlr1 = [ctx['increment'], ctx];
-    const b2 = catcher1(component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx), [hdlr1]);
-    return block1([], [b2]);
-  }
-}"
-`;
-
-exports[`t-on t-on on components, variation 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  
-  let block1 = createBlock(\`<button><block-text-0/></button>\`);
-  
-  return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx['props'].value;
-    return block1([txt1]);
-  }
-}"
-`;
-
 exports[`t-on t-on on destroyed components 1`] = `
 "function anonymous(bdom, helpers
 ) {
@@ -210,79 +151,3 @@ exports[`t-on t-on on destroyed components 2`] = `
   }
 }"
 `;
-
-exports[`t-on t-on on t-set-slots 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { capture, createCatcher, markRaw } = helpers;
-  const catcher1 = createCatcher({\\"click\\":0});
-  
-  let block6 = createBlock(\`<p>something</p>\`);
-  let block7 = createBlock(\`<p>paragraph</p>\`);
-  
-  function slot1(ctx, node, key = \\"\\") {
-    const b6 = block6();
-    const b7 = block7();
-    const hdlr1 = [()=>this.state.count++, ctx];
-    return catcher1(multi([b6, b7]), [hdlr1]);
-  }
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\` [\`);
-    const b3 = text(ctx['state'].count);
-    const b4 = text(\`] \`);
-    const ctx1 = capture(ctx);
-    const b8 = component(\`Child\`, {slots: markRaw({'myslot': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
-    return multi([b2, b3, b4, b8]);
-  }
-}"
-`;
-
-exports[`t-on t-on on t-set-slots 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { callSlot } = helpers;
-  
-  return function template(ctx, node, key = \\"\\") {
-    return callSlot(ctx, node, key, 'myslot', false, null);
-  }
-}"
-`;
-
-exports[`t-on t-on on t-slots 1`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
-  
-  let block1 = createBlock(\`<p>something</p>\`);
-  
-  function slot1(ctx, node, key = \\"\\") {
-    return block1();
-  }
-  
-  return function template(ctx, node, key = \\"\\") {
-    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__1\`, node, ctx);
-  }
-}"
-`;
-
-exports[`t-on t-on on t-slots 2`] = `
-"function anonymous(bdom, helpers
-) {
-  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { callSlot, createCatcher } = helpers;
-  const catcher1 = createCatcher({\\"click\\":0});
-  
-  return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\` [\`);
-    const b3 = text(ctx['state'].count);
-    const b4 = text(\`] \`);
-    const hdlr1 = [()=>this.state.count++, ctx];
-    const b5 = catcher1(callSlot(ctx, node, key, 'default', false, null), [hdlr1]);
-    return multi([b2, b3, b4, b5]);
-  }
-}"
-`;

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

@@ -8,7 +8,7 @@ exports[`t-props basic use 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, Object.assign({}, ctx['some'].obj), key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, Object.assign({}, ctx['some'].obj), key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -60,7 +60,7 @@ exports[`t-props t-props and other props 1`] = `
   let block1 = createBlock(\`<div><div><block-child-0/></div></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Comp\`, Object.assign({}, ctx['state1'], {a: ctx['a']}), key + \`__1\`, node, ctx);
+    let b2 = component(\`Comp\`, Object.assign({}, ctx['state1'], {a: ctx['a']}), key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -89,7 +89,7 @@ exports[`t-props t-props only 1`] = `
   let block1 = createBlock(\`<div><div><block-child-0/></div></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Comp\`, Object.assign({}, ctx['state']), key + \`__1\`, node, ctx);
+    let b2 = component(\`Comp\`, Object.assign({}, ctx['state']), key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"
@@ -117,7 +117,7 @@ exports[`t-props t-props with props 1`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = component(\`Child\`, Object.assign({}, ctx['childProps'], {a: 1, b: 2}), key + \`__1\`, node, ctx);
+    let b2 = component(\`Child\`, Object.assign({}, ctx['childProps'], {a: 1, b: 2}), key + \`__1\`, node, ctx);
     return block1([], [b2]);
   }
 }"

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

@@ -4,7 +4,7 @@ exports[`t-set slot setted value (with t-set) not accessible with t-esc 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { isBoundary, withDefault, setContextValue, capture, markRaw } = helpers;
+  let { isBoundary, withDefault, setContextValue, capture } = helpers;
   
   let block1 = createBlock(\`<div><p><block-text-0/></p><block-child-0/><p><block-text-1/></p></div>\`);
   
@@ -21,7 +21,7 @@ exports[`t-set slot setted value (with t-set) not accessible with t-esc 1`] = `
     setContextValue(ctx, \\"iter\\", 'source');
     let txt1 = ctx['iter'];
     const ctx1 = capture(ctx);
-    const b2 = component(\`Childcomp\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Childcomp\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1\`, node, ctx);
     let txt2 = ctx['iter'];
     return block1([txt1, txt2], [b2]);
   }
@@ -51,14 +51,14 @@ exports[`t-set slots with a t-set with a component in body 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { capture, isBoundary, withDefault, LazyValue, safeOutput, markRaw } = helpers;
+  let { capture, isBoundary, withDefault, LazyValue, safeOutput } = helpers;
   
   function slot1(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx[\`v\`] = new LazyValue(value1, ctx, node);
-    const b3 = text(\` in slot \`);
-    const b4 = safeOutput(ctx['v']);
+    let b3 = text(\` in slot \`);
+    let b4 = safeOutput(ctx['v']);
     return multi([b3, b4]);
   }
   
@@ -68,7 +68,7 @@ exports[`t-set slots with a t-set with a component in body 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -80,8 +80,8 @@ exports[`t-set slots with a t-set with a component in body 2`] = `
   let { callSlot } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`Child \`);
-    const b3 = callSlot(ctx, node, key, 'default', false, null);
+    let b2 = text(\`Child \`);
+    let b3 = callSlot(ctx, node, key, 'default', false, {});
     return multi([b2, b3]);
   }
 }"
@@ -102,7 +102,7 @@ exports[`t-set slots with an t-set with a component in body 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { capture, isBoundary, withDefault, LazyValue, safeOutput, markRaw } = helpers;
+  let { capture, isBoundary, withDefault, LazyValue, safeOutput } = helpers;
   
   let block4 = createBlock(\`<div>coffee</div>\`);
   
@@ -110,20 +110,20 @@ exports[`t-set slots with an t-set with a component in body 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx[\`v\`] = new LazyValue(value1, ctx, node);
-    const b5 = text(\` tea \`);
-    const b6 = safeOutput(ctx['v']);
+    let b5 = text(\` tea \`);
+    let b6 = safeOutput(ctx['v']);
     return multi([b5, b6]);
   }
   
   function value1(ctx, node, key = \\"\\") {
-    const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
-    const b4 = block4();
+    let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+    let b4 = block4();
     return multi([b3, b4]);
   }
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Blorg\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
+    return component(\`Blorg\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -135,8 +135,8 @@ exports[`t-set slots with an t-set with a component in body 2`] = `
   let { callSlot } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`Blorg \`);
-    const b3 = callSlot(ctx, node, key, 'default', false, null);
+    let b2 = text(\`Blorg \`);
+    let b3 = callSlot(ctx, node, key, 'default', false, {});
     return multi([b2, b3]);
   }
 }"
@@ -157,7 +157,7 @@ exports[`t-set slots with an unused t-set with a component in body 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { capture, isBoundary, withDefault, LazyValue, markRaw } = helpers;
+  let { capture, isBoundary, withDefault, LazyValue } = helpers;
   
   function slot1(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
@@ -172,7 +172,7 @@ exports[`t-set slots with an unused t-set with a component in body 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const ctx1 = capture(ctx);
-    return component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx1}})}, key + \`__2\`, node, ctx);
+    return component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__2\`, node, ctx);
   }
 }"
 `;
@@ -184,8 +184,8 @@ exports[`t-set slots with an unused t-set with a component in body 2`] = `
   let { callSlot } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`Child \`);
-    const b3 = callSlot(ctx, node, key, 'default', false, null);
+    let b2 = text(\`Child \`);
+    let b3 = callSlot(ctx, node, key, 'default', false, {});
     return multi([b2, b3]);
   }
 }"
@@ -267,7 +267,7 @@ exports[`t-set t-set not altered by child comp 1`] = `
     ctx[isBoundary] = 1
     setContextValue(ctx, \\"iter\\", 'source');
     let txt1 = ctx['iter'];
-    const b2 = component(\`Childcomp\`, {}, key + \`__1\`, node, ctx);
+    let b2 = component(\`Childcomp\`, {}, key + \`__1\`, node, ctx);
     let txt2 = ctx['iter'];
     return block1([txt1, txt2], [b2]);
   }
@@ -335,7 +335,7 @@ exports[`t-set t-set with a component in body 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx[\`v\`] = new LazyValue(value1, ctx, node);
-    const b3 = safeOutput(ctx['v']);
+    let b3 = safeOutput(ctx['v']);
     return block1([], [b3]);
   }
 }"
@@ -369,7 +369,7 @@ exports[`t-set t-set with something in body 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1
     ctx[\`v\`] = new LazyValue(value1, ctx, node);
-    const b3 = safeOutput(ctx['v']);
+    let b3 = safeOutput(ctx['v']);
     return block1([], [b3]);
   }
 }"

tests/components/basics.test.ts

@@ -1,4 +1,4 @@
-import { App, Component, mount, status, toRaw, useState, xml } from "../../src";
+import { App, Component, mount, status, useState, xml } from "../../src";
 import { elem, makeTestFixture, nextTick, snapshotEverything, useLogLifecycle } from "../helpers";
 import { markup } from "../../src/utils";
 
@@ -121,7 +121,7 @@ describe("basics", () => {
     class Test extends Component {
       static template = xml`<span>simple vnode</span>`;
       setup() {
-        expect(toRaw(this.props)).toBe(p);
+        expect(this.props).toBe(p);
       }
     }
 

tests/components/concurrency.test.ts

@@ -3,7 +3,6 @@ import {
   Component,
   mount,
   onMounted,
-  onRendered,
   onWillStart,
   onWillUnmount,
   onWillUpdateProps,
@@ -40,8 +39,6 @@ Scheduler.prototype.addFiber = function (fiber: Fiber) {
 
 afterEach(() => {
   if (lastScheduler && lastScheduler.tasks.size > 0) {
-    // we still clear the scheduler to prevent additional noise
-    lastScheduler.tasks.clear();
     throw new Error("we got a memory leak...");
   }
 });
@@ -100,17 +97,14 @@ test("destroying/recreating a subwidget with different props (if start is not ov
   expect(["W:setup", "W:willStart", "W:willRender", "W:rendered", "W:mounted"]).toBeLogged();
 
   expect(n).toBe(0);
-
   w.state.val = 2;
-  await nextMicroTick();
-  await nextMicroTick();
+  await new Promise(requestAnimationFrame); // calls to _render are batched per animation frame
   expect(n).toBe(1);
 
   expect(["W:willRender", "Child:setup", "Child:willStart", "W:rendered"]).toBeLogged();
 
   w.state.val = 3;
-  await nextMicroTick();
-  await nextMicroTick();
+  await new Promise(requestAnimationFrame);
   expect(n).toBe(2);
 
   expect([
@@ -134,58 +128,6 @@ test("destroying/recreating a subwidget with different props (if start is not ov
   ]).toBeLogged();
 });
 
-test("destroying/recreating a subcomponent, other scenario", async () => {
-  let flag = false;
-
-  class Child extends Component {
-    static template = xml`child`;
-    setup() {
-      if (!flag) {
-        flag = true;
-        parent.render(true);
-      }
-      useLogLifecycle();
-    }
-  }
-
-  class Parent extends Component {
-    static template = xml`parent<Child t-if="state.hasChild"/>`;
-    static components = { Child };
-    state = useState({ hasChild: false });
-    setup() {
-      useLogLifecycle();
-    }
-  }
-
-  const parent = await mount(Parent, fixture);
-
-  expect([
-    "Parent:setup",
-    "Parent:willStart",
-    "Parent:willRender",
-    "Parent:rendered",
-    "Parent:mounted",
-  ]).toBeLogged();
-  expect(fixture.innerHTML).toBe("parent");
-
-  parent.state.hasChild = true;
-
-  await nextTick();
-  expect([
-    "Parent:willRender",
-    "Child:setup",
-    "Child:willStart",
-    "Parent:rendered",
-    "Child:willRender",
-    "Child:rendered",
-    "Parent:willPatch",
-    "Child:mounted",
-    "Parent:patched",
-  ]).toBeLogged();
-
-  expect(fixture.innerHTML).toBe("parentchild");
-});
-
 test("creating two async components, scenario 1", async () => {
   let defA = makeDeferred();
   let defB = makeDeferred();
@@ -576,7 +518,7 @@ test("properly behave when destroyed/unmounted while rendering ", async () => {
   }
 
   class Child extends Component {
-    static template = xml`<div><SubChild val="props.val"/></div>`;
+    static template = xml`<div><SubChild /></div>`;
     static components = { SubChild };
     setup() {
       useLogLifecycle();
@@ -870,7 +812,6 @@ test("concurrent renderings scenario 2", async () => {
     "ComponentB:rendered",
   ]).toBeLogged();
 
-  debugger; 
   stateB.fromB = "c";
   await nextTick();
   expect(fixture.innerHTML).toBe("<div>1<p><span>1b</span></p></div>");
@@ -882,7 +823,7 @@ test("concurrent renderings scenario 2", async () => {
 
   defs[1].resolve(); // resolve rendering initiated in B
   await nextTick();
-  debugger
+  expect(fixture.innerHTML).toBe("<div>2<p><span>2c</span></p></div>");
   expect([
     "ComponentC:willRender",
     "ComponentC:rendered",
@@ -893,7 +834,6 @@ test("concurrent renderings scenario 2", async () => {
     "ComponentB:patched",
     "ComponentA:patched",
   ]).toBeLogged();
-  expect(fixture.innerHTML).toBe("<div>2<p><span>2c</span></p></div>");
 
   defs[0].resolve(); // resolve rendering initiated in A
   await nextTick();
@@ -1082,7 +1022,11 @@ test("concurrent renderings scenario 3", async () => {
   stateC.fromC = "d";
   await nextTick();
   expect(fixture.innerHTML).toBe("<div><p><span><i>1c</i></span></p></div>");
-  expect([]).toBeLogged();
+  expect([
+    "ComponentC:willRender",
+    "ComponentD:willUpdateProps",
+    "ComponentC:rendered",
+  ]).toBeLogged();
 
   defB.resolve(); // resolve rendering initiated in A (still blocked in D)
   await nextTick();
@@ -1098,7 +1042,14 @@ test("concurrent renderings scenario 3", async () => {
 
   defsD[0].resolve(); // resolve rendering initiated in C (should be ignored)
   await nextTick();
+  expect(ComponentD.prototype.someValue).toBeCalledTimes(1);
+  expect(fixture.innerHTML).toBe("<div><p><span><i>1c</i></span></p></div>");
+  expect([]).toBeLogged();
+
+  defsD[1].resolve(); // completely resolve rendering initiated in A
+  await nextTick();
   expect(fixture.innerHTML).toBe("<div><p><span><i>2d</i></span></p></div>");
+  expect(ComponentD.prototype.someValue).toBeCalledTimes(2);
   expect([
     "ComponentD:willRender",
     "ComponentD:rendered",
@@ -1111,7 +1062,6 @@ test("concurrent renderings scenario 3", async () => {
     "ComponentB:patched",
     "ComponentA:patched",
   ]).toBeLogged();
-  expect(ComponentD.prototype.someValue).toBeCalledTimes(2);
 });
 
 test("concurrent renderings scenario 4", async () => {
@@ -1200,7 +1150,11 @@ test("concurrent renderings scenario 4", async () => {
   stateC.fromC = "d";
   await nextTick();
   expect(fixture.innerHTML).toBe("<div><p><span><i>1c</i></span></p></div>");
-  expect([]).toBeLogged();
+  expect([
+    "ComponentC:willRender",
+    "ComponentD:willUpdateProps",
+    "ComponentC:rendered",
+  ]).toBeLogged();
 
   defB.resolve(); // resolve rendering initiated in A (still blocked in D)
   await nextTick();
@@ -1216,12 +1170,6 @@ test("concurrent renderings scenario 4", async () => {
 
   defsD[1].resolve(); // completely resolve rendering initiated in A
   await nextTick();
-  expect(fixture.innerHTML).toBe("<div><p><span><i>1c</i></span></p></div>");
-  expect(ComponentD.prototype.someValue).toBeCalledTimes(1);
-  expect([]).toBeLogged();
-
-  defsD[0].resolve(); // resolve rendering initiated in C (should be ignored)
-  await nextTick();
   expect(fixture.innerHTML).toBe("<div><p><span><i>2d</i></span></p></div>");
   expect(ComponentD.prototype.someValue).toBeCalledTimes(2);
   expect([
@@ -1236,6 +1184,12 @@ test("concurrent renderings scenario 4", async () => {
     "ComponentB:patched",
     "ComponentA:patched",
   ]).toBeLogged();
+
+  defsD[0].resolve(); // resolve rendering initiated in C (should be ignored)
+  await nextTick();
+  expect(fixture.innerHTML).toBe("<div><p><span><i>2d</i></span></p></div>");
+  expect(ComponentD.prototype.someValue).toBeCalledTimes(2);
+  expect([]).toBeLogged();
 });
 
 test("concurrent renderings scenario 5", async () => {
@@ -1950,13 +1904,18 @@ test("concurrent renderings scenario 13", async () => {
   await nextTick(); // wait for this change to be applied
   expect([
     "Parent:willRender",
+    "Child:willUpdateProps",
     "Child:setup",
     "Child:willStart",
     "Parent:rendered",
     "Child:willRender",
     "Child:rendered",
+    "Child:willRender",
+    "Child:rendered",
     "Parent:willPatch",
+    "Child:willPatch",
     "Child:mounted",
+    "Child:patched",
     "Parent:patched",
     "Child:willRender",
     "Child:rendered",
@@ -2510,9 +2469,9 @@ test("two renderings initiated between willPatch and patched", async () => {
       useLogLifecycle();
       onMounted(() => {
         this.mounted = "Mounted";
-        parent.render(true);
+        parent.render();
       });
-      onWillUnmount(() => parent.render(true));
+      onWillUnmount(() => parent.render());
     }
   }
 
@@ -2545,11 +2504,15 @@ test("two renderings initiated between willPatch and patched", async () => {
     "Parent:rendered",
   ]).toBeLogged();
 
-  await nextMicroTick();
-  expect(["Panel:willRender", "Panel:rendered"]).toBeLogged();
-
   await nextTick();
-  expect(["Parent:willPatch", "Panel:willPatch", "Panel:patched", "Parent:patched"]).toBeLogged();
+  expect([
+    "Panel:willRender",
+    "Panel:rendered",
+    "Parent:willPatch",
+    "Panel:willPatch",
+    "Panel:patched",
+    "Parent:patched",
+  ]).toBeLogged();
   expect(fixture.innerHTML).toBe("<div><abc>Panel1Mounted</abc></div>");
 
   parent.state.panel = "Panel2";
@@ -2703,7 +2666,13 @@ test("delay willUpdateProps", async () => {
   parent.render();
   await nextTick();
   expect(fixture.innerHTML).toBe("0_0");
-  expect(["Parent:willRender", "Child:willUpdateProps", "Parent:rendered"]).toBeLogged();
+  expect([
+    "Child:willRender",
+    "Child:rendered",
+    "Parent:willRender",
+    "Child:willUpdateProps",
+    "Parent:rendered",
+  ]).toBeLogged();
 
   promise = makeDeferred();
   const prom2 = promise;
@@ -2781,20 +2750,12 @@ test("delay willUpdateProps with rendering grandchild", async () => {
     static template = xml`<Parent state="state"/>`;
     static components = { Parent };
     state = { value: 0 };
-    setup() {
-      useLogLifecycle();
-    }
   }
-
   const parent = await mount(GrandParent, fixture);
   expect(fixture.innerHTML).toBe("0_0<div></div>");
   expect([
-    "GrandParent:setup",
-    "GrandParent:willStart",
-    "GrandParent:willRender",
     "Parent:setup",
     "Parent:willStart",
-    "GrandParent:rendered",
     "Parent:willRender",
     "DelayedChild:setup",
     "DelayedChild:willStart",
@@ -2808,21 +2769,22 @@ test("delay willUpdateProps with rendering grandchild", async () => {
     "ReactiveChild:mounted",
     "DelayedChild:mounted",
     "Parent:mounted",
-    "GrandParent:mounted",
   ]).toBeLogged();
 
   promise = makeDeferred();
   const prom1 = promise;
   parent.state.value = 1;
   child.render(); // trigger a root rendering first
-  parent.render(true);
+  parent.render();
   reactiveChild.render();
   await nextTick();
   expect(fixture.innerHTML).toBe("0_0<div></div>");
   expect([
-    "GrandParent:willRender",
+    "DelayedChild:willRender",
+    "DelayedChild:rendered",
     "Parent:willUpdateProps",
-    "GrandParent:rendered",
+    "ReactiveChild:willRender",
+    "ReactiveChild:rendered",
     "Parent:willRender",
     "DelayedChild:willUpdateProps",
     "ReactiveChild:willUpdateProps",
@@ -2835,14 +2797,14 @@ test("delay willUpdateProps with rendering grandchild", async () => {
   const prom2 = promise;
   child.render(); // trigger a root rendering first
   parent.state.value = 2;
-  parent.render(true);
+  parent.render();
   reactiveChild.render();
   await nextTick();
   expect(fixture.innerHTML).toBe("0_0<div></div>");
   expect([
-    "GrandParent:willRender",
     "Parent:willUpdateProps",
-    "GrandParent:rendered",
+    "ReactiveChild:willRender",
+    "ReactiveChild:rendered",
     "Parent:willRender",
     "DelayedChild:willUpdateProps",
     "ReactiveChild:willUpdateProps",
@@ -2857,14 +2819,12 @@ test("delay willUpdateProps with rendering grandchild", async () => {
   expect([
     "DelayedChild:willRender",
     "DelayedChild:rendered",
-    "GrandParent:willPatch",
     "Parent:willPatch",
     "ReactiveChild:willPatch",
     "DelayedChild:willPatch",
     "DelayedChild:patched",
     "ReactiveChild:patched",
     "Parent:patched",
-    "GrandParent:patched",
   ]).toBeLogged();
 
   prom1.resolve();
@@ -3166,532 +3126,6 @@ test("Cascading renders after microtaskTick", async () => {
   await nextTick();
   expect(fixture.innerHTML).toBe("0123 _ 0123");
 });
-
-test("rendering parent twice, with different props on child and stuff", async () => {
-  class Child extends Component {
-    static template = xml`<t t-esc="props.value"/>`;
-    setup() {
-      useLogLifecycle();
-    }
-  }
-
-  class Parent extends Component {
-    static template = xml`<Child value="state.value"/>`;
-    static components = { Child };
-    state = useState({ value: 1 });
-    setup() {
-      useLogLifecycle();
-    }
-  }
-
-  const parent = await mount(Parent, fixture);
-  expect(fixture.innerHTML).toBe("1");
-  expect([
-    "Parent:setup",
-    "Parent:willStart",
-    "Parent:willRender",
-    "Child:setup",
-    "Child:willStart",
-    "Parent:rendered",
-    "Child:willRender",
-    "Child:rendered",
-    "Child:mounted",
-    "Parent:mounted",
-  ]).toBeLogged();
-
-  parent.state.value = 2;
-  // wait for child to be rendered
-  await nextMicroTick();
-  await nextMicroTick();
-  await nextMicroTick();
-  await nextMicroTick();
-  expect([
-    "Parent:willRender",
-    "Child:willUpdateProps",
-    "Parent:rendered",
-    "Child:willRender",
-    "Child:rendered",
-  ]).toBeLogged();
-  expect(fixture.innerHTML).toBe("1");
-
-  // trigger a render, but keep the props for child the same
-  parent.render();
-  await nextTick();
-  expect(fixture.innerHTML).toBe("2");
-  expect([
-    "Parent:willRender",
-    "Child:willUpdateProps",
-    "Parent:rendered",
-    "Child:willRender",
-    "Child:rendered",
-    "Parent:willPatch",
-    "Child:willPatch",
-    "Child:patched",
-    "Parent:patched",
-  ]).toBeLogged();
-});
-
-test("delayed rendering, but then initial rendering is cancelled by yet another render", async () => {
-  const promC = makeDeferred();
-  let stateB: any = null;
-
-  class D extends Component {
-    static template = xml`<button t-on-click="increment"><t t-esc="state.val"/></button>`;
-    state = useState({ val: 1 });
-    setup() {
-      useLogLifecycle();
-    }
-    increment() {
-      this.state.val++;
-    }
-  }
-
-  class C extends Component {
-    static template = xml`<D/><p><t t-esc="props.value"/></p>`;
-    static components = { D };
-    setup() {
-      useLogLifecycle();
-      onWillUpdateProps(() => promC);
-    }
-  }
-
-  class B extends Component {
-    static template = xml`<C value="state.someValue + props.value"/>`;
-    static components = { C };
-    state = useState({ someValue: 3 });
-    setup() {
-      useLogLifecycle();
-      stateB = this.state;
-    }
-  }
-
-  class A extends Component {
-    static template = xml`<B value="state.value"/>`;
-    static components = { B };
-    state = useState({ value: 33 });
-    setup() {
-      useLogLifecycle();
-    }
-  }
-
-  const parent = await mount(A, fixture);
-  expect(fixture.innerHTML).toBe("<button>1</button><p>36</p>");
-  expect([
-    "A:setup",
-    "A:willStart",
-    "A:willRender",
-    "B:setup",
-    "B:willStart",
-    "A:rendered",
-    "B:willRender",
-    "C:setup",
-    "C:willStart",
-    "B:rendered",
-    "C:willRender",
-    "D:setup",
-    "D:willStart",
-    "C:rendered",
-    "D:willRender",
-    "D:rendered",
-    "D:mounted",
-    "C:mounted",
-    "B:mounted",
-    "A:mounted",
-  ]).toBeLogged();
-
-  // update B and C, but render is blocked by C willupdateProps
-  stateB.someValue = 5;
-  await nextTick();
-  expect(["B:willRender", "C:willUpdateProps", "B:rendered"]).toBeLogged();
-
-  // update D => render should be delayed, because B is currently rendering
-  fixture.querySelector("button")!.click();
-  await nextTick();
-  expect([]).toBeLogged();
-
-  // update A => render should go to B and cancel it
-  parent.state.value = 34;
-  await nextTick();
-  expect([
-    "A:willRender",
-    "B:willUpdateProps",
-    "A:rendered",
-    "B:willRender",
-    "C:willUpdateProps",
-    "B:rendered",
-  ]).toBeLogged();
-
-  promC.resolve();
-  await nextTick();
-  expect([
-    "C:willRender",
-    "C:rendered",
-    "D:willRender",
-    "D:rendered",
-    "D:willPatch",
-    "D:patched",
-    "A:willPatch",
-    "B:willPatch",
-    "C:willPatch",
-    "C:patched",
-    "B:patched",
-    "A:patched",
-  ]).toBeLogged();
-  expect(fixture.innerHTML).toBe("<button>2</button><p>39</p>");
-});
-
-test("delayed rendering, reusing fiber and stuff", async () => {
-  let prom1 = makeDeferred();
-  let prom2 = makeDeferred();
-
-  class C extends Component {
-    static template = xml`<button t-on-click="increment"><t t-esc="state.val"/></button>`;
-    state = useState({ val: 1 });
-    setup() {
-      useLogLifecycle();
-    }
-    increment() {
-      this.state.val++;
-    }
-  }
-
-  class B extends Component {
-    static template = xml`<t t-esc="props.value"/><C />`;
-    static components = { C };
-    setup() {
-      useLogLifecycle();
-      let flag = false;
-      onWillUpdateProps(() => {
-        flag = true;
-        return prom1;
-      });
-      onRendered(async () => {
-        if (flag) {
-          await nextMicroTick();
-          prom2.resolve();
-        }
-      });
-    }
-  }
-
-  class A extends Component {
-    static template = xml`<B value="state.value"/>`;
-    static components = { B };
-    state = useState({ value: 33 });
-    setup() {
-      useLogLifecycle();
-    }
-  }
-
-  const parent = await mount(A, fixture);
-  expect(fixture.innerHTML).toBe("33<button>1</button>");
-  expect([
-    "A:setup",
-    "A:willStart",
-    "A:willRender",
-    "B:setup",
-    "B:willStart",
-    "A:rendered",
-    "B:willRender",
-    "C:setup",
-    "C:willStart",
-    "B:rendered",
-    "C:willRender",
-    "C:rendered",
-    "C:mounted",
-    "B:mounted",
-    "A:mounted",
-  ]).toBeLogged();
-
-  // initiate a render in A, but is blocked in B
-  parent.state.value = 34;
-  await nextTick();
-  expect(["A:willRender", "B:willUpdateProps", "A:rendered"]).toBeLogged();
-
-  // initiate a render in C => delayed because of render in A
-  fixture.querySelector("button")!.click();
-  await nextTick();
-  expect([]).toBeLogged();
-
-  // wait for render in A to be completed
-  prom1.resolve();
-  await prom2;
-  expect(["B:willRender", "B:rendered", "C:willRender", "C:rendered"]).toBeLogged();
-
-  // initiate a new render in A => fiber will be reused
-  parent.state.value = 355;
-  await nextTick();
-  expect(fixture.innerHTML).toBe("355<button>2</button>");
-  expect([
-    "A:willRender",
-    "B:willUpdateProps",
-    "A:rendered",
-    "B:willRender",
-    "B:rendered",
-    "A:willPatch",
-    "B:willPatch",
-    "B:patched",
-    "A:patched",
-    "C:willPatch",
-    "C:patched",
-  ]).toBeLogged();
-});
-
-test("delayed rendering, then component is destroyed and  stuff", async () => {
-  let prom1 = makeDeferred();
-
-  class C extends Component {
-    static template = xml`<button t-on-click="increment"><t t-esc="state.val"/></button>`;
-    state = useState({ val: 1 });
-    setup() {
-      useLogLifecycle();
-    }
-    increment() {
-      this.state.val++;
-    }
-  }
-
-  class B extends Component {
-    static template = xml`<t t-esc="props.value"/><t t-if="props.value lt 10"><C /></t>`;
-    static components = { C };
-    setup() {
-      useLogLifecycle();
-      onWillUpdateProps(() => prom1);
-    }
-  }
-
-  class A extends Component {
-    static template = xml`<B value="state.value"/>`;
-    static components = { B };
-    state = useState({ value: 3 });
-    setup() {
-      useLogLifecycle();
-    }
-  }
-
-  const parent = await mount(A, fixture);
-  expect(fixture.innerHTML).toBe("3<button>1</button>");
-  expect([
-    "A:setup",
-    "A:willStart",
-    "A:willRender",
-    "B:setup",
-    "B:willStart",
-    "A:rendered",
-    "B:willRender",
-    "C:setup",
-    "C:willStart",
-    "B:rendered",
-    "C:willRender",
-    "C:rendered",
-    "C:mounted",
-    "B:mounted",
-    "A:mounted",
-  ]).toBeLogged();
-
-  // initiate a render in C (so will be first task)
-  fixture.querySelector("button")!.click();
-  // initiate a render in A, but is blocked in B. the render will destroy c. also,
-  // it blocks the render C
-  parent.state.value = 34;
-  await nextTick();
-  expect(["A:willRender", "B:willUpdateProps", "A:rendered"]).toBeLogged();
-
-  // wait for render in A to be completed
-  prom1.resolve();
-  await nextTick();
-  expect(fixture.innerHTML).toBe("34");
-  expect([
-    "B:willRender",
-    "B:rendered",
-    "A:willPatch",
-    "B:willPatch",
-    "C:willUnmount",
-    "C:willDestroy",
-    "B:patched",
-    "A:patched",
-  ]).toBeLogged();
-
-  await nextTick();
-});
-
-test("delayed rendering, reusing fiber then component is destroyed and  stuff", async () => {
-  let prom1 = makeDeferred();
-
-  class C extends Component {
-    static template = xml`<button t-on-click="increment"><t t-esc="state.val"/></button>`;
-    state = useState({ val: 1 });
-    setup() {
-      useLogLifecycle();
-    }
-    increment() {
-      this.state.val++;
-    }
-  }
-
-  class B extends Component {
-    static template = xml`<t t-esc="props.value"/><C />`;
-    static components = { C };
-    setup() {
-      useLogLifecycle();
-      onWillUpdateProps(() => prom1);
-    }
-  }
-
-  class A extends Component {
-    static template = xml`A<t t-if="state.value lt 15"><B value="state.value"/></t>`;
-    static components = { B };
-    state = useState({ value: 3 });
-    setup() {
-      useLogLifecycle();
-    }
-  }
-
-  const parent = await mount(A, fixture);
-  expect(fixture.innerHTML).toBe("A3<button>1</button>");
-  expect([
-    "A:setup",
-    "A:willStart",
-    "A:willRender",
-    "B:setup",
-    "B:willStart",
-    "A:rendered",
-    "B:willRender",
-    "C:setup",
-    "C:willStart",
-    "B:rendered",
-    "C:willRender",
-    "C:rendered",
-    "C:mounted",
-    "B:mounted",
-    "A:mounted",
-  ]).toBeLogged();
-
-  // initiate a render in A, but is blocked in B
-  parent.state.value = 5;
-  await nextTick();
-  expect(["A:willRender", "B:willUpdateProps", "A:rendered"]).toBeLogged();
-
-  // initiate a render in C (will be delayed because of render in A)
-  fixture.querySelector("button")!.click();
-  await nextTick();
-  expect([]).toBeLogged();
-
-  // initiate a render in A, that will destroy B
-  parent.state.value = 23;
-  await nextTick();
-  expect(fixture.innerHTML).toBe("A");
-  expect([
-    "A:willRender",
-    "A:rendered",
-    "A:willPatch",
-    "B:willUnmount",
-    "C:willUnmount",
-    "C:willDestroy",
-    "B:willDestroy",
-    "A:patched",
-  ]).toBeLogged();
-});
-
-test("another scenario with delayed rendering", async () => {
-  let prom1 = makeDeferred();
-  let onSecondRenderA = makeDeferred();
-
-  class C extends Component {
-    static template = xml`<button t-on-click="increment"><t t-esc="state.val"/></button>`;
-    state = useState({ val: 1 });
-    setup() {
-      useLogLifecycle();
-    }
-    increment() {
-      this.state.val++;
-    }
-  }
-
-  class B extends Component {
-    static template = xml`<t t-esc="props.value"/><C />`;
-    static components = { C };
-    setup() {
-      useLogLifecycle();
-      onWillUpdateProps(() => prom1);
-    }
-  }
-
-  class A extends Component {
-    static template = xml`A<t t-if="state.value lt 15"><B value="state.value"/></t>`;
-    static components = { B };
-    state = useState({ value: 3 });
-    setup() {
-      useLogLifecycle();
-      let n = 0;
-      onRendered(() => {
-        n++;
-        if (n === 2) {
-          onSecondRenderA.resolve();
-        }
-      });
-    }
-  }
-
-  const parent = await mount(A, fixture);
-  expect(fixture.innerHTML).toBe("A3<button>1</button>");
-  expect([
-    "A:setup",
-    "A:willStart",
-    "A:willRender",
-    "B:setup",
-    "B:willStart",
-    "A:rendered",
-    "B:willRender",
-    "C:setup",
-    "C:willStart",
-    "B:rendered",
-    "C:willRender",
-    "C:rendered",
-    "C:mounted",
-    "B:mounted",
-    "A:mounted",
-  ]).toBeLogged();
-
-  // initiate a render in A, but is blocked in B
-  parent.state.value = 5;
-  await nextTick();
-  expect(["A:willRender", "B:willUpdateProps", "A:rendered"]).toBeLogged();
-
-  // initiate a render in C (will be delayed because of render in A)
-  fixture.querySelector("button")!.click();
-  await nextTick();
-  expect([]).toBeLogged();
-
-  // initiate a render in A, that will destroy B
-  parent.state.value = 23;
-  await onSecondRenderA;
-  await nextMicroTick();
-  expect(["A:willRender", "A:rendered"]).toBeLogged();
-
-  // rerender A, but without destroying B
-  parent.state.value = 7;
-  await nextTick();
-  expect(["A:willRender", "B:willUpdateProps", "A:rendered"]).toBeLogged();
-
-  prom1.resolve();
-  await nextTick();
-  expect(fixture.innerHTML).toBe("A7<button>2</button>");
-
-  expect([
-    "B:willRender",
-    "B:rendered",
-    "C:willRender",
-    "C:rendered",
-    "A:willPatch",
-    "B:willPatch",
-    "B:patched",
-    "A:patched",
-    "C:willPatch",
-    "C:patched",
-  ]).toBeLogged();
-});
-
 //   test.skip("components with shouldUpdate=false", async () => {
 //     const state = { p: 1, cc: 10 };
 

tests/components/env.test.ts

@@ -49,7 +49,5 @@ describe("env handling", () => {
 
     await new App(Test, { env }).mount(fixture);
     expect(child.env).toEqual(env);
-    // we check that the frozen env maintain the same prototype chain
-    expect(Object.getPrototypeOf(child.env)).toBe(Object.getPrototypeOf(env));
   });
 });

tests/components/error_handling.test.ts

@@ -5,8 +5,6 @@ import {
   onPatched,
   onWillPatch,
   onWillStart,
-  onWillRender,
-  onRendered,
   onWillUnmount,
   useState,
   xml,
@@ -201,50 +199,6 @@ describe("errors and promises", () => {
     expect(mockConsoleWarn).toBeCalledTimes(1);
   });
 
-  test("errors in onWillRender/onRender aren't wrapped more than once", async () => {
-    class App extends Component {
-      static template = xml`<div>abc</div>`;
-      setup() {
-        onWillRender(() => {
-          throw new Error("boom in onWillRender");
-        });
-        onRendered(() => {
-          throw new Error("boom in onRendered");
-        });
-      }
-    }
-
-    let error: Error;
-    try {
-      await mount(App, fixture, { test: true });
-    } catch (e) {
-      error = e as Error;
-    }
-    expect(error!).toBeDefined();
-    expect(error!.message).toBe(
-      `The following error occurred in onWillRender: "boom in onWillRender"`
-    );
-  });
-
-  test("error while rendering component isn't wrapped by onWillRender/onRendered", async () => {
-    class App extends Component {
-      static template = xml`<div t-att-class="{ 'invalid: 5 }">abc</div>`;
-      setup() {
-        onWillRender(() => {});
-        onRendered(() => {});
-      }
-    }
-
-    let error: Error;
-    try {
-      await mount(App, fixture, { test: true });
-    } catch (e) {
-      error = e as Error;
-    }
-    expect(error!).toBeDefined();
-    expect(error!.message).toBe("Tokenizer error: could not tokenize `{ 'invalid: 5 }`");
-  });
-
   test("an error in willPatch call will reject the render promise", async () => {
     class Root extends Component {
       static template = xml`<div><t t-esc="val"/></div>`;

tests/components/hooks.test.ts

@@ -238,7 +238,7 @@ describe("hooks", () => {
     expect(fixture.innerHTML).toBe("<div>maggot brain</div>");
     someVal = "brain";
     someVal2 = "maggot";
-    component.render(true);
+    component.render();
     await nextTick();
     expect(fixture.innerHTML).toBe("<div>brain maggot</div>");
   });
@@ -272,7 +272,7 @@ describe("hooks", () => {
     expect(fixture.innerHTML).toBe("<div>maggot brain</div>");
     someVal = "brain";
     someVal2 = "maggot";
-    component.render(true);
+    component.render();
     await nextTick();
     expect(fixture.innerHTML).toBe("<div>brain maggot</div>");
   });
@@ -632,35 +632,5 @@ describe("hooks", () => {
         "cleaning up for 1",
       ]);
     });
-
-    test("properly behaves when the effect function throws", async () => {
-      let originalconsoleError = console.error;
-      let originalconsoleWarn = console.warn;
-      console.error = jest.fn(() => {});
-      console.warn = jest.fn(() => {});
-      class MyComponent extends Component {
-        static template = xml`<div/>`;
-        setup() {
-          useEffect(
-            () => {
-              throw new Error("Intentional error");
-            },
-            () => []
-          );
-        }
-      }
-
-      try {
-        await mount(MyComponent, fixture);
-      } catch (e: any) {
-        expect(e.message).toBe("Intentional error");
-      }
-      // no console.error because the error has been caught in this test
-      expect(console.error).toHaveBeenCalledTimes(0);
-      console.error = originalconsoleError;
-      // 1 console.warn because app is destroyed
-      expect(console.warn).toHaveBeenCalledTimes(1);
-      console.warn = originalconsoleWarn;
-    });
   });
 });

tests/components/lifecycle.test.ts

@@ -14,7 +14,6 @@ import {
   logStep,
   makeDeferred,
   makeTestFixture,
-  nextMicroTick,
   nextTick,
   snapshotEverything,
   useLogLifecycle,
@@ -105,83 +104,6 @@ describe("lifecycle hooks", () => {
     await mount(Test, fixture);
   });
 
-  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;
-    window.setTimeout = ((cb: any) => {
-      timeoutCbs[++timeoutId] = cb;
-      return timeoutId;
-    }) as any;
-    class Test extends Component {
-      static template = xml`<span/>`;
-      setup() {
-        onWillStart(() => new Promise(() => {}));
-      }
-    }
-    mount(Test, fixture, { test: true });
-    nextTick();
-    for (const id in timeoutCbs) {
-      timeoutCbs[id]();
-      delete timeoutCbs[id];
-    }
-    await nextMicroTick();
-    await nextMicroTick();
-    expect(console.warn).toHaveBeenCalledTimes(1);
-    expect(warnArgs![0]!.message).toBe("onWillStart's promise hasn't resolved after 3 seconds");
-    console.warn = warn;
-    window.setTimeout = setTimeout;
-  });
-
-  test("timeout in onWillUpdateProps emits a warning", async () => {
-    class Child extends Component {
-      static template = xml``;
-      setup() {
-        onWillUpdateProps(() => new Promise(() => {}));
-      }
-    }
-    class Parent extends Component {
-      static template = xml`<Child prop="state.prop"/>`;
-      static components = { Child };
-      state = useState({ prop: 1 });
-    }
-    const parent = await mount(Parent, fixture, { test: true });
-
-    const { warn } = console;
-    let warnArgs: any[];
-    console.warn = jest.fn((...args) => (warnArgs = args));
-    const { setTimeout } = window;
-    let timeoutCbs: any = {};
-    let timeoutId = 0;
-    window.setTimeout = ((cb: any) => {
-      timeoutCbs[++timeoutId] = cb;
-      return timeoutId;
-    }) as any;
-
-    parent.state.prop = 2;
-    let tick = nextTick();
-    for (const id in timeoutCbs) {
-      timeoutCbs[id]();
-      delete timeoutCbs[id];
-    }
-    await tick;
-    tick = nextTick();
-    for (const id in timeoutCbs) {
-      timeoutCbs[id]();
-      delete timeoutCbs[id];
-    }
-    await tick;
-    expect(console.warn).toHaveBeenCalledTimes(1);
-    expect(warnArgs![0]!.message).toBe(
-      "onWillUpdateProps's promise hasn't resolved after 3 seconds"
-    );
-    console.warn = warn;
-    window.setTimeout = setTimeout;
-  });
-
   test("mounted hook is called if mounted in DOM", async () => {
     let mounted = false;
     class Test extends Component {
@@ -927,9 +849,8 @@ describe("lifecycle hooks", () => {
 
     class Parent extends Component {
       static template = xml`
-        <Child someValue="state.value" />`;
+        <Child />`;
       static components = { Child };
-      state = useState({ value: 1 });
       setup() {
         useLogLifecycle();
       }
@@ -950,7 +871,7 @@ describe("lifecycle hooks", () => {
       "Parent:mounted",
     ]).toBeLogged();
 
-    parent.state.value++; // to block child render
+    parent.render(); // to block child render
     await nextTick();
     expect(["Parent:willRender", "Child:willUpdateProps", "Parent:rendered"]).toBeLogged();
 
@@ -1087,15 +1008,20 @@ describe("lifecycle hooks", () => {
     await nextTick();
     expect([
       "C:willRender",
+      "D:willUpdateProps",
       "F:setup",
       "F:willStart",
       "C:rendered",
+      "D:willRender",
+      "D:rendered",
       "F:willRender",
       "F:rendered",
       "C:willPatch",
+      "D:willPatch",
       "E:willUnmount",
       "E:willDestroy",
       "F:mounted",
+      "D:patched",
       "C:patched",
     ]).toBeLogged();
   });

tests/components/reactivity.test.ts

@@ -8,7 +8,7 @@ import {
   useState,
   xml,
 } from "../../src";
-import { makeTestFixture, nextTick, snapshotEverything, useLogLifecycle } from "../helpers";
+import { makeTestFixture, nextTick, snapshotEverything } from "../helpers";
 
 let fixture: HTMLElement;
 
@@ -53,18 +53,6 @@ describe("reactivity in lifecycle", () => {
     expect(n).toBe(2); // no new rendering occured: b was never read via state!
   });
 
-  test("can use a state hook on Map", async () => {
-    class Counter extends Component {
-      static template = xml`<div><t t-esc="counter.get('value')"/></div>`;
-      counter = useState(new Map([["value", 42]]));
-    }
-    const counter = await mount(Counter, fixture);
-    expect(fixture.innerHTML).toBe("<div>42</div>");
-    counter.counter.set("value", 3);
-    await nextTick();
-    expect(fixture.innerHTML).toBe("<div>3</div>");
-  });
-
   test("state changes in willUnmount do not trigger rerender", async () => {
     const steps: string[] = [];
     class Child extends Component {
@@ -155,48 +143,4 @@ describe("reactivity in lifecycle", () => {
     expect(steps).toEqual([2]);
     expect(fixture.innerHTML).toBe("<div>2</div>");
   });
-
-  test("Child component doesn't render when state they depend on changes but their parent is about to unmount them", async () => {
-    class Child extends Component {
-      static template = xml`<t t-esc="props.state.content.a"/>`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-    class Parent extends Component {
-      static template = xml`<Child t-if="state.renderChild" state="state"/>`;
-      static components = { Child };
-      state: any = useState({ renderChild: true, content: { a: 2 } });
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    const parent = await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("2");
-    expect([
-      "Parent:setup",
-      "Parent:willStart",
-      "Parent:willRender",
-      "Child:setup",
-      "Child:willStart",
-      "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Child:mounted",
-      "Parent:mounted",
-    ]).toBeLogged();
-
-    parent.state.content = null;
-    parent.state.renderChild = false;
-    await nextTick();
-    expect([
-      "Parent:willRender",
-      "Parent:rendered",
-      "Parent:willPatch",
-      "Child:willUnmount",
-      "Child:willDestroy",
-      "Parent:patched",
-    ]).toBeLogged();
-  });
 });

tests/components/rendering.test.ts

@@ -1,442 +0,0 @@
-import { Component, mount, onRendered, onWillUpdateProps, useState, xml } from "../../src";
-import {
-  makeTestFixture,
-  snapshotEverything,
-  nextTick,
-  useLogLifecycle,
-  makeDeferred,
-  nextMicroTick,
-} from "../helpers";
-
-let fixture: HTMLElement;
-
-snapshotEverything();
-
-beforeEach(() => {
-  fixture = makeTestFixture();
-});
-
-describe("rendering semantics", () => {
-  test("can render a parent without rendering child", async () => {
-    class Child extends Component {
-      static template = xml`child`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        <t t-esc="state.value"/>
-        <Child/>
-      `;
-      static components = { Child };
-
-      state = useState({ value: "A" });
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    const parent = await mount(Parent, fixture);
-
-    expect(fixture.innerHTML).toBe("Achild");
-    expect([
-      "Parent:setup",
-      "Parent:willStart",
-      "Parent:willRender",
-      "Child:setup",
-      "Child:willStart",
-      "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Child:mounted",
-      "Parent:mounted",
-    ]).toBeLogged();
-
-    parent.state.value = "B";
-    await nextTick();
-    expect(fixture.innerHTML).toBe("Bchild");
-    expect([
-      "Parent:willRender",
-      "Parent:rendered",
-      "Parent:willPatch",
-      "Parent:patched",
-    ]).toBeLogged();
-  });
-
-  test("can force a render to update sub tree", async () => {
-    let childN = 0;
-    let parentN = 0;
-    class Child extends Component {
-      static template = xml`child`;
-      setup() {
-        onRendered(() => childN++);
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        <t t-esc="state.value"/>
-        <Child/>
-      `;
-      static components = { Child };
-
-      state = { value: "A" };
-      setup() {
-        onRendered(() => parentN++);
-      }
-    }
-
-    const parent = await mount(Parent, fixture);
-
-    expect(fixture.innerHTML).toBe("Achild");
-    expect(parentN).toBe(1);
-    expect(childN).toBe(1);
-
-    parent.state.value = "B";
-    parent.render(true);
-    await nextTick();
-    expect(fixture.innerHTML).toBe("Bchild");
-    expect(parentN).toBe(2);
-    expect(childN).toBe(2);
-  });
-
-  test("render with deep=true followed by render with deep=false work as expected", async () => {
-    class Child extends Component {
-      static template = xml`child<t t-esc="env.getValue()"/>`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`parent<t t-esc="state.value"/><Child/>`;
-      static components = { Child };
-
-      state = useState({ value: "A" });
-
-      setup() {
-        useLogLifecycle();
-      }
-    }
-    let value = 3;
-    const env = {
-      getValue() {
-        return value;
-      },
-    };
-
-    const parent = await mount(Parent, fixture, { env });
-
-    expect(fixture.innerHTML).toBe("parentAchild3");
-    expect([
-      "Parent:setup",
-      "Parent:willStart",
-      "Parent:willRender",
-      "Child:setup",
-      "Child:willStart",
-      "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Child:mounted",
-      "Parent:mounted",
-    ]).toBeLogged();
-
-    value = 4;
-    parent.render(true);
-
-    // wait for child to be rendered, but dom not yet patched
-    await nextMicroTick();
-    await nextMicroTick();
-    await nextMicroTick();
-    expect([
-      "Parent:willRender",
-      "Child:willUpdateProps",
-      "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-    ]).toBeLogged();
-
-    parent.state.value = "B";
-
-    await nextTick();
-
-    expect(fixture.innerHTML).toBe("parentBchild4");
-    expect([
-      "Parent:willRender",
-      "Child:willUpdateProps",
-      "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Parent:willPatch",
-      "Child:willPatch",
-      "Child:patched",
-      "Parent:patched",
-    ]).toBeLogged();
-  });
-
-  test("props are reactive", async () => {
-    class Child extends Component {
-      static template = xml`<t t-esc="props.a.b"/>`;
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        <Child a="state"/>
-      `;
-      static components = { Child };
-
-      state = useState({ b: 1 });
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    const parent = await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("1");
-    expect([
-      "Parent:setup",
-      "Parent:willStart",
-      "Parent:willRender",
-      "Child:setup",
-      "Child:willStart",
-      "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Child:mounted",
-      "Parent:mounted",
-    ]).toBeLogged();
-
-    parent.state.b = 3;
-    await nextTick();
-    expect(fixture.innerHTML).toBe("3");
-    expect(["Child:willRender", "Child:rendered", "Child:willPatch", "Child:patched"]).toBeLogged();
-  });
-
-  test("props are reactive (nested prop)", async () => {
-    class Child extends Component {
-      static template = xml`<t t-esc="props.a.b.c"/>`;
-
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        <Child a="state"/>
-      `;
-      static components = { Child };
-
-      state = useState({ b: { c: 1 } });
-
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    const parent = await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("1");
-    expect([
-      "Parent:setup",
-      "Parent:willStart",
-      "Parent:willRender",
-      "Child:setup",
-      "Child:willStart",
-      "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Child:mounted",
-      "Parent:mounted",
-    ]).toBeLogged();
-
-    parent.state.b.c = 3; // parent is now subscribed to 'b' key
-    await nextTick();
-    expect(fixture.innerHTML).toBe("3");
-    expect(["Child:willRender", "Child:rendered", "Child:willPatch", "Child:patched"]).toBeLogged();
-
-    parent.state.b = { c: 444 }; // triggers a parent and a child render
-    await nextTick();
-    expect(fixture.innerHTML).toBe("444");
-    expect([
-      "Parent:willRender",
-      "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Parent:willPatch",
-      "Parent:patched",
-      "Child:willPatch",
-      "Child:patched",
-    ]).toBeLogged();
-  });
-
-  test("works as expected for dynamic number of props", async () => {
-    class Child extends Component {
-      static template = xml`<t t-esc="Object.keys(props).length"/>`;
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        <Child t-props="state"/>
-      `;
-      static components = { Child };
-
-      state: any = useState({ b: 1 });
-    }
-
-    const parent = await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("1");
-    parent.state.newkey = 3;
-    await nextTick();
-    expect(fixture.innerHTML).toBe("2");
-  });
-
-  test("rendering is atomic (for one subtree)", async () => {
-    const def = makeDeferred();
-
-    class C extends Component {
-      static template = xml`<t t-esc="props.obj.val"/>`;
-
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    class B extends Component {
-      static template = xml`<C obj="props.obj"/>`;
-      static components = { C };
-
-      setup() {
-        useLogLifecycle();
-        onWillUpdateProps(() => def);
-      }
-    }
-
-    class A extends Component {
-      static template = xml`<t t-esc="state.obj.val"/><B obj="state.obj"/>`;
-      static components = { B };
-
-      state = useState({ obj: { val: 1 } });
-
-      setup() {
-        useLogLifecycle();
-      }
-    }
-
-    const parent = await mount(A, fixture);
-    expect(fixture.innerHTML).toBe("11");
-    expect([
-      "A:setup",
-      "A:willStart",
-      "A:willRender",
-      "B:setup",
-      "B:willStart",
-      "A:rendered",
-      "B:willRender",
-      "C:setup",
-      "C:willStart",
-      "B:rendered",
-      "C:willRender",
-      "C:rendered",
-      "C:mounted",
-      "B:mounted",
-      "A:mounted",
-    ]).toBeLogged();
-
-    parent.state.obj.val = 3;
-    await nextTick();
-    expect(fixture.innerHTML).toBe("33");
-    expect([
-      "A:willRender",
-      "A:rendered",
-      "C:willRender",
-      "C:rendered",
-      "A:willPatch",
-      "A:patched",
-      "C:willPatch",
-      "C:patched",
-    ]).toBeLogged();
-
-    def.resolve();
-    await nextTick();
-    expect([]).toBeLogged();
-  });
-});
-
-test("force render in case of existing render", async () => {
-  const def = makeDeferred();
-
-  class C extends Component {
-    static template = xml`C`;
-    setup() {
-      useLogLifecycle();
-    }
-  }
-  class B extends Component {
-    static template = xml`<C/><t t-esc="props.val"/>`;
-    static components = { C };
-    setup() {
-      useLogLifecycle();
-      onWillUpdateProps(() => def);
-    }
-  }
-  class A extends Component {
-    static template = xml`<B val="state.val"/>`;
-    static components = { B };
-    state = useState({ val: 1 });
-    setup() {
-      useLogLifecycle();
-    }
-  }
-  const parent = await mount(A, fixture);
-  expect(fixture.innerHTML).toBe("C1");
-  expect([
-    "A:setup",
-    "A:willStart",
-    "A:willRender",
-    "B:setup",
-    "B:willStart",
-    "A:rendered",
-    "B:willRender",
-    "C:setup",
-    "C:willStart",
-    "B:rendered",
-    "C:willRender",
-    "C:rendered",
-    "C:mounted",
-    "B:mounted",
-    "A:mounted",
-  ]).toBeLogged();
-
-  // trigger a new rendering, blocked in B
-  parent.state.val = 2;
-  await nextTick();
-  expect(["A:willRender", "B:willUpdateProps", "A:rendered"]).toBeLogged();
-
-  // initiate a new render with deep=true. it should cancel the current render
-  // and also be blocked in B
-  parent.render(true);
-  await nextTick();
-  expect(["A:willRender", "B:willUpdateProps", "A:rendered"]).toBeLogged();
-
-  def.resolve();
-  await nextTick();
-  // we check here that the render reaches C (so, that it was properly forced)
-  expect([
-    "B:willRender",
-    "C:willUpdateProps",
-    "B:rendered",
-    "C:willRender",
-    "C:rendered",
-    "A:willPatch",
-    "B:willPatch",
-    "C:willPatch",
-    "C:patched",
-    "B:patched",
-    "A:patched",
-  ]).toBeLogged();
-});

tests/components/slots.test.ts

@@ -74,43 +74,6 @@ describe("slots", () => {
     expect(fixture.innerHTML).toBe("<span>other text</span>");
   });
 
-  test("simple named and empty slot", async () => {
-    class Child extends Component {
-      static template = xml`<span><t t-slot="default" /><t t-slot="myEmptySlot"/></span>`;
-
-      setup() {
-        expect(this.props.slots["myEmptySlot"]).toBeTruthy();
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`<Child>some text<t t-set-slot="myEmptySlot" /></Child>`;
-      static components = { Child };
-    }
-    await mount(Parent, fixture);
-
-    expect(fixture.innerHTML).toBe("<span>some text</span>");
-  });
-
-  test("simple named and empty slot -- 2", async () => {
-    class Child extends Component {
-      static template = xml`<span><t t-slot="myEmptySlot">default empty</t></span>`;
-
-      setup() {
-        expect(this.props.slots["myEmptySlot"]).toBeTruthy();
-        expect(this.props.slots["myEmptySlot"].myProp).toBe("myProp text");
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`<Child><t t-set-slot="myEmptySlot" myProp="'myProp text'" /></Child>`;
-      static components = { Child };
-    }
-    await mount(Parent, fixture);
-
-    expect(fixture.innerHTML).toBe("<span>default empty</span>");
-  });
-
   test("default slot with slot scope: shorthand syntax", async () => {
     let child: any;
     class Child extends Component {
@@ -1712,60 +1675,4 @@ describe("slots", () => {
     await mount(Parent, fixture);
     expect(fixture.innerHTML).toBe("<div>SlotDisplay</div><div>Parent</div>");
   });
-
-  test("mix of slots, t-call, t-call with body, and giving own props child", async () => {
-    expect.assertions(11);
-
-    class C extends Component {
-      static template = xml`[C]<t t-slot="default" />`;
-    }
-    class B extends Component {
-      static template = xml`[B]<C slots="props.slots" />`;
-      static components = { C };
-    }
-
-    const subTemplate2 = xml`[sub2<t t-esc="v"/>]`;
-    const subTemplate1 = xml`[sub1]
-      <t t-set="dummy" t-value="validate"/>
-      <t t-call="${subTemplate2}">
-        <t t-set="v" t-value="props.number"/>
-      </t>`;
-
-    let a: any;
-    class A extends Component {
-      static components = { B };
-      static template = xml`<B>[A]<t t-call="${subTemplate1}"/></B>`;
-      setup() {
-        a = this;
-      }
-
-      get validate() {
-        // we check here that the actual component was not lost somehow
-        expect(this.__owl__.component === a).toBe(true);
-        return 1;
-      }
-    }
-
-    class P extends Component {
-      static components = { A };
-      static template = xml`<button t-on-click="inc">inc</button><A number="state.number"/>`;
-
-      state = useState({ number: 333 });
-      inc() {
-        this.state.number++;
-      }
-    }
-
-    class Parent extends Component {
-      static template = xml`<P/>`;
-      static components = { P };
-    }
-
-    await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("<button>inc</button>[B][C][A][sub1] [sub2333]");
-
-    fixture.querySelector("button")!.click();
-    await nextTick();
-    expect(fixture.innerHTML).toBe("<button>inc</button>[B][C][A][sub1] [sub2334]");
-  });
 });

tests/components/t_on.test.ts

@@ -142,107 +142,4 @@ describe("t-on", () => {
     buttons[1].click();
     expect(comp.otherState.vals).toStrictEqual(["0_0", "1_1"]);
   });
-
-  test("t-on on components", async () => {
-    class Child extends Component {
-      static template = xml`<button t-esc="props.value"/>`;
-    }
-
-    class Parent extends Component {
-      static template = xml`<Child t-on-click="increment" value="state.value"/>`;
-      static components = { Child };
-      state = useState({ value: 1 });
-      increment() {
-        this.state.value++;
-      }
-    }
-    await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("<button>1</button>");
-    fixture.querySelector("button")!.click();
-    await nextTick();
-    expect(fixture.innerHTML).toBe("<button>2</button>");
-  });
-
-  test("t-on on components, variation", async () => {
-    class Child extends Component {
-      static template = xml`<button t-esc="props.value"/>`;
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        <div>
-          <span/>
-          <Child t-on-click="increment" value="state.value"/>
-          <p/>
-        </div>`;
-      static components = { Child };
-      state = useState({ value: 1 });
-      increment() {
-        this.state.value++;
-      }
-    }
-    await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("<div><span></span><button>1</button><p></p></div>");
-
-    fixture.querySelector("span")!.click();
-    await nextTick();
-    expect(fixture.innerHTML).toBe("<div><span></span><button>1</button><p></p></div>");
-
-    fixture.querySelector("button")!.click();
-    await nextTick();
-    expect(fixture.innerHTML).toBe("<div><span></span><button>2</button><p></p></div>");
-
-    fixture.querySelector("p")!.click();
-    await nextTick();
-    expect(fixture.innerHTML).toBe("<div><span></span><button>2</button><p></p></div>");
-  });
-
-  test("t-on on t-slots", async () => {
-    class Child extends Component {
-      static template = xml`
-        [<t t-esc="state.count"/>]
-        <t t-slot="default" t-on-click="() => this.state.count++"/>`;
-
-      state = useState({ count: 0 });
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        <Child>
-          <p>something</p>
-        </Child>`;
-      static components = { Child };
-    }
-
-    await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe(" [0] <p>something</p>");
-    fixture.querySelector("p")!.click();
-    await nextTick();
-    expect(fixture.innerHTML).toBe(" [1] <p>something</p>");
-  });
-
-  test("t-on on t-set-slots", async () => {
-    class Child extends Component {
-      static template = xml`<t t-slot="myslot"/>`;
-    }
-
-    class Parent extends Component {
-      static template = xml`
-        [<t t-esc="state.count"/>]
-        <Child>
-          <t t-set-slot="myslot" t-on-click="() => this.state.count++">
-            <p>something</p>
-            <p>paragraph</p>
-          </t>
-        </Child>`;
-      static components = { Child };
-      state = useState({ count: 0 });
-    }
-
-    await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe(" [0] <p>something</p><p>paragraph</p>");
-    fixture.querySelector("p")!.click();
-    await nextTick();
-    expect(fixture.innerHTML).toBe(" [1] <p>something</p><p>paragraph</p>");
-  });
 });

tests/components/t_props.test.ts

@@ -53,7 +53,7 @@ describe("t-props", () => {
   });
 
   test("basic use", async () => {
-    expect.assertions(5);
+    expect.assertions(4);
 
     let props = { a: 1, b: 2 };
 
@@ -65,7 +65,6 @@ describe("t-props", () => {
         `;
       setup() {
         expect(this.props).toEqual({ a: 1, b: 2 });
-        expect(this.props).not.toBe(props);
       }
     }
     class Parent extends Component {

tests/helpers.ts

@@ -15,11 +15,10 @@ import {
   useComponent,
   xml,
 } from "../src";
-import { helpers } from "../src/app/template_helpers";
-import { TemplateSet } from "../src/app/template_set";
+import { UTILS } from "../src/app/template_helpers";
+import { globalTemplates, TemplateSet } from "../src/app/template_set";
 import { BDom } from "../src/blockdom";
 import { compile } from "../src/compiler";
-import { globalTemplates } from "../src/utils";
 
 const mount = blockDom.mount;
 
@@ -49,7 +48,7 @@ export async function nextTick(): Promise<void> {
 
 interface Deferred extends Promise<any> {
   resolve(val?: any): void;
-  reject(val?: any): void;
+  reject(): void;
 }
 
 export function makeDeferred(): Deferred {
@@ -92,7 +91,7 @@ export function renderToBdom(template: string, context: any = {}, node?: any): B
     snapshottedTemplates.add(template);
     expect(fn.toString()).toMatchSnapshot();
   }
-  return fn(blockDom, helpers)(context, node);
+  return fn(blockDom, UTILS)(context, node);
 }
 
 export function renderToString(template: string, context: any = {}, node?: any): string {

tests/misc/__snapshots__/memo.test.ts.snap

@@ -0,0 +1,68 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Memo if no prop change, prevent renderings from above  1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  function slot1(ctx, node, key = \\"\\") {
+    let b6 = text(ctx['state'].a);
+    let b7 = text(ctx['state'].b);
+    let b8 = text(ctx['state'].c);
+    return multi([b6, b7, b8]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = text(ctx['state'].a);
+    let b3 = text(ctx['state'].b);
+    let b4 = text(ctx['state'].c);
+    let b9 = component(\`Memo\`, {a: ctx['state'].a, b: ctx['state'].b,slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    return multi([b2, b3, b4, b9]);
+  }
+}"
+`;
+
+exports[`Memo if no props, prevent renderings from above  1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  function slot1(ctx, node, key = \\"\\") {
+    return component(\`Child\`, {value: ctx['state'].value}, key + \`__2\`, node, ctx);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = component(\`Child\`, {value: ctx['state'].value}, key + \`__1\`, node, ctx);
+    let b4 = component(\`Memo\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__3\`, node, ctx);
+    return multi([b2, b4]);
+  }
+}"
+`;
+
+exports[`Memo if no props, prevent renderings from above  2`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(ctx['props'].value);
+  }
+}"
+`;
+
+exports[`Memo if no props, prevent renderings from above (work with simple html)  1`] = `
+"function anonymous(bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
+  
+  function slot1(ctx, node, key = \\"\\") {
+    return text(ctx['state'].value);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2 = text(ctx['state'].value);
+    let b4 = component(\`Memo\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    return multi([b2, b4]);
+  }
+}"
+`;

tests/misc/__snapshots__/portal.test.ts.snap

@@ -7,18 +7,18 @@ exports[`Portal Add and remove portals 1`] = `
   let { prepareList, Portal, capture, withKey } = helpers;
   
   function slot1(ctx, node, key = \\"\\") {
-    const b3 = text(\` Portal\`);
-    const b4 = text(ctx['portalId']);
+    let b3 = text(\` Portal\`);
+    let b4 = text(ctx['portalId']);
     return multi([b3, b4]);
   }
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`portalId\`] = v_block1[i1];
-      const key1 = ctx['portalId'];
-      const ctx1 = capture(ctx);;
+      let key1 = ctx['portalId'];
+      const ctx1 = capture(ctx);
       c_block1[i1] = withKey(component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
@@ -41,11 +41,11 @@ exports[`Portal Add and remove portals on div 1`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`portalId\`] = v_block1[i1];
-      const key1 = ctx['portalId'];
-      const ctx1 = capture(ctx);;
+      let key1 = ctx['portalId'];
+      const ctx1 = capture(ctx);
       c_block1[i1] = withKey(component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
     return list(c_block1);
@@ -62,20 +62,20 @@ exports[`Portal Add and remove portals with t-foreach 1`] = `
   let block2 = createBlock(\`<div><block-text-0/><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    const b4 = text(\` Portal\`);
-    const b5 = text(ctx['portalId']);
+    let b4 = text(\` Portal\`);
+    let b5 = text(ctx['portalId']);
     return multi([b4, b5]);
   }
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`portalId\`] = v_block1[i1];
-      const key1 = ctx['portalId'];
+      let key1 = ctx['portalId'];
       let txt1 = ctx['portalId'];
-      const ctx1 = capture(ctx);;
-      const b6 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
+      const ctx1 = capture(ctx);
+      let b6 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
       c_block1[i1] = withKey(block2([txt1], [b6]), key1);
     }
     return list(c_block1);
@@ -92,20 +92,20 @@ exports[`Portal Add and remove portals with t-foreach and destroy 1`] = `
   let block2 = createBlock(\`<div><block-text-0/><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    const b4 = text(\` Portal\`);
-    const b5 = text(ctx['portalId']);
+    let b4 = text(\` Portal\`);
+    let b5 = text(ctx['portalId']);
     return multi([b4, b5]);
   }
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);;
+    const [k_block1, v_block1, l_block1, c_block1] = prepareList(ctx['portalIds']);
     for (let i1 = 0; i1 < l_block1; i1++) {
       ctx[\`portalId\`] = v_block1[i1];
-      const key1 = ctx['portalId'];
+      let key1 = ctx['portalId'];
       let txt1 = ctx['portalId'];
-      const ctx1 = capture(ctx);;
-      const b6 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
+      const ctx1 = capture(ctx);
+      let b6 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
       c_block1[i1] = withKey(block2([txt1], [b6]), key1);
     }
     return list(c_block1);
@@ -123,23 +123,23 @@ exports[`Portal Add and remove portals with t-foreach inside div 1`] = `
   let block3 = createBlock(\`<div><block-text-0/><block-child-0/></div>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    const b5 = text(\` Portal\`);
-    const b6 = text(ctx['portalId']);
+    let b5 = text(\` Portal\`);
+    let b6 = text(ctx['portalId']);
     return multi([b5, b6]);
   }
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['portalIds']);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['portalIds']);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`portalId\`] = v_block2[i1];
-      const key1 = ctx['portalId'];
+      let key1 = ctx['portalId'];
       let txt1 = ctx['portalId'];
-      const ctx1 = capture(ctx);;
-      const b7 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
+      const ctx1 = capture(ctx);
+      let b7 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx);
       c_block2[i1] = withKey(block3([txt1], [b7]), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -149,7 +149,6 @@ exports[`Portal Portal composed with t-slot 1`] = `
 "function anonymous(bdom, helpers
 ) {
   let { text, createBlock, list, multi, html, toggler, component, comment } = bdom;
-  let { markRaw } = helpers;
   
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
@@ -158,7 +157,7 @@ exports[`Portal Portal composed with t-slot 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(\`Child\`, {slots: markRaw({'default': {__render: slot1, __ctx: ctx}})}, key + \`__2\`, node, ctx);
+    let b3 = component(\`Child\`, {slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -171,7 +170,7 @@ exports[`Portal Portal composed with t-slot 2`] = `
   let { Portal, callSlot } = helpers;
   
   function slot1(ctx, node, key = \\"\\") {
-    return callSlot(ctx, node, key, 'default', false, null);
+    return callSlot(ctx, node, key, 'default', false, {});
   }
   
   return function template(ctx, node, key = \\"\\") {
@@ -208,7 +207,7 @@ exports[`Portal basic use of portal 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -228,7 +227,7 @@ exports[`Portal basic use of portal in dev mode 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -248,7 +247,7 @@ exports[`Portal basic use of portal on div 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -345,14 +344,14 @@ exports[`Portal conditional use of Portal with child and div 2`] = `
   
   return function template(ctx, node, key = \\"\\") {
     ctx = Object.create(ctx);
-    const [k_block2, v_block2, l_block2, c_block2] = prepareList([1]);;
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([1]);
     for (let i1 = 0; i1 < l_block2; i1++) {
       ctx[\`elem\`] = v_block2[i1];
-      const key1 = ctx['elem'];
-      const ctx1 = capture(ctx);;
+      let key1 = ctx['elem'];
+      const ctx1 = capture(ctx);
       c_block2[i1] = withKey(component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
-    const b2 = list(c_block2);
+    let b2 = list(c_block2);
     return block1([], [b2]);
   }
 }"
@@ -368,7 +367,7 @@ exports[`Portal conditional use of Portal with child and div, variation 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasPortal) {
-      const b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
+      let b3 = component(\`Child\`, {}, key + \`__1\`, node, ctx);
       b2 = block2([], [b3]);
     }
     return multi([b2]);
@@ -390,16 +389,16 @@ exports[`Portal conditional use of Portal with child and div, variation 2`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = block2();
+    let b2 = block2();
     ctx = Object.create(ctx);
-    const [k_block3, v_block3, l_block3, c_block3] = prepareList([1]);;
+    const [k_block3, v_block3, l_block3, c_block3] = prepareList([1]);
     for (let i1 = 0; i1 < l_block3; i1++) {
       ctx[\`elem\`] = v_block3[i1];
-      const key1 = ctx['elem'];
-      const ctx1 = capture(ctx);;
+      let key1 = ctx['elem'];
+      const ctx1 = capture(ctx);
       c_block3[i1] = withKey(component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx1}}}, key + \`__1__\${key1}\`, node, ctx), key1);
     }
-    const b3 = list(c_block3);
+    let b3 = list(c_block3);
     return multi([b2, b3]);
   }
 }"
@@ -421,7 +420,7 @@ exports[`Portal conditional use of Portal with div 1`] = `
   return function template(ctx, node, key = \\"\\") {
     let b2;
     if (ctx['state'].hasPortal) {
-      const b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+      let b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
       b2 = block2([], [b4]);
     }
     return multi([b2]);
@@ -484,7 +483,7 @@ exports[`Portal portal could have dynamically no content 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b4]);
   }
 }"
@@ -503,7 +502,7 @@ exports[`Portal portal destroys on crash 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -536,7 +535,7 @@ exports[`Portal portal with child and props 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -578,7 +577,7 @@ exports[`Portal portal with dynamic body 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b5 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b5 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -595,13 +594,13 @@ exports[`Portal portal with many children 1`] = `
   let block4 = createBlock(\`<p>2</p>\`);
   
   function slot1(ctx, node, key = \\"\\") {
-    const b3 = block3();
-    const b4 = block4();
+    let b3 = block3();
+    let b4 = block4();
     return multi([b3, b4]);
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b5 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b5 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b5]);
   }
 }"
@@ -624,7 +623,7 @@ exports[`Portal portal with no content 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b4 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b4]);
   }
 }"
@@ -643,7 +642,7 @@ exports[`Portal portal with only text as content 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -663,7 +662,7 @@ exports[`Portal portal with target not in dom 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#does-not-exist',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: '#does-not-exist',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -682,7 +681,7 @@ exports[`Portal portal's parent's env is not polluted 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -735,7 +734,7 @@ exports[`Portal simple catchError with portal 2`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -755,7 +754,7 @@ exports[`Portal with target in template (after portal) 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#local-target',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: '#local-target',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -775,7 +774,7 @@ exports[`Portal with target in template (before portal) 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#local-target',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: '#local-target',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -795,7 +794,7 @@ exports[`Portal: Props validation target must be a valid selector 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: ' ',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: ' ',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -815,7 +814,7 @@ exports[`Portal: Props validation target must be a valid selector 2 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: 'aa',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
+    let b3 = component(Portal, {target: 'aa',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__1\`, node, ctx);
     return block1([], [b3]);
   }
 }"
@@ -834,7 +833,7 @@ exports[`Portal: UI/UX focus is kept across re-renders 1`] = `
   }
   
   return function template(ctx, node, key = \\"\\") {
-    const b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
+    let b3 = component(Portal, {target: '#outside',slots: {'default': {__render: slot1, __ctx: ctx}}}, key + \`__2\`, node, ctx);
     return block1([], [b3]);
   }
 }"

tests/misc/memo.test.ts

@@ -0,0 +1,92 @@
+import { Component, mount, useState, xml } from "../../src";
+import { Memo } from "../../src/";
+import { makeTestFixture, nextTick, snapshotEverything } from "../helpers";
+
+let fixture: HTMLElement;
+
+snapshotEverything();
+
+beforeEach(() => {
+  fixture = makeTestFixture();
+});
+
+describe("Memo", () => {
+  test("if no props, prevent renderings from above ", async () => {
+    class Child extends Component {
+      static template = xml`<t t-esc="props.value"/>`;
+    }
+    class Test extends Component {
+      static template = xml`
+              <Child value="state.value"/>
+              <Memo> 
+                  <Child value="state.value"/>
+              </Memo>`;
+
+      static components = { Memo, Child };
+
+      state = useState({ value: 1 });
+    }
+
+    const component = await mount(Test, fixture);
+
+    expect(fixture.innerHTML).toBe("11");
+    component.state.value = 2;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("21");
+  });
+
+  test("if no props, prevent renderings from above (work with simple html) ", async () => {
+    class Test extends Component {
+      static template = xml`
+              <t t-esc="state.value"/>
+              <Memo> 
+                  <t t-esc="state.value"/>
+              </Memo>`;
+
+      static components = { Memo };
+
+      state = useState({ value: 1 });
+    }
+
+    const component = await mount(Test, fixture);
+
+    expect(fixture.innerHTML).toBe("11");
+    component.state.value = 2;
+    await nextTick();
+    expect(fixture.innerHTML).toBe("21");
+  });
+
+  test("if no prop change, prevent renderings from above ", async () => {
+    class Child extends Component {
+      static template = xml`<t t-esc="props.value"/>`;
+    }
+
+    class Test extends Component {
+      static template = xml`
+              <t t-esc="state.a"/>
+              <t t-esc="state.b"/>
+              <t t-esc="state.c"/>
+              <Memo a="state.a" b="state.b"> 
+                <t t-esc="state.a"/>
+                <t t-esc="state.b"/>
+                <t t-esc="state.c"/>
+              </Memo>`;
+
+      static components = { Memo, Child };
+
+      state = useState({ a: "a", b: "b", c: "c" });
+    }
+
+    const component = await mount(Test, fixture);
+
+    expect(fixture.innerHTML).toBe("abcabc");
+
+    component.state.c = "C";
+    await nextTick();
+    expect(fixture.innerHTML).toBe("abCabc");
+
+    component.state.a = "A";
+    await nextTick();
+    expect(fixture.innerHTML).toBe("AbCAbC");
+  });
+});

tests/misc/portal.test.ts

@@ -421,7 +421,6 @@ describe("Portal", () => {
     addOutsideDiv(fixture);
     const parent = await mount(Parent, fixture);
     expect(steps).toEqual(["parent:mounted"]);
-    expect(fixture.innerHTML).toBe('<div id="outside"></div><div></div>');
 
     parent.state.hasChild = true;
     await nextTick();
@@ -431,7 +430,6 @@ describe("Portal", () => {
       "child:mounted",
       "parent:patched",
     ]);
-    expect(fixture.innerHTML).toBe('<div id="outside"><span>1</span></div><div></div>');
 
     parent.state.val = 2;
     await nextTick();
@@ -445,7 +443,6 @@ describe("Portal", () => {
       "child:patched",
       "parent:patched",
     ]);
-    expect(fixture.innerHTML).toBe('<div id="outside"><span>2</span></div><div></div>');
 
     parent.state.hasChild = false;
     await nextTick();
@@ -462,7 +459,6 @@ describe("Portal", () => {
       "child:willUnmount",
       "parent:patched",
     ]);
-    expect(fixture.innerHTML).toBe('<div id="outside"></div><div></div>');
   });
 
   test("portal destroys on crash", async () => {

tests/reactivity.test.ts

@@ -171,8 +171,6 @@ describe("Reactivity", () => {
     expect(n).toBe(2);
   });
 
-  // Skipped because the hasOwnProperty trap is tripped by *writing*. We
-  // (probably) do not want to subscribe to changes on writes.
   test.skip("hasOwnProperty causes the key's presence to be observed", async () => {
     let n = 0;
     const state = createReactive({}, () => n++);
@@ -208,46 +206,6 @@ describe("Reactivity", () => {
     expect(n).toBe(1); // two operations but only one notification
   });
 
-  test("batched: modifying the reactive in the callback doesn't break reactivity", async () => {
-    let n = 0;
-    let obj = { a: 1 };
-    const state = createReactive(
-      obj,
-      batched(() => {
-        state.a; // subscribe to a
-        state.a = 2;
-        n++;
-      })
-    );
-    expect(n).toBe(0);
-    state.a = 2;
-    expect(n).toBe(0);
-    await nextMicroTick();
-    expect(n).toBe(0); // key has not be read yet
-    state.a = state.a + 5; // key is read and then modified
-    expect(n).toBe(0);
-    await nextMicroTick();
-    expect(n).toBe(1);
-    // the write a = 2 inside the batched callback triggered another notification, wait for it
-    await nextMicroTick();
-    expect(n).toBe(2);
-    // Should now be stable as we're writing the same value again
-    await nextMicroTick();
-    expect(n).toBe(2);
-
-    // Do it again to check it's not broken
-    state.a = state.a + 5; // key is read and then modified
-    expect(n).toBe(2);
-    await nextMicroTick();
-    expect(n).toBe(3);
-    // the write a = 2 inside the batched callback triggered another notification, wait for it
-    await nextMicroTick();
-    expect(n).toBe(4);
-    // Should now be stable as we're writing the same value again
-    await nextMicroTick();
-    expect(n).toBe(4);
-  });
-
   test("setting property to same value does not trigger callback", async () => {
     let n = 0;
     const state = createReactive({ a: 1 }, () => n++);
@@ -1136,545 +1094,17 @@ describe("Reactivity", () => {
     expect(state.k).toEqual({ n: 2 });
   });
 
-  test("can access properties on reactive of frozen objects", async () => {
-    const obj = Object.freeze({ a: {} });
-    const state = createReactive(obj);
-    expect(() => state.a).not.toThrow();
-    expect(state.a).toBe(obj.a);
-  });
-});
+  test("can add collections set/weakset/map/weakmap in a reactive object", () => {
+    const rawSet = new Set();
+    const rawWeakSet = new WeakSet();
+    const rawMap = new Map();
+    const rawWeakMap = new WeakMap();
 
-describe("Collections", () => {
-  describe("Set", () => {
-    test("can make reactive Set", () => {
-      const set = new Set<number>();
-      const obj = reactive(set);
-      expect(obj).not.toBe(set);
-    });
-
-    test("can read", async () => {
-      const state = reactive(new Set([1]));
-      expect(state.has(1)).toBe(true);
-      expect(state.has(0)).toBe(false);
-    });
-
-    test("can add entries", () => {
-      const state = reactive(new Set());
-      state.add(1);
-      expect(state.has(1)).toBe(true);
-    });
-
-    test("can remove entries", () => {
-      const state = reactive(new Set([1]));
-      state.delete(1);
-      expect(state.has(1)).toBe(false);
-    });
-
-    test("can clear entries", () => {
-      const state = reactive(new Set([1]));
-      expect(state.size).toBe(1);
-      state.clear();
-      expect(state.size).toBe(0);
-    });
-
-    test("act like a Set", () => {
-      const state = reactive(new Set([1]));
-      expect([...state.entries()]).toEqual([[1, 1]]);
-      expect([...state.values()]).toEqual([1]);
-      expect([...state.keys()]).toEqual([1]);
-      expect([...state]).toEqual([1]); // Checks Symbol.iterator
-      expect(state.size).toBe(1);
-      expect(typeof state).toBe("object");
-      expect(state).toBeInstanceOf(Set);
-    });
-
-    test("reactive Set contains its keys", () => {
-      const state = reactive(new Set([{}]));
-      expect(state.has(state.keys().next().value)).toBe(true);
-    });
-
-    test("reactive Set contains its values", () => {
-      const state = reactive(new Set([{}]));
-      expect(state.has(state.values().next().value)).toBe(true);
-    });
-
-    test("reactive Set contains its entries' keys and values", () => {
-      const state = reactive(new Set([{}]));
-      const [key, val] = state.entries().next().value;
-      expect(state.has(key)).toBe(true);
-      expect(state.has(val)).toBe(true);
-    });
-
-    test("checking for a key subscribes the callback to changes to that key", () => {
-      const observer = jest.fn();
-      const state = reactive(new Set([1]), observer);
-
-      expect(state.has(2)).toBe(false); // subscribe to 2
-      expect(observer).toHaveBeenCalledTimes(0);
-      state.add(2);
-      expect(observer).toHaveBeenCalledTimes(1);
-      expect(state.has(2)).toBe(true); // subscribe to 2
-      state.delete(2);
-      expect(observer).toHaveBeenCalledTimes(2);
-      state.add(2);
-      expect(state.has(2)).toBe(true); // subscribe to 2
-      state.clear();
-      expect(observer).toHaveBeenCalledTimes(3);
-      expect(state.has(2)).toBe(false); // subscribe to 2
-      state.clear(); // clearing again doesn't notify again
-      expect(observer).toHaveBeenCalledTimes(3);
-
-      state.add(3); // setting unobserved key doesn't notify
-      expect(observer).toHaveBeenCalledTimes(3);
-    });
-
-    test("iterating on keys returns reactives", async () => {
-      const obj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Set([obj]), observer);
-      const reactiveObj = state.keys().next().value;
-      expect(reactiveObj).not.toBe(obj);
-      expect(toRaw(reactiveObj as any)).toBe(obj);
-      reactiveObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveObj.a; // observe key "a" in sub-reactive;
-      reactiveObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveObj.a = 1; // setting same value again shouldn't notify
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    test("iterating on values returns reactives", async () => {
-      const obj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Set([obj]), observer);
-      const reactiveObj = state.values().next().value;
-      expect(reactiveObj).not.toBe(obj);
-      expect(toRaw(reactiveObj as any)).toBe(obj);
-      reactiveObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveObj.a; // observe key "a" in sub-reactive;
-      reactiveObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveObj.a = 1; // setting same value again shouldn't notify
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    test("iterating on entries returns reactives", async () => {
-      const obj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Set([obj]), observer);
-      const [reactiveObj, reactiveObj2] = state.entries().next().value;
-      expect(reactiveObj2).toBe(reactiveObj);
-      expect(reactiveObj).not.toBe(obj);
-      expect(toRaw(reactiveObj as any)).toBe(obj);
-      reactiveObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveObj.a; // observe key "a" in sub-reactive;
-      reactiveObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveObj.a = 1; // setting same value again shouldn't notify
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    test("iterating on reactive Set returns reactives", async () => {
-      const obj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Set([obj]), observer);
-      const reactiveObj = state[Symbol.iterator]().next().value;
-      expect(reactiveObj).not.toBe(obj);
-      expect(toRaw(reactiveObj as any)).toBe(obj);
-      reactiveObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveObj.a; // observe key "a" in sub-reactive;
-      reactiveObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveObj.a = 1; // setting same value again shouldn't notify
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    test("iterating with forEach returns reactives", async () => {
-      const keyObj = { a: 2 };
-      const thisArg = {};
-      const observer = jest.fn();
-      const state = reactive(new Set([keyObj]), observer);
-      let reactiveKeyObj: any, reactiveValObj: any, thisObj: any, mapObj: any;
-      state.forEach(function (this: any, val, key, map) {
-        [reactiveValObj, reactiveKeyObj, mapObj, thisObj] = [val, key, map, this];
-      }, thisArg);
-      expect(reactiveKeyObj).not.toBe(keyObj);
-      expect(reactiveValObj).not.toBe(keyObj);
-      expect(mapObj).toBe(state); // third argument should be the reactive
-      expect(thisObj).toBe(thisArg); // thisArg should not be made reactive
-      expect(toRaw(reactiveKeyObj as any)).toBe(keyObj);
-      expect(toRaw(reactiveValObj as any)).toBe(keyObj);
-      expect(reactiveKeyObj).toBe(reactiveValObj); // reactiveKeyObj and reactiveValObj should be the same object
-      reactiveKeyObj!.a = 0;
-      reactiveValObj!.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveKeyObj!.a; // observe key "a" in key sub-reactive;
-      reactiveKeyObj!.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveKeyObj!.a = 1; // setting same value again shouldn't notify
-      reactiveValObj!.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("WeakSet", () => {
-    test("cannot make reactive WeakSet", () => {
-      const set = new WeakSet();
-      expect(() => reactive(set)).toThrowError("Cannot make the given value reactive");
-    });
-
-    test("WeakSet in reactive is original WeakSet", () => {
-      const obj = { set: new WeakSet() };
-      const state = reactive(obj);
-      expect(state.set).toBe(obj.set);
-    });
-  });
-
-  describe("Map", () => {
-    test("can make reactive Map", () => {
-      const map = new Map();
-      const obj = reactive(map);
-      expect(obj).not.toBe(map);
-    });
-
-    test("can read", async () => {
-      const state = reactive(new Map([[1, 0]]));
-      expect(state.has(1)).toBe(true);
-      expect(state.has(0)).toBe(false);
-      expect(state.get(1)).toBe(0);
-      expect(state.get(0)).toBeUndefined();
-    });
-
-    test("can add entries", () => {
-      const state = reactive(new Map());
-      state.set(1, 2);
-      expect(state.has(1)).toBe(true);
-      expect(state.get(1)).toBe(2);
-    });
-
-    test("can remove entries", () => {
-      const state = reactive(new Map([[1, 2]]));
-      state.delete(1);
-      expect(state.has(1)).toBe(false);
-      expect(state.get(1)).toBeUndefined();
-    });
-
-    test("can clear entries", () => {
-      const state = reactive(new Map([[1, 2]]));
-      expect(state.size).toBe(1);
-      state.clear();
-      expect(state.size).toBe(0);
-    });
-
-    test("act like a Map", () => {
-      const state = reactive(new Map([[1, 2]]));
-      expect([...state.entries()]).toEqual([[1, 2]]);
-      expect([...state.values()]).toEqual([2]);
-      expect([...state.keys()]).toEqual([1]);
-      expect([...state]).toEqual([[1, 2]]); // Checks Symbol.iterator
-      expect(state.size).toBe(1);
-      expect(typeof state).toBe("object");
-      expect(state).toBeInstanceOf(Map);
-    });
-
-    test("reactive Map contains its keys", () => {
-      const state = reactive(new Map([[{}, 1]]));
-      expect(state.has(state.keys().next().value)).toBe(true);
-    });
-
-    test("reactive Map values are equal to doing a get on the appropriate key", () => {
-      const state = reactive(new Map([[1, {}]]));
-      expect(state.get(1)).toBe(state.values().next().value);
-    });
-
-    test("reactive Map contains its entries' keys, and the associated value is the same as doing get", () => {
-      const state = reactive(new Map([[{}, {}]]));
-      const [key, val] = state.entries().next().value;
-      expect(state.has(key)).toBe(true);
-      expect(val).toBe(state.get(key));
-    });
-
-    test("checking for a key with 'has' subscribes the callback to changes to that key", () => {
-      const observer = jest.fn();
-      const state = reactive(new Map([[1, 2]]), observer);
-
-      expect(state.has(2)).toBe(false); // subscribe to 2
-      expect(observer).toHaveBeenCalledTimes(0);
-      state.set(2, 3);
-      expect(observer).toHaveBeenCalledTimes(1);
-      expect(state.has(2)).toBe(true); // subscribe to 2
-      state.delete(2);
-      expect(observer).toHaveBeenCalledTimes(2);
-      state.set(2, 3);
-      expect(state.has(2)).toBe(true); // subscribe to 2
-      state.clear();
-      expect(observer).toHaveBeenCalledTimes(3);
-      expect(state.has(2)).toBe(false); // subscribe to 2
-      state.clear(); // clearing again doesn't notify again
-      expect(observer).toHaveBeenCalledTimes(3);
-
-      state.set(3, 4); // setting unobserved key doesn't notify
-      expect(observer).toHaveBeenCalledTimes(3);
-    });
-
-    test("checking for a key with 'get' subscribes the callback to changes to that key", () => {
-      const observer = jest.fn();
-      const state = reactive(new Map([[1, 2]]), observer);
-
-      expect(state.get(2)).toBeUndefined(); // subscribe to 2
-      expect(observer).toHaveBeenCalledTimes(0);
-      state.set(2, 3);
-      expect(observer).toHaveBeenCalledTimes(1);
-      expect(state.get(2)).toBe(3); // subscribe to 2
-      state.delete(2);
-      expect(observer).toHaveBeenCalledTimes(2);
-      state.delete(2); // deleting again doesn't notify again
-      expect(observer).toHaveBeenCalledTimes(2);
-      state.set(2, 3);
-      expect(state.get(2)).toBe(3); // subscribe to 2
-      state.clear();
-      expect(observer).toHaveBeenCalledTimes(3);
-      expect(state.get(2)).toBeUndefined(); // subscribe to 2
-      state.clear(); // clearing again doesn't notify again
-      expect(observer).toHaveBeenCalledTimes(3);
-
-      state.set(3, 4); // setting unobserved key doesn't notify
-      expect(observer).toHaveBeenCalledTimes(3);
-    });
-
-    test("getting values returns a reactive", async () => {
-      const obj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Map([[1, obj]]), observer);
-      const reactiveObj = state.get(1)!;
-      expect(reactiveObj).not.toBe(obj);
-      expect(toRaw(reactiveObj as any)).toBe(obj);
-      reactiveObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveObj.a; // observe key "a" in sub-reactive;
-      reactiveObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveObj.a = 1; // setting same value again shouldn't notify
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    test("iterating on values returns reactives", async () => {
-      const obj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Map([[1, obj]]), observer);
-      const reactiveObj = state.values().next().value;
-      expect(reactiveObj).not.toBe(obj);
-      expect(toRaw(reactiveObj as any)).toBe(obj);
-      reactiveObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveObj.a; // observe key "a" in sub-reactive;
-      reactiveObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveObj.a = 1; // setting same value again shouldn't notify
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    test("iterating on keys returns reactives", async () => {
-      const obj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Map([[obj, 1]]), observer);
-      const reactiveObj = state.keys().next().value;
-      expect(reactiveObj).not.toBe(obj);
-      expect(toRaw(reactiveObj as any)).toBe(obj);
-      reactiveObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveObj.a; // observe key "a" in sub-reactive;
-      reactiveObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveObj.a = 1; // setting same value again shouldn't notify
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
-
-    test("iterating on reactive map returns reactives", async () => {
-      const keyObj = { a: 2 };
-      const valObj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Map([[keyObj, valObj]]), observer);
-      const [reactiveKeyObj, reactiveValObj] = state[Symbol.iterator]().next().value;
-      expect(reactiveKeyObj).not.toBe(keyObj);
-      expect(reactiveValObj).not.toBe(valObj);
-      expect(toRaw(reactiveKeyObj as any)).toBe(keyObj);
-      expect(toRaw(reactiveValObj as any)).toBe(valObj);
-      reactiveKeyObj.a = 0;
-      reactiveValObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveKeyObj.a; // observe key "a" in key sub-reactive;
-      reactiveKeyObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveValObj.a; // observe key "a" in val sub-reactive;
-      reactiveValObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(2);
-      reactiveKeyObj.a = 1; // setting same value again shouldn't notify
-      reactiveValObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(2);
-    });
-
-    test("iterating on entries returns reactives", async () => {
-      const keyObj = { a: 2 };
-      const valObj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new Map([[keyObj, valObj]]), observer);
-      const [reactiveKeyObj, reactiveValObj] = state.entries().next().value;
-      expect(reactiveKeyObj).not.toBe(keyObj);
-      expect(reactiveValObj).not.toBe(valObj);
-      expect(toRaw(reactiveKeyObj as any)).toBe(keyObj);
-      expect(toRaw(reactiveValObj as any)).toBe(valObj);
-      reactiveKeyObj.a = 0;
-      reactiveValObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveKeyObj.a; // observe key "a" in key sub-reactive;
-      reactiveKeyObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveValObj.a; // observe key "a" in val sub-reactive;
-      reactiveValObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(2);
-      reactiveKeyObj.a = 1; // setting same value again shouldn't notify
-      reactiveValObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(2);
-    });
-
-    test("iterating with forEach returns reactives", async () => {
-      const keyObj = { a: 2 };
-      const valObj = { a: 2 };
-      const thisArg = {};
-      const observer = jest.fn();
-      const state = reactive(new Map([[keyObj, valObj]]), observer);
-      let reactiveKeyObj: any, reactiveValObj: any, thisObj: any, mapObj: any;
-      state.forEach(function (this: any, val, key, map) {
-        [reactiveValObj, reactiveKeyObj, mapObj, thisObj] = [val, key, map, this];
-      }, thisArg);
-      expect(reactiveKeyObj).not.toBe(keyObj);
-      expect(reactiveValObj).not.toBe(valObj);
-      expect(mapObj).toBe(state); // third argument should be the reactive
-      expect(thisObj).toBe(thisArg); // thisArg should not be made reactive
-      expect(toRaw(reactiveKeyObj as any)).toBe(keyObj);
-      expect(toRaw(reactiveValObj as any)).toBe(valObj);
-      reactiveKeyObj!.a = 0;
-      reactiveValObj!.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveKeyObj!.a; // observe key "a" in key sub-reactive;
-      reactiveKeyObj!.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveValObj!.a; // observe key "a" in val sub-reactive;
-      reactiveValObj!.a = 1;
-      expect(observer).toHaveBeenCalledTimes(2);
-      reactiveKeyObj!.a = 1; // setting same value again shouldn't notify
-      reactiveValObj!.a = 1;
-      expect(observer).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe("WeakMap", () => {
-    test("can make reactive WeakMap", () => {
-      const map = new WeakMap();
-      const obj = reactive(map);
-      expect(obj).not.toBe(map);
-    });
-
-    test("can read", async () => {
-      const obj = {};
-      const obj2 = {};
-      const state = reactive(new WeakMap([[obj, 0]]));
-      expect(state.has(obj)).toBe(true);
-      expect(state.has(obj2)).toBe(false);
-      expect(state.get(obj)).toBe(0);
-      expect(state.get(obj2)).toBeUndefined();
-    });
-
-    test("can add entries", () => {
-      const obj = {};
-      const state = reactive(new WeakMap());
-      state.set(obj, 2);
-      expect(state.has(obj)).toBe(true);
-      expect(state.get(obj)).toBe(2);
-    });
-
-    test("can remove entries", () => {
-      const obj = {};
-      const state = reactive(new WeakMap([[obj, 2]]));
-      state.delete(obj);
-      expect(state.has(obj)).toBe(false);
-      expect(state.get(obj)).toBeUndefined();
-    });
-
-    test("act like a WeakMap", () => {
-      const obj = {};
-      const state = reactive(new WeakMap([[obj, 2]]));
-      expect(typeof state).toBe("object");
-      expect(state).toBeInstanceOf(WeakMap);
-    });
-
-    test("checking for a key with 'has' subscribes the callback to changes to that key", () => {
-      const observer = jest.fn();
-      const obj = {};
-      const obj2 = {};
-      const obj3 = {};
-      const state = reactive(new WeakMap([[obj2, 2]]), observer);
-
-      expect(state.has(obj)).toBe(false); // subscribe to obj
-      expect(observer).toHaveBeenCalledTimes(0);
-      state.set(obj, 3);
-      expect(observer).toHaveBeenCalledTimes(1);
-      expect(state.has(obj)).toBe(true); // subscribe to obj
-      state.delete(obj);
-      expect(observer).toHaveBeenCalledTimes(2);
-      state.set(obj, 3);
-      state.delete(obj);
-      expect(observer).toHaveBeenCalledTimes(2);
-      expect(state.has(obj)).toBe(false); // subscribe to obj
-
-      state.set(obj3, 4); // setting unobserved key doesn't notify
-      expect(observer).toHaveBeenCalledTimes(2);
-    });
-
-    test("checking for a key with 'get' subscribes the callback to changes to that key", () => {
-      const observer = jest.fn();
-      const obj = {};
-      const obj2 = {};
-      const obj3 = {};
-      const state = reactive(new WeakMap([[obj2, 2]]), observer);
-
-      expect(state.get(obj)).toBeUndefined(); // subscribe to obj
-      expect(observer).toHaveBeenCalledTimes(0);
-      state.set(obj, 3);
-      expect(observer).toHaveBeenCalledTimes(1);
-      expect(state.get(obj)).toBe(3); // subscribe to obj
-      state.delete(obj);
-      expect(observer).toHaveBeenCalledTimes(2);
-      state.set(obj, 3);
-      state.delete(obj);
-      expect(observer).toHaveBeenCalledTimes(2);
-      expect(state.get(obj)).toBeUndefined(); // subscribe to obj
-
-      state.set(obj3, 4); // setting unobserved key doesn't notify
-      expect(observer).toHaveBeenCalledTimes(2);
-    });
-
-    test("getting values returns a reactive", async () => {
-      const keyObj = {};
-      const valObj = { a: 2 };
-      const observer = jest.fn();
-      const state = reactive(new WeakMap([[keyObj, valObj]]), observer);
-      const reactiveObj = state.get(keyObj)!;
-      expect(reactiveObj).not.toBe(valObj);
-      expect(toRaw(reactiveObj as any)).toBe(valObj);
-      reactiveObj.a = 0;
-      expect(observer).toHaveBeenCalledTimes(0);
-      reactiveObj.a; // observe key "a" in sub-reactive;
-      reactiveObj.a = 1;
-      expect(observer).toHaveBeenCalledTimes(1);
-      reactiveObj.a = 1; // setting same value again shouldn't notify
-      expect(observer).toHaveBeenCalledTimes(1);
-    });
+    const obj = reactive({ rawSet, rawWeakSet, rawMap, rawWeakMap });
+    expect(obj.rawSet).toBe(rawSet);
+    expect(obj.rawWeakSet).toBe(rawWeakSet);
+    expect(obj.rawMap).toBe(rawMap);
+    expect(obj.rawWeakMap).toBe(rawWeakMap);
   });
 });
 
@@ -2227,7 +1657,7 @@ describe("Reactivity: useState", () => {
     expect([...steps]).toEqual(["list"]);
     await nextTick();
     expect(fixture.innerHTML).toBe("<div><div>3</div> Total: 3 Count: 1</div>");
-    expect([...steps]).toEqual(["list"]);
+    expect([...steps]).toEqual(["list", "quantity1"]);
     steps.clear();
 
     secondQuantity.quantity = 2;

tests/utils.test.ts

@@ -50,24 +50,4 @@ describe("batched", () => {
     await nextMicroTick();
     expect(n).toBe(1);
   });
-
-  test("calling batched function from within the callback is not treated as part of the original batch", async () => {
-    let n = 0;
-    let fn = batched(() => {
-      n++;
-      if (n === 1) {
-        fn();
-      }
-    });
-
-    expect(n).toBe(0);
-    fn();
-    expect(n).toBe(0);
-    await nextMicroTick(); // First batch
-    expect(n).toBe(1);
-    await nextMicroTick(); // Second batch initiated from within the callback
-    expect(n).toBe(2);
-    await nextMicroTick();
-    expect(n).toBe(2);
-  });
 });

tools/playground/samples.js

@@ -24,7 +24,8 @@ class Root extends Component {
     }
 }
 
-mount(Root, document.body, { templates: TEMPLATES, dev: true });`;
+// dev=false for benchmarking. we don't want to benchmark dev code!
+mount(Root, document.body, { templates: TEMPLATES, dev: false });`;
 
 const COMPONENTS_XML = /*xml*/`
 <templates>
@@ -933,7 +934,7 @@ const env = {
   ui: createUI()
 };
 
-mount(Root, document.body, { templates: TEMPLATES, env, dev: true });
+mount(Root, document.body, { templates: TEMPLATES, env });
 `;
 
 const RESPONSIVE_XML = /*xml*/`
@@ -1740,8 +1741,7 @@ class Root extends Component {
 }
 
 
-// dev=false for benchmarking. we don't want to benchmark dev code!
-mount(Root, document.body, { templates: TEMPLATES, dev: false });
+mount(Root, document.body, { templates: TEMPLATES, dev: true });
 
 `;
 

tools/release.js

@@ -106,7 +106,7 @@ async function startRelease() {
   // ---------------------------------------------------------------------------
 
   log(`Step 7/${STEPS}: Creating the release...`);
-  const relaseResult = await execCommand(`gh release create v${next} dist/*.js ${draft} -F ${REL_NOTES_FILE}`);
+  const relaseResult = await execCommand(`gh release create v${next} dist/*.js ${draft} -F release-notes.md`);
   if (relaseResult !== 0) {
     logError("github release failed. Aborting.");
     return;