fix: remove dirtyAsyncCheck option and implement

src/bench.ts

@@ -8,7 +8,7 @@ import type {
 } from 'types/index';
 import { createBenchEvent } from './event';
 import Task from './task';
-import { isAsyncFunction, isAsyncFunctionDirty, now } from './utils';
+import { now } from './utils';
 
 /**
  * The Benchmark instance for keeping track of the benchmark tasks and controlling
@@ -32,8 +32,6 @@ export default class Bench extends EventTarget {
 
   now = now;
 
-  isAsyncFunction: (fn: Fn) => boolean;
-
   setup: Hook;
 
   teardown: Hook;
@@ -44,7 +42,6 @@ export default class Bench extends EventTarget {
     this.warmupTime = options.warmupTime ?? this.warmupTime;
     this.warmupIterations = options.warmupIterations ?? this.warmupIterations;
     this.time = options.time ?? this.time;
-    this.isAsyncFunction = options.dirtyAsyncCheck ? isAsyncFunctionDirty : isAsyncFunction;
     this.iterations = options.iterations ?? this.iterations;
     this.signal = options.signal;
     // eslint-disable-next-line @typescript-eslint/no-empty-function

src/task.ts

@@ -4,7 +4,7 @@ import type {
 import Bench from './bench';
 import tTable from './constants';
 import { createBenchEvent } from './event';
-import { getMean, getVariance } from './utils';
+import { getMean, getVariance, isAsyncFunction } from './utils';
 
 /**
  * A class that represents each benchmark task in Tinybench. It keeps track of the
@@ -47,7 +47,7 @@ export default class Task extends EventTarget {
     this.dispatchEvent(createBenchEvent('start', this));
     let totalTime = 0; // ms
     const samples: number[] = [];
-    const isAsync = this.bench.isAsyncFunction(this.fn);
+    const isAsync = isAsyncFunction(this.fn);
 
     await this.bench.setup(this, 'run');
     while (

src/utils.ts

@@ -29,16 +29,3 @@ const AsyncFunctionConstructor = (async () => {}).constructor;
  * an async function check method only consider runtime support async syntax
  */
 export const isAsyncFunction = (fn: Fn) => fn.constructor === AsyncFunctionConstructor;
-
-/**
- * an async function check method consider runtime not support async syntax
- */
-export const isAsyncFunctionDirty = (fn: Fn) => {
-  try {
-    const ret = fn();
-    return !!ret && typeof ret === 'object' && typeof ret.then === 'function';
-  } catch {
-    // if fn throw error directly, consider it's a sync function
-    return false;
-  }
-};

types/index.d.ts

@@ -179,16 +179,6 @@ export type Options = {
    */
   now?: () => number;
 
-  /**
-   * decide use which way to check task's fn is a async function.
-   *
-   * when it's false, only compare function's constructor
-   * when is's true, run task's fn and check whether return a PromiseLike object
-   *
-   * @default false
-   */
-  dirtyAsyncCheck?: boolean;
-
   /**
    * An AbortSignal for aborting the benchmark
    */