flexi-bench 0.0.0-alpha.4 → 0.2.0

package/dist/suite.js

@@ -1,24 +1,21 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Suite = void 0;
+const api_types_1 = require("./api-types");
 const suite_console_reporter_1 = require("./reporters/suite-console-reporter");
 class Suite {
+    name;
+    benchmarks = [];
+    variations = [];
+    reporter;
+    benchmarkReporter;
+    errorStrategy = api_types_1.ErrorStrategy.Continue;
+    shouldSetErrorStrategyOnBenchmarks = false;
     constructor(name, options) {
         this.name = name;
-        this.benchmarks = [];
-        this.variations = [];
         this.name = name;
         this.benchmarks = [];
-        this.reporter = (options === null || options === void 0 ? void 0 : options.reporter) || new suite_console_reporter_1.SuiteConsoleReporter();
+        this.reporter = options?.reporter || new suite_console_reporter_1.SuiteConsoleReporter();
     }
     addBenchmark(benchmark) {
         this.benchmarks.push(benchmark);
@@ -40,19 +37,42 @@ class Suite {
         this.benchmarkReporter = reporter;
         return this;
     }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = {};
-            for (const benchmark of this.benchmarks) {
-                benchmark.withVariations(this.variations);
-                if (this.benchmarkReporter) {
-                    benchmark.withReporter(this.benchmarkReporter);
-                }
-                results[benchmark.name] = yield benchmark.run();
+    /**
+     * Sets the error strategy for the suite and optionally for the benchmarks.
+     * @param errorStrategy Determines what to do when an error occurs during a benchmark run. See {@link ErrorStrategy}
+     * @param opts Options for the error strategy. If `shouldSetOnBenchmarks` is true, the error strategy will be set on all benchmarks in the suite.
+     */
+    withErrorStrategy(errorStrategy, opts) {
+        this.errorStrategy = errorStrategy;
+        if (opts?.shouldSetOnBenchmarks) {
+            this.shouldSetErrorStrategyOnBenchmarks = opts?.shouldSetOnBenchmarks;
+        }
+        return this;
+    }
+    async run() {
+        this.reporter.onSuiteStart?.(this.name);
+        const results = {};
+        for (const benchmark of this.benchmarks) {
+            this.reporter.onBenchmarkStart?.(benchmark.name);
+            benchmark.withVariations(this.variations);
+            if (this.benchmarkReporter) {
+                benchmark.withReporter(this.benchmarkReporter);
+            }
+            if (this.shouldSetErrorStrategyOnBenchmarks) {
+                benchmark.withErrorStrategy(this.errorStrategy);
+            }
+            const benchmarkResults = await benchmark.run();
+            results[benchmark.name] = benchmarkResults;
+            this.reporter.onBenchmarkEnd?.(benchmark.name, benchmarkResults);
+        }
+        this.reporter.report(results);
+        if (this.errorStrategy === api_types_1.ErrorStrategy.DelayedThrow) {
+            const failedResults = Object.values(results).flatMap((r) => r.filter((r) => r.failed));
+            if (failedResults.length > 0) {
+                throw new api_types_1.AggregateSuiteError(results);
             }
-            this.reporter.report(results);
-            return results;
-        });
+        }
+        return results;
     }
 }
 exports.Suite = Suite;

package/dist/variation.d.ts

