feat: add reporterOptions support with printHeader opt (#92)

Fixes: #88

Co-authored-by: Jason <jdmarshall@users.noreply.github.com>

Author: RafaelGSS

README.md

@@ -97,12 +97,14 @@ A `Suite` manages and executes benchmark functions. It provides two methods: `ad
 ### `new Suite([options])`
 
 * `options` {Object} Configuration options for the suite.
-  * `reporter` {Function} Callback function for reporting results. Receives one argument:
+  * `reporter` {Function} Callback function for reporting results. Receives two arguments:
     * `results` {Object[]} Array of benchmark results:
       * `name` {string} Benchmark name.
       * `opsSec` {string} Operations per second.
       * `iterations` {Number} Number of iterations.
       * `histogram` {Histogram} Histogram instance.
+    * `reporterOptions` {Object} Reporter-specific options.
+      * `printHeader` {boolean} Whether to print system information header. **Default:** `true`.
   * `benchmarkMode` {string} Benchmark mode to use. Can be 'ops' or 'time'. **Default:** `'ops'`.
     * `'ops'` - Measures operations per second (traditional benchmarking).
     * `'time'` - Measures actual execution time for a single run.
@@ -252,9 +254,15 @@ const { Suite, chartReport } = require('bench-node');
 
 const suite = new Suite({
   reporter: chartReport,
+  // Optionally control header display
+  reporterOptions: {
+    printHeader: true // Set to false to hide system info header
+  }
 });
 ```
 
+The `reporterOptions.printHeader` setting controls whether the system information (Node.js version, platform, and CPU cores) appears at the top of the output. This is useful when running multiple suites in sequence and you want to avoid duplicate headers.
+
 ### `htmlReport`
 
 The `htmlReport` generates an interactive HTML visualization of benchmark results.

examples/chart-report/node.js

@@ -1,21 +1,46 @@
 const { Suite, chartReport } = require('../../lib');
 const assert = require('node:assert');
 
-const suite = new Suite({
-  reporter: chartReport,
-});
+async function runSuiteOne() {
+  const suite = new Suite({
+    reporter: chartReport,
+  });
 
-suite
-  .add('single with matcher', function () {
-    const pattern = /[123]/g
-    const replacements = { 1: 'a', 2: 'b', 3: 'c' }
-    const subject = '123123123123123123123123123123123123123123123123'
-    const r = subject.replace(pattern, m => replacements[m])
-    assert.ok(r);
-  })
-  .add('multiple replaces', function () {
-    const subject = '123123123123123123123123123123123123123123123123'
-    const r = subject.replace(/1/g, 'a').replace(/2/g, 'b').replace(/3/g, 'c')
-    assert.ok(r);
-  })
-  .run();
+  await suite
+    .add('test 1', function () {
+      const pattern = /[123]/g
+    })
+    .add('test 2', function () {
+      const subject = '123123123123123123123123123123123123123123123123'
+      const r = subject.replace(/1/g, 'a').replace(/2/g, 'b').replace(/3/g, 'c')
+    })
+    .run();
+}
+
+async function runSuiteTwo() {
+  const suite = new Suite({
+    reporter: chartReport,
+    reporterOptions: {
+      printHeader: false
+    }
+  });
+
+  await suite
+    .add('test 3', function () {
+      const pattern = /[123]/g
+    })
+    .add('test 4', function () {
+      const subject = '123123123123123123123123123123123123123123123123'
+      const r = subject.replace(/1/g, 'a').replace(/2/g, 'b').replace(/3/g, 'c')
+      assert.ok(r)
+    })
+    .run();
+}
+
+async function main() {
+  await runSuiteOne()
+  process.stdout.write('\n\n')
+  await runSuiteTwo()
+}
+
+main()

lib/index.js

@@ -108,6 +108,7 @@ class Suite {
 	#plugins;
 	#useWorkers;
 	#benchmarkMode;
+	#reporterOptions;
 
 	constructor(options = {}) {
 		this.#benchmarks = [];
@@ -135,6 +136,10 @@ class Suite {
 		// Benchmark Mode setup
 		this.#benchmarkMode = options.benchmarkMode || "ops"; // Default to 'ops'
 		validateBenchmarkMode(this.#benchmarkMode, "options.benchmarkMode");
+
+		this.#reporterOptions = options.reporterOptions || {
+			printHeader: true,
+		};
 	}
 
 	add(name, options, fn) {
@@ -236,7 +241,7 @@ class Suite {
 		}
 
 		if (this.#reporter) {
-			this.#reporter(results);
+			this.#reporter(results, this.#reporterOptions);
 		}
 
 		return results;

lib/reporter/chart.js

@@ -72,17 +72,19 @@ const environment = {
  * Displays system information and a bar chart of operations per second or time per operation
  * @param {import('../report').BenchmarkResult[]} results - Array of benchmark results
  */
-function chartReport(results) {
+function chartReport(results, options) {
 	// Determine the primary metric and calculate max value for scaling
 	const primaryMetric =
 		results[0]?.opsSec !== undefined ? "opsSec" : "totalTime";
 	const maxValue = Math.max(...results.map((b) => b[primaryMetric]));
 
-	process.stdout.write(
-		`${environment.nodeVersion}\n` +
-			`Platform: ${environment.platform}\n` +
-			`CPU Cores: ${environment.hardware}\n\n`,
-	);
+	if (options?.printHeader) {
+		process.stdout.write(
+			`${environment.nodeVersion}\n` +
+				`Platform: ${environment.platform}\n` +
+				`CPU Cores: ${environment.hardware}\n\n`,
+		);
+	}
 
 	for (const result of results) {
 		drawBar(

test/reporter.js

@@ -70,6 +70,88 @@ describe("chartReport outputs benchmark results as a bar chart", async (t) => {
 	});
 });
 
+describe("chartReport respects reporterOptions.printHeader", async (t) => {
+	let outputWithHeader = "";
+	let outputWithoutHeader = "";
+
+	before(async () => {
+		const originalStdoutWrite = process.stdout.write;
+
+		// Test with default settings (printHeader: true)
+		process.stdout.write = (data) => {
+			outputWithHeader += data;
+		};
+
+		const suiteWithHeader = new Suite({
+			reporter: chartReport,
+			reporterOptions: {
+				printHeader: true,
+			},
+		});
+
+		suiteWithHeader.add("test benchmark", () => {
+			const a = 1 + 1;
+			assert.strictEqual(a, 2);
+		});
+		await suiteWithHeader.run();
+
+		// Test with printHeader: false
+		outputWithoutHeader = "";
+		process.stdout.write = (data) => {
+			outputWithoutHeader += data;
+		};
+
+		const suiteWithoutHeader = new Suite({
+			reporter: chartReport,
+			reporterOptions: {
+				printHeader: false,
+			},
+		});
+
+		suiteWithoutHeader.add("test benchmark", () => {
+			const a = 1 + 1;
+			assert.strictEqual(a, 2);
+		});
+		await suiteWithoutHeader.run();
+
+		process.stdout.write = originalStdoutWrite;
+	});
+
+	it("should include Node.js version when printHeader is true", () => {
+		const regex = /Node\.js version: v\d+\.\d+\.\d+/;
+		assert.ok(outputWithHeader.match(regex));
+	});
+
+	it("should include Platform when printHeader is true", () => {
+		assert.ok(outputWithHeader.includes("Platform:"));
+	});
+
+	it("should include CPU Cores when printHeader is true", () => {
+		assert.ok(outputWithHeader.includes("CPU Cores:"));
+	});
+
+	it("should NOT include Node.js version when printHeader is false", () => {
+		const regex = /Node\.js version: v\d+\.\d+\.\d+/;
+		assert.ok(!outputWithoutHeader.match(regex));
+	});
+
+	it("should NOT include Platform when printHeader is false", () => {
+		assert.ok(!outputWithoutHeader.includes("Platform:"));
+	});
+
+	it("should NOT include CPU Cores when printHeader is false", () => {
+		assert.ok(!outputWithoutHeader.includes("CPU Cores:"));
+	});
+
+	it("should still include benchmark data with or without header", () => {
+		// Both outputs should still have benchmark bars and results
+		assert.ok(outputWithHeader.includes("█"));
+		assert.ok(outputWithoutHeader.includes("█"));
+		assert.ok(outputWithHeader.includes("test benchmark"));
+		assert.ok(outputWithoutHeader.includes("test benchmark"));
+	});
+});
+
 describe("htmlReport should create a file", async (t) => {
 	let output = "";
 	let htmlName = "";