overtake 2.0.2 → 2.0.3

package/build/executor.js

@@ -115,15 +115,16 @@ export const createExecutor = (options) => {
             }
         }
         const stats = count > 0 ? computeStats(durations) : undefined;
-        const report = reportTypes
+        const entries = reportTypes
             .map((type) => [type, createReport(durations, type, stats)])
             .concat([
             ['count', count],
             ['heapUsedKB', heapUsedKB],
             ['dceWarning', dceWarning],
-            ['error', workerError],
         ]);
-        return Object.fromEntries(report);
+        if (workerError)
+            entries.push(['error', workerError]);
+        return Object.fromEntries(entries);
     };
     return {
         pushAsync,

package/build/loader-hook.d.ts

@@ -0,0 +1,2 @@
+export declare function resolve(specifier: string, context: unknown, nextResolve: (...args: unknown[]) => unknown): Promise<unknown>;
+export declare function load(url: string, context: unknown, nextLoad: (...args: unknown[]) => unknown): Promise<unknown>;

package/build/loader-hook.js

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { transformSync } from '@swc/core';
+export async function resolve(specifier, context, nextResolve) {
+    try {
+        return await nextResolve(specifier, context);
+    }
+    catch (e) {
+        if (specifier.endsWith('.js'))
+            try {
+                return await nextResolve(specifier.slice(0, -3) + '.ts', context);
+            }
+            catch { }
+        throw e;
+    }
+}
+export async function load(url, context, nextLoad) {
+    if (!url.endsWith('.ts') && !url.endsWith('.mts')) {
+        return nextLoad(url, context);
+    }
+    const filePath = fileURLToPath(url);
+    const rawSource = await readFile(filePath, 'utf-8');
+    const { code } = transformSync(rawSource, {
+        filename: filePath,
+        jsc: {
+            parser: { syntax: 'typescript' },
+            target: 'esnext',
+        },
+        module: { type: 'es6' },
+        sourceMaps: false,
+    });
+    return { format: 'module', source: code, shortCircuit: true };
+}

package/build/register-hook.js

@@ -1,15 +1,2 @@
 import { register } from 'node:module';
-async function resolve(s, c, n) {
-    try {
-        return await n(s, c);
-    }
-    catch (e) {
-        if (s.endsWith('.js'))
-            try {
-                return await n(s.slice(0, -3) + '.ts', c);
-            }
-            catch { }
-        throw e;
-    }
-}
-register('data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`));
+register(new URL('../build/loader-hook.js', import.meta.url).href);

package/build/utils.js

@@ -1,18 +1,5 @@
 import { parseSync } from '@swc/core';
-async function resolve(s, c, n) {
-    try {
-        return await n(s, c);
-    }
-    catch (e) {
-        if (s.endsWith('.js'))
-            try {
-                return await n(s.slice(0, -3) + '.ts', c);
-            }
-            catch { }
-        throw e;
-    }
-}
-export const resolveHookUrl = 'data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`);
+export const resolveHookUrl = new URL('./loader-hook.js', import.meta.url).href;
 export const isqrt = (n) => {
     if (n < 0n)
         throw new RangeError('Square root of negative');
@@ -44,7 +31,7 @@ export const max = (a, b) => {
 export function div(a, b, decimals = 2) {
     if (b === 0n)
         throw new RangeError('Division by zero');
-    const neg = (a < 0n) !== (b < 0n);
+    const neg = a < 0n !== b < 0n;
     const absA = a < 0n ? -a : a;
     const absB = b < 0n ? -b : b;
     const scale = 10n ** BigInt(decimals);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overtake",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "NodeJS performance benchmark",
   "type": "module",
   "types": "build/index.d.ts",
@@ -12,7 +12,7 @@
     "overtake": "bin/overtake.js"
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=22"
   },
   "repository": {
     "type": "git",

package/src/__tests__/fixtures/enum-bench.ts

@@ -0,0 +1,17 @@
+import 'overtake';
+
+const suite = benchmark('ops', () => null);
+
+const target = suite.target('enum', () => {
+  enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+  }
+  return { Direction };
+});
+
+target.measure('access', ({ Direction }) => {
+  return Direction.Up + Direction.Right;
+});

package/src/__tests__/fixtures/param-property-bench.ts

@@ -0,0 +1,14 @@
+import 'overtake';
+
+const suite = benchmark('ops', () => null);
+
+const target = suite.target('param-property', () => {
+  class Container {
+    constructor(public value: number) {}
+  }
+  return { Container };
+});
+
+target.measure('create', ({ Container }) => {
+  return new Container(42);
+});

package/src/__tests__/loader-hook.ts

@@ -0,0 +1,33 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+
+const exec = promisify(execFile);
+const overtakeBin = fileURLToPath(new URL('../../bin/overtake.js', import.meta.url));
+const nodeFlags = ['--experimental-vm-modules', '--no-warnings', '--expose-gc'];
+
+const runBench = async (fixture: string) => {
+  const { stdout } = await exec(process.execPath, [...nodeFlags, overtakeBin, '-f', 'json', '--max-cycles', '50', '--min-cycles', '10', '--warmup-cycles', '5', fixture], {
+    timeout: 30_000,
+  });
+
+  const result = JSON.parse(stdout);
+  const key = Object.keys(result)[0];
+  assert.ok(key, 'should have at least one benchmark result');
+  const feeds = result[key];
+  const feed = Object.keys(feeds)[0];
+  assert.ok(feeds[feed].ops, 'should have ops metric');
+  assert.ok(!feeds[feed].error, 'should not have an error');
+};
+
+describe('loader-hook', () => {
+  it('loads benchmark files using parameter properties', async () => {
+    await runBench(fileURLToPath(new URL('fixtures/param-property-bench.ts', import.meta.url)));
+  });
+
+  it('loads benchmark files using enums', async () => {
+    await runBench(fileURLToPath(new URL('fixtures/enum-bench.ts', import.meta.url)));
+  });
+});

package/src/executor.ts

@@ -153,15 +153,15 @@ export const createExecutor = <TContext, TInput, R extends ReportTypeList>(optio
     }
 
     const stats = count > 0 ? computeStats(durations) : undefined;
-    const report = reportTypes
+    const entries: [string, unknown][] = reportTypes
       .map<[string, unknown]>((type) => [type, createReport(durations, type, stats)] as [ReportType, Report])
       .concat([
         ['count', count],
         ['heapUsedKB', heapUsedKB],
         ['dceWarning', dceWarning],
-        ['error', workerError],
       ]);
-    return Object.fromEntries(report);
+    if (workerError) entries.push(['error', workerError]);
+    return Object.fromEntries(entries);
   };
 
   return {

package/src/loader-hook.ts

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { transformSync } from '@swc/core';
+
+export async function resolve(specifier: string, context: unknown, nextResolve: (...args: unknown[]) => unknown) {
+  try {
+    return await nextResolve(specifier, context);
+  } catch (e) {
+    if (specifier.endsWith('.js'))
+      try {
+        return await nextResolve(specifier.slice(0, -3) + '.ts', context);
+      } catch {}
+    throw e;
+  }
+}
+
+export async function load(url: string, context: unknown, nextLoad: (...args: unknown[]) => unknown) {
+  if (!url.endsWith('.ts') && !url.endsWith('.mts')) {
+    return nextLoad(url, context);
+  }
+  const filePath = fileURLToPath(url);
+  const rawSource = await readFile(filePath, 'utf-8');
+  const { code } = transformSync(rawSource, {
+    filename: filePath,
+    jsc: {
+      parser: { syntax: 'typescript' },
+      target: 'esnext',
+    },
+    module: { type: 'es6' },
+    sourceMaps: false,
+  });
+  return { format: 'module', source: code, shortCircuit: true };
+}

package/src/register-hook.ts

@@ -1,15 +1,3 @@
 import { register } from 'node:module';
 
-async function resolve(s: string, c: unknown, n: (...args: unknown[]) => unknown) {
-  try {
-    return await n(s, c);
-  } catch (e) {
-    if (s.endsWith('.js'))
-      try {
-        return await n(s.slice(0, -3) + '.ts', c);
-      } catch {}
-    throw e;
-  }
-}
-
-register('data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`));
+register(new URL('../build/loader-hook.js', import.meta.url).href);

package/src/utils.ts

@@ -1,18 +1,6 @@
 import { parseSync } from '@swc/core';
 
-async function resolve(s: string, c: unknown, n: (...args: unknown[]) => unknown) {
-  try {
-    return await n(s, c);
-  } catch (e) {
-    if (s.endsWith('.js'))
-      try {
-        return await n(s.slice(0, -3) + '.ts', c);
-      } catch {}
-    throw e;
-  }
-}
-
-export const resolveHookUrl = 'data:text/javascript,' + encodeURIComponent(`export ${resolve.toString()}`);
+export const resolveHookUrl = new URL('./loader-hook.js', import.meta.url).href;
 
 export const isqrt = (n: bigint): bigint => {
   if (n < 0n) throw new RangeError('Square root of negative');