@esportsplus/reactivity 0.36.7 → 0.37.1

package/bench/system.bench.ts

@@ -1,371 +1,371 @@
-import { bench, describe } from 'vitest';
+import { test } from 'vitest';
 import { computed, dispose, effect, onCleanup, read, root, signal, write } from '~/system';
+import type { Computed } from '~/system';
 
 
-describe('signal', () => {
-    bench('create signal', () => {
-        signal(0);
-    });
+test('signal', async ({ bench }) => {
+    await bench.compare(
+        bench('create signal', () => {
+            signal(0);
+        }),
+        bench('read signal (no observer)', () => {
+            let s = signal(0);
 
-    bench('read signal (no observer)', () => {
-        let s = signal(0);
+            read(s);
+        }),
+        bench('write signal (no subscribers)', () => {
+            let s = signal(0);
 
-        read(s);
-    });
+            write(s, 1);
+        }),
+        bench('write signal (1 subscriber)', () => {
+            let s = signal(0),
+                i = 0;
 
-    bench('write signal (no subscribers)', () => {
-        let s = signal(0);
+            effect(() => {
+                read(s);
+            });
 
-        write(s, 1);
-    });
+            write(s, ++i);
+        }),
+        bench('write + read cycle', () => {
+            let s = signal(0);
 
-    bench('write signal (1 subscriber)', () => {
-        let s = signal(0),
-            i = 0;
+            write(s, 1);
 
-        effect(() => {
             read(s);
-        });
-
-        write(s, ++i);
-    });
-
-    bench('write + read cycle', () => {
-        let s = signal(0);
-
-        write(s, 1);
-
-        read(s);
-    });
+        })
+    );
 });
 
 
-describe('computed', () => {
-    bench('create computed', () => {
-        let s = signal(0);
-
-        computed(() => read(s));
-    });
-
-    bench('read computed', () => {
-        let s = signal(0),
-            c = computed(() => read(s));
-
-        read(c);
-    });
-
-    bench('computed chain (depth 5)', () => {
-        let s = signal(0),
-            c1 = computed(() => read(s) + 1),
-            c2 = computed(() => read(c1) + 1),
-            c3 = computed(() => read(c2) + 1),
-            c4 = computed(() => read(c3) + 1),
-            c5 = computed(() => read(c4) + 1);
+test('computed', async ({ bench }) => {
+    await bench.compare(
+        bench('create computed', () => {
+            let s = signal(0);
 
-        read(c5);
-    });
+            computed(() => read(s));
+        }),
+        bench('read computed', () => {
+            let s = signal(0),
+                c = computed(() => read(s));
 
-    bench('computed diamond', () => {
-        let s = signal(0),
-            a = computed(() => read(s) + 1),
-            b = computed(() => read(s) * 2),
-            c = computed(() => read(a) + read(b));
+            read(c);
+        }),
+        bench('computed chain (depth 5)', () => {
+            let s = signal(0),
+                c1 = computed(() => read(s) + 1),
+                c2 = computed(() => read(c1) + 1),
+                c3 = computed(() => read(c2) + 1),
+                c4 = computed(() => read(c3) + 1),
+                c5 = computed(() => read(c4) + 1);
+
+            read(c5);
+        }),
+        bench('computed diamond', () => {
+            let s = signal(0),
+                a = computed(() => read(s) + 1),
+                b = computed(() => read(s) * 2),
+                c = computed(() => read(a) + read(b));
 
-        read(c);
-    });
+            read(c);
+        })
+    );
 });
 
 
-describe('asyncComputed', () => {
-    bench('create asyncComputed', () => {
-        computed(() => Promise.resolve(0));
-    });
-
-    bench('create asyncComputed from signal', () => {
-        let s = signal(0);
+test('asyncComputed', async ({ bench }) => {
+    await bench.compare(
+        bench('create asyncComputed', () => {
+            computed(() => Promise.resolve(0));
+        }),
+        bench('create asyncComputed from signal', () => {
+            let s = signal(0);
 
-        computed(() => Promise.resolve(read(s)));
-    });
+            computed(() => Promise.resolve(read(s)));
+        })
+    );
 });
 
 
-describe('effect', () => {
-    bench('create + dispose effect', () => {
-        let stop = effect(() => {});
-
-        stop();
-    });
-
-    bench('effect with 1 signal', () => {
-        let s = signal(0);
-
-        let stop = effect(() => {
-            read(s);
-        });
+test('effect', async ({ bench }) => {
+    await bench.compare(
+        bench('create + dispose effect', () => {
+            let stop = effect(() => {});
 
-        stop();
-    });
+            stop();
+        }),
+        bench('effect with 1 signal', () => {
+            let s = signal(0);
 
-    bench('effect with 10 signals', () => {
-        let signals: ReturnType<typeof signal<number>>[] = [];
+            let stop = effect(() => {
+                read(s);
+            });
 
-        for (let i = 0; i < 10; i++) {
-            signals.push(signal(i));
-        }
+            stop();
+        }),
+        bench('effect with 10 signals', () => {
+            let signals: ReturnType<typeof signal<number>>[] = [];
 
-        let stop = effect(() => {
             for (let i = 0; i < 10; i++) {
-                read(signals[i]);
+                signals.push(signal(i));
             }
-        });
-
-        stop();
-    });
-});
-
 
-describe('propagation', () => {
-    bench('1 signal → 1 effect (sync write)', () => {
-        let s = signal(0),
-            i = 0;
+            let stop = effect(() => {
+                for (let i = 0; i < 10; i++) {
+                    read(signals[i]);
+                }
+            });
 
-        effect(() => {
-            read(s);
-        });
+            stop();
+        })
+    );
+});
 
-        write(s, ++i);
-    });
 
-    bench('1 signal → 10 effects (sync write)', () => {
-        let s = signal(0),
-            i = 0;
+test('propagation', async ({ bench }) => {
+    await bench.compare(
+        bench('1 signal → 1 effect (sync write)', () => {
+            let s = signal(0),
+                i = 0;
 
-        for (let j = 0; j < 10; j++) {
             effect(() => {
                 read(s);
             });
-        }
-
-        write(s, ++i);
-    });
 
-    bench('10 signals → 1 computed → 1 effect', () => {
-        let signals: ReturnType<typeof signal<number>>[] = [],
-            i = 0;
+            write(s, ++i);
+        }),
+        bench('1 signal → 10 effects (sync write)', () => {
+            let s = signal(0),
+                i = 0;
 
-        for (let j = 0; j < 10; j++) {
-            signals.push(signal(j));
-        }
+            for (let j = 0; j < 10; j++) {
+                effect(() => {
+                    read(s);
+                });
+            }
 
-        let c = computed(() => {
-            let sum = 0;
+            write(s, ++i);
+        }),
+        bench('10 signals → 1 computed → 1 effect', () => {
+            let signals: ReturnType<typeof signal<number>>[] = [],
+                i = 0;
 
             for (let j = 0; j < 10; j++) {
-                sum += read(signals[j]);
+                signals.push(signal(j));
             }
 
-            return sum;
-        });
+            let c = computed(() => {
+                let sum = 0;
 
-        effect(() => {
-            read(c);
-        });
+                for (let j = 0; j < 10; j++) {
+                    sum += read(signals[j]);
+                }
 
-        write(signals[0], ++i);
-    });
+                return sum;
+            });
 
-    bench('deep chain (10 computeds)', () => {
-        let s = signal(0),
-            chain: ReturnType<typeof computed>[] = [],
-            i = 0;
+            effect(() => {
+                read(c);
+            });
 
-        chain[0] = computed(() => read(s) + 1);
+            write(signals[0], ++i);
+        }),
+        bench('deep chain (10 computeds)', () => {
+            let s = signal(0),
+                chain: Computed<number>[] = [],
+                i = 0;
 
-        for (let j = 1; j < 10; j++) {
-            let prev = chain[j - 1];
+            chain[0] = computed(() => read(s) + 1);
 
-            chain[j] = computed(() => read(prev) + 1);
-        }
+            for (let j = 1; j < 10; j++) {
+                let prev = chain[j - 1];
 
-        effect(() => {
-            read(chain[9]);
-        });
+                chain[j] = computed(() => read(prev) + 1);
+            }
 
-        write(s, ++i);
-    });
+            effect(() => {
+                read(chain[9]);
+            });
 
-    bench('wide fan-out (1 signal → 100 computeds)', () => {
-        let s = signal(0),
-            i = 0;
+            write(s, ++i);
+        }),
+        bench('wide fan-out (1 signal → 100 computeds)', () => {
+            let s = signal(0),
+                i = 0;
 
-        for (let j = 0; j < 100; j++) {
-            computed(() => read(s) + j);
-        }
+            for (let j = 0; j < 100; j++) {
+                computed(() => read(s) + j);
+            }
 
-        write(s, ++i);
-    });
+            write(s, ++i);
+        })
+    );
 });
 
 
-describe('memory', () => {
-    bench('create + dispose 100 computeds', () => {
-        let computeds: ReturnType<typeof computed<number>>[] = [];
-
-        for (let i = 0; i < 100; i++) {
-            computeds.push(computed(() => i));
-        }
+test('memory', async ({ bench }) => {
+    await bench.compare(
+        bench('create + dispose 100 computeds', () => {
+            let computeds: ReturnType<typeof computed<number>>[] = [];
 
-        for (let i = 0; i < 100; i++) {
-            dispose(computeds[i]);
-        }
-    });
+            for (let i = 0; i < 100; i++) {
+                computeds.push(computed(() => i));
+            }
 
-    bench('link pool (create + dispose cycle)', () => {
-        let s = signal(0);
+            for (let i = 0; i < 100; i++) {
+                dispose(computeds[i]);
+            }
+        }),
+        bench('link pool (create + dispose cycle)', () => {
+            let s = signal(0);
 
-        for (let i = 0; i < 100; i++) {
-            let c = computed(() => read(s));
+            for (let i = 0; i < 100; i++) {
+                let c = computed(() => read(s));
 
-            read(c);
-            dispose(c);
-        }
-    });
-
-    bench('root scope create + dispose', () => {
-        root((dispose) => {
-            let s = signal(0);
+                read(c);
+                dispose(c);
+            }
+        }),
+        bench('root scope create + dispose', () => {
+            root((dispose) => {
+                let s = signal(0);
 
-            computed(() => read(s));
+                computed(() => read(s));
 
-            dispose();
-        });
-    });
+                dispose();
+            });
+        })
+    );
 });
 
 
-describe('effect stress', () => {
-    bench('create + dispose 1000 effects (pool recycling)', () => {
+test('effect stress', async ({ bench }) => {
+    await bench('create + dispose 1000 effects (pool recycling)', () => {
         for (let i = 0; i < 1000; i++) {
             let stop = effect(() => {});
 
             stop();
         }
-    });
+    }).run();
 });
 
 
-describe('deep propagation', () => {
-    bench('deep chain (50 computeds)', () => {
-        let s = signal(0),
-            chain: ReturnType<typeof computed>[] = [],
-            i = 0;
+test('deep propagation', async ({ bench }) => {
+    await bench.compare(
+        bench('deep chain (50 computeds)', () => {
+            let s = signal(0),
+                chain: Computed<number>[] = [],
+                i = 0;
 
-        chain[0] = computed(() => read(s) + 1);
+            chain[0] = computed(() => read(s) + 1);
 
-        for (let j = 1; j < 50; j++) {
-            let prev = chain[j - 1];
-
-            chain[j] = computed(() => read(prev) + 1);
-        }
+            for (let j = 1; j < 50; j++) {
+                let prev = chain[j - 1];
 
-        effect(() => {
-            read(chain[49]);
-        });
+                chain[j] = computed(() => read(prev) + 1);
+            }
 
-        write(s, ++i);
-    });
+            effect(() => {
+                read(chain[49]);
+            });
 
-    bench('deep chain (100 computeds)', () => {
-        let s = signal(0),
-            chain: ReturnType<typeof computed>[] = [],
-            i = 0;
+            write(s, ++i);
+        }),
+        bench('deep chain (100 computeds)', () => {
+            let s = signal(0),
+                chain: Computed<number>[] = [],
+                i = 0;
 
-        chain[0] = computed(() => read(s) + 1);
+            chain[0] = computed(() => read(s) + 1);
 
-        for (let j = 1; j < 100; j++) {
-            let prev = chain[j - 1];
+            for (let j = 1; j < 100; j++) {
+                let prev = chain[j - 1];
 
-            chain[j] = computed(() => read(prev) + 1);
-        }
+                chain[j] = computed(() => read(prev) + 1);
+            }
 
-        effect(() => {
-            read(chain[99]);
-        });
+            effect(() => {
+                read(chain[99]);
+            });
 
-        write(s, ++i);
-    });
+            write(s, ++i);
+        })
+    );
 });
 
 
-describe('stabilization', () => {
-    bench('write during stabilization (reschedule path)', () => {
-        let a = signal(0),
-            b = signal(0),
-            i = 0;
+test('stabilization', async ({ bench }) => {
+    await bench.compare(
+        bench('write during stabilization (reschedule path)', () => {
+            let a = signal(0),
+                b = signal(0),
+                i = 0;
 
-        effect(() => {
-            let val = read(a);
-
-            if (val > 0) {
-                write(b, val * 10);
-            }
-        });
+            effect(() => {
+                let val = read(a);
 
-        effect(() => {
-            read(b);
-        });
+                if (val > 0) {
+                    write(b, val * 10);
+                }
+            });
 
-        write(a, ++i);
-    });
+            effect(() => {
+                read(b);
+            });
 
-    bench('read computed during stabilization', () => {
-        let a = signal(0),
-            b = signal(0),
-            c = computed(() => read(b) * 2),
-            i = 0;
+            write(a, ++i);
+        }),
+        bench('read computed during stabilization', () => {
+            let a = signal(0),
+                b = signal(0),
+                c = computed(() => read(b) * 2),
+                i = 0;
 
-        effect(() => {
-            let val = read(a);
+            effect(() => {
+                let val = read(a);
 
-            if (val > 0) {
-                write(b, val * 10);
-            }
-        });
+                if (val > 0) {
+                    write(b, val * 10);
+                }
+            });
 
-        effect(() => {
-            read(c);
-        });
+            effect(() => {
+                read(c);
+            });
 
-        write(a, ++i);
-    });
+            write(a, ++i);
+        })
+    );
 });
 
 
-describe('root', () => {
-    bench('root scope creation + disposal', () => {
+test('root', async ({ bench }) => {
+    await bench('root scope creation + disposal', () => {
         root((dispose) => {
             dispose();
         });
-    });
+    }).run();
 });
 
 
-describe('onCleanup', () => {
-    bench('register 1 cleanup', () => {
-        root(() => {
-            effect(() => {
-                onCleanup(() => {});
-            });
-        });
-    });
-
-    bench('register 10 cleanups', () => {
-        root(() => {
-            effect(() => {
-                for (let i = 0; i < 10; i++) {
+test('onCleanup', async ({ bench }) => {
+    await bench.compare(
+        bench('register 1 cleanup', () => {
+            root(() => {
+                effect(() => {
                     onCleanup(() => {});
-                }
+                });
             });
-        });
-    });
+        }),
+        bench('register 10 cleanups', () => {
+            root(() => {
+                effect(() => {
+                    for (let i = 0; i < 10; i++) {
+                        onCleanup(() => {});
+                    }
+                });
+            });
+        })
+    );
 });