@ryupold/vode 1.8.7 → 1.8.8

package/src/state-context.ts

@@ -41,13 +41,13 @@ export interface SubContext<SubState> {
 }
 
 export type ProxyStateContext<S extends PatchableState, SubState> = StateContext<S, SubState> & {
-    [K in keyof SubState]-?: SubState[K] extends object
+    [K in keyof SubState]-?: SubState[K] extends object | null
     ? ProxyStateContext<S, SubState[K]>
     : StateContext<S, SubState[K]>
 };
 
 export type ProxySubContext<SubState> = SubContext<SubState> & {
-    [K in keyof SubState]-?: SubState[K] extends object
+    [K in keyof SubState]-?: SubState[K] extends object | null
     ? ProxySubContext<SubState[K]>
     : SubContext<SubState[K]>
 };
@@ -107,10 +107,12 @@ class ProxyStateContextImpl<S extends PatchableState, SubState>
                 }
                 raw[keys[i]] = value;
             } else if (keys.length === 1) {
-                if (typeof (<any>target)[keys[0]] === "object" && typeof value === "object")
+                if (typeof (<any>target)[keys[0]] === "object" && typeof value === "object" && value !== null) {
                     Object.assign((<any>target)[keys[0]], value);
-                else
+                }
+                else {
                     (<any>target)[keys[0]] = value;
+                }
             } else {
                 Object.assign(target, value as DeepPartial<S>);
             }

package/src/vode.ts

@@ -7,7 +7,7 @@ export type TextVode = string & {};
 export type NoVode = undefined | null | number | boolean | bigint | void;
 export type AttachedVode<S> = Vode<S> & { node: ChildNode } | Text & { node?: never };
 export type Tag = keyof (HTMLElementTagNameMap & SVGElementTagNameMap & MathMLElementTagNameMap) | (string & {});
-export type Component<S> = (s: S) => ChildVode<S>;
+export type Component<S = PatchableState> = (s: S) => ChildVode<S>;
 
 export type Patch<S> =
     | IgnoredPatch // ignored
