@travetto/di 8.0.0-alpha.19 → 8.0.0-alpha.20

package/README.md

@@ -13,10 +13,10 @@ npm install @travetto/di
 yarn add @travetto/di
 ```
 
-[Dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) is a framework primitive.  When used in conjunction with automatic file scanning, it provides for handling of application dependency wiring. Due to the nature of [Typescript](https://typescriptlang.org) and type erasure of interfaces, dependency injection only supports `class`es as a type signifier. The primary goal of dependency injection is to allow for separation of concerns of object creation and it's usage.
+[Dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) is a framework primitive. When used in conjunction with automatic file scanning, it provides for handling of application dependency wiring. Due to the nature of [Typescript](https://typescriptlang.org) and type erasure of interfaces, dependency injection only supports `class`es as a type signifier. The primary goal of dependency injection is to allow for separation of concerns of object creation and it's usage.
 
 ## Declaration
-The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) and [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L48) decorators provide the registration of dependencies.   Dependency declaration revolves around exposing `class`es and subtypes thereof to provide necessary functionality.  Additionally, the framework will utilize dependencies to satisfy contracts with various implementation.
+The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) and [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L48) decorators provide the registration of dependencies. Dependency declaration revolves around exposing `class`es and subtypes thereof to provide necessary functionality. Additionally, the framework will utilize dependencies to satisfy contracts with various implementation.
 
 **Code: Example Injectable**
 ```typescript
@@ -30,11 +30,11 @@ class CustomService {
 }
 ```
 
-When declaring a dependency, you can also provide a token to allow for multiple instances of the dependency to be defined.  This can be used in many situations:
+When declaring a dependency, you can also provide a token to allow for multiple instances of the dependency to be defined. This can be used in many situations:
 
 **Code: Example Injectable with multiple targets**
 ```typescript