@@ -4,7 +4,46 @@ export declare class Variation extends BenchmarkBase {
     name: string;
     environment: Partial<NodeJS.ProcessEnv>;
     cliArgs: string[];
+    private context;
     constructor(name: string);
+    /**
+     * Sets a value in the variation's context.
+     * This allows passing custom data to the action without using environment variables.
+     *
+     * @example
+     * ```typescript
+     * new Variation('fast-impl')
+     *   .withContext('implementation', fastProcessor)
+     *   .withAction((variation) => {
+     *     const impl = variation.get<DataProcessor>('implementation');
+     *     impl.process(data);
+     *   })
+     * ```
+     */
+    withContext<T>(key: string, value: T): this;
+    /**
+     * Gets a value from the variation's context.
+     * Returns undefined if the key is not found.
+     *
+     * @example
+     * ```typescript
+     * b.withAction((variation) => {
+     *   const driver = variation.get<Driver>('driver');
+     *   driver.connect();
+     * });
+     * ```
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Gets a value from the variation's context with a default value.
+     * Returns the default if the key is not found.
+     *
+     * @example
+     * ```typescript
+     * const iterations = variation.getOrDefault<number>('iterations', 10);
+     * ```
+     */
+    getOrDefault<T>(key: string, defaultValue: T): T;
     static FromEnvironmentVariables(variables: EnvironmentVariableOptions): Variation[];
     /**
      *
@@ -23,6 +62,29 @@ export declare class Variation extends BenchmarkBase {
      * ]);
      */
     static FromCliArgs(args: Array<string | string[]>): Variation[];
+    /**
+     * Creates variations with context values for a single key.
+     * Useful for swapping implementations or configurations.
+     *
+     * @param key The context key to set
+     * @param values Array of [name, value] tuples
+     * @returns An array of variations with context set
+     *
+     * @example
+     * ```typescript
+     * const variations = Variation.FromContext('processor', [
+     *   ['loop', loopProcessor],
+     *   ['reduce', reduceProcessor],
+     * ]);
+     *
+     * benchmark.withVariations(variations);
+     * benchmark.withAction((variation) => {
+     *   const processor = variation.get<DataProcessor>('processor');
+     *   processor.process(data);
+     * });
+     * ```
+     */
+    static FromContexts<T>(key: string, values: readonly (readonly [name: string, value: T])[]): Variation[];
     withEnvironmentVariables(env: Partial<NodeJS.ProcessEnv>): this;
     withEnvironmentVariable(name: string, value: string): this;
     withCliArgs(...args: string[]): this;

package/dist/variation.js

@@ -4,11 +4,58 @@ exports.Variation = void 0;
 const shared_api_1 = require("./shared-api");
 const utils_1 = require("./utils");
 class Variation extends shared_api_1.BenchmarkBase {
+    name;
+    environment = {};
+    cliArgs = [];
+    context = new Map();
     constructor(name) {
         super();
         this.name = name;
-        this.environment = {};
-        this.cliArgs = [];
+    }
+    /**
+     * Sets a value in the variation's context.
+     * This allows passing custom data to the action without using environment variables.
+     *
+     * @example
+     * ```typescript
+     * new Variation('fast-impl')
+     *   .withContext('implementation', fastProcessor)
+     *   .withAction((variation) => {
+     *     const impl = variation.get<DataProcessor>('implementation');
+     *     impl.process(data);
+     *   })
+     * ```
+     */
+    withContext(key, value) {
+        this.context.set(key, value);
+        return this;
+    }
+    /**
+     * Gets a value from the variation's context.
+     * Returns undefined if the key is not found.
+     *
+     * @example
+     * ```typescript
+     * b.withAction((variation) => {
+     *   const driver = variation.get<Driver>('driver');
+     *   driver.connect();
+     * });
+     * ```
+     */
+    get(key) {
+        return this.context.get(key);
+    }
+    /**
+     * Gets a value from the variation's context with a default value.
+     * Returns the default if the key is not found.
+     *
+     * @example
+     * ```typescript
+     * const iterations = variation.getOrDefault<number>('iterations', 10);
+     * ```
+     */
+    getOrDefault(key, defaultValue) {
+        return this.context.get(key) ?? defaultValue;
     }
     static FromEnvironmentVariables(variables) {
         const combinations = (0, utils_1.findCombinations)(variables.map(([name, values]) => values.map((value) => [name, value])));
@@ -49,8 +96,38 @@ class Variation extends shared_api_1.BenchmarkBase {
             return new Variation(label).withCliArgs(...cliArgs);
         });
     }
+    /**
+     * Creates variations with context values for a single key.
+     * Useful for swapping implementations or configurations.
+     *
+     * @param key The context key to set
+     * @param values Array of [name, value] tuples
+     * @returns An array of variations with context set
+     *
+     * @example
+     * ```typescript
+     * const variations = Variation.FromContext('processor', [
+     *   ['loop', loopProcessor],
+     *   ['reduce', reduceProcessor],
+     * ]);
+     *
+     * benchmark.withVariations(variations);
+     * benchmark.withAction((variation) => {
+     *   const processor = variation.get<DataProcessor>('processor');
+     *   processor.process(data);
+     * });
+     * ```
+     */
+    static FromContexts(key, values) {
+        return values.map(([name, value]) => {
+            return new Variation(name).withContext(key, value);
+        });
+    }
     withEnvironmentVariables(env) {
-        this.environment = Object.assign(Object.assign({}, this.environment), env);
+        this.environment = {
+            ...this.environment,
+            ...env,
+        };
         return this;
     }
     withEnvironmentVariable(name, value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flexi-bench",
-  "version": "0.0.0-alpha.4",
+  "version": "0.2.0",
   "description": "",
   "main": "dist/index.js",
   "repository": {
@@ -11,18 +11,22 @@
     "test": "node --import tsx --test './src/**/*.spec.ts'",
     "test:watch": "node --import tsx --test --watch './src/**/*.spec.ts'",
     "build": "tsc -p tsconfig.json",
-    "format": "prettier --write src"
+    "format": "prettier --write src",
+    "prepare": "patch-package && nx build flexi-bench"
   },
   "author": "",
   "license": "MIT",
   "devDependencies": {
+    "@nx-dotnet/nx-ghpages": "^2.3.0",
     "@nx/js": "^19.4.2",
     "@swc-node/register": "~1.9.1",
     "@swc/core": "~1.5.7",
     "@swc/helpers": "~0.5.11",
     "@types/cli-progress": "^3.11.6",
+    "@types/is-ci": "^3.0.4",
     "@types/node": "^20.14.10",
     "nx": "19.4.2",
+    "patch-package": "^8.0.0",
     "prettier": "^3.3.2",
     "ts-node": "^10.9.2",
     "tsx": "^4.16.2",
@@ -31,6 +35,7 @@
   },
   "dependencies": {
     "cli-progress": "^3.12.0",
+    "is-ci": "^4.1.0",
     "markdown-factory": "^0.0.6"
   },
   "nx": {},