@@ -217,7 +217,7 @@ export function app<S extends PatchableState = PatchableState>(
     });
 
     function renderDom(isAsync: boolean) {
-        const sw = Date.now();
+        const sw = performance.now();
         const vom = dom(_vode.state);
         _vode.vode = render<S>(_vode.state, container.parentElement as Element, 0, 0, _vode.vode, vom)!;
 
@@ -227,7 +227,7 @@ export function app<S extends PatchableState = PatchableState>(
         }
 
         if (!isAsync) {
-            _vode.stats.lastSyncRenderTime = Date.now() - sw;
+            _vode.stats.lastSyncRenderTime = performance.now() - sw;
             _vode.stats.syncRenderCount++;
             _vode.isRendering = false;
             if (_vode.qSync) _vode.renderSync();
@@ -258,7 +258,7 @@ export function app<S extends PatchableState = PatchableState>(
             if (_vode.isAnimating || !_vode.qAsync || document.hidden) return;
 
             _vode.isAnimating = true;
-            const sw = Date.now();
+            const sw = performance.now();
             try {
                 _vode.state = mergeState(_vode.state, _vode.qAsync, true);
                 _vode.qAsync = null;
@@ -267,7 +267,7 @@ export function app<S extends PatchableState = PatchableState>(
 
                 await globals.currentViewTransition?.updateCallbackDone;
             } finally {
-                _vode.stats.lastAsyncRenderTime = Date.now() - sw;
+                _vode.stats.lastAsyncRenderTime = performance.now() - sw;
                 _vode.stats.asyncRenderCount++;
                 _vode.isAnimating = false;
             }
@@ -384,13 +384,20 @@ export function hydrate<S = PatchableState>(element: Element | Text, prepareForR
 }
 
 /** memoizes the resulting component or props by comparing element by element (===) with the
- * `compare` of the previous render. otherwise skips the render step (not calling `componentOrProps`)*/
-export function memo<S = PatchableState>(compare: any[], componentOrProps: Component<S> | ((s: S) => Props<S>)): typeof componentOrProps extends ((s: S) => Props<S>) ? ((s: S) => Props<S>) : Component<S> {
+ * `compare` of the previous render. otherwise skips the render step (not calling `componentOrProps`)
+ */
+export function memo<S = PatchableState>(compare: any[], component: Component<S>): Component<S> {
     if (!compare || !Array.isArray(compare)) throw new Error("first argument to memo() must be an array of values to compare");
-    if (typeof componentOrProps !== "function") throw new Error("second argument to memo() must be a function that returns a vode or props object");
+    if (typeof component !== "function") throw new Error("second argument to memo() must be a function that returns a child vode");
+
+    if ((<any>component).__memo) { // wrap to prevent double memoization
+        const comp = component;
+        component = (s: S) => comp(s);
+    }
 
-    (<any>componentOrProps).__memo = compare;
-    return componentOrProps as typeof componentOrProps extends ((s: S) => Props<S>) ? ((s: S) => Props<S>) : Component<S>;
+    (<any>component).__memo = compare;
+
+    return component;
 }
 
 /** 
@@ -559,7 +566,7 @@ function render<S extends PatchableState>(state: S, parent: Element, childIndex:
                 for (let i = indexInParent; i < parent.childNodes.length; i++) {
                     const nextSibling = parent.childNodes[i];
                     if (nextSibling) {
-                        nextSibling.before(text, nextSibling);
+                        nextSibling.before(text);
                         inserted = true;
                         break;
                     }
@@ -605,7 +612,7 @@ function render<S extends PatchableState>(state: S, parent: Element, childIndex:
                 for (let i = indexInParent; i < parent.childNodes.length; i++) {
                     const nextSibling = parent.childNodes[i];
                     if (nextSibling) {
-                        nextSibling.before(newNode, nextSibling);
+                        nextSibling.before(newNode);
                         inserted = true;
                         break;
                     }
@@ -615,12 +622,12 @@ function render<S extends PatchableState>(state: S, parent: Element, childIndex:
                 }
             }
 
-            const newKids = children(newVode);
-            if (newKids) {
+            const newStart = childrenStart(newVode);
+            if (newStart > 0) {
                 const childOffset = !!properties ? 2 : 1;
                 let indexP = 0;
-                for (let i = 0; i < newKids.length; i++) {
-                    const child = newKids[i];
+                for (let i = 0; i < (<Vode<S>>newVode).length - newStart; i++) {
+                    const child = (<Vode<S>>newVode)[i + newStart] as ChildVode<S>;
                     // render child in xml mode to prevent using the dom properties
                     const attached = render(state, newNode as Element, i, indexP, undefined, child, xmlns ?? null);
                     (<Vode<S>>newVode!)[i + childOffset] = <Vode<S>>attached;
@@ -639,49 +646,37 @@ function render<S extends PatchableState>(state: S, parent: Element, childIndex:
         if (!oldIsText && isNode && (<Vode<S>>oldVode)[0] === (<Vode<S>>newVode)[0]) {
             (<AttachedVode<S>>newVode).node = oldNode;
 
-            const newvode = <Vode<S>>newVode;
-            const oldvode = <Vode<S>>oldVode;
-
             const properties = props(newVode);
             const oldProps = props(oldVode);
 
-            if (properties?.xmlns !== undefined) xmlns = properties.xmlns;
+            if (properties?.xmlns !== undefined)
+                xmlns = properties.xmlns;
 
-            if ((<any>newvode[1])?.__memo) {
-                const prev = newvode[1] as any;
-                newvode[1] = remember(state, newvode[1], oldvode[1]) as Vode<S>;
-                if (prev !== newvode[1]) {
-                    patchProperties(state, oldNode!, oldProps, properties, xmlns);
-                }
-            }
-            else {
-                patchProperties(state, oldNode!, oldProps, properties, xmlns);
-            }
+            patchProperties(state, oldNode!, oldProps, properties, xmlns);
 
             if (!!properties?.catch && oldProps?.catch !== properties.catch) {
                 (<any>newVode).node['catch'] = null;
                 (<any>newVode).node.removeAttribute('catch');
             }
 
-            const newKids = children(newVode);
-            const oldKids = children(oldVode) as AttachedVode<S>[];
-            if (newKids) {
-                const childOffset = !!properties ? 2 : 1;
+            const newStart = childrenStart(newVode);
+            const oldStart = childrenStart(oldVode);
+            if (newStart > 0) {
                 let indexP = 0;
-                for (let i = 0; i < newKids.length; i++) {
-                    const child = newKids[i];
-                    const oldChild = oldKids && oldKids[i];
+                for (let i = 0; i < (<Vode<S>>newVode).length - newStart; i++) {
+                    const child = (<Vode<S>>newVode)[i + newStart] as ChildVode<S>;
+                    const oldChild = oldStart > 0 ? (<Vode<S>>oldVode)[i + oldStart] as AttachedVode<S> : undefined;
 
                     const attached = render(state, oldNode as Element, i, indexP, oldChild, child, xmlns);
-                    (<Vode<S>>newVode)[i + childOffset] = <Vode<S>>attached;
+                    (<any>newVode)[i + newStart] = attached;
                     if (attached) indexP++;
                 }
             }
 
-            if (oldKids) {
-                const newKidsCount = newKids ? newKids.length : 0;
-                for (let i = oldKids.length - 1; i >= newKidsCount; i--) {
-                    render(state, oldNode as Element, i, i, oldKids[i], undefined, xmlns);
+            if (oldStart > 0) {
+                const newKidsCount = newStart > 0 ? (<Vode<S>>newVode).length - newStart : 0;
+                for (let i = (<Vode<S>>oldVode).length - 1 - oldStart; i >= newKidsCount; i--) {
+                    render(state, oldNode as Element, i, i, (<any>oldVode)[i + oldStart], undefined, xmlns);
                 }
             }
 
@@ -745,14 +740,19 @@ function isTextVode<S>(x: ChildVode<S>): x is TextVode {
 }
 
 function remember<S>(state: S, present: any, past: any): ChildVode<S> | AttachedVode<S> {
+    while (typeof present === "function" && !present.__memo) {
+        present = present(state);
+    }
+
     if (typeof present !== "function")
         return present;
 
-    const presentMemo = present?.__memo;
-    const pastMemo = past?.__memo;
 
-    if (Array.isArray(presentMemo)
-        && Array.isArray(pastMemo)
+    const presentMemo: unknown[] = present?.__memo;
+    const pastMemo: unknown[] = past?.__memo;
+
+    if (
+        Array.isArray(presentMemo) && Array.isArray(pastMemo)
         && presentMemo.length === pastMemo.length
     ) {
         let same = true;
@@ -765,40 +765,17 @@ function remember<S>(state: S, present: any, past: any): ChildVode<S> | Attached
         if (same) return past;
     }
 
-    const result = present(state);
-
-    if (typeof result === "function" && result?.__memo) {
-        const resultMemo = result.__memo;
-        if (Array.isArray(resultMemo) && Array.isArray(pastMemo) && resultMemo.length === pastMemo.length) {
-            let same = true;
-            for (let i = 0; i < resultMemo.length; i++) {
-                if (resultMemo[i] !== pastMemo[i]) {
-                    same = false;
-                    break;
-                }
-            }
-            if (same) return past;
-        }
-        const innerRender = result(state);
-        if (typeof innerRender === "object") {
-            innerRender.__memo = resultMemo;
-        }
-        return innerRender;
+    // memos are not equal so we unwrap the present
+    while (typeof present === "function") {
+        present = present(state);
     }
 
-    const newRender = typeof result === "function" ? unwrap(result, state) : result;
-    if (typeof newRender === "object") {
-        (<any>newRender).__memo = result?.__memo || present?.__memo;
+    // attach memo to the unwrapped present for future comparisons
+    if (typeof present === "object") {
+        (<any>present).__memo = presentMemo;
     }
-    return newRender;
-}
 
-function unwrap<S>(c: Component<S> | ChildVode<S>, s: S): ChildVode<S> {
-    if (typeof c === "function") {
-        return unwrap(c(s), s);
-    } else {
-        return c;
-    }
+    return present;
 }
 
 function patchProperties<S extends PatchableState>(

package/test/helper.ts

@@ -1,16 +1,18 @@
-import { children, ChildVode, PatchableState, tag, Vode } from "../src/vode";
-import { MockElement, MockText } from "./mocks";
+import { children, ChildVode, PatchableState, props, tag, Vode } from "../src/vode";
+import { FakeElement, FakeTextNode } from "./mocks";
 
 export class Expectation {
     constructor(public readonly what: any) { }
 
-    toBeA(type: "undefined" | "object" | "function" | "bigint" | "boolean" | "number" | "string" | "symbol") {
+    toBeA(type: "undefined" | "object" | "function" | "bigint" | "boolean" | "number" | "string" | "symbol", failMessage?: string) {
         if (typeof this.what !== type) {
-            throw new ExpectationError(this, `expected \n\ntypeof ${this.what}\n\nto be \n\n${type}`);
+            throw new ExpectationError(this, `expected \n\ntypeof ${this.what}\n\nto be \n\n${type}${failMessage ? `\n\n${failMessage}` : ""}`);
         }
     }
 
-    toEqual(other: any) {
+    toEqual(other: any, failMessage?: string) {
+        const failSuffix = failMessage ? `\n\n${failMessage}` : "";
+
         function deepCompare(a: any, b: any, path: string[]): string[] | null {
             if (typeof a !== typeof b) {
                 if (path.length === 0) path.push(``);
@@ -46,12 +48,12 @@ export class Expectation {
         if (typeof this.what === "object" && typeof other === "object" && this.what !== null && other !== null) {
             const unequal = deepCompare(this.what, other, []);
             if (unequal) {
-                throw new ExpectationError(this, `expected \n\n${JSON.stringify(this.what, null, 2)}\n\n to equal \n\n${JSON.stringify(other, null, 2)}\n\nThey differ in: ${unequal.join(".")}`);
+                throw new ExpectationError(this, `expected \n\n${JSON.stringify(this.what, null, 2)}\n\n to equal \n\n${JSON.stringify(other, null, 2)}\n\nThey differ in: ${unequal.join(".")}${failSuffix}`);
             }
         }
         else {
             if (this.what !== other) {
-                throw new ExpectationError(this, `expected (${typeof this.what})\n\n${this.what}\n\nto equal (${typeof other})\n\n${other}`);
+                throw new ExpectationError(this, `expected (${typeof this.what})\n\n${this.what}\n\nto equal (${typeof other})\n\n${other}${failSuffix}`);
             }
         }
     }
@@ -77,82 +79,126 @@ export class Expectation {
         throw new ExpectationError(this, `expected function to fail\n\nbut it succeeded with a result of type ${typeof r}\n\n${r}`);
     }
 
-    toMatch(v: ChildVode, state?: PatchableState) {
-        if (this.what instanceof MockElement || this.what instanceof MockText || typeof this.what === "string" || Array.isArray(this.what) || typeof this.what === "function") {
+    toMatch(v: ChildVode, state?: PatchableState | null, failMessage?: string) {
+        const failSuffix = failMessage ? `\n\n${failMessage}` : "";
+
+        if (this.what instanceof FakeElement || this.what instanceof FakeTextNode || typeof this.what === "string" || Array.isArray(this.what) || typeof this.what === "function") {
             const that = this;
-            function deepCompare(e: MockElement | MockText | ChildVode, cv: ChildVode, path: string[]): string[] | null {
+
+            function deepCompare(e: FakeElement | FakeTextNode | ChildVode, cv: ChildVode, path: string[]): string[] | null {
 
                 // unwrap component
                 while (typeof cv === "function") {
                     if (!state) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na Component\n\nbut got no state passed in [toMatch]`);
+                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na Component\n\nbut got no state passed in [toMatch]${failSuffix}`);
                     }
                     cv = cv(state);
                 }
                 while (typeof e === "function") {
                     if (!state) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na Component\n\nbut got no state passed in [toMatch]`);
+                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na Component\n\nbut got no state passed in [toMatch]${failSuffix}`);
                     }
                     e = e(state);
                 }
 
-                if (typeof cv === "string" && e instanceof MockText) {
+                // string matches TextNode
+                if (typeof cv === "string" && e instanceof FakeTextNode) {
                     if (cv !== e.wholeText) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node with\n${cv}\n\nbut text was\n${e.wholeText}`);
+                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node with\n${cv}\n\nbut text was\n${e.wholeText}${failSuffix}`);
                     }
                 }
+                // string matches string
                 else if (typeof cv === "string" && typeof e === "string") {
                     if (cv !== e) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node with\n${cv}\n\nbut text was\n${e}`);
+                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node with\n${cv}\n\nbut text was\n${e}${failSuffix}`);
                     }
                 }
 
-                else if (Array.isArray(cv) && e instanceof MockElement) {
-                    if (tag(cv)?.toLocaleUpperCase() !== e.tagName.toUpperCase()) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)}>\n\nbut got <${e.tagName}>`);
+                // vode matches element
+                else if (Array.isArray(cv) && e instanceof FakeElement) {
+                    if (tag(cv)?.toUpperCase() !== e.tagName.toUpperCase()) {
+                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got <${e.tagName.toUpperCase()}>${failSuffix}`);
+                    }
+
+                    // compare attributes/props
+                    const properties = props(cv);
+                    if (properties) {
+                        for (const [k, v] of Object.entries(properties)) {
+                            const attributeValue = e.fakeAttributes[k];
+                            if (!attributeValue) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nwith attribute [${k}="${v}"]\n\nbut it was not found${failSuffix}`);
+                            }
+                            if (attributeValue !== v) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nwith attribute [${k}="${v}"]\n\nbut it was [${k}="${attributeValue}"]${failSuffix}`);
+                            }
+                        }
                     }
+
+                    // compare children
                     const kids = children(cv) || [];
                     for (let i = 0; i < kids.length; i++) {
-                        deepCompare(e.children[i], kids[i], [...path, `${tag(kids[i] as Vode) || "#text"}`]);
+                        deepCompare(e.children.item(i) as any, kids[i], [...path, `[${i}]${tag(kids[i] as Vode)?.toUpperCase() || "#text"}`]);
                     }
                     if (kids.length !== e.children.length) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\n${kids.length} children\n\nbut <${e.tagName}> has ${e.children.length} children`);
+                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\n${kids.length} children\n\nbut <${e.tagName.toUpperCase()}> has ${e.children.length} children${failSuffix}`);
                     }
                 }
+                // vode matches vode
                 else if (Array.isArray(cv) && Array.isArray(e)) {
-                    if (tag(cv)?.toLocaleUpperCase() !== tag(e)?.toUpperCase()) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element [${tag(cv)}]\n\nbut got [${tag(e)}]`);
+                    if (tag(cv)?.toUpperCase() !== tag(e)?.toUpperCase()) {
+                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nbut got [${tag(e)?.toUpperCase()}]${failSuffix}`);
+                    }
+
+                    // compare attributes/props
+                    const properties = props(cv);
+                    const otherProperties = props(e) || {};
+                    if (properties) {
+                        for (const [k, v] of Object.entries(properties)) {
+                            const attributeValue = otherProperties[k];
+                            if (!attributeValue) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nwith attribute [${k}="${v}"]\n\nbut it was not found${failSuffix}`);
+                            }
+                            if (attributeValue !== v) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nwith attribute [${k}="${v}"]\n\nbut its value was [${k}="${attributeValue}"]${failSuffix}`);
+                            }
+                        }
                     }
+
+                    // compare children
                     const kids = children(cv) || [];
                     const otherKids = children(e) || [];
                     for (let i = 0; i < kids.length; i++) {
-                        deepCompare(otherKids[i], kids[i], [...path, `${tag(kids[i] as Vode) || "#text"}`]);
+                        deepCompare(otherKids[i], kids[i], [...path, `[${i}]${tag(kids[i] as Vode)?.toUpperCase() || "#text"}`]);
                     }
                     if (kids.length !== otherKids.length) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\n${kids.length} children\n\nbut [${tag(e)}] has ${otherKids.length} children`);
+                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\n${kids.length} children\n\nbut [${tag(e)?.toUpperCase()}] has ${otherKids.length} children${failSuffix}`);
                     }
                 }
 
-                else if (typeof cv === "string" && e instanceof MockElement) {
-                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node\n\nbut got <${e.tagName}>`);
+                // mismatch between text and element
+                else if (typeof cv === "string" && e instanceof FakeElement) {
+                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node\n\nbut got <${e.tagName.toUpperCase()}>${failSuffix}`);
                 }
+                // mismatch between text and vode
                 else if (typeof cv === "string" && Array.isArray(e)) {
-                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node\n\nbut got [${tag(e)}]`);
+                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node\n\nbut got [${tag(e)?.toUpperCase()}]${failSuffix}`);
                 }
 
-                else if (Array.isArray(cv) && e instanceof MockText) {
-                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)}>\n\nbut got #text (${e.wholeText})`);
+                // mismatch between vode and text node
+                else if (Array.isArray(cv) && e instanceof FakeTextNode) {
+                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got #text (${e.wholeText})${failSuffix}`);
                 }
+                // mismatch between vode and text
                 else if (Array.isArray(cv) && typeof e === "string") {
-                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)}>\n\nbut got #text (${e})`);
+                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got #text (${e})${failSuffix}`);
                 }
 
                 return null;
             }
 
-            deepCompare(this.what, v, [tag(v as Vode) || "#text"]);
+            deepCompare(this.what, v, [`${tag(v as Vode)?.toUpperCase() || "#text"}`]);
         } else {
-            throw new ExpectationError(this, `expected an element or text node\n\nbut it is a ${typeof this.what}\n${this.what}`);
+            throw new ExpectationError(this, `expected an element or text node\n\nbut it is a ${typeof this.what}\n${this.what}${failSuffix}`);
         }
     }
 };

package/test/index.ts

@@ -17,6 +17,10 @@ import mergeStyleTests from "./tests-mergeStyle";
 import mergePropsTests from "./tests-mergeProps";
 import stateContextTests from "./tests-state-context";
 import mountUnmountTests from "./tests-mount-unmount";
+import exampleTests from "./tests-examples";
+import catchTests from "./tests-catch";
+import patchAdvancedTests from "./tests-patch-advanced";
+import patchMergeTests from "./tests-patch-merge";
 
 const tests = {
     ...vodeTests,
@@ -38,6 +42,10 @@ const tests = {
     ...mergePropsTests,
 
     ...stateContextTests,
+    ...exampleTests,
+    ...catchTests,
+    ...patchAdvancedTests,
+    ...patchMergeTests,
 };
 //===================================================
 
@@ -48,15 +56,21 @@ const count = {
 }
 const line = "----------------------------------";
 
-for (const test of Object.entries(tests)) {
+async function runTest(test: [string, () => any]) {
     count.total++;
     resetMocks();
+    const start = performance.now();
     try {
-        test[1]()
+        const result = test[1]();
+        if (result && typeof (result as any)?.then === "function") {
+            await result;
+        }
         count.passed++;
-        console.log(`#${count.total} ${test[0]}\n-> 🟢 passed\n${line}`);
+        const time = (performance.now() - start).toFixed(3) + " ms";
+        console.log(`#${count.total} ${test[0]}\n-> 🟢 passed ${time}\n${line}`);
     } catch (err: any) {
-        console.error(`#${count.total} ${test[0]}\n-> 🔴 failed`);
+        const time = (performance.now() - start).toFixed(3) + " ms";
+        console.error(`#${count.total} ${test[0]}\n-> 🔴 failed ${time}`);
         if (err instanceof ExpectationError) {
             count.failed.push(`#${count.total} ${test[0]}\n-> 🔴 failed:\n${err.message}\n${line}`);
         }
@@ -66,17 +80,28 @@ for (const test of Object.entries(tests)) {
     }
 }
 
-console.log(`
-    total: ${count.total}
-    passed: ${count.passed}
-    failed: ${count.failed.length}
-`);
+const sw = performance.now();
+(async () => {
+    for (const test of Object.entries(tests)) {
+        await runTest(test);
+    }
+
+    const time = (performance.now() - sw).toFixed(3) + " ms";
 
-if (count.passed === count.total) {
-    console.log("\n\nall tests passed\n");
-}
-else {
-    console.error(`${line.replaceAll("-", "=")}\nError summary:\n\n${count.failed.join(`\n${line}\n`)}`);
+    console.log(`
+        total: ${count.total}
+        passed: ${count.passed}
+        failed: ${count.failed.length}
 
-    throw "\n\nsome tests failed (see output)\n";
-}
+        time: ${time}
+    `);
+
+    if (count.passed === count.total) {
+        console.log("\n\nall tests passed\n");
+    }
+    else {
+        console.error(`${line.replaceAll("-", "=")}\nError summary:\n\n${count.failed.join(`\n${line}\n`)}`);
+
+        throw "\n\nsome tests failed (see output)\n";
+    }
+})();