-import { Injectable, Inject } from '@travetto/di';
+import { Inject, Injectable } from '@travetto/di';
 
 @Injectable()
 class CustomService {
@@ -59,7 +59,7 @@ class Consumer {
 }
 ```
 
-As you can see, the `target` field is also set, which indicates to the dependency registration process what `class` the injectable is compatible with.  Additionally, when using `abstract` classes, the parent `class` is always considered as a valid candidate type.
+As you can see, the `target` field is also set, which indicates to the dependency registration process what `class` the injectable is compatible with. Additionally, when using `abstract` classes, the parent `class` is always considered as a valid candidate type.
 
 **Code: Example Injectable with target via abstract class**
 ```typescript
@@ -77,16 +77,14 @@ class SpecificService extends BaseService {
 }
 ```
 
-In this scenario, `SpecificService` is a valid candidate for `BaseService` due to the abstract inheritance. Sometimes, you may want to provide a slight variation to  a dependency without extending a class.  To this end, the [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L48) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16).
+In this scenario, `SpecificService` is a valid candidate for `BaseService` due to the abstract inheritance. Sometimes, you may want to provide a slight variation to a dependency without extending a class. To this end, the [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L48) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16).
 
 **Code: Example InjectableFactory**
 ```typescript
 import { InjectableFactory } from '@travetto/di';
 
 // Not injectable by default
-class CoolService {
-
-}
+class CoolService {}
 
 class Config {
   @InjectableFactory()
@@ -96,12 +94,12 @@ class Config {
 }
 ```
 
-Given the `static` method `initService`, the function will be provided as a valid candidate for `CoolService`.  Instead of calling the constructor of the type directly, this function will work as a factory for producing the injectable.
+Given the `static` method `initService`, the function will be provided as a valid candidate for `CoolService`. Instead of calling the constructor of the type directly, this function will work as a factory for producing the injectable.
 
 **Code: Example Conditional Dependency**
 ```typescript
-import { Runtime } from '@travetto/runtime';
 import { Inject, Injectable } from '@travetto/di';
+import { Runtime } from '@travetto/runtime';
 
 @Injectable({ enabled: Runtime.production })
 class ProductionLogger {
@@ -123,18 +121,19 @@ class RuntimeService {
 }
 ```
 
-In this example, the enabled flag is specified in relationship to the deployment environment.  When coupled with optional properties, and optional chaining, allows for seamless inclusion of optional dependencies at runtime.
+In this example, the enabled flag is specified in relationship to the deployment environment. When coupled with optional properties, and optional chaining, allows for seamless inclusion of optional dependencies at runtime.
 
-**Note**: Other modules are able to provide aliases to [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) that also provide additional functionality.  For example, the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") module @Config or the [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") module @Controller decorator registers the associated class as an injectable element.
+**Note**: Other modules are able to provide aliases to [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) that also provide additional functionality. For example, the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") module @Config or the [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") module @Controller decorator registers the associated class as an injectable element.
 
 ## Injection
-Once all of your necessary dependencies are defined, now is the time to provide those [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) instances to your code.  There are three primary methods for injection: 
+Once all of your necessary dependencies are defined, now is the time to provide those [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) instances to your code. There are three primary methods for injection: 
 
-The [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) decorator, which denotes a desire to inject a value directly.  These will be set post construction. 
+The [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) decorator, which denotes a desire to inject a value directly. These will be set post construction. 
 
 **Code: Example Injectable with dependencies as Inject fields**
 ```typescript
-import { Injectable, Inject } from '@travetto/di';
+import { Inject, Injectable } from '@travetto/di';
+
 import type { DependentService } from './dependency.ts';
 
 @Injectable()
@@ -153,11 +152,11 @@ The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/d
 **Code: Example Injectable with dependencies in constructor**
 ```typescript
 import { Injectable } from '@travetto/di';
+
 import type { DependentService } from './dependency.ts';
 
 @Injectable()
 class CustomService {
-
   dependentService: DependentService;
 
   constructor(service: DependentService) {
@@ -176,7 +175,7 @@ Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/d
 ```typescript
 import { InjectableFactory } from '@travetto/di';
 
-import { type DependentService, CustomService } from './dependency.ts';
+import { CustomService, type DependentService } from './dependency.ts';
 
 class Config {
   @InjectableFactory()
@@ -191,17 +190,15 @@ If you are building modules for others to consume, often times it is possible to
 
 **Code: Example Multiple Candidate Types**
 ```typescript
-import { Injectable, Inject } from '@travetto/di';
+import { Inject, Injectable } from '@travetto/di';
 
-export abstract class Contract {
-
-}
+export abstract class Contract {}
 
 @Injectable()
-class SimpleContract extends Contract { }
+class SimpleContract extends Contract {}
 
 @Injectable()
-export class ComplexContract extends Contract { }
+export class ComplexContract extends Contract {}
 
 @Injectable()
 class ContractConsumer {
@@ -211,12 +208,13 @@ class ContractConsumer {
 }
 ```
 
-By default, if there is only one candidate without qualification, then that candidate will be used.  If multiple candidates are found, then the injection system will bail.  To overcome this the end user will need to specify which candidate type should be considered `primary`:
+By default, if there is only one candidate without qualification, then that candidate will be used. If multiple candidates are found, then the injection system will bail. To overcome this the end user will need to specify which candidate type should be considered `primary`:
 
 **Code: Example Multiple Candidate Types**
 ```typescript
 import { InjectableFactory } from '@travetto/di';
-import type { Contract, ComplexContract } from './injectable-multiple-default.ts';
+
+import type { ComplexContract, Contract } from './injectable-multiple-default.ts';
 
 class Config {
   // Complex will be marked as the available Contract
@@ -228,9 +226,9 @@ class Config {
 ```
 
 ## Non-Framework Dependencies
-The module is built around the framework's management of class registration, and being able to decorate the code with [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) decorators. There may also be a desire to leverage external code and pull it into the dependency injection framework.  This could easily be achieved using a wrapper class that is owned by the framework. 
+The module is built around the framework's management of class registration, and being able to decorate the code with [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) decorators. There may also be a desire to leverage external code and pull it into the dependency injection framework. This could easily be achieved using a wrapper class that is owned by the framework. 
 
-It is also possible to directly reference external types, and they will be converted into unique symbols.  These symbols cannot be used manually, but can be leveraged using [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) decorators.
+It is also possible to directly reference external types, and they will be converted into unique symbols. These symbols cannot be used manually, but can be leveraged using [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L16) decorators.
 
 **Code: Example External Dependencies**
 ```typescript
@@ -272,10 +270,10 @@ Some times you will need to lookup a dependency dynamically, or you want to cont
 
 **Code: Example of Manual Lookup**
 ```typescript
-import { Injectable, DependencyRegistryIndex } from '@travetto/di';
+import { DependencyRegistryIndex, Injectable } from '@travetto/di';
 
 @Injectable()
-class Complex { }
+class Complex {}
 
 class ManualLookup {
   async invoke() {
@@ -307,7 +305,6 @@ class MyCustomService implements ServiceContract {
 
 @Injectable()
 class SpecificService {
-
   @Inject()
   service: ServiceContract;
 }

package/__index__.ts

@@ -1,5 +1,5 @@
 export * from './src/decorator.ts';
 export * from './src/error.ts';
-export * from './src/registry/registry-index.ts';
 export * from './src/registry/registry-adapter.ts';
+export * from './src/registry/registry-index.ts';
 export * from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/di",
-  "version": "8.0.0-alpha.19",
+  "version": "8.0.0-alpha.20",
   "type": "module",
   "description": "Dependency registration/management and injection support.",
   "keywords": [
@@ -28,10 +28,10 @@
     "directory": "module/di"
   },
   "dependencies": {
-    "@travetto/registry": "^8.0.0-alpha.19"
+    "@travetto/registry": "^8.0.0-alpha.20"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^8.0.0-alpha.13"
+    "@travetto/transformer": "^8.0.0-alpha.14"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/decorator.ts

@@ -1,8 +1,8 @@
-import { type Any, castTo, type ClassInstance, getClass, type Class } from '@travetto/runtime';
+import { type Any, type Class, type ClassInstance, castTo, getClass } from '@travetto/runtime';
 import { CONSTRUCTOR_PROPERTY } from '@travetto/schema';
 
-import type { InjectableCandidate, ResolutionType } from './types.ts';
 import { DependencyRegistryIndex } from './registry/registry-index.ts';
+import type { InjectableCandidate, ResolutionType } from './types.ts';
 
 const fromInput = <T extends { qualifier?: symbol }>(input?: T | symbol): T =>
   typeof input === 'symbol' ? castTo({ qualifier: input }) : (input ?? castTo<T>({}));
@@ -19,7 +19,7 @@ export function Injectable(input?: Partial<InjectableCandidate> | symbol) {
   };
 }
 
-export type InjectConfig = { qualifier?: symbol, resolution?: ResolutionType };
+export type InjectConfig = { qualifier?: symbol; resolution?: ResolutionType };
 
 /**
  * Indicate that a field or parameter is able to be injected
@@ -48,7 +48,7 @@ export function Inject(input?: InjectConfig | symbol) {
 export function InjectableFactory(input?: Partial<InjectableCandidate> | symbol) {
   return <T extends Class>(cls: T, property: string, descriptor: TypedPropertyDescriptor<(...args: Any[]) => Any>): void => {
     DependencyRegistryIndex.registerFactory(cls, property, fromInput(input), {
-      factory: (...params: unknown[]) => descriptor.value!.apply(cls, params),
+      factory: (...params: unknown[]) => descriptor.value!.apply(cls, params)
     });
   };
 }
@@ -61,4 +61,4 @@ export function PostConstruct(priority: number = 10) {
   return (instance: ClassInstance, property: string, descriptor: TypedPropertyDescriptor<() => Any>): void => {
     DependencyRegistryIndex.registerPostConstruct(getClass(instance), { operation: descriptor.value!, priority });
   };
-}
+}

package/src/error.ts

@@ -1,4 +1,4 @@
-import { RuntimeError, type Class } from '@travetto/runtime';
+import { type Class, RuntimeError } from '@travetto/runtime';
 
 function getName(symbol: symbol): string {
   return symbol.toString().split(/[()]/g)[1];
@@ -14,4 +14,4 @@ export class InjectionError extends RuntimeError {
       }
     });
   }
-}
+}

package/src/registry/registry-adapter.ts

@@ -2,7 +2,7 @@ import type { RegistryAdapter } from '@travetto/registry';
 import { type Class, classConstruct, describeFunction, safeAssign } from '@travetto/runtime';
 import { CONSTRUCTOR_PROPERTY, SchemaRegistryIndex } from '@travetto/schema';
 
-import { type InjectableConfig, getDefaultQualifier, type InjectableCandidate } from '../types.ts';
+import { getDefaultQualifier, type InjectableCandidate, type InjectableConfig } from '../types.ts';
 
 function combineInjectableCandidates<T extends InjectableCandidate>(base: T, ...overrides: Partial<T>[]): typeof base {
   for (const override of overrides) {
@@ -43,7 +43,7 @@ export class DependencyRegistryAdapter implements RegistryAdapter<InjectableConf
       method,
       enabled: true,
       factory: undefined!,
-      candidateType: undefined!,
+      candidateType: undefined!
     };
     return combineInjectableCandidates(candidates[method], ...data);
   }
@@ -51,7 +51,7 @@ export class DependencyRegistryAdapter implements RegistryAdapter<InjectableConf
   registerClass(...data: Partial<InjectableCandidate<unknown>>[]): InjectableCandidate {
     return this.registerFactory(CONSTRUCTOR_PROPERTY, ...data, {
       factory: (...args: unknown[]) => classConstruct(this.#cls, args),
-      candidateType: this.#cls,
+      candidateType: this.#cls
     });
   }
 
@@ -67,8 +67,9 @@ export class DependencyRegistryAdapter implements RegistryAdapter<InjectableConf
       candidate.qualifier ??= getDefaultQualifier(candidateType);
     }
     // Inherit post construct from parent
-    this.#config.postConstruct = [...(parent?.postConstruct ?? []), ...this.#config.postConstruct]
-      .sort((a, b) => (a.priority ?? 1) - (b.priority ?? 1));
+    this.#config.postConstruct = [...(parent?.postConstruct ?? []), ...this.#config.postConstruct].sort(
+      (a, b) => (a.priority ?? 1) - (b.priority ?? 1)
+    );
   }
 
   getCandidateConfigs(): InjectableCandidate[] {

package/src/registry/registry-index.ts

@@ -1,10 +1,10 @@
-import { type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { castKey, castTo, type Class, describeFunction, getParentClass, TypedObject } from '@travetto/runtime';
+import { Registry, type RegistryIndex, RegistryIndexStore } from '@travetto/registry';
+import { type Class, castKey, castTo, describeFunction, getParentClass, TypedObject } from '@travetto/runtime';
 import { type SchemaFieldConfig, type SchemaParameterConfig, SchemaRegistryIndex } from '@travetto/schema';
 
+import { InjectionError } from '../error.ts';
 import type { Dependency, InjectableCandidate, InjectableConfig, PostConstructor, ResolutionType } from '../types.ts';
 import { DependencyRegistryAdapter } from './registry-adapter.ts';
-import { InjectionError } from '../error.ts';
 import { DependencyRegistryResolver } from './registry-resolver.ts';
 
 const MetadataSymbol = Symbol();
@@ -15,7 +15,6 @@ function readMetadata(item: { metadata?: Record<symbol, unknown> }): Dependency
 }
 
 export class DependencyRegistryIndex implements RegistryIndex {
-
   static #instance = Registry.registerIndex(DependencyRegistryIndex);
 
   static getForRegister(cls: Class): DependencyRegistryAdapter {
@@ -79,7 +78,9 @@ export class DependencyRegistryIndex implements RegistryIndex {
 
   store = new RegistryIndexStore(DependencyRegistryAdapter);
 
-  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+  /** @private */ constructor(source: unknown) {
+    Registry.validateConstructor(source);
+  }
 
   getConfig(cls: Class): InjectableConfig {
     return this.store.get(cls).get();
@@ -91,7 +92,7 @@ export class DependencyRegistryIndex implements RegistryIndex {
     for (const config of adapter.getCandidateConfigs()) {
       const parentClass = getParentClass(config.candidateType);
       const parentConfig = parentClass ? this.store.getOptional(parentClass) : undefined;
-      const hasParentBase = (parentConfig || (parentClass && !!describeFunction(parentClass)?.abstract));
+      const hasParentBase = parentConfig || (parentClass && !!describeFunction(parentClass)?.abstract);
       const baseParent = hasParentBase ? parentClass : undefined;
       this.#resolver.registerClass(config, baseParent);
     }
@@ -128,11 +129,11 @@ export class DependencyRegistryIndex implements RegistryIndex {
    * Retrieve list dependencies
    */
   async fetchDependencyParameters<T>(candidate: InjectableCandidate<T>): Promise<unknown[]> {
-    const inputs = SchemaRegistryIndex.has(candidate.class) ?
-      SchemaRegistryIndex.get(candidate.class).getMethod(candidate.method).parameters : [];
+    const inputs = SchemaRegistryIndex.has(candidate.class)
+      ? SchemaRegistryIndex.get(candidate.class).getMethod(candidate.method).parameters
+      : [];
 
-    const promises = inputs
-      .map(input => this.#resolveDependencyValue(readMetadata(input) ?? {}, input, candidate.class));
+    const promises = inputs.map(input => this.#resolveDependencyValue(readMetadata(input) ?? {}, input, candidate.class));
 
     return await Promise.all(promises);
   }
@@ -144,7 +145,7 @@ export class DependencyRegistryIndex implements RegistryIndex {
     const inputs = SchemaRegistryIndex.getOptional(candidateType)?.getFields() ?? {};
 
     const promises = TypedObject.entries(inputs)
-      .filter(([key, input]) => readMetadata(input) !== undefined && (input.access !== 'readonly' && instance[castKey(key)] === undefined))
+      .filter(([key, input]) => readMetadata(input) !== undefined && input.access !== 'readonly' && instance[castKey(key)] === undefined)
       .map(async ([key, input]) => [key, await this.#resolveDependencyValue(readMetadata(input) ?? {}, input, sourceClass)] as const);
 
     const pairs = await Promise.all(promises);
@@ -188,8 +189,8 @@ export class DependencyRegistryIndex implements RegistryIndex {
   async getInstance<T>(candidateType: Class<T>, requestedQualifier?: symbol, resolution?: ResolutionType): Promise<T> {
     const { target, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier, resolution);
 
-    return castTo(this.#instancePromises
-      .getOrInsert(target, new Map())
-      .getOrInsertComputed(qualifier, () => this.construct(target, qualifier)));
+    return castTo(
+      this.#instancePromises.getOrInsert(target, new Map()).getOrInsertComputed(qualifier, () => this.construct(target, qualifier))
+    );
   }
-}
+}

package/src/registry/registry-resolver.ts

@@ -1,10 +1,10 @@
+import { type Class, castTo } from '@travetto/runtime';
 import { SchemaRegistryIndex, UnknownType } from '@travetto/schema';
-import { castTo, type Class } from '@travetto/runtime';
 
-import { getDefaultQualifier, type InjectableCandidate, PrimaryCandidateSymbol, type ResolutionType } from '../types.ts';
 import { InjectionError } from '../error.ts';
+import { getDefaultQualifier, type InjectableCandidate, PrimaryCandidateSymbol, type ResolutionType } from '../types.ts';
 
-type Resolved<T> = { candidate: InjectableCandidate<T>, qualifier: symbol, target: Class };
+type Resolved<T> = { candidate: InjectableCandidate<T>; qualifier: symbol; target: Class };
 
 function setInMap<T>(map: Map<Class, Map<typeof key, T>>, cls: Class, key: symbol | string, dest: T): void {
   map.getOrInsert(cls, new Map()).set(key, dest);
@@ -35,9 +35,7 @@ export class DependencyRegistryResolver {
     if (qualifiers.has(PrimaryCandidateSymbol)) {
       return PrimaryCandidateSymbol;
     } else {
-      const filtered = resolved
-        .filter(qualifier => !!qualifier)
-        .filter(qualifier => this.#defaultSymbols.has(qualifier));
+      const filtered = resolved.filter(qualifier => !!qualifier).filter(qualifier => this.#defaultSymbols.has(qualifier));
       // If there is only one default symbol
       if (filtered.length === 1) {
         return filtered[0];
@@ -82,8 +80,7 @@ export class DependencyRegistryResolver {
     setInMap(this.#byCandidateType, candidateType, qualifier, config);
 
     // Track interface aliases as targets
-    const interfaces = SchemaRegistryIndex.has(candidateType) ?
-      SchemaRegistryIndex.get(candidateType).get().interfaces : [];
+    const interfaces = SchemaRegistryIndex.has(candidateType) ? SchemaRegistryIndex.get(candidateType).get().interfaces : [];
 
     for (const type of interfaces) {
       setInMap(this.#byCandidateType, type, qualifier, config);
@@ -151,7 +148,7 @@ export class DependencyRegistryResolver {
     return {
       candidate: castTo(config),
       qualifier,
-      target: (config.target ?? config.candidateType)
+      target: config.target ?? config.candidateType
     };
   }
 
@@ -162,10 +159,10 @@ export class DependencyRegistryResolver {
   }
 
   getCandidateEntries(candidateType: Class): [symbol, InjectableCandidate][] {
-    return [...this.#byCandidateType.get(candidateType)?.entries() ?? []];
+    return [...(this.#byCandidateType.get(candidateType)?.entries() ?? [])];
   }
 
   getContainerEntries(containerType: Class): [symbol, InjectableCandidate][] {
-    return [...this.#byContainerType.get(containerType)?.entries() ?? []];
+    return [...(this.#byContainerType.get(containerType)?.entries() ?? [])];
   }
-}
+}

package/src/types.ts

@@ -65,11 +65,10 @@ export interface InjectableCandidate<T = unknown> {
 
 /** Post Construct Handler */
 export type PostConstructor<T> = {
-  operation: ((this: T) => Promise<unknown> | unknown);
+  operation: (this: T) => Promise<unknown> | unknown;
   priority: number;
 };
 
-
 /**
  * Full injectable configuration for a class
  */
@@ -92,4 +91,4 @@ export function getDefaultQualifier(cls: Class): symbol {
   return Symbol.for(cls.Ⲑid);
 }
 
-export const PrimaryCandidateSymbol = Symbol();
+export const PrimaryCandidateSymbol = Symbol();

package/support/test/suite.ts

@@ -1,6 +1,6 @@
-import { type Class } from '@travetto/runtime';
 import { Registry } from '@travetto/registry';
-import { SuiteRegistryIndex, type SuitePhaseHandler } from '@travetto/test';
+import type { Class } from '@travetto/runtime';
+import { type SuitePhaseHandler, SuiteRegistryIndex } from '@travetto/test';
 
 import { DependencyRegistryIndex } from '../../src/registry/registry-index.ts';
 
@@ -26,4 +26,4 @@ export function InjectableSuite() {
       phaseHandlers: [new ModelSuiteHandler(cls)]
     });
   };
-}
+}