@esportsplus/reactivity 0.36.7 → 0.37.1

package/bench/cellx.bench.ts

@@ -1,4 +1,4 @@
-import { bench, describe } from 'vitest';
+import { test } from 'vitest';
 import { assert, framework, ReactiveComputed } from './lib/reactive-adapter';
 
 
@@ -54,8 +54,8 @@ function cellx(layers: number, before: readonly number[], after: readonly number
 }
 
 
-describe('cellx', () => {
-    bench('cellx1000', async () => {
+test('cellx', async ({ bench }) => {
+    await bench('cellx1000', async () => {
         await framework.withBuild(() => cellx(1000, [-3, -6, -2, 2], [-2, -4, 2, 3]));
-    });
+    }).run();
 });

package/bench/dynamic.bench.ts

@@ -1,4 +1,4 @@
-import { bench, describe } from 'vitest';
+import { test } from 'vitest';
 import { assert, framework, ReactiveComputed } from './lib/reactive-adapter';
 
 
@@ -89,15 +89,16 @@ function movingBranchPoint() {
 }
 
 
-describe('dynamic graphs', () => {
+test('dynamic graphs', async ({ bench }) => {
     let branchRun = framework.withBuild(movingBranchPoint),
         swapRun = framework.withBuild(dependencySwap);
 
-    bench('dependency set swap (20 computeds x 10 deps)', async () => {
-        await swapRun();
-    });
-
-    bench('moving branch point (30-deep chain re-link)', async () => {
-        await branchRun();
-    });
+    await bench.compare(
+        bench('dependency set swap (20 computeds x 10 deps)', async () => {
+            await swapRun();
+        }),
+        bench('moving branch point (30-deep chain re-link)', async () => {
+            await branchRun();
+        })
+    );
 });

package/bench/kairo.bench.ts

@@ -1,4 +1,4 @@
-import { bench, describe } from 'vitest';
+import { test } from 'vitest';
 import { assert, framework, ReactiveComputed } from './lib/reactive-adapter';
 
 
@@ -324,7 +324,7 @@ function unstable() {
 }
 
 
-describe('kairo', () => {
+test('kairo', async ({ bench }) => {
     let avoidableRun = framework.withBuild(avoidablePropagation),
         broadRun = framework.withBuild(broadPropagation),
         deepRun = framework.withBuild(deepPropagation),
@@ -334,35 +334,30 @@ describe('kairo', () => {
         triangleRun = framework.withBuild(triangle),
         unstableRun = framework.withBuild(unstable);
 
-    bench('avoidablePropagation', async () => {
-        await avoidableRun();
-    });
-
-    bench('broad', async () => {
-        await broadRun();
-    });
-
-    bench('deep', async () => {
-        await deepRun();
-    });
-
-    bench('diamond', async () => {
-        await diamondRun();
-    });
-
-    bench('mux', async () => {
-        await muxRun();
-    });
-
-    bench('repeatedObservers', async () => {
-        await repeatedRun();
-    });
-
-    bench('triangle', async () => {
-        await triangleRun();
-    });
-
-    bench('unstable', async () => {
-        await unstableRun();
-    });
+    await bench.compare(
+        bench('avoidablePropagation', async () => {
+            await avoidableRun();
+        }),
+        bench('broad', async () => {
+            await broadRun();
+        }),
+        bench('deep', async () => {
+            await deepRun();
+        }),
+        bench('diamond', async () => {
+            await diamondRun();
+        }),
+        bench('mux', async () => {
+            await muxRun();
+        }),
+        bench('repeatedObservers', async () => {
+            await repeatedRun();
+        }),
+        bench('triangle', async () => {
+            await triangleRun();
+        }),
+        bench('unstable', async () => {
+            await unstableRun();
+        })
+    );
 });

package/bench/molbench.bench.ts

@@ -1,4 +1,4 @@
-import { bench, describe } from 'vitest';
+import { test } from 'vitest';
 import { assert, framework } from './lib/reactive-adapter';
 
 
@@ -66,10 +66,10 @@ function mol() {
 }
 
 
-describe('molBench', () => {
+test('molBench', async ({ bench }) => {
     let molRun = framework.withBuild(mol);
 
-    bench('molBench', async () => {
+    await bench('molBench', async () => {
         await molRun();
-    });
+    }).run();
 });

package/bench/reactive/array.bench.ts

@@ -1,233 +1,233 @@
-import { bench, describe } from 'vitest';
+import { test } from 'vitest';
 import { ReactiveArray } from '~/reactive/array';
 import { effect } from '~/system';
 
 
-describe('ReactiveArray creation', () => {
-    bench('create empty', () => {
-        new ReactiveArray<number>();
-    });
-
-    bench('create with 10 items', () => {
-        new ReactiveArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-    });
-
-    bench('create with 100 items', () => {
-        let items = [];
-
-        for (let i = 0; i < 100; i++) {
-            items.push(i);
-        }
-
-        new ReactiveArray(items);
-    });
+test('ReactiveArray creation', async ({ bench }) => {
+    await bench.compare(
+        bench('create empty', () => {
+            new ReactiveArray<number>();
+        }),
+        bench('create with 10 items', () => {
+            new ReactiveArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+        }),
+        bench('create with 100 items', () => {
+            let items = [];
+
+            for (let i = 0; i < 100; i++) {
+                items.push(i);
+            }
+
+            new ReactiveArray(items);
+        })
+    );
 });
 
 
-describe('ReactiveArray push', () => {
-    bench('push 1 item', () => {
-        let arr = new ReactiveArray<number>();
-
-        arr.push(1);
-    });
-
-    bench('push 10 items (single call)', () => {
-        let arr = new ReactiveArray<number>();
-
-        arr.push(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
-    });
+test('ReactiveArray push', async ({ bench }) => {
+    await bench.compare(
+        bench('push 1 item', () => {
+            let arr = new ReactiveArray<number>();
 
-    bench('push 10 items (10 calls)', () => {
-        let arr = new ReactiveArray<number>();
+            arr.push(1);
+        }),
+        bench('push 10 items (single call)', () => {
+            let arr = new ReactiveArray<number>();
 
-        for (let i = 0; i < 10; i++) {
-            arr.push(i);
-        }
-    });
+            arr.push(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+        }),
+        bench('push 10 items (10 calls)', () => {
+            let arr = new ReactiveArray<number>();
 
-    bench('push with listener', () => {
-        let arr = new ReactiveArray<number>();
+            for (let i = 0; i < 10; i++) {
+                arr.push(i);
+            }
+        }),
+        bench('push with listener', () => {
+            let arr = new ReactiveArray<number>();
 
-        arr.on('push', () => {});
-        arr.push(1);
-    });
+            arr.on('push', () => {});
+            arr.push(1);
+        })
+    );
 });
 
 
-describe('ReactiveArray pop', () => {
-    bench('pop', () => {
+test('ReactiveArray pop', async ({ bench }) => {
+    await bench('pop', () => {
         let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
         arr.pop();
-    });
+    }).run();
 });
 
 
-describe('ReactiveArray splice', () => {
-    bench('splice remove 1', () => {
-        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
-
-        arr.splice(2, 1);
-    });
+test('ReactiveArray splice', async ({ bench }) => {
+    await bench.compare(
+        bench('splice remove 1', () => {
+            let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
-    bench('splice insert 1', () => {
-        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
+            arr.splice(2, 1);
+        }),
+        bench('splice insert 1', () => {
+            let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
-        arr.splice(2, 0, 99);
-    });
+            arr.splice(2, 0, 99);
+        }),
+        bench('splice replace 1', () => {
+            let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
-    bench('splice replace 1', () => {
-        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
-
-        arr.splice(2, 1, 99);
-    });
+            arr.splice(2, 1, 99);
+        })
+    );
 });
 
 
-describe('ReactiveArray sort', () => {
-    bench('sort 10 items', () => {
-        let arr = new ReactiveArray([5, 3, 8, 1, 9, 2, 7, 4, 6, 10]);
-
-        arr.sort((a, b) => a - b);
-    });
+test('ReactiveArray sort', async ({ bench }) => {
+    await bench.compare(
+        bench('sort 10 items', () => {
+            let arr = new ReactiveArray([5, 3, 8, 1, 9, 2, 7, 4, 6, 10]);
 
-    bench('sort 100 items', () => {
-        let items = [];
+            arr.sort((a, b) => a - b);
+        }),
+        bench('sort 100 items', () => {
+            let items = [];
 
-        for (let i = 100; i > 0; i--) {
-            items.push(i);
-        }
+            for (let i = 100; i > 0; i--) {
+                items.push(i);
+            }
 
-        let arr = new ReactiveArray(items);
+            let arr = new ReactiveArray(items);
 
-        arr.sort((a, b) => a - b);
-    });
+            arr.sort((a, b) => a - b);
+        }),
+        bench('sort 1000 items', () => {
+            let items = [];
 
-    bench('sort 1000 items', () => {
-        let items = [];
+            for (let i = 1000; i > 0; i--) {
+                items.push(i);
+            }
 
-        for (let i = 1000; i > 0; i--) {
-            items.push(i);
-        }
+            let arr = new ReactiveArray(items);
 
-        let arr = new ReactiveArray(items);
-
-        arr.sort((a, b) => a - b);
-    });
+            arr.sort((a, b) => a - b);
+        })
+    );
 });
 
 
-describe('ReactiveArray $set', () => {
-    bench('$set', () => {
-        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
-
-        arr.$set(2, 99);
-    });
+test('ReactiveArray $set', async ({ bench }) => {
+    await bench.compare(
+        bench('$set', () => {
+            let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
-    bench('$set same value (no-op)', () => {
-        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
+            arr.$set(2, 99);
+        }),
+        bench('$set same value (no-op)', () => {
+            let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
-        arr.$set(2, 3);
-    });
+            arr.$set(2, 3);
+        })
+    );
 });
 
 
-describe('ReactiveArray events', () => {
-    bench('dispatch to 1 listener', () => {
-        let arr = new ReactiveArray<number>();
+test('ReactiveArray events', async ({ bench }) => {
+    await bench.compare(
+        bench('dispatch to 1 listener', () => {
+            let arr = new ReactiveArray<number>();
 
-        arr.on('push', () => {});
-        arr.push(1);
-    });
-
-    bench('dispatch to 10 listeners', () => {
-        let arr = new ReactiveArray<number>();
-
-        for (let i = 0; i < 10; i++) {
             arr.on('push', () => {});
-        }
+            arr.push(1);
+        }),
+        bench('dispatch to 10 listeners', () => {
+            let arr = new ReactiveArray<number>();
 
-        arr.push(1);
-    });
+            for (let i = 0; i < 10; i++) {
+                arr.on('push', () => {});
+            }
 
-    bench('on + once interleaved', () => {
-        let arr = new ReactiveArray<number>();
+            arr.push(1);
+        }),
+        bench('on + once interleaved', () => {
+            let arr = new ReactiveArray<number>();
 
-        arr.on('push', () => {});
-        arr.once('push', () => {});
-        arr.on('push', () => {});
-        arr.push(1);
-    });
+            arr.on('push', () => {});
+            arr.once('push', () => {});
+            arr.on('push', () => {});
+            arr.push(1);
+        })
+    );
 });
 
 
-describe('ReactiveArray dispose/clear', () => {
-    bench('dispose with 100 items', () => {
-        let items = [];
-
-        for (let i = 0; i < 100; i++) {
-            items.push(i);
-        }
+test('ReactiveArray dispose/clear', async ({ bench }) => {
+    await bench.compare(
+        bench('dispose with 100 items', () => {
+            let items = [];
 
-        let arr = new ReactiveArray(items);
+            for (let i = 0; i < 100; i++) {
+                items.push(i);
+            }
 
-        arr.dispose();
-    });
+            let arr = new ReactiveArray(items);
 
-    bench('clear with 100 items', () => {
-        let items = [];
+            arr.dispose();
+        }),
+        bench('clear with 100 items', () => {
+            let items = [];
 
-        for (let i = 0; i < 100; i++) {
-            items.push(i);
-        }
+            for (let i = 0; i < 100; i++) {
+                items.push(i);
+            }
 
-        let arr = new ReactiveArray(items);
+            let arr = new ReactiveArray(items);
 
-        arr.clear();
-    });
+            arr.clear();
+        })
+    );
 });
 
 
-describe('ReactiveArray concat/unshift/shift/reverse', () => {
-    bench('concat 100 items', () => {
-        let arr = new ReactiveArray<number>(),
-            items = [];
+test('ReactiveArray concat/unshift/shift/reverse', async ({ bench }) => {
+    await bench.compare(
+        bench('concat 100 items', () => {
+            let arr = new ReactiveArray<number>(),
+                items = [];
 
-        for (let i = 0; i < 100; i++) {
-            items.push(i);
-        }
+            for (let i = 0; i < 100; i++) {
+                items.push(i);
+            }
 
-        arr.concat(items);
-    });
-
-    bench('unshift 10 items', () => {
-        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
-
-        arr.unshift(10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
-    });
-
-    bench('shift', () => {
-        let arr = new ReactiveArray([1, 2, 3, 4, 5]);
+            arr.concat(items);
+        }),
+        bench('unshift 10 items', () => {
+            let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
-        arr.shift();
-    });
+            arr.unshift(10, 20, 30, 40, 50, 60, 70, 80, 90, 100);
+        }),
+        bench('shift', () => {
+            let arr = new ReactiveArray([1, 2, 3, 4, 5]);
 
-    bench('reverse 100 items', () => {
-        let items = [];
+            arr.shift();
+        }),
+        bench('reverse 100 items', () => {
+            let items = [];
 
-        for (let i = 0; i < 100; i++) {
-            items.push(i);
-        }
+            for (let i = 0; i < 100; i++) {
+                items.push(i);
+            }
 
-        let arr = new ReactiveArray(items);
+            let arr = new ReactiveArray(items);
 
-        arr.reverse();
-    });
+            arr.reverse();
+        })
+    );
 });
 
 
-describe('ReactiveArray reactive length', () => {
-    bench('read $length in effect', () => {
+test('ReactiveArray reactive length', async ({ bench }) => {
+    await bench('read $length in effect', () => {
         let arr = new ReactiveArray([1, 2, 3]);
 
         let stop = effect(() => {
@@ -235,5 +235,5 @@ describe('ReactiveArray reactive length', () => {
         });
 
         stop();
-    });
+    }).run();
 });

package/bench/reactive/reactive-object.bench.ts

@@ -1,59 +1,61 @@
-import { bench, describe } from 'vitest';
+import { test } from 'vitest';
 import { ReactiveObject } from '~/reactive/object';
 
 
-describe('ReactiveObject creation', () => {
-    bench('create with 5 signal properties', () => {
-        new ReactiveObject({ a: 1, b: 2, c: 3, d: 4, e: 5 });
-    });
-
-    bench('create with computed properties', () => {
-        new ReactiveObject({
-            a: 1,
-            b: 2,
-            sum: () => 0
-        });
-    });
-
-    bench('create with async computed property', () => {
-        new ReactiveObject({
-            value: 1,
-            async: () => Promise.resolve(0)
-        });
-    });
+test('ReactiveObject creation', async ({ bench }) => {
+    await bench.compare(
+        bench('create with 5 signal properties', () => {
+            new ReactiveObject({ a: 1, b: 2, c: 3, d: 4, e: 5 });
+        }),
+        bench('create with computed properties', () => {
+            new ReactiveObject({
+                a: 1,
+                b: 2,
+                sum: () => 0
+            });
+        }),
+        bench('create with async computed property', () => {
+            new ReactiveObject({
+                value: 1,
+                async: () => Promise.resolve(0)
+            });
+        })
+    );
 });
 
 
-describe('ReactiveObject read/write', () => {
-    bench('read property (signal-backed)', () => {
-        let obj = new ReactiveObject({ a: 1, b: 2, c: 3, d: 4, e: 5 });
+test('ReactiveObject read/write', async ({ bench }) => {
+    await bench.compare(
+        bench('read property (signal-backed)', () => {
+            let obj = new ReactiveObject({ a: 1, b: 2, c: 3, d: 4, e: 5 });
 
-        (obj as any).a;
-    });
+            (obj as any).a;
+        }),
+        bench('write property (signal-backed)', () => {
+            let obj = new ReactiveObject({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
+                i = 0;
 
-    bench('write property (signal-backed)', () => {
-        let obj = new ReactiveObject({ a: 1, b: 2, c: 3, d: 4, e: 5 }),
-            i = 0;
-
-        (obj as any).a = ++i;
-    });
+            (obj as any).a = ++i;
+        })
+    );
 });
 
 
-describe('ReactiveObject dispose', () => {
-    bench('dispose with 5 properties', () => {
-        let obj = new ReactiveObject({ a: 1, b: 2, c: 3, d: 4, e: 5 });
-
-        obj.dispose();
-    });
+test('ReactiveObject dispose', async ({ bench }) => {
+    await bench.compare(
+        bench('dispose with 5 properties', () => {
+            let obj = new ReactiveObject({ a: 1, b: 2, c: 3, d: 4, e: 5 });
 
-    bench('dispose with arrays + computeds', () => {
-        let obj = new ReactiveObject({
-            items: [1, 2, 3],
-            name: 'test',
-            total: () => 0
-        });
+            obj.dispose();
+        }),
+        bench('dispose with arrays + computeds', () => {
+            let obj = new ReactiveObject({
+                items: [1, 2, 3],
+                name: 'test',
+                total: () => 0
+            });
 
-        obj.dispose();
-    });
+            obj.dispose();
+        })
+    );
 });