@travetto/test 8.0.0-alpha.9 → 8.0.1

package/README.md

@@ -18,10 +18,10 @@ This module provides unit testing functionality that integrates with the framewo
    *  [JSON](https://www.json.org), best for integrating with at a code level
    *  [xUnit](https://en.wikipedia.org/wiki/XUnit), standard format for CI/CD systems e.g. Jenkins, Bamboo, etc.
 
-**Note**: All tests should be under the `**/*` folders.  The pattern for tests is defined as as a standard glob using [Node](https://nodejs.org)'s built in globbing support.
+**Note**: All tests should be under the `**/*` folders. The pattern for tests is defined as as a standard glob using [Node](https://nodejs.org)'s built in globbing support.
 
 ## Definition
-A test suite is a collection of individual tests.  All test suites are classes with the [@Suite](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/suite.ts#L13) decorator. Tests are defined as methods on the suite class, using the [@Test](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/test.ts#L25) decorator.  All tests intrinsically support `async`/`await`. 
+A test suite is a collection of individual tests. All test suites are classes with the [@Suite](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/suite.ts#L13) decorator. Tests are defined as methods on the suite class, using the [@Test](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/test.ts#L25) decorator. All tests intrinsically support `async`/`await`. 
 
 A simple example would be:
 
@@ -33,7 +33,6 @@ import { Suite, Test } from '@travetto/test';
 
 @Suite()
 class SimpleTest {
-
   #complexService: {
     doLongOperation(): Promise<number>;
     getText(): string;
@@ -54,7 +53,7 @@ class SimpleTest {
 ```
 
 ## Assertions
-A common aspect of the tests themselves are the assertions that are made.  [Node](https://nodejs.org) provides a built-in [assert](https://nodejs.org/api/assert.html) library.  The framework uses AST transformations to modify the assertions to provide integration with the test module, and to provide a much higher level of detail in the failed assertions.  For example:
+A common aspect of the tests themselves are the assertions that are made. [Node](https://nodejs.org) provides a built-in [assert](https://nodejs.org/api/assert.html) library. The framework uses AST transformations to modify the assertions to provide integration with the test module, and to provide a much higher level of detail in the failed assertions. For example:
 
 **Code: Example assertion for deep comparison**
 ```typescript
@@ -64,7 +63,6 @@ import { Suite, Test } from '@travetto/test';
 
 @Suite()
 class SimpleTest {
-
   @Test()
   async test() {
     assert.deepStrictEqual({ size: 20, address: { state: 'VA' } }, {});
@@ -86,11 +84,11 @@ const Δm_1 = ["@travetto/test", "doc/assert-example.ts"];
 import assert from 'node:assert';
 import { Suite, Test } from '@travetto/test';
 let SimpleTest = class SimpleTest {
-    static { Δfunction.registerFunction(SimpleTest, Δm_1, { hash: 1887908328, lines: [5, 12] }, { test: { hash: 102834457, lines: [8, 11, 10] } }, false); }
+    static { Δfunction.registerFunction(SimpleTest, Δm_1, { hash: 539050626, lines: [5, 11] }, { test: { hash: 102834457, lines: [7, 10, 9] } }, false); }
     async test() {
         if (Δdebug.tryDebugger)
             debugger;
-        Δcheck.AssertCheck.check({ module: Δm_1, line: 10, text: "{ size: 20, address: { state: 'VA' } }", operator: "deepStrictEqual" }, true, { size: 20, address: { state: 'VA' } }, {});
+        Δcheck.AssertCheck.check({ module: Δm_1, line: 9, text: "{ size: 20, address: { state: 'VA' } }", operator: "deepStrictEqual" }, true, { size: 20, address: { state: 'VA' } }, {});
     }
 };
 __decorate([
@@ -125,7 +123,7 @@ The equivalences for all of the [assert](https://nodejs.org/api/assert.html) ope
    *  `assert(a.includes(b))` as `assert.ok(a.includes(b))`
    *  `assert(/a/.test(b))` as `assert.ok(/a/.test(b))`
 
-In addition to the standard operations, there is support for throwing/rejecting errors (or the inverse).  This is useful for testing error states or ensuring errors do not occur.
+In addition to the standard operations, there is support for throwing/rejecting errors (or the inverse). This is useful for testing error states or ensuring errors do not occur.
 
 ### Throws
 `throws`/`doesNotThrow` is for catching synchronous rejections
@@ -138,7 +136,6 @@ import { Suite, Test } from '@travetto/test';
 
 @Suite()
 class SimpleTest {
-
   @Test()
   async testThrows() {
     assert.throws(() => {
@@ -146,7 +143,6 @@ class SimpleTest {
     });
 
     assert.doesNotThrow(() => {
-
       let a = 5;
     });
   }
@@ -164,7 +160,6 @@ import { Suite, Test } from '@travetto/test';
 
 @Suite()
 class SimpleTest {
-
   @Test()
   async testRejects() {
     await assert.rejects(async () => {
@@ -172,7 +167,6 @@ class SimpleTest {
     });
 
     await assert.doesNotReject(async () => {
-
       let a = 5;
     });
   }
@@ -193,7 +187,6 @@ import { Suite, Test } from '@travetto/test';
 
 @Suite()
 class SimpleTest {
-
   @Test()
   async errorTypes() {
     assert.throws(() => {
@@ -208,10 +201,11 @@ class SimpleTest {
       throw new Error('Big Error');
     }, Error);
 
-    await assert.rejects(() => {
-      throw new Error('Big Error');
-    }, (error: Error) =>
-      error.message.startsWith('Big') && error.message.length > 4
+    await assert.rejects(
+      () => {
+        throw new Error('Big Error');
+      },
+      (error: Error) => error.message.startsWith('Big') && error.message.length > 4
     );
   }
 }
@@ -220,12 +214,20 @@ class SimpleTest {
 ## Running Tests
 To run the tests you can either call the [Command Line Interface](https://github.com/travetto/travetto/tree/main/module/cli#readme "CLI infrastructure for Travetto framework") by invoking
 
-**Terminal: Test Help Output**
+## CLI - test
+
+**Terminal: Help for test**
 ```bash
 $ trv test --help
 
 Usage: test [options] [first:string] [globs...:string]
 
+Description:
+  Execute the test framework for targeted files, suites, or methods.
+
+  Supports glob-based discovery, import-based targeting, tag filtering, and
+  configurable output consumers for local and CI workflows.
+
 Options:
   -f, --format <string>          Output format for test results (default: "tap")
   -c, --concurrency <number>     Number of tests to run concurrently (default: 9)
@@ -237,9 +239,9 @@ Options:
 The regexes are the patterns of tests you want to run, and all tests must be found under the `test/` folder.
 
 ### Travetto Plugin
-The [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=arcsine.travetto-plugin) also supports test running,  which will provide even more functionality for real-time testing and debugging.
+The [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=arcsine.travetto-plugin) also supports test running, which will provide even more functionality for real-time testing and debugging.
 
 ## Additional Considerations
-During the test execution, a few things additionally happen that should be helpful.  The primary addition, is that all console output is captured, and will be exposed in the test output.  This allows for investigation at a later point in time by analyzing the output. 
+During the test execution, a few things additionally happen that should be helpful. The primary addition, is that all console output is captured, and will be exposed in the test output. This allows for investigation at a later point in time by analyzing the output. 
 
-Like output, all promises are also intercepted.  This allows the code to ensure that all promises have been resolved before completing the test.  Any uncompleted promises will automatically trigger an error state and fail the test.
+Like output, all promises are also intercepted. This allows the code to ensure that all promises have been resolved before completing the test. Any uncompleted promises will automatically trigger an error state and fail the test.

package/__index__.ts

@@ -1,15 +1,15 @@
-import type { } from './src/trv.d.ts';
+import type {} from './src/trv.d.ts';
+
+export * from './src/consumer/registry-index.ts';
+export * from './src/consumer/types.ts';
 export * from './src/decorator/suite.ts';
 export * from './src/decorator/test.ts';
-export * from './src/model/suite.ts';
+export * from './src/fixture.ts';
 export * from './src/model/error.ts';
-export * from './src/model/test.ts';
 export * from './src/model/event.ts';
+export * from './src/model/suite.ts';
+export * from './src/model/test.ts';
 export * from './src/model/util.ts';
-export * from './src/registry/registry-index.ts';
 export * from './src/registry/registry-adapter.ts';
-export * from './src/fixture.ts';
-export * from './src/consumer/types.ts';
-export * from './src/consumer/registry-index.ts';
-
-export { TestWatchEvent } from './src/worker/types.ts';
+export * from './src/registry/registry-index.ts';
+export { TestWatchEvent } from './src/worker/types.ts';

package/package.json

@@ -1,42 +1,45 @@
 {
   "name": "@travetto/test",
-  "version": "8.0.0-alpha.9",
-  "type": "module",
+  "version": "8.0.1",
   "description": "Declarative test framework",
   "keywords": [
-    "unit-testing",
+    "ast-transformations",
+    "decorators",
     "testing",
     "travetto",
     "typescript",
-    "decorators",
-    "ast-transformations"
+    "unit-testing"
   ],
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
+  },
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/test"
   },
   "files": [
     "__index__.ts",
     "src",
     "support"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/test"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@travetto/registry": "^8.0.0-alpha.9",
-    "@travetto/runtime": "^8.0.0-alpha.9",
-    "@travetto/terminal": "^8.0.0-alpha.9",
-    "@travetto/worker": "^8.0.0-alpha.9",
-    "yaml": "^2.8.2"
+    "@travetto/registry": "^8.0.1",
+    "@travetto/runtime": "^8.0.1",
+    "@travetto/terminal": "^8.0.1",
+    "@travetto/worker": "^8.0.1",
+    "yaml": "^2.9.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.14",
-    "@travetto/transformer": "^8.0.0-alpha.4"
+    "@travetto/cli": "^8.0.1",
+    "@travetto/transformer": "^8.0.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {
@@ -52,8 +55,5 @@
     "roles": [
       "test"
     ]
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/assert/capture.ts

@@ -14,7 +14,6 @@ export interface CapturedAssertion extends Partial<Assertion> {
  * Assertion capturer
  */
 class $AssertCapture {
-
   #emitter = new EventEmitter();
 
   /**
@@ -27,15 +26,15 @@ class $AssertCapture {
 
     // Emit and collect, every assertion as it occurs
     const handler = (a: CapturedAssertion): void => {
-      const asrt: Assertion = {
+      const assertion: Assertion = {
         ...a,
         import: a.import ?? a.module!.join('/'),
         classId: test.classId,
         methodName: test.methodName
       };
-      assertions.push(asrt);
+      assertions.push(assertion);
       if (listener) {
-        listener(asrt);
+        listener(assertion);
       }
     };
 
@@ -52,4 +51,4 @@ class $AssertCapture {
   }
 }
 
-export const AssertCapture = new $AssertCapture();
+export const AssertCapture = new $AssertCapture();

package/src/assert/check.ts

@@ -1,20 +1,20 @@
 import assert from 'node:assert';
 import { isPromise } from 'node:util/types';
 
-import { RuntimeError, type Class, castTo, castKey, asConstructable } from '@travetto/runtime';
+import { asConstructable, type Class, castKey, castTo, RuntimeError } from '@travetto/runtime';
 
-import type { ThrowableError, TestConfig, Assertion, TestStatus } from '../model/test.ts';
+import { TestExecutionError } from '../model/error.ts';
+import type { Assertion, TestConfig, TestStatus, ThrowableError } from '../model/test.ts';
 import { AssertCapture, type CapturedAssertion } from './capture.ts';
-import { AssertUtil } from './util.ts';
 import { ASSERT_FN_OPERATOR, OP_MAPPING } from './types.ts';
-import { TestExecutionError } from '../model/error.ts';
+import { AssertUtil } from './util.ts';
 
 type StringFields<T> = {
-  [K in Extract<keyof T, string>]:
-  (T[K] extends string ? K : never)
+  [K in Extract<keyof T, string>]: T[K] extends string ? K : never;
 }[Extract<keyof T, string>];
 
-const isClass = (input: unknown): input is Class => input === Error || input === RuntimeError || Object.getPrototypeOf(input) !== Object.getPrototypeOf(Function);
+const isClass = (input: unknown): input is Class =>
+  input === Error || input === RuntimeError || Object.getPrototypeOf(input) !== Object.getPrototypeOf(Function);
 
 /**
  * Check assertion
@@ -36,7 +36,7 @@ export class AssertCheck {
     };
 
     // Invert check for negative
-    const assertFn = positive ? assert : (value: unknown, msg?: string): unknown => assert(!value, msg);
+    const assertFn = positive ? assert : (value: unknown, msg?: string): unknown => assert(!value, msg!);
 
     // Check fn to call
     if (fn === 'fail') {
@@ -55,7 +55,7 @@ export class AssertCheck {
     } else if (fn === 'ok' || fn === 'assert') {
       fn = assertion.operator = 'ok';
       [assertion.actual, assertion.message] = castTo(args);
-      assertion.expected = { toClean: (): string => positive ? 'truthy' : 'falsy' };
+      assertion.expected = { toClean: (): string => (positive ? 'truthy' : 'falsy') };
       common.state = 'should be';
     } else if (fn === 'includes') {
       assertion.operator = fn;
@@ -64,7 +64,8 @@ export class AssertCheck {
       assertion.operator = fn;
       [assertion.actual, assertion.expected, assertion.message] = castTo(args);
       assertion.actual = asConstructable(assertion.actual)?.constructor;
-    } else { // Handle unknown
+    } else {
+      // Handle unknown
       assertion.operator = fn ?? '';
       [assertion.actual, assertion.expected, assertion.message] = castTo(args);
     }
@@ -83,17 +84,36 @@ export class AssertCheck {
 
       // Actually run the assertion
       switch (fn) {
-        case 'includes': assertFn(castTo<unknown[]>(actual).includes(expected), message); break;
-        case 'test': assertFn(castTo<RegExp>(expected).test(castTo(actual)), message); break;
-        case 'instanceof': assertFn(actual instanceof castTo<Class>(expected), message); break;
-        case 'in': assertFn(castTo<string>(actual) in castTo<object>(expected), message); break;
-        case 'lessThan': assertFn(castTo<number>(actual) < castTo<number>(expected), message); break;
-        case 'lessThanEqual': assertFn(castTo<number>(actual) <= castTo<number>(expected), message); break;
-        case 'greaterThan': assertFn(castTo<number>(actual) > castTo<number>(expected), message); break;
-        case 'greaterThanEqual': assertFn(castTo<number>(actual) >= castTo<number>(expected), message); break;
-        case 'ok': assertFn(...castTo<Parameters<typeof assertFn>>(args)); break;
+        case 'includes':
+          assertFn(castTo<unknown[]>(actual).includes(expected), message);
+          break;
+        case 'test':
+          assertFn(castTo<RegExp>(expected).test(castTo(actual)), message);
+          break;
+        case 'instanceof':
+          assertFn(actual instanceof castTo<Class>(expected), message);
+          break;
+        case 'in':
+          assertFn(castTo<string>(actual) in castTo<object>(expected), message);
+          break;
+        case 'lessThan':
+          assertFn(castTo<number>(actual) < castTo<number>(expected), message);
+          break;
+        case 'lessThanEqual':
+          assertFn(castTo<number>(actual) <= castTo<number>(expected), message);
+          break;
+        case 'greaterThan':
+          assertFn(castTo<number>(actual) > castTo<number>(expected), message);
+          break;
+        case 'greaterThanEqual':
+          assertFn(castTo<number>(actual) >= castTo<number>(expected), message);
+          break;
+        case 'ok':
+          assertFn.apply(null, castTo(args));
+          break;
         default:
-          if (fn && assert[castKey<typeof assert>(fn)]) { // Assert call
+          if (fn && assert[castKey<typeof assert>(fn)]) {
+            // Assert call
             if (/not/i.test(fn)) {
               common.state = 'should not';
             }
@@ -107,7 +127,7 @@ export class AssertCheck {
       // On error, produce the appropriate error message
       if (error instanceof assert.AssertionError) {
         if (!assertion.message) {
-          assertion.message = (OP_MAPPING[fn] ?? '{state} be {expected}');
+          assertion.message = OP_MAPPING[fn] ?? '{state} be {expected}';
         }
         assertion.message = assertion.message
           .replace(/[{]([A-Za-z]+)[}]/g, (a, key: StringFields<Assertion>) => common[key] || assertion[key]!)
@@ -126,7 +146,8 @@ export class AssertCheck {
    * @param error The provided error
    */
   static checkError(shouldThrow: ThrowableError | undefined, error: Error | string | undefined): Error | undefined {
-    if (!shouldThrow) { // If we shouldn't be throwing anything, we are good
+    if (!shouldThrow) {
+      // If we shouldn't be throwing anything, we are good
       return;
     } else if (!error) {
       return new assert.AssertionError({ message: 'Expected to throw an error, but got nothing' });
@@ -152,7 +173,7 @@ export class AssertCheck {
       if (!(error instanceof shouldThrow)) {
         return new assert.AssertionError({
           message: `Expected to throw ${shouldThrow.name}, but got ${error}`,
-          actual: (error ?? 'nothing'),
+          actual: error ?? 'nothing',
           expected: shouldThrow.name
         });
       }
@@ -220,7 +241,10 @@ export class AssertCheck {
         if (typeof shouldThrow === 'function') {
           shouldThrow = shouldThrow.name;
         }
-        throw (missed = new assert.AssertionError({ message: `No error thrown, but expected ${shouldThrow ?? 'an error'}`, expected: shouldThrow ?? 'an error' }));
+        throw (missed = new assert.AssertionError({
+          message: `No error thrown, but expected ${shouldThrow ?? 'an error'}`,
+          expected: shouldThrow ?? 'an error'
+        }));
       }
     } catch (error) {
       this.#onError(positive, message, error, missed, shouldThrow, assertion);
@@ -256,7 +280,10 @@ export class AssertCheck {
         if (typeof shouldThrow === 'function') {
           shouldThrow = shouldThrow.name;
         }
-        throw (missed = new assert.AssertionError({ message: `No error thrown, but expected ${shouldThrow ?? 'an error'}`, expected: shouldThrow ?? 'an error' }));
+        throw (missed = new assert.AssertionError({
+          message: `No error thrown, but expected ${shouldThrow ?? 'an error'}`,
+          expected: shouldThrow ?? 'an error'
+        }));
       }
     } catch (error) {
       this.#onError(positive, message, error, missed, shouldThrow, assertion);
@@ -299,4 +326,4 @@ export class AssertCheck {
       return ['errored', error];
     }
   }
-}
+}

package/src/assert/types.ts

@@ -37,4 +37,4 @@ export const OP_MAPPING: Record<string, string> = {
   instanceof: '{actual} instance {state} be of type {expected}',
   lessThanEqual: '{actual} {state} be less than or equal to {expected}',
   lessThan: '{actual} {state} be less than {expected}'
-};
+};

package/src/assert/util.ts

@@ -1,9 +1,9 @@
 import util from 'node:util';
 
-import { JSONUtil, hasFunction, RuntimeIndex, Util } from '@travetto/runtime';
+import { hasFunction, JSONUtil, RuntimeIndex, Util } from '@travetto/runtime';
 
-import type { Assertion, TestConfig } from '../model/test.ts';
 import type { SuiteConfig } from '../model/suite.ts';
+import type { Assertion, TestConfig } from '../model/test.ts';
 
 const isCleanable = hasFunction<{ toClean(): unknown }>('toClean');
 
@@ -16,7 +16,12 @@ export class AssertUtil {
    */
   static cleanValue(value: unknown): unknown {
     switch (typeof value) {
-      case 'number': case 'boolean': case 'bigint': case 'string': case 'undefined': return value;
+      case 'number':
+      case 'boolean':
+      case 'bigint':
+      case 'string':
+      case 'undefined':
+        return value;
       case 'object': {
         if (isCleanable(value)) {
           return value.toClean();
@@ -38,12 +43,11 @@ export class AssertUtil {
   /**
    * Determine file location for a given error and the stack trace
    */
-  static getPositionOfError(error: Error): { import: string, line: number } | undefined {
-    const frames = Util.stackTraceToParts(error.stack ?? new Error().stack!)
-      .map(frame => {
-        const entry = RuntimeIndex.getEntry(frame.filename);
-        return { ...frame, import: entry?.import!, line: entry?.type === 'ts' ? frame.line : 1 };
-      });
+  static getPositionOfError(error: Error): { import: string; line: number } | undefined {
+    const frames = Util.stackTraceToParts(error.stack ?? new Error().stack!).map(frame => {
+      const entry = RuntimeIndex.getEntry(frame.filename);
+      return { ...frame, import: entry?.import ?? undefined!, line: entry?.type === 'ts' ? frame.line : 1 };
+    });
 
     return frames.find(frame => frame.import);
   }
@@ -51,9 +55,9 @@ export class AssertUtil {
   /**
    * Generate a suite error given a suite config, and an error
    */
-  static generateAssertion(config: { suite: SuiteConfig, test: TestConfig, error: Error, importLocation?: string }): Assertion {
+  static generateAssertion(config: { suite: SuiteConfig; test: TestConfig; error: Error; importLocation?: string }): Assertion {
     const { suite, test, error: errorValue, importLocation } = config;
-    const error = (errorValue.cause && errorValue.cause instanceof Error) ? errorValue.cause : errorValue;
+    const error = errorValue.cause && errorValue.cause instanceof Error ? errorValue.cause : errorValue;
     const testImport = importLocation ?? test.import;
     const position = this.getPositionOfError(error);
     const line = position?.line ?? (testImport === suite.import ? suite.lineStart : 1);
@@ -68,4 +72,4 @@ export class AssertUtil {
       text: test.methodName
     };
   }
-}
+}

package/src/consumer/decorator.ts

@@ -1,7 +1,7 @@
 import type { Class } from '@travetto/runtime';
 
-import type { TestConsumerShape } from './types.ts';
 import { TestConsumerRegistryIndex } from './registry-index.ts';
+import type { TestConsumerShape } from './types.ts';
 
 /**
  * Registers a class a valid test consumer
@@ -10,4 +10,4 @@ export function TestConsumer(): (cls: Class<TestConsumerShape>) => void {
   return function (cls: Class<TestConsumerShape>): void {
     TestConsumerRegistryIndex.getForRegister(cls).register();
   };
-}
+}

package/src/consumer/enhancer.ts

@@ -11,10 +11,10 @@ const input = {
   assertLine: ['#ffffe0'], // light yellow
   objectInspect: ['#cd00cd'], // Magenta
   suiteName: ['#cdcd00'], // Yellow
-  testName: ['#00cdcd'],  // Cyan
-  total: ['#e5e5e5'], // White
+  testName: ['#00cdcd'], // Cyan
+  total: ['#e5e5e5'] // White
 } as const;
 
 export const CONSOLE_ENHANCER = StyleUtil.getPalette(input);
 
-export type TestResultsEnhancer = Record<keyof typeof input, TermStyleFn>;
+export type TestResultsEnhancer = Record<keyof typeof input, TermStyleFn>;

package/src/consumer/registry-adapter.ts

@@ -1,9 +1,9 @@
 import path from 'node:path';
 
-import { classConstruct, describeFunction, type Class } from '@travetto/runtime';
 import type { RegistryAdapter } from '@travetto/registry';
+import { type Class, classConstruct, describeFunction } from '@travetto/runtime';
 
-import type { TestConsumerShape, TestConsumerConfig } from './types.ts';
+import type { TestConsumerConfig, TestConsumerShape } from './types.ts';
 
 /**
  * Test Results Handler Registry
@@ -39,4 +39,4 @@ export class TestConsumerRegistryAdapter implements RegistryAdapter<TestConsumer
     await inst.setOptions?.(options);
     return inst;
   }
-}
+}

package/src/consumer/registry-index.ts

@@ -1,15 +1,14 @@
-import { RuntimeIndex, type Class } from '@travetto/runtime';
 import { Registry, type RegistryIndex, RegistryIndexStore } from '@travetto/registry';
+import { type Class, RuntimeIndex } from '@travetto/runtime';
 
-import type { TestConsumerShape } from './types.ts';
 import type { TestConsumerConfig } from '../execute/types.ts';
 import { TestConsumerRegistryAdapter } from './registry-adapter.ts';
+import type { TestConsumerShape } from './types.ts';
 
 /**
  * Test Results Handler Registry
  */
 export class TestConsumerRegistryIndex implements RegistryIndex {
-
   static #instance = Registry.registerIndex(this);
 
   static getForRegister(cls: Class): TestConsumerRegistryAdapter {
@@ -34,7 +33,9 @@ export class TestConsumerRegistryIndex implements RegistryIndex {
   #initialized: Promise<void>;
   store = new RegistryIndexStore(TestConsumerRegistryAdapter);
 
-  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+  /** @private */ constructor(source: unknown) {
+    Registry.validateConstructor(source);
+  }
 
   /**
    * Manual initialization when running outside of the bootstrap process
@@ -79,4 +80,4 @@ export class TestConsumerRegistryIndex implements RegistryIndex {
     }
     throw new Error(`No test consumer registered for type ${state.consumer}`);
   }
-}
+}

package/src/consumer/types/cumulative.ts

@@ -1,10 +1,10 @@
-import type { TestConsumerShape } from '../types.ts';
+import type { SuiteCore } from '../../model/common.ts';
 import type { TestEvent, TestRemoveEvent } from '../../model/event.ts';
-import type { TestConfig, TestDiffSource, TestResult } from '../../model/test.ts';
 import type { SuiteConfig, SuiteResult } from '../../model/suite.ts';
-import { DelegatingConsumer } from './delegating.ts';
-import type { SuiteCore } from '../../model/common.ts';
+import type { TestConfig, TestDiffSource, TestResult } from '../../model/test.ts';
 import { TestModelUtil } from '../../model/util.ts';
+import type { TestConsumerShape } from '../types.ts';
+import { DelegatingConsumer } from './delegating.ts';
 
 type ClassId = string;
 type ImportName = string;
@@ -32,7 +32,7 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
   }
 
   getOrCreateSuite({ tests: _, ...core }: SuiteConfig | SuiteResult): CumulativeSuiteResult {
-    return (this.#state[core.import] ??= {})[core.classId] ??= { ...core, tests: {} };
+    return ((this.#state[core.import] ??= {})[core.classId] ??= { ...core, tests: {} });
   }
 
   onTestBefore(config: TestConfig): TestConfig {
@@ -114,4 +114,4 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
     }
     return output;
   }
-}
+}

package/src/consumer/types/delegating.ts

@@ -1,5 +1,5 @@
-import type { SuitesSummary, TestConsumerShape, TestRunState } from '../types.ts';
 import type { TestEvent, TestRemoveEvent } from '../../model/event.ts';
+import type { SuitesSummary, TestConsumerShape, TestRunState } from '../types.ts';
 
 /**
  * Delegating event consumer
@@ -64,4 +64,4 @@ export abstract class DelegatingConsumer implements TestConsumerShape {
 
   transform?(event: TestEvent): TestEvent | undefined;
   transformRemove?(event: TestRemoveEvent): TestRemoveEvent | undefined;
-}
+}

package/src/consumer/types/event.ts

@@ -3,8 +3,8 @@ import type { Writable } from 'node:stream';
 import { JSONUtil } from '@travetto/runtime';
 
 import type { TestEvent, TestRemoveEvent } from '../../model/event.ts';
-import type { TestConsumerShape } from '../types.ts';
 import { TestConsumer } from '../decorator.ts';
+import type { TestConsumerShape } from '../types.ts';
 
 /**
  * Streams all test events a JSON payload, in an nd-json format
@@ -28,4 +28,4 @@ export class EventStreamer implements TestConsumerShape {
   onRemoveEvent(event: TestRemoveEvent): void {
     this.sendPayload(event);
   }
-}
+}