wip

src/runtime/app.ts

@@ -3,7 +3,6 @@ import { ComponentNode } from "./component_node";
 import { nodeErrorHandlers } from "./error_handling";
 import { Fiber, MountOptions } from "./fibers";
 import { Scheduler } from "./scheduler";
-import { STATUS } from "./status";
 import { validateProps } from "./template_helpers";
 import { TemplateSet, TemplateSetConfig } from "./template_set";
 import { validateTarget } from "./utils";
@@ -141,10 +140,7 @@ export class App<
     return (props: P, key: string, ctx: ComponentNode, parent: any, C: any) => {
       let children = ctx.children;
       let node: any = children[key];
-      if (
+      if (isDynamic && node && node.component.constructor !== C) {
-        node &&
-        (node.status === STATUS.DESTROYED || (isDynamic && node.component.constructor !== C))
-      ) {
         node = undefined;
       }
       const parentFiber = ctx.fiber!;

src/runtime/component_node.ts

@@ -12,7 +12,7 @@ import {
   TARGET,
 } from "./reactivity";
 import { STATUS } from "./status";
-import { batched, Callback } from "./utils";
+import { Callback } from "./utils";
 
 let currentNode: ComponentNode | null = null;
 
@@ -41,7 +41,7 @@ function applyDefaultProps<P extends object>(props: P, defaultProps: Partial<P>)
 // Integration with reactivity system (useState)
 // -----------------------------------------------------------------------------
 
-const batchedRenderFunctions = new WeakMap<ComponentNode, Callback>();
+const renderFunctions = 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
@@ -54,10 +54,10 @@ const batchedRenderFunctions = new WeakMap<ComponentNode, Callback>();
  */
 export function useState<T extends object>(state: T): Reactive<T> | NonReactive<T> {
   const node = getCurrent();
-  let render = batchedRenderFunctions.get(node)!;
+  let render = renderFunctions.get(node)!;
   if (!render) {
-    render = batched(node.render.bind(node, false));
+    render = node.render.bind(node, false);
-    batchedRenderFunctions.set(node, render);
+    renderFunctions.set(node, render);
     // manual implementation of onWillDestroy to break cyclic dependency
     node.willDestroy.push(clearReactivesForCallback.bind(null, render));
   }
@@ -140,11 +140,22 @@ export class ComponentNode<P extends Props = any, E = any> implements VNode<Comp
       fiber.root!.mounted.push(fiber);
     }
     const component = this.component;
-    try {
+    if (this.willStart.length) {
-      await Promise.all(this.willStart.map((f) => f.call(component)));
+      let willStartResults;
-    } catch (e) {
+      try {
-      handleError({ node: this, error: e });
+        willStartResults = this.willStart.map((f) => f.call(component));
-      return;
+      } catch (e) {
+        handleError({ node: this, error: e });
+        return;
+      }
+      if (willStartResults.some((result) => result instanceof Promise)) {
+        try {
+          await Promise.all(willStartResults);
+        } catch (e) {
+          handleError({ node: this, error: e });
+          return;
+        }
+      }
     }
     if (this.status === STATUS.NEW && this.fiber === fiber) {
       fiber.render();
@@ -153,10 +164,9 @@ export class ComponentNode<P extends Props = any, E = any> implements VNode<Comp
 
   async render(deep: boolean) {
     let current = this.fiber;
-    if (current && (current.root!.locked || (current as any).bdom === true)) {
+    if (current && (current.root!.locked || current as any).bdom === true) {
-      await Promise.resolve();
+      this.app.scheduler.requestAnimationFrame(() => this.render(deep));
-      // situation may have changed after the microtask tick
+      return;
-      current = this.fiber;
     }
     if (current) {
       if (!current.bdom && !fibersInError.has(current)) {
@@ -175,26 +185,28 @@ export class ComponentNode<P extends Props = any, E = any> implements VNode<Comp
     const fiber = makeRootFiber(this);
     fiber.deep = deep;
     this.fiber = fiber;
+    const scheduler = this.app.scheduler;
 
-    this.app.scheduler.addFiber(fiber);
+    scheduler.requestAnimationFrame(() => {
-    await Promise.resolve();
+      if (this.status === STATUS.DESTROYED) {
-    if (this.status === STATUS.DESTROYED) {
+        return;
-      return;
+      }
-    }
+      // We only want to actually render the component if the following two
-    // We only want to actually render the component if the following two
+      // conditions are true:
-    // conditions are true:
+      // * this.fiber: it could be null, in which case the render has been cancelled
-    // * 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
-    // * (current || !fiber.parent): if current is not null, this means that the
+      //   render function was called when a render was already occurring. In this
-    //   render function was called when a render was already occurring. In this
+      //   case, the pending rendering was cancelled, and the fiber needs to be
-    //   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
-    //   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
-    //   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
-    //   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
-    //   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.
-    //   in the next microtick anyway, so we should not render it again.
+      if (this.fiber === fiber && (current || !fiber.parent)) {
-    if (this.fiber === fiber && (current || !fiber.parent)) {
+        fiber.render();
-      fiber.render();
+      }
-    }
+    });
+    scheduler.addFiber(fiber);
   }
 
   destroy() {
@@ -247,14 +259,17 @@ export class ComponentNode<P extends Props = any, E = any> implements VNode<Comp
       }
     }
     currentNode = null;
-    const prom = Promise.all(this.willUpdateProps.map((f) => f.call(component, props)));
+    if (this.willUpdateProps.length) {
-    await prom;
+      const willUpdatePropsResults = this.willUpdateProps.map((f) => f.call(component, props));
-    if (fiber !== this.fiber) {
+      if (willUpdatePropsResults.some((res) => res instanceof Promise)) {
-      return;
+        await Promise.all(willUpdatePropsResults);
+      }
+      if (fiber !== this.fiber) {
+        return;
+      }
     }
     component.props = props;
     this.props = rawProps;
-    fiber.render();
     const parentRoot = parentFiber.root!;
     if (this.willPatch.length) {
       parentRoot.willPatch.push(fiber);
@@ -262,6 +277,7 @@ export class ComponentNode<P extends Props = any, E = any> implements VNode<Comp
     if (this.patched.length) {
       parentRoot.patched.push(fiber);
     }
+    fiber.render();
   }
 
   /**
@@ -349,7 +365,7 @@ export class ComponentNode<P extends Props = any, E = any> implements VNode<Comp
   }
 
   get subscriptions(): ReturnType<typeof getSubscriptions> {
-    const render = batchedRenderFunctions.get(this);
+    const render = renderFunctions.get(this);
     return render ? getSubscriptions(render) : [];
   }
 }

src/runtime/fibers.ts

@@ -20,6 +20,7 @@ export function makeRootFiber(node: ComponentNode): Fiber {
     // which means any arbitrary code can be run in onWillDestroy, which may
     // trigger new renderings
     root.locked = true;
+    debugger
     root.setCounter(root.counter + 1 - cancelFibers(current.children));
     root.locked = false;
     current.children = [];
@@ -55,7 +56,9 @@ function cancelFibers(fibers: Fiber[]): number {
     let node = fiber.node;
     fiber.render = throwOnRender;
     if (node.status === STATUS.NEW) {
+      console.log('asdfasdfsdf')
       node.destroy();
+      delete node.parent!.children[node.parentKey!];
     }
     node.fiber = null;
     if (fiber.bdom) {
@@ -150,6 +153,7 @@ export class RootFiber extends Fiber {
   complete() {
     const node = this.node;
     this.locked = true;
+    debugger
     let current: Fiber | undefined = undefined;
     try {
       // Step 1: calling all willPatch lifecycle hooks

src/runtime/scheduler.ts

@@ -11,12 +11,29 @@ 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();
-  requestAnimationFrame: Window["requestAnimationFrame"];
+  _requestAnimationFrame: Window["requestAnimationFrame"];
+  cbs: Function[] = [];
   frame: number = 0;
   delayedRenders: Fiber[] = [];
+  shouldFlush = false;
 
   constructor() {
-    this.requestAnimationFrame = Scheduler.requestAnimationFrame;
+    this._requestAnimationFrame = Scheduler.requestAnimationFrame;
+  }
+
+  requestAnimationFrame(cb: Function) {
+    this.cbs.push(cb);
+    if (this.frame === 0) {
+      this.frame = this._requestAnimationFrame(() => {
+        // note that some callbacks may be added to this.cbs while this look is
+        // running, and they will be executed immediately
+        for (let i = 0; i < this.cbs.length; i++) {
+          this.cbs[i]();
+        }
+        this.cbs = [];
+        this.frame = 0;
+      });
+    }
   }
 
   addFiber(fiber: Fiber) {
@@ -37,18 +54,18 @@ export class Scheduler {
         }
       }
     }
-
+    // if (this.shouldFlush === false) {
-    if (this.frame === 0) {
+    // this.shouldFlush = true;
-      this.frame = this.requestAnimationFrame(() => {
+    this.requestAnimationFrame(() => {
-        this.frame = 0;
+      // this.shouldFlush = false;
-        this.tasks.forEach((fiber) => this.processFiber(fiber));
+      this.tasks.forEach((fiber) => this.processFiber(fiber));
-        for (let task of this.tasks) {
+      for (let task of this.tasks) {
-          if (task.node.status === STATUS.DESTROYED) {
+        if (task.node.status === STATUS.DESTROYED) {
-            this.tasks.delete(task);
+          this.tasks.delete(task);
-          }
         }
-      });
+      }
-    }
+    });
+    // }
   }
 
   processFiber(fiber: RootFiber) {

src/runtime/utils.ts

@@ -1,31 +1,5 @@
 export type Callback = () => void;
 
-/**
- * Creates a batched version of a callback so that all calls to it in the same
- * microtick will only call the original callback once.
- *
- * @param callback the callback to batch
- * @returns a batched version of the original callback
- */
-export function batched(callback: Callback): Callback {
-  let called = false;
-  return async () => {
-    // This await blocks all calls to the callback here, then releases them sequentially
-    // in the next microtick. This line decides the granularity of the batch.
-    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();
-    }
-  };
-}
-
 export function validateTarget(target: HTMLElement) {
   if (!(target instanceof HTMLElement)) {
     throw new Error("Cannot mount component: the target is not a valid DOM element");

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

@@ -1730,10 +1730,10 @@ exports[`renderings, destruction, patch, stuff, ... yet another variation 3`] =
 ) {
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   
-  let block3 = createBlock(\`<p block-handler-0=\\"click\\"><block-text-1/></p>\`);
+  let block3 = createBlock(\`<span block-handler-0=\\"click\\"><block-text-1/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`D\`);
+    const b2 = text(\`C\`);
     let hdlr1 = [ctx['increment'], ctx];
     let txt1 = ctx['state'].val;
     const b3 = block3([hdlr1, txt1]);
@@ -1747,10 +1747,10 @@ exports[`renderings, destruction, patch, stuff, ... yet another variation 4`] =
 ) {
   let { text, createBlock, list, multi, html, toggler, comment } = bdom;
   
-  let block3 = createBlock(\`<span block-handler-0=\\"click\\"><block-text-1/></span>\`);
+  let block3 = createBlock(\`<p block-handler-0=\\"click\\"><block-text-1/></p>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = text(\`C\`);
+    const b2 = text(\`D\`);
     let hdlr1 = [ctx['increment'], ctx];
     let txt1 = ctx['state'].val;
     const b3 = block3([hdlr1, txt1]);

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

@@ -131,6 +131,19 @@ exports[`can catch errors an error in onWillDestroy 2`] = `
 }"
 `;
 
+exports[`can catch errors an error in onWillDestroy 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<div>abc</div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
 exports[`can catch errors an error in onWillDestroy, variation 1`] = `
 "function anonymous(app, bdom, helpers
 ) {

tests/components/concurrency.test.ts

@@ -103,15 +103,13 @@ test("destroying/recreating a subwidget with different props (if start is not ov
   expect(n).toBe(0);
 
   w.state.val = 2;
-  await nextMicroTick();
+  await nextTick();
-  await nextMicroTick();
   expect(n).toBe(1);
 
   expect(["W:willRender", "Child:setup", "Child:willStart", "W:rendered"]).toBeLogged();
 
   w.state.val = 3;
-  await nextMicroTick();
+  await nextTick();
-  await nextMicroTick();
   expect(n).toBe(2);
 
   expect([
@@ -176,14 +174,16 @@ test("destroying/recreating a subcomponent, other scenario", async () => {
     "Parent:willRender",
     "Child:setup",
     "Child:willStart",
+    "Child:willRender",
+    "Child:rendered",
     "Parent:rendered",
     "Child:willDestroy",
     "Parent:willRender",
     "Child:setup",
     "Child:willStart",
-    "Parent:rendered",
     "Child:willRender",
     "Child:rendered",
+    "Parent:rendered",
     "Parent:willPatch",
     "Child:mounted",
     "Parent:patched",
@@ -319,9 +319,9 @@ test("creating two async components, scenario 2", async () => {
     "Parent:willRender",
     "ChildA:setup",
     "ChildA:willStart",
-    "Parent:rendered",
     "ChildA:willRender",
     "ChildA:rendered",
+    "Parent:rendered",
     "ChildA:mounted",
     "Parent:mounted",
   ]).toBeLogged();
@@ -2235,13 +2235,13 @@ test("concurrent renderings scenario 16", async () => {
     "A:willRender",
     "B:setup",
     "B:willStart",
-    "A:rendered",
     "B:willRender",
     "C:setup",
     "C:willStart",
-    "B:rendered",
     "C:willRender",
     "C:rendered",
+    "B:rendered",
+    "A:rendered",
     "C:mounted",
     "B:mounted",
     "A:mounted",
@@ -2906,9 +2906,9 @@ test("two sequential renderings before an animation frame", async () => {
     "Parent:willRender",
     "Child:setup",
     "Child:willStart",
-    "Parent:rendered",
     "Child:willRender",
     "Child:rendered",
+    "Parent:rendered",
     "Child:mounted",
     "Parent:mounted",
   ]).toBeLogged();
@@ -2920,13 +2920,7 @@ test("two sequential renderings before an animation frame", async () => {
   await nextMicroTick();
   await nextMicroTick();
   expect(fixture.innerHTML).toBe("0");
-  expect([
+  expect([]).toBeLogged();
-    "Parent:willRender",
-    "Child:willUpdateProps",
-    "Parent:rendered",
-    "Child:willRender",
-    "Child:rendered",
-  ]).toBeLogged();
 
   parent.state.value = 2;
   // enough microticks to wait for render + willupdateprops
@@ -2936,17 +2930,21 @@ test("two sequential renderings before an animation frame", async () => {
   await nextMicroTick();
   await nextMicroTick();
   expect(fixture.innerHTML).toBe("0");
-  expect([
+  expect([]).toBeLogged();
-    "Parent:willRender",
-    "Child:willUpdateProps",
-    "Parent:rendered",
-    "Child:willRender",
-    "Child:rendered",
-  ]).toBeLogged();
 
   await nextTick();
   // we check here that the willPatch and patched hooks are called only once
-  expect(["Parent:willPatch", "Child:willPatch", "Child:patched", "Parent:patched"]).toBeLogged();
+  expect([
+    "Parent:willRender",
+    "Child:willUpdateProps",
+    "Child:willRender",
+    "Child:rendered",
+    "Parent:rendered",
+    "Parent:willPatch",
+    "Child:willPatch",
+    "Child:patched",
+    "Parent:patched",
+  ]).toBeLogged();
 });
 
 test("t-key on dom node having a component", async () => {
@@ -3736,15 +3734,15 @@ test("delayed fiber does not get rendered if it was cancelled", async () => {
     "A:setup",
     "A:willRender",
     "B:setup",
-    "A:rendered",
     "B:willRender",
     "C:setup",
-    "B:rendered",
     "C:willRender",
     "D:setup",
-    "C:rendered",
     "D:willRender",
     "D:rendered",
+    "C:rendered",
+    "B:rendered",
+    "A:rendered",
     "D:mounted",
     "C:mounted",
     "B:mounted",
@@ -3753,7 +3751,7 @@ test("delayed fiber does not get rendered if it was cancelled", async () => {
   // Start a render in C
   c!.render(true);
   await nextMicroTick();
-  expect(["C:willRender", "C:rendered"]).toBeLogged();
+  expect(["C:willRender", "D:willRender", "D:rendered", "C:rendered"]).toBeLogged();
   // Start a render in A such that C is already rendered, but D will be delayed
   // (because A is rendering) then cancelled (when the render from A reaches C)
   a.render(true);
@@ -3761,13 +3759,13 @@ test("delayed fiber does not get rendered if it was cancelled", async () => {
   await nextTick();
   expect([
     "A:willRender",
-    "A:rendered",
     "B:willRender",
-    "B:rendered",
     "C:willRender",
-    "C:rendered",
     "D:willRender",
     "D:rendered",
+    "C:rendered",
+    "B:rendered",
+    "A:rendered",
     "A:willPatch",
     "B:willPatch",
     "C:willPatch",
@@ -3779,7 +3777,7 @@ test("delayed fiber does not get rendered if it was cancelled", async () => {
   ]).toBeLogged();
 });
 
-test("destroyed component causes other soon to be destroyed component to rerender, weird stuff happens", async () => {
+test.only("destroyed component causes other soon to be destroyed component to rerender, weird stuff happens", async () => {
   let def = makeDeferred();
   let c: any = null;
 
@@ -3787,6 +3785,9 @@ test("destroyed component causes other soon to be destroyed component to rerende
     static template = xml`<t t-esc="props.value"/>`;
     setup() {
       useLogLifecycle();
+      onWillStart(async () => {
+        await nextMicroTick();
+      });
       onRendered(() => {
         def.resolve();
       });
@@ -3802,6 +3803,9 @@ test("destroyed component causes other soon to be destroyed component to rerende
     setup() {
       c = this;
       useLogLifecycle();
+      onWillStart(async () => {
+        await nextMicroTick();
+      })
     }
   }
 
@@ -3816,6 +3820,9 @@ test("destroyed component causes other soon to be destroyed component to rerende
     state = useState({ flag: false, valueB: 1, valueC: 2 });
     setup() {
       useLogLifecycle();
+      onWillStart(async () => {
+        await nextMicroTick();
+      })
     }
   }
 
@@ -3917,17 +3924,17 @@ test("delayed rendering, destruction, stuff happens", async () => {
     "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",
+    "C:rendered",
+    "B:rendered",
+    "A:rendered",
     "D:mounted",
     "C:mounted",
     "B:mounted",
@@ -3940,10 +3947,10 @@ test("delayed rendering, destruction, stuff happens", async () => {
   expect([
     "A:willRender",
     "B:willUpdateProps",
-    "A:rendered",
     "B:willRender",
     "C:willUpdateProps",
     "B:rendered",
+    "A:rendered",
   ]).toBeLogged();
 
   // update B => removes child C
@@ -4018,19 +4025,19 @@ test("renderings, destruction, patch, stuff, ... yet another variation", async (
     "A:willRender",
     "B:setup",
     "B:willStart",
-    "D:setup",
-    "D:willStart",
-    "A:rendered",
     "B:willRender",
     "C:setup",
     "C:willStart",
-    "B:rendered",
-    "D:willRender",
-    "D:rendered",
     "C:willRender",
     "C:rendered",
-    "C:mounted",
+    "B:rendered",
+    "D:setup",
+    "D:willStart",
+    "D:willRender",
+    "D:rendered",
+    "A:rendered",
     "D:mounted",
+    "C:mounted",
     "B:mounted",
     "A:mounted",
   ]).toBeLogged();

tests/components/error_handling.test.ts

@@ -3,10 +3,10 @@ import {
   onError,
   onMounted,
   onPatched,
-  onWillPatch,
-  onWillStart,
-  onWillRender,
   onRendered,
+  onWillPatch,
+  onWillRender,
+  onWillStart,
   onWillUnmount,
   useState,
   xml,
@@ -14,8 +14,8 @@ import {
 import {
   logStep,
   makeTestFixture,
-  nextTick,
   nextMicroTick,
+  nextTick,
   snapshotEverything,
   useLogLifecycle,
 } from "../helpers";
@@ -1251,9 +1251,9 @@ describe("can catch errors", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -1276,7 +1276,7 @@ describe("can catch errors", () => {
     expect(fixture.innerHTML).toBe("2");
   });
 
-  test("an error in onWillDestroy, variation", async () => {
+  test.only("an error in onWillDestroy, variation", async () => {
     class Child extends Component {
       static template = xml`<div>abc</div>`;
       setup() {
@@ -1314,27 +1314,26 @@ describe("can catch errors", () => {
     ]).toBeLogged();
 
     parent.state.hasChild = true;
-    await nextMicroTick();
+    await nextTick();
-    await nextMicroTick();
-    await nextMicroTick();
-    await nextMicroTick();
-    await nextMicroTick();
     expect([
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
+      "Parent:willPatch",
+      "Child:mounted",
+      "Parent:patched",
     ]).toBeLogged();
     parent.state.hasChild = false;
     await nextTick();
     expect([
-      "Child:willDestroy",
       "Parent:willRender",
       "Parent:rendered",
       "Parent:willPatch",
-      "Parent:patched",
+      "Child:willUnmount",
+      "Child:willDestroy",
     ]).toBeLogged();
     expect(fixture.innerHTML).toBe("2");
   });

tests/components/lifecycle.test.ts

@@ -461,9 +461,9 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -474,9 +474,9 @@ describe("lifecycle hooks", () => {
     expect([
       "Parent:willRender",
       "Child:willUpdateProps",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Parent:willPatch",
       "Child:willPatch",
       "Child:patched",
@@ -520,9 +520,9 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -638,9 +638,9 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -694,13 +694,13 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "GrandChild:setup",
       "GrandChild:willStart",
-      "Child:rendered",
       "GrandChild:willRender",
       "GrandChild:rendered",
+      "Child:rendered",
+      "Parent:rendered",
       "Parent:willPatch",
       "GrandChild:mounted",
       "Child:mounted",
@@ -803,11 +803,11 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "GrandChild:setup",
       "GrandChild:willStart",
       "Child:rendered",
+      "Parent:rendered",
     ]).toBeLogged();
 
     app.destroy();
@@ -843,9 +843,9 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -886,9 +886,9 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -898,9 +898,9 @@ describe("lifecycle hooks", () => {
     expect([
       "Parent:willRender",
       "Child:willUpdateProps",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Parent:willPatch",
       "Child:willPatch",
       "Child:patched",
@@ -943,9 +943,9 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -1060,21 +1060,21 @@ describe("lifecycle hooks", () => {
       "A:willRender",
       "B:setup",
       "B:willStart",
-      "C:setup",
-      "C:willStart",
-      "A:rendered",
       "B:willRender",
       "B:rendered",
+      "C:setup",
+      "C:willStart",
       "C:willRender",
       "D:setup",
       "D:willStart",
-      "E:setup",
-      "E:willStart",
-      "C:rendered",
       "D:willRender",
       "D:rendered",
+      "E:setup",
+      "E:willStart",
       "E:willRender",
       "E:rendered",
+      "C:rendered",
+      "A:rendered",
       "E:mounted",
       "D:mounted",
       "C:mounted",
@@ -1089,9 +1089,9 @@ describe("lifecycle hooks", () => {
       "C:willRender",
       "F:setup",
       "F:willStart",
-      "C:rendered",
       "F:willRender",
       "F:rendered",
+      "C:rendered",
       "C:willPatch",
       "E:willUnmount",
       "E:willDestroy",
@@ -1124,9 +1124,9 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -1148,9 +1148,9 @@ describe("lifecycle hooks", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Parent:willPatch",
       "Child:mounted",
       "Parent:patched",
@@ -1171,7 +1171,7 @@ describe("lifecycle hooks", () => {
     }
 
     await mount(Parent, fixture);
-    expect(fixture.innerHTML).toBe("<span></span>");
+    expect(fixture.innerHTML).toBe("<span>Patched</span>");
     expect([
       "Parent:setup",
       "Parent:willStart",
@@ -1180,11 +1180,13 @@ describe("lifecycle hooks", () => {
       "Parent:mounted",
       "Parent:willRender",
       "Parent:rendered",
+      "Parent:willPatch",
+      "Parent:patched",
     ]).toBeLogged();
 
     await nextTick();
     expect(fixture.innerHTML).toBe("<span>Patched</span>");
-    expect(["Parent:willPatch", "Parent:patched"]).toBeLogged();
+    expect([]).toBeLogged();
   });
 
   test("render in patched", async () => {
@@ -1215,7 +1217,7 @@ describe("lifecycle hooks", () => {
 
     parent.render();
     await nextTick();
-    expect(fixture.innerHTML).toBe("<span></span>");
+    expect(fixture.innerHTML).toBe("<span>Patched</span>");
     expect([
       "Parent:willRender",
       "Parent:rendered",
@@ -1223,11 +1225,13 @@ describe("lifecycle hooks", () => {
       "Parent:patched",
       "Parent:willRender",
       "Parent:rendered",
+      "Parent:willPatch",
+      "Parent:patched",
     ]).toBeLogged();
 
     await nextTick();
     expect(fixture.innerHTML).toBe("<span>Patched</span>");
-    expect(["Parent:willPatch", "Parent:patched"]).toBeLogged();
+    expect([]).toBeLogged();
   });
 
   test("render in willPatch", async () => {
@@ -1265,12 +1269,15 @@ describe("lifecycle hooks", () => {
       "Parent:rendered",
       "Parent:willPatch",
       "Parent:patched",
-      "Parent:willRender",
-      "Parent:rendered",
     ]).toBeLogged();
 
     await nextTick();
-    expect(["Parent:willPatch", "Parent:patched"]).toBeLogged();
+    expect([
+      "Parent:willRender",
+      "Parent:rendered",
+      "Parent:willPatch",
+      "Parent:patched",
+    ]).toBeLogged();
     expect(fixture.innerHTML).toBe("<span>Patched</span>");
   });
 
@@ -1333,6 +1340,9 @@ describe("lifecycle hooks", () => {
       static template = xml`child`;
       setup() {
         useLogLifecycle();
+        onWillStart(async () => {
+          await nextMicroTick();
+        });
       }
     }
 

tests/components/reactivity.test.ts

@@ -152,7 +152,7 @@ describe("reactivity in lifecycle", () => {
     const prom = mount(Comp, fixture);
     (STATE as any).val = 2;
     await prom;
-    expect(steps).toEqual([2]);
+    expect(steps).toEqual([1, 2]);
     expect(fixture.innerHTML).toBe("<div>2</div>");
   });
 
@@ -180,9 +180,9 @@ describe("reactivity in lifecycle", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();

tests/components/rendering.test.ts

@@ -1,11 +1,10 @@
 import { Component, mount, onRendered, onWillUpdateProps, useState, xml } from "../../src";
 import {
-  makeTestFixture,
-  snapshotEverything,
-  nextTick,
-  useLogLifecycle,
   makeDeferred,
-  nextMicroTick,
+  makeTestFixture,
+  nextTick,
+  snapshotEverything,
+  useLogLifecycle,
 } from "../helpers";
 
 let fixture: HTMLElement;
@@ -47,9 +46,9 @@ describe("rendering semantics", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -139,11 +138,16 @@ describe("rendering semantics", () => {
     expect(childN).toBe(1);
   });
 
-  test("render with deep=true followed by render with deep=false work as expected", async () => {
+  test.only("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();
+        onRendered(() => {
+          if (value === 4) {
+            parent.state.value = "B";
+          }
+        });
       }
     }
 
@@ -173,9 +177,9 @@ describe("rendering semantics", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -184,33 +188,39 @@ describe("rendering semantics", () => {
     parent.render(true);
 
     // wait for child to be rendered, but dom not yet patched
-    await nextMicroTick();
+    // await nextMicroTick();
-    await nextMicroTick();
+    // await nextMicroTick();
-    await nextMicroTick();
+    // await nextMicroTick();
-    expect([
+    // expect([
-      "Parent:willRender",
+    //   "Parent:willRender",
-      "Child:willUpdateProps",
+    //   "Child:willUpdateProps",
-      "Parent:rendered",
+    //   "Child:willRender",
-      "Child:willRender",
+    //   "Child:rendered",
-      "Child:rendered",
+    //   "Parent:rendered",
-    ]).toBeLogged();
+    // ]).toBeLogged();
 
-    parent.state.value = "B";
+    // parent.state.value = "B";
 
     await nextTick();
+    // await nextTick();
 
-    expect(fixture.innerHTML).toBe("parentBchild4");
     expect([
       "Parent:willRender",
       "Child:willUpdateProps",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
+      "Parent:willRender",
+      "Child:willUpdateProps",
+      "Child:willRender",
+      "Child:rendered",
+      "Parent:rendered",
       "Parent:willPatch",
       "Child:willPatch",
       "Child:patched",
       "Parent:patched",
     ]).toBeLogged();
+    expect(fixture.innerHTML).toBe("parentBchild4");
   });
 
   test("props are reactive", async () => {
@@ -241,9 +251,9 @@ describe("rendering semantics", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -284,9 +294,9 @@ describe("rendering semantics", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -372,13 +382,13 @@ describe("rendering semantics", () => {
       "A:willRender",
       "B:setup",
       "B:willStart",
-      "A:rendered",
       "B:willRender",
       "C:setup",
       "C:willStart",
-      "B:rendered",
       "C:willRender",
       "C:rendered",
+      "B:rendered",
+      "A:rendered",
       "C:mounted",
       "B:mounted",
       "A:mounted",
@@ -437,13 +447,13 @@ test("force render in case of existing render", async () => {
     "A:willRender",
     "B:setup",
     "B:willStart",
-    "A:rendered",
     "B:willRender",
     "C:setup",
     "C:willStart",
-    "B:rendered",
     "C:willRender",
     "C:rendered",
+    "B:rendered",
+    "A:rendered",
     "C:mounted",
     "B:mounted",
     "A:mounted",
@@ -466,9 +476,9 @@ test("force render in case of existing render", async () => {
   expect([
     "B:willRender",
     "C:willUpdateProps",
-    "B:rendered",
     "C:willRender",
     "C:rendered",
+    "B:rendered",
     "A:willPatch",
     "B:willPatch",
     "C:willPatch",
@@ -509,9 +519,9 @@ test("children, default props and renderings", async () => {
     "Parent:willRender",
     "Child:setup",
     "Child:willStart",
-    "Parent:rendered",
     "Child:willRender",
     "Child:rendered",
+    "Parent:rendered",
     "Child:mounted",
     "Parent:mounted",
   ]).toBeLogged();

tests/reactivity.test.ts

@@ -10,7 +10,6 @@ import {
   toRaw,
 } from "../src";
 import { reactive, Reactive } from "../src/runtime/reactivity";
-import { batched } from "../src/runtime/utils";
 import {
   makeDeferred,
   makeTestFixture,
@@ -190,64 +189,6 @@ describe("Reactivity", () => {
     expect(n).toBe(2);
   });
 
-  test("batched: callback is called after batch of operation", async () => {
-    let n = 0;
-    const state = createReactive(
-      { a: 1, b: 2 },
-      batched(() => n++)
-    );
-    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);
-    state.b = state.b + 5; // key is read and then modified
-    expect(n).toBe(0);
-    await nextMicroTick();
-    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++);
@@ -1772,13 +1713,13 @@ describe("Reactivity: useState", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
+      "Child:willRender",
+      "Child:rendered",
       "Child:setup",
       "Child:willStart",
+      "Child:willRender",
+      "Child:rendered",
       "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Child:willRender",
-      "Child:rendered",
       "Child:mounted",
       "Child:mounted",
       "Parent:mounted",
@@ -1826,13 +1767,13 @@ describe("Reactivity: useState", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
+      "Child:willRender",
+      "Child:rendered",
       "Child:setup",
       "Child:willStart",
+      "Child:willRender",
+      "Child:rendered",
       "Parent:rendered",
-      "Child:willRender",
-      "Child:rendered",
-      "Child:willRender",
-      "Child:rendered",
       "Child:mounted",
       "Child:mounted",
       "Parent:mounted",
@@ -1840,18 +1781,17 @@ describe("Reactivity: useState", () => {
 
     expect(fixture.innerHTML).toBe("<div><span>123</span><span>123</span></div>");
     testContext.value = 321;
-    await nextMicroTick();
+    await nextTick();
-    await nextMicroTick();
     expect([
       "Child:willRender",
       "Child:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Child:willPatch",
+      "Child:patched",
+      "Child:willPatch",
+      "Child:patched"
     ]).toBeLogged();
-    expect(fixture.innerHTML).toBe("<div><span>123</span><span>123</span></div>");
-
-    await nextTick();
-    expect(["Child:willPatch", "Child:patched", "Child:willPatch", "Child:patched"]).toBeLogged();
     expect(fixture.innerHTML).toBe("<div><span>321</span><span>321</span></div>");
   });
 
@@ -1891,17 +1831,17 @@ describe("Reactivity: useState", () => {
       "GrandFather:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:setup",
-      "Parent:willStart",
-      "GrandFather:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:setup",
+      "Parent:willStart",
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
+      "GrandFather:rendered",
       "Child:mounted",
       "Parent:mounted",
       "Child:mounted",
@@ -1909,19 +1849,18 @@ describe("Reactivity: useState", () => {
     ]).toBeLogged();
 
     testContext.value = 321;
-    await nextMicroTick();
+    await nextTick();
-    await nextMicroTick();
+    expect(fixture.innerHTML).toBe("<div><span>321</span><div><span>321</span></div></div>");
-    expect(fixture.innerHTML).toBe("<div><span>123</span><div><span>123</span></div></div>");
     expect([
       "Child:willRender",
       "Child:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Child:willPatch", 
+      "Child:patched", 
+      "Child:willPatch", 
+      "Child:patched"
     ]).toBeLogged();
-
-    await nextTick();
-    expect(fixture.innerHTML).toBe("<div><span>321</span><div><span>321</span></div></div>");
-    expect(["Child:willPatch", "Child:patched", "Child:willPatch", "Child:patched"]).toBeLogged();
   });
 
   test("one components can subscribe twice to same context", async () => {
@@ -2103,9 +2042,9 @@ describe("Reactivity: useState", () => {
       "Parent:willRender",
       "Child:setup",
       "Child:willStart",
-      "Parent:rendered",
       "Child:willRender",
       "Child:rendered",
+      "Parent:rendered",
       "Child:mounted",
       "Parent:mounted",
     ]).toBeLogged();
@@ -2222,8 +2161,7 @@ describe("Reactivity: useState", () => {
     steps.clear();
 
     delete testContext[2];
-    await nextMicroTick();
+    await nextTick();
-    await nextMicroTick();
     expect([...steps]).toEqual(["list"]);
     await nextTick();
     expect(fixture.innerHTML).toBe("<div><div>3</div> Total: 3 Count: 1</div>");

tests/utils.test.ts

@@ -1,5 +1,4 @@
-import { batched, EventBus } from "../src/runtime/utils";
+import { EventBus } from "../src/runtime/utils";
-import { nextMicroTick } from "./helpers";
 
 describe("event bus behaviour", () => {
   test("can subscribe and be notified", () => {
@@ -34,40 +33,3 @@ describe("event bus behaviour", () => {
     bus.trigger("event", "hello world");
   });
 });
-
-describe("batched", () => {
-  test("callback is called only once after operations", async () => {
-    let n = 0;
-    let fn = batched(() => n++);
-
-    expect(n).toBe(0);
-    fn();
-    fn();
-    expect(n).toBe(0);
-
-    await nextMicroTick();
-    expect(n).toBe(1);
-    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);
-  });
-});