chore: improve code size (#443)

* chore: reduce package size

* reduce sligtly

* reduce sligtly

Author: Uzlopak

src/bench.ts

@@ -47,7 +47,7 @@ export class Bench extends EventTarget implements BenchLike {
    * - When `mode` is set to 'task', each task's iterations (calls of a task function) run concurrently.
    * - When `mode` is set to 'bench', different tasks within the bench run concurrently.
    */
-  readonly concurrency: 'bench' | 'task' | null = null
+  readonly concurrency: 'bench' | 'task' | null
 
   /**
    * The amount of executions per task.
@@ -107,7 +107,7 @@ export class Bench extends EventTarget implements BenchLike {
    * The maximum number of concurrent tasks to run
    * @default Number.POSITIVE_INFINITY
    */
-  readonly threshold = Number.POSITIVE_INFINITY
+  readonly threshold: number
 
   /**
    * Whether to throw an error if a task function throws
@@ -159,7 +159,7 @@ export class Bench extends EventTarget implements BenchLike {
   /**
    * The task map
    */
-  readonly #tasks = new Map<string, Task>()
+  readonly #tasks: Map<string, Task> = new Map<string, Task>()
 
   constructor (options: BenchOptions = {}) {
     super()
@@ -168,7 +168,7 @@ export class Bench extends EventTarget implements BenchLike {
     this.runtime = runtime
     this.runtimeVersion = runtimeVersion
     this.concurrency = restOptions.concurrency ?? null
-    this.threshold = restOptions.threshold ?? Number.POSITIVE_INFINITY
+    this.threshold = restOptions.threshold ?? Infinity
 
     this.time = restOptions.time ?? defaultTime
     this.iterations = restOptions.iterations ?? defaultIterations

src/task.ts

@@ -19,7 +19,7 @@ import type {
 import { BenchEvent } from './event'
 import {
   assert,
-  getStatisticsSorted,
+  computeStatistics,
   isFnAsyncResource,
   isPromiseLike,
   isValidSamples,
@@ -339,41 +339,37 @@ export class Task extends EventTarget {
   ): Promise<
     { error: Error; samples?: never } | { error?: never; samples?: Samples }
   > {
-    if (this.#fnOpts.beforeAll) {
-      try {
+    try {
+      if (this.#fnOpts.beforeAll) {
         await this.#fnOpts.beforeAll.call(this, mode)
-      } catch (error) {
-        return { error: toError(error) }
       }
-    }
 
-    let totalTime = 0 // ms
-    const samples: number[] = []
+      let totalTime = 0 // ms
+      const samples: number[] = []
 
-    const benchmarkTask = async () => {
-      if (this.#aborted) {
-        return
-      }
-      try {
-        if (this.#fnOpts.beforeEach != null) {
-          await this.#fnOpts.beforeEach.call(this, mode)
+      const benchmarkTask = async () => {
+        if (this.#aborted) {
+          return
         }
-
-        const taskTime = this.#async
-          ? await this.#measure()
-          : this.#measureSync()
-
-        samples.push(taskTime)
-        totalTime += taskTime
-      } finally {
-        if (this.#fnOpts.afterEach != null) {
-          await this.#fnOpts.afterEach.call(this, mode)
+        try {
+          if (this.#fnOpts.beforeEach != null) {
+            await this.#fnOpts.beforeEach.call(this, mode)
+          }
+
+          const taskTime = this.#async
+            ? await this.#measure()
+            : this.#measureSync()
+
+          samples.push(taskTime)
+          totalTime += taskTime
+        } finally {
+          if (this.#fnOpts.afterEach != null) {
+            await this.#fnOpts.afterEach.call(this, mode)
+          }
         }
       }
-    }
 
-    if (this.#bench.concurrency === 'task') {
-      try {
+      if (this.#bench.concurrency === 'task') {
         await withConcurrency({
           fn: benchmarkTask,
           iterations,
@@ -382,33 +378,25 @@ export class Task extends EventTarget {
           time,
           timestampProvider: this.#timestampProvider,
         })
-      } catch (error) {
-        return { error: toError(error) }
-      }
-      this.#runs = samples.length
-    } else {
-      try {
+        this.#runs = samples.length
+      } else {
         while (
           // eslint-disable-next-line no-unmodified-loop-condition
           (totalTime < time || samples.length < iterations) &&
           !this.#aborted
         ) {
           await benchmarkTask()
         }
-      } catch (error) {
-        return { error: toError(error) }
       }
-    }
 
-    if (this.#fnOpts.afterAll != null) {
-      try {
+      if (this.#fnOpts.afterAll != null) {
         await this.#fnOpts.afterAll.call(this, mode)
-      } catch (error) {
-        return { error: toError(error) }
       }
-    }
 
-    return isValidSamples(samples) ? { samples } : {}
+      return isValidSamples(samples) ? { samples } : {}
+    } catch (error) {
+      return { error: toError(error) }
+    }
   }
 
   /**
@@ -422,73 +410,65 @@ export class Task extends EventTarget {
     time: number,
     iterations: number
   ): { error: Error; samples?: never } | { error?: never; samples?: Samples } {
-    if (this.#fnOpts.beforeAll) {
-      try {
+    try {
+      if (this.#fnOpts.beforeAll) {
         const beforeAllResult = this.#fnOpts.beforeAll.call(this, mode)
         assert(
           !isPromiseLike(beforeAllResult),
           '`beforeAll` function must be sync when using `runSync()`'
         )
-      } catch (error) {
-        return { error: toError(error) }
       }
-    }
 
-    let totalTime = 0
-    const samples: number[] = []
+      let totalTime = 0
+      const samples: number[] = []
 
-    const benchmarkTask = () => {
-      if (this.#aborted) {
-        return
-      }
-      try {
-        if (this.#fnOpts.beforeEach) {
-          const beforeEachResult = this.#fnOpts.beforeEach.call(this, mode)
-          assert(
-            !isPromiseLike(beforeEachResult),
-            '`beforeEach` function must be sync when using `runSync()`'
-          )
+      const benchmarkTask = () => {
+        if (this.#aborted) {
+          return
         }
-
-        const taskTime = this.#measureSync()
-
-        samples.push(taskTime)
-        totalTime += taskTime
-      } finally {
-        if (this.#fnOpts.afterEach) {
-          const afterEachResult = this.#fnOpts.afterEach.call(this, mode)
-          assert(
-            !isPromiseLike(afterEachResult),
-            '`afterEach` function must be sync when using `runSync()`'
-          )
+        try {
+          if (this.#fnOpts.beforeEach) {
+            const beforeEachResult = this.#fnOpts.beforeEach.call(this, mode)
+            assert(
+              !isPromiseLike(beforeEachResult),
+              '`beforeEach` function must be sync when using `runSync()`'
+            )
+          }
+
+          const taskTime = this.#measureSync()
+
+          samples.push(taskTime)
+          totalTime += taskTime
+        } finally {
+          if (this.#fnOpts.afterEach) {
+            const afterEachResult = this.#fnOpts.afterEach.call(this, mode)
+            assert(
+              !isPromiseLike(afterEachResult),
+              '`afterEach` function must be sync when using `runSync()`'
+            )
+          }
         }
       }
-    }
 
-    try {
       while (
         // eslint-disable-next-line no-unmodified-loop-condition
         (totalTime < time || samples.length < iterations) &&
         !this.#aborted
       ) {
         benchmarkTask()
       }
-    } catch (error) {
-      return { error: toError(error) }
-    }
 
-    if (this.#fnOpts.afterAll) {
-      try {
+      if (this.#fnOpts.afterAll) {
         const afterAllResult = this.#fnOpts.afterAll.call(this, mode)
         assert(
           !isPromiseLike(afterAllResult),
           '`afterAll` function must be sync when using `runSync()`'
         )
-      } catch (error) {
-        return { error: toError(error) }
       }
+      return isValidSamples(samples) ? { samples } : {}
+    } catch (error) {
+      return { error: toError(error) }
     }
-    return isValidSamples(samples) ? { samples } : {}
   }
 
   /**
@@ -585,7 +565,7 @@ export class Task extends EventTarget {
 
       sortSamples(latencySamples)
 
-      const latencyStatistics = getStatisticsSorted(latencySamples, this.#retainSamples)
+      const latencyStatistics = computeStatistics(latencySamples, this.#retainSamples)
       const latencyStatisticsMean = latencyStatistics.mean
 
       let totalTime = 0
@@ -603,7 +583,7 @@ export class Task extends EventTarget {
       }
 
       sortSamples(throughputSamples)
-      const throughputStatistics = getStatisticsSorted(throughputSamples, this.#retainSamples)
+      const throughputStatistics = computeStatistics(throughputSamples, this.#retainSamples)
 
       /* eslint-disable perfectionist/sort-objects */
       this.#result = {

src/utils.ts

@@ -164,9 +164,9 @@ export const formatNumber = (
   significantDigits = 5,
   maxFractionDigits = 2
 ): string => {
-  if (value === Number.POSITIVE_INFINITY) return '+∞'
-  if (value === Number.NEGATIVE_INFINITY) return '-∞'
-  if (Number.isNaN(value)) return 'NaN'
+  if (value === Infinity) return '+∞'
+  if (value === -Infinity) return '-∞'
+  if (value !== value) return 'NaN' // eslint-disable-line no-self-compare
 
   const absValue = Math.abs(value)
 
@@ -413,15 +413,14 @@ export function absoluteDeviationMedian (
  * @param retainSamples - whether to keep the samples in the statistics
  * @returns the statistics of the sample
  */
-export function getStatisticsSorted (samples: SortedSamples, retainSamples = false): Statistics {
+export function computeStatistics (samples: SortedSamples, retainSamples = false): Statistics {
   const { mean, vr } = meanAndVariance(samples)
   const sd = Math.sqrt(vr)
   const sem = sd / Math.sqrt(samples.length)
   const df = samples.length - 1
   const critical = tTable[df || 1] ?? tTable[0]
   const moe = sem * critical
-  const absMean = Math.abs(mean)
-  const rme = absMean === 0 ? Number.POSITIVE_INFINITY : (moe / absMean) * 100
+  const rme = mean === 0 ? Number.POSITIVE_INFINITY : (moe / Math.abs(mean)) * 100
   const p50 = quantileSorted(samples, 0.5)
 
   return {
@@ -503,8 +502,8 @@ export const defaultConvertTaskResultForConsoleTable: ConsoleTableConverter = (
     'Task name': task.name,
     ...(state === 'aborted-with-statistics' || state === 'completed'
       ? {
-          'Latency avg (ns)': `${formatNumber(mToNs(task.result.latency.mean), 5, 2)} \xb1 ${task.result.latency.rme.toFixed(2)}%`,
-          'Latency med (ns)': `${formatNumber(mToNs(task.result.latency.p50), 5, 2)} \xb1 ${formatNumber(mToNs(task.result.latency.mad), 5, 2)}`,
+          'Latency avg (ns)': `${formatNumber(mToNs(task.result.latency.mean))} \xb1 ${task.result.latency.rme.toFixed(2)}%`,
+          'Latency med (ns)': `${formatNumber(mToNs(task.result.latency.p50))} \xb1 ${formatNumber(mToNs(task.result.latency.mad))}`,
           'Throughput avg (ops/s)': `${Math.round(task.result.throughput.mean).toString()} \xb1 ${task.result.throughput.rme.toFixed(2)}%`,
           'Throughput med (ops/s)': `${Math.round(task.result.throughput.p50).toString()} \xb1 ${Math.round(task.result.throughput.mad).toString()}`,
           Samples: task.result.latency.samplesCount,
@@ -635,7 +634,7 @@ export const withConcurrency = async <R>(
   await Promise.allSettled(promises)
 
   if (errors.length === 0) return results
-  if (errors.length === 1) throw toError(errors[0])
+  if (errors.length === 1) throw errors[0] // eslint-disable-line @typescript-eslint/only-throw-error
   throw new AggregateError(
     errors,
     'Multiple errors occurred during concurrent execution'
@@ -663,25 +662,12 @@ export const performanceNowTimestampProvider: TimestampProvider = {
  * Returns the current timestamp in nanoseconds using `process.hrtime.bigint()`.
  * @returns the current timestamp in nanoseconds
  */
-const hrtimeBigint =
-  typeof (globalThis as { process?: { hrtime?: { bigint: () => bigint } } })
-    .process?.hrtime?.bigint === 'function'
-    ? (
-        globalThis as unknown as {
-          process: { hrtime: { bigint: () => bigint } }
-        }
-      ).process.hrtime.bigint.bind(
-        (
-          globalThis as unknown as {
-            process: { hrtime: { bigint: () => bigint } }
-          }
-        ).process.hrtime
-      )
-    : () => {
-        throw new Error(
-          'hrtime.bigint() is not supported in this JS environment'
-        )
-      }
+const hrtimeBigint = globalThis.process?.hrtime?.bigint.bind(globalThis.process?.hrtime) ?? // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+  (() => {
+    throw new Error(
+      'hrtime.bigint() is not supported in this JS environment'
+    )
+  })
 /* eslint-enable jsdoc/require-returns-check */
 
 /**