@travetto/transformer 2.1.3 → 2.2.1

package/README.md

@@ -16,7 +16,7 @@ Because working with the [Typescript](https://typescriptlang.org) API can be del
 
 ## Custom Transformer
 
-Below is an example of a transformer that uppercases all `class`, `method` and `param` declarations.  This will break any code that depends upon it as we are redefining all the identifiers at compile time.  
+Below is an example of a transformer that upper cases all `class`, `method` and `param` declarations.  This will break any code that depends upon it as we are redefining all the identifiers at compile time.  
 
 **Code: Sample Transformer - Upper case all declarations**
 ```typescript
@@ -29,7 +29,7 @@ export class MakeUpper {
   static [TransformerId] = '@trv:transformer-test';
 
   @OnProperty()
-  static handleProperty(state: TransformerState, node: ts.PropertyDeclaration) {
+  static handleProperty(state: TransformerState, node: ts.PropertyDeclaration): ts.PropertyDeclaration {
     if (!state.source.fileName.includes('doc/src')) {
       return node;
     }
@@ -45,7 +45,7 @@ export class MakeUpper {
   }
 
   @OnClass()
-  static handleClass(state: TransformerState, node: ts.ClassDeclaration) {
+  static handleClass(state: TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
     if (!state.source.fileName.includes('doc/src')) {
       return node;
     }
@@ -61,7 +61,7 @@ export class MakeUpper {
   }
 
   @OnMethod()
-  static handleMethod(state: TransformerState, node: ts.MethodDeclaration) {
+  static handleMethod(state: TransformerState, node: ts.MethodDeclaration): ts.MethodDeclaration {
     if (!state.source.fileName.includes('doc/src')) {
       return node;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/transformer",
   "displayName": "Transformation",
-  "version": "2.1.3",
+  "version": "2.2.1",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "typescript",
@@ -25,7 +25,7 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/base": "^2.1.3"
+    "@travetto/base": "^2.2.1"
   },
   "publishConfig": {
     "access": "public"

package/src/importer.ts

@@ -26,7 +26,7 @@ export class ImportManager {
   /**
    * Produces a unique ID for a given file, importing if needed
    */
-  getId(file: string) {
+  getId(file: string): string {
     if (!this.#ids.has(file)) {
       const key = basename(file).replace(/[.][^.]*$/, '').replace(/[^A-Za-z0-9]+/g, '_');
       this.#ids.set(file, `ᚕ_${key}_${this.#idx[key] = (this.#idx[key] || 0) + 1}`);
@@ -37,7 +37,7 @@ export class ImportManager {
   /**
    * Import a file if needed, and record it's identifier
    */
-  importFile(file: string, base?: string) {
+  importFile(file: string, base?: string): Import {
     file = ModuleUtil.normalizePath(file);
 
     // Allow for node classes to be imported directly
@@ -65,9 +65,9 @@ export class ImportManager {
       }
 
       const ident = this.factory.createIdentifier(id);
-      const imprt = { path: file, ident };
-      this.#imports.set(ident.escapedText.toString(), imprt);
-      this.#newImports.set(file, imprt);
+      const newImport = { path: file, ident };
+      this.#imports.set(ident.escapedText.toString(), newImport);
+      this.#newImports.set(file, newImport);
     }
     return this.#newImports.get(file)!;
   }
@@ -75,7 +75,7 @@ export class ImportManager {
   /**
    * Import given an external type
    */
-  importFromResolved(...types: AnyType[]) {
+  importFromResolved(...types: AnyType[]): void {
     for (const type of types) {
       if (type.key === 'external' && type.source && type.source !== this.source.fileName) {
         this.importFile(type.source, this.source.fileName);
@@ -93,19 +93,19 @@ export class ImportManager {
   /**
    * Add imports to a source file
    */
-  finalizeNewImports(file: ts.SourceFile) {
+  finalizeNewImports(file: ts.SourceFile): ts.SourceFile | undefined {
     if (!this.#newImports.size) {
       return;
     }
 
     try {
       const importStmts = [...this.#newImports.values()].map(({ path, ident }) => {
-        const imptStmt = this.factory.createImportDeclaration(
+        const importStmt = this.factory.createImportDeclaration(
           undefined, undefined,
           this.factory.createImportClause(false, undefined, this.factory.createNamespaceImport(ident)),
           this.factory.createStringLiteral(path)
         );
-        return imptStmt;
+        return importStmt;
       });
 
       return CoreUtil.updateSource(this.factory, file, [
@@ -113,6 +113,9 @@ export class ImportManager {
         ...file.statements.filter((x: ts.Statement & { remove?: boolean }) => !x.remove) // Exclude culled imports
       ]);
     } catch (err) { // Missing import
+      if (!(err instanceof Error)) {
+        throw err;
+      }
       const out = new Error(`${err.message} in ${file.fileName.replace(PathUtil.cwd, '.')}`);
       out.stack = err.stack;
       throw out;
@@ -122,14 +125,14 @@ export class ImportManager {
   /**
    * Reset the imports into the source file
    */
-  finalize(ret: ts.SourceFile) {
+  finalize(ret: ts.SourceFile): ts.SourceFile {
     return this.finalizeNewImports(ret) ?? ret;
   }
 
   /**
    * Get the identifier and import if needed
    */
-  getOrImport(factory: ts.NodeFactory, type: ExternalType) {
+  getOrImport(factory: ts.NodeFactory, type: ExternalType): ts.Identifier | ts.PropertyAccessExpression {
     if (type.source === this.source.fileName) {
       return factory.createIdentifier(type.name!);
     } else {

package/src/register.ts

@@ -9,12 +9,12 @@ type TransformerWithHandlers = Transformer & { [HandlersProp]?: NodeTransformer[
  * Get all transformers
  * @param obj Object to search for transformers
  */
-export function getAllTransformers(obj: Record<string, { [HandlersProp]?: NodeTransformer[] }>) {
+export function getAllTransformers(obj: Record<string, { [HandlersProp]?: NodeTransformer[] }>): NodeTransformer[] {
   return Object.values(obj).flatMap(x => x[HandlersProp] ?? []);
 }
 
 // Store handlers in class
-function storeHandler(cls: TransformerWithHandlers, fn: Function, phase: TransformPhase, type: TransformerType, target?: string[]) {
+function storeHandler(cls: TransformerWithHandlers, fn: Function, phase: TransformPhase, type: TransformerType, target?: string[]): void {
   if (target) {
     const ns = cls[TransformerId].split('/')[0]; // Everything before the '/'
     target = target.map(x => x.startsWith('@') ? x : `${ns}/${x}`);
@@ -29,7 +29,7 @@ function storeHandler(cls: TransformerWithHandlers, fn: Function, phase: Transfo
 export function OnCall(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.CallExpression) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'call', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'call', target);
 }
 
 /**
@@ -38,7 +38,7 @@ export function OnCall(...target: string[]) {
 export function OnFunction(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'function', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'function', target);
 }
 
 /**
@@ -47,7 +47,7 @@ export function OnFunction(...target: string[]) {
 export function OnParameter(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'parameter', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'parameter', target);
 }
 
 /**
@@ -56,7 +56,7 @@ export function OnParameter(...target: string[]) {
 export function OnProperty(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'property', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'property', target);
 }
 
 /**
@@ -65,7 +65,7 @@ export function OnProperty(...target: string[]) {
 export function OnGetter(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'getter', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'getter', target);
 }
 
 /**
@@ -74,7 +74,7 @@ export function OnGetter(...target: string[]) {
 export function OnSetter(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'setter', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'setter', target);
 }
 
 /**
@@ -83,7 +83,7 @@ export function OnSetter(...target: string[]) {
 export function OnMethod(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'method', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'method', target);
 }
 
 /**
@@ -92,7 +92,7 @@ export function OnMethod(...target: string[]) {
 export function OnStaticMethod(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'static-method', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'static-method', target);
 }
 
 /**
@@ -101,7 +101,7 @@ export function OnStaticMethod(...target: string[]) {
 export function OnClass(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'before', 'class', target);
+  ): void => storeHandler(inst, d.value!, 'before', 'class', target);
 }
 
 /**
@@ -110,7 +110,7 @@ export function OnClass(...target: string[]) {
 export function AfterCall(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.CallExpression, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'call', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'call', target);
 }
 
 /**
@@ -119,7 +119,7 @@ export function AfterCall(...target: string[]) {
 export function AfterFunction(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'function', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'function', target);
 }
 
 /**
@@ -128,7 +128,7 @@ export function AfterFunction(...target: string[]) {
 export function AfterParameter(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'parameter', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'parameter', target);
 }
 
 /**
@@ -137,7 +137,7 @@ export function AfterParameter(...target: string[]) {
 export function AfterProperty(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'property', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'property', target);
 }
 
 /**
@@ -146,7 +146,7 @@ export function AfterProperty(...target: string[]) {
 export function AfterGetter(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'getter', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'getter', target);
 }
 
 /**
@@ -155,7 +155,7 @@ export function AfterGetter(...target: string[]) {
 export function AfterSetter(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'setter', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'setter', target);
 }
 
 /**
@@ -164,7 +164,7 @@ export function AfterSetter(...target: string[]) {
 export function AfterMethod(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'method', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'method', target);
 }
 
 /**
@@ -173,7 +173,7 @@ export function AfterMethod(...target: string[]) {
 export function AfterStaticMethod(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'static-method', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'static-method', target);
 }
 
 /**
@@ -182,5 +182,5 @@ export function AfterStaticMethod(...target: string[]) {
 export function AfterClass(...target: string[]) {
   return <S extends State = State, R extends ts.Node = ts.Node>(
     inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, dm?: DecoratorMeta) => R>
-  ) => storeHandler(inst, d.value!, 'after', 'class', target);
+  ): void => storeHandler(inst, d.value!, 'after', 'class', target);
 }

package/src/resolver/builder.ts

@@ -117,6 +117,7 @@ export const TypeBuilder: {
 
       if (name in GLOBAL_SIMPLE) {
         const cons = GLOBAL_SIMPLE[name];
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         const ret = LiteralUtil.isLiteralType(type) ? Util.coerceType(type.value, cons as typeof String, false) :
           undefined;
 
@@ -148,8 +149,7 @@ export const TypeBuilder: {
     }
   },
   union: {
-    build: (checker, type) => {
-      const uType = type as ts.UnionType;
+    build: (checker, uType: ts.UnionType) => {
       let undefinable = false;
       let nullable = false;
       const remainder = uType.types.filter(ut => {
@@ -159,7 +159,7 @@ export const TypeBuilder: {
         nullable = nullable || n;
         return !(u || n);
       });
-      const name = CoreUtil.getSymbol(type)?.getName();
+      const name = CoreUtil.getSymbol(uType)?.getName();
       return { key: 'union', name, undefinable, nullable, tsSubTypes: remainder, subTypes: [] };
     },
     finalize: (type: UnionType) => {
@@ -208,9 +208,9 @@ export const TypeBuilder: {
           source = '.';
         }
 
-        const sourceFile = DeclarationUtil.getDeclarations(type)
+        const sourceFile: string = DeclarationUtil.getDeclarations(type)
           ?.find(x => ts.getAllJSDocTags(x, (t): t is ts.JSDocTag => t.tagName.getText() === 'concrete').length)
-          ?.getSourceFile().fileName as string;
+          ?.getSourceFile().fileName ?? '';
 
         if (source === '.') {
           source = sourceFile;

package/src/resolver/service.ts

@@ -19,7 +19,7 @@ export class TypeResolver implements Checker {
    * Get type checker
    * @private
    */
-  getChecker() {
+  getChecker(): ts.TypeChecker {
     return this.#tsChecker;
   }
 
@@ -27,21 +27,22 @@ export class TypeResolver implements Checker {
    * Get type from element
    * @param el
    */
-  getType(el: ts.Type | ts.Node) {
-    return 'getSourceFile' in el ? this.#tsChecker.getTypeAtLocation(el as ts.Node) : el;
+  getType(el: ts.Type | ts.Node): ts.Type {
+    return 'getSourceFile' in el ? this.#tsChecker.getTypeAtLocation(el) : el;
   }
 
   /**
    * Fetch all type arguments for a give type
    */
   getAllTypeArguments(ref: ts.Type): ts.Type[] {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return this.#tsChecker.getTypeArguments(ref as ts.TypeReference) as ts.Type[];
   }
 
   /**
    * Resolve the return type for a method
    */
-  getReturnType(node: ts.MethodDeclaration) {
+  getReturnType(node: ts.MethodDeclaration): ts.Type {
     const type = this.getType(node);
     const [sig] = type.getCallSignatures();
     return this.#tsChecker.getReturnTypeOfSignature(sig);
@@ -50,14 +51,14 @@ export class TypeResolver implements Checker {
   /**
    * Get type as a string representation
    */
-  getTypeAsString(type: ts.Type) {
+  getTypeAsString(type: ts.Type): string | undefined {
     return this.#tsChecker.typeToString(this.#tsChecker.getApparentType(type)) || undefined;
   }
 
   /**
    * Get list of properties
    */
-  getPropertiesOfType(type: ts.Type) {
+  getPropertiesOfType(type: ts.Type): ts.Symbol[] {
     return this.#tsChecker.getPropertiesOfType(type);
   }
 
@@ -102,6 +103,7 @@ export class TypeResolver implements Checker {
           delete result.tsSubTypes;
         }
         if (finalize) {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           result = finalize(result as never);
         }
       }
@@ -112,6 +114,9 @@ export class TypeResolver implements Checker {
     try {
       return resolve(this.getType(node));
     } catch (err) {
+      if (!(err instanceof Error)) {
+        throw err;
+      }
       console.error('Unable to resolve type', err.stack);
       return { key: 'literal', ctor: Object, name: 'object' };
     }

package/src/resolver/types.ts

@@ -141,7 +141,12 @@ export interface PointerType extends Type<'pointer'> {
   target: Exclude<AnyType, PointerType>;
 }
 
-export type AnyType = TupleType | ShapeType | UnionType | LiteralType | ExternalType | PointerType;
+/**
+ * Unknown type, should default to object
+ */
+export interface UnknownType extends Type<'unknown'> { }
+
+export type AnyType = TupleType | ShapeType | UnionType | LiteralType | ExternalType | PointerType | UnknownType;
 
 /**
  * Simple interface for checked methods

package/src/state.ts

@@ -12,12 +12,15 @@ import { DocUtil } from './util/doc';
 import { DecoratorUtil } from './util/decorator';
 import { DeclarationUtil } from './util/declaration';
 import { CoreUtil, LiteralUtil } from './util';
+import { Import } from './types/shared';
 
 function hasOriginal(n: unknown): n is { original: ts.Node } {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!n && !(n as { parent?: unknown }).parent && !!(n as { original: unknown }).original;
 }
 
 function hasEscapedName(n: unknown): n is { name: { escapedText: string } } {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!n && !!(n as { name?: { escapedText?: string } }).name?.escapedText;
 }
 
@@ -45,28 +48,28 @@ export class TransformerState implements State {
    * Allow access to resolver
    * @private
    */
-  getResolver() {
+  getResolver(): TypeResolver {
     return this.#resolver;
   }
 
   /**
    * Get or import the node or external type
    */
-  getOrImport(type: ExternalType) {
+  getOrImport(type: ExternalType): ts.Identifier | ts.PropertyAccessExpression {
     return this.#imports.getOrImport(this.factory, type);
   }
 
   /**
    * Import a given file
    */
-  importFile(file: string) {
+  importFile(file: string): Import {
     return this.#imports.importFile(file);
   }
 
   /**
    * Resolve an `AnyType` from a `ts.Type` or `ts.Node`
    */
-  resolveType(node: ts.Type | ts.Node) {
+  resolveType(node: ts.Type | ts.Node): AnyType {
     const resolved = this.#resolver.resolveType(node);
     this.#imports.importFromResolved(resolved);
     return resolved;
@@ -75,7 +78,7 @@ export class TransformerState implements State {
   /**
    * Resolve external type
    */
-  resolveExternalType(node: ts.Node) {
+  resolveExternalType(node: ts.Node): ExternalType {
     const resolved = this.resolveType(node);
     if (resolved.key !== 'external') {
       throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${node.getSourceFile().fileName}`);
@@ -86,7 +89,7 @@ export class TransformerState implements State {
   /**
    * Convert a type to it's identifier, will return undefined if none match
    */
-  typeToIdentifier(node: ts.Type | AnyType) {
+  typeToIdentifier(node: ts.Type | AnyType): ts.Identifier | ts.PropertyAccessExpression | undefined {
     const type = 'flags' in node ? this.resolveType(node) : node;
     switch (type.key) {
       case 'literal': return this.factory.createIdentifier(type.ctor!.name);
@@ -98,7 +101,7 @@ export class TransformerState implements State {
   /**
    * Resolve the return type
    */
-  resolveReturnType(node: ts.MethodDeclaration) {
+  resolveReturnType(node: ts.MethodDeclaration): AnyType {
     const typeNode = ts.getJSDocReturnType(node);
     if (typeNode) {
       const resolved = this.#resolver.getChecker().getTypeFromTypeNode(typeNode);
@@ -111,14 +114,14 @@ export class TransformerState implements State {
   /**
    * Read all JSDoc tags
    */
-  readDocTag(node: ts.Declaration, name: string) {
+  readDocTag(node: ts.Declaration, name: string): string[] {
     return DocUtil.readDocTag(this.#resolver.getType(node), name);
   }
 
   /**
    * Import a decorator, generally to handle erasure
    */
-  importDecorator(pth: string, name: string) {
+  importDecorator(pth: string, name: string): ts.PropertyAccessExpression | undefined {
     if (!this.#decorators.has(`${pth}:${name}`)) {
       const ref = this.#imports.importFile(pth);
       const ident = this.factory.createIdentifier(name);
@@ -130,7 +133,7 @@ export class TransformerState implements State {
   /**
    * Create a decorator to add functionality to a declaration
    */
-  createDecorator(pth: string, name: string, ...contents: (ts.Expression | undefined)[]) {
+  createDecorator(pth: string, name: string, ...contents: (ts.Expression | undefined)[]): ts.Decorator {
     this.importDecorator(pth, name);
     return CoreUtil.createDecorator(this.factory, this.#decorators.get(name)!, ...contents);
   }
@@ -151,6 +154,7 @@ export class TransformerState implements State {
       module: decl ? ModuleUtil.normalizePath(decl.getSourceFile().fileName) : undefined, // All #decorators will be absolute
       targets: DocUtil.readAugments(this.#resolver.getType(ident)),
       name: ident ?
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         ident.escapedText! as string :
         undefined
     };
@@ -160,7 +164,7 @@ export class TransformerState implements State {
    * Get list of all #decorators for a node
    */
   getDecoratorList(node: ts.Node): DecoratorMeta[] {
-    return ((node.decorators ?? []) as ts.Decorator[])
+    return (node.decorators ?? [])
       .map(dec => this.getDecoratorMeta(dec))
       .filter(x => !!x.ident);
   }
@@ -177,7 +181,7 @@ export class TransformerState implements State {
    * @param stmt
    * @param before
    */
-  addStatement(stmt: ts.Statement, before?: ts.Node) {
+  addStatement(stmt: ts.Statement, before?: ts.Node): void {
     const stmts = this.source.statements.slice(0);
     let idx = stmts.length;
     let n = before;
@@ -187,8 +191,10 @@ export class TransformerState implements State {
     while (n && !ts.isSourceFile(n.parent)) {
       n = n.parent;
     }
-    if (n && ts.isSourceFile(n.parent) && stmts.indexOf(n as ts.Statement) >= 0) {
-      idx = stmts.indexOf(n as ts.Statement) - 1;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const nStmt: ts.Statement = n as ts.Statement;
+    if (n && ts.isSourceFile(n.parent) && stmts.indexOf(nStmt) >= 0) {
+      idx = stmts.indexOf(nStmt) - 1;
     }
     if (!this.added.has(idx)) {
       this.added.set(idx, []);
@@ -199,7 +205,7 @@ export class TransformerState implements State {
   /**
    * Finalize the source file for emission
    */
-  finalize(ret: ts.SourceFile) {
+  finalize(ret: ts.SourceFile): ts.SourceFile {
     ret = this.#imports.finalize(ret);
     return ret;
   }
@@ -207,9 +213,9 @@ export class TransformerState implements State {
   /**
    * Get Filename as ᚕsrc
    */
-  getFilenameAsSrc() {
+  getFilenameAsSrc(): ts.CallExpression {
     const ident = this.factory.createIdentifier('ᚕsrc');
-    ident.getSourceFile = () => this.source;
+    ident.getSourceFile = (): ts.SourceFile => this.source;
     return this.factory.createCallExpression(ident, [], [this.createIdentifier('__filename')]);
   }
 
@@ -223,20 +229,21 @@ export class TransformerState implements State {
   fromLiteral(val: unknown[]): ts.ArrayLiteralExpression;
   fromLiteral(val: string | boolean | number): ts.LiteralExpression;
   fromLiteral(val: unknown): ts.Node {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return LiteralUtil.fromLiteral(this.factory, val as object);
   }
 
   /**
    * Extend
    */
-  extendObjectLiteral(src: object | ts.Expression, ...rest: (object | ts.Expression)[]) {
+  extendObjectLiteral(src: object | ts.Expression, ...rest: (object | ts.Expression)[]): ts.ObjectLiteralExpression {
     return LiteralUtil.extendObjectLiteral(this.factory, src, ...rest);
   }
 
   /**
    * Create property access
    */
-  createAccess(first: string | ts.Expression, second: string | ts.Identifier, ...items: (string | ts.Identifier)[]) {
+  createAccess(first: string | ts.Expression, second: string | ts.Identifier, ...items: (string | ts.Identifier)[]): ts.PropertyAccessExpression {
     return CoreUtil.createAccess(this.factory, first, second, ...items);
   }
 
@@ -248,10 +255,10 @@ export class TransformerState implements State {
   }
 
   /**
-   * Ceate identifier from node or text
+   * Create identifier from node or text
    * @param name
    */
-  createIdentifier(name: string | { getText(): string }) {
+  createIdentifier(name: string | { getText(): string }): ts.Identifier {
     return this.factory.createIdentifier(typeof name === 'string' ? name : name.getText());
   }
 
@@ -262,7 +269,7 @@ export class TransformerState implements State {
    * @param name
    * @param module
    */
-  findDecorator(cls: Transformer, node: ts.Node, name: string, module?: string) {
+  findDecorator(cls: Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
     const target = `${cls[TransformerId]}/${name}`;
     return this.getDecoratorList(node)
       .find(x => x.targets?.includes(target) && (!module || x.name === name && x.module === module))?.dec;
@@ -273,7 +280,7 @@ export class TransformerState implements State {
    * @param node
    * @param type
    */
-  generateUniqueIdentifier(node: ts.Node, type: AnyType) {
+  generateUniqueIdentifier(node: ts.Node, type: AnyType): string {
     let unique: string;
     try {
       // Tie to source location if possible
@@ -295,16 +302,16 @@ export class TransformerState implements State {
   }
 
   /**
-   * Register synthetic idetnifier
+   * Register synthetic identifier
    */
-  createSyntheticIdentifier(id: string) {
+  createSyntheticIdentifier(id: string): [identifier: ts.Identifier, exists: boolean] {
     id = `${id}${TransformerState.SYNTHETIC_EXT}`;
     let exists = true;
     if (!this.#syntheticIdentifiers.has(id)) {
       this.#syntheticIdentifiers.set(id, this.factory.createIdentifier(id));
       exists = false;
     }
-    return [this.#syntheticIdentifiers.get(id), exists] as [id: ts.Identifier, exists: boolean];
+    return [this.#syntheticIdentifiers.get(id)!, exists];
   }
 
   /**
@@ -315,8 +322,8 @@ export class TransformerState implements State {
   findMethodByName(cls: ts.ClassLikeDeclaration | ts.Type, method: string): ts.MethodDeclaration | undefined {
     if ('getSourceFile' in cls) {
       return cls.members.find(
-        m => ts.isMethodDeclaration(m) && ts.isIdentifier(m.name) && m.name.escapedText === method
-      ) as ts.MethodDeclaration;
+        (m): m is ts.MethodDeclaration => ts.isMethodDeclaration(m) && ts.isIdentifier(m.name) && m.name.escapedText === method
+      );
     } else {
       const props = this.getResolver().getPropertiesOfType(cls);
       for (const prop of props) {

package/src/util/core.ts

@@ -8,6 +8,7 @@ export class CoreUtil {
    * See if inbound node has an original property
    */
   static hasOriginal(o: ts.Node): o is (ts.Node & { original: ts.Node }) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return 'original' in o && !!(o as { original?: ts.Node }).original;
   }
 
@@ -15,6 +16,7 @@ export class CoreUtil {
    * See if type has target
    */
   static hasTarget(o: ts.Type): o is (ts.Type & { target: ts.Type }) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return 'target' in o && !!(o as { target?: ts.Type }).target;
   }
 
@@ -22,7 +24,7 @@ export class CoreUtil {
    * Get first line of method body
    * @param m
    */
-  static getRangeOf<T extends ts.Node>(source: ts.SourceFile, o: T | undefined) {
+  static getRangeOf<T extends ts.Node>(source: ts.SourceFile, o: T | undefined): { start: number, end: number } | undefined {
     if (o) {
       const start = ts.getLineAndCharacterOfPosition(source, o.getStart(source));
       const end = ts.getLineAndCharacterOfPosition(source, o.getEnd());
@@ -38,6 +40,7 @@ export class CoreUtil {
    */
   static getArgument<T extends ts.Expression = ts.Expression>(node: ts.CallExpression | undefined, position = 0): T | undefined {
     if (node && node!.arguments && node!.arguments.length >= position + 1) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return node.arguments[position] as T;
     }
     return;
@@ -57,11 +60,13 @@ export class CoreUtil {
   /**
    * Get `ts.Symbol` from a `ts.Type`
    */
-  static getSymbol(type: ts.Type | ts.Symbol) {
+  static getSymbol(type: ts.Type | ts.Symbol | ts.TypeReference): ts.Symbol {
     if ('valueDeclaration' in type || 'escapedName' in type) {
       return type;
+    } else if ('aliasSymbol' in type && type.aliasSymbol) {
+      return type.aliasSymbol;
     } else {
-      return (type as ts.TypeReference).aliasSymbol ?? (type as ts.Type).symbol;
+      return type.symbol;
     }
   }
 
@@ -70,7 +75,7 @@ export class CoreUtil {
    * @param src
    * @param statements
    */
-  static updateSource(factory: ts.NodeFactory, src: ts.SourceFile, statements: ts.NodeArray<ts.Statement> | ts.Statement[]) {
+  static updateSource(factory: ts.NodeFactory, src: ts.SourceFile, statements: ts.NodeArray<ts.Statement> | ts.Statement[]): ts.SourceFile {
     return factory.updateSourceFile(
       src, statements, src.isDeclarationFile, src.referencedFiles, src.typeReferenceDirectives, src.hasNoDefaultLib
     );
@@ -79,7 +84,12 @@ export class CoreUtil {
   /**
    * Create property access
    */
-  static createAccess(factory: ts.NodeFactory, first: string | ts.Expression, second: string | ts.Identifier, ...items: (string | ts.Identifier)[]) {
+  static createAccess(
+    factory: ts.NodeFactory,
+    first: string | ts.Expression,
+    second: string | ts.Identifier,
+    ...items: (string | ts.Identifier)[]
+  ): ts.PropertyAccessExpression {
     if (typeof first === 'string') {
       first = factory.createIdentifier(first);
     }
@@ -92,12 +102,12 @@ export class CoreUtil {
   /**
    * Create a decorator with a given name, and arguments
    */
-  static createDecorator(factory: ts.NodeFactory, name: ts.Expression, ...contents: (ts.Expression | undefined)[]) {
+  static createDecorator(factory: ts.NodeFactory, name: ts.Expression, ...contents: (ts.Expression | undefined)[]): ts.Decorator {
     return factory.createDecorator(
       factory.createCallExpression(
         name,
         undefined,
-        contents.filter(x => !!x) as ts.Expression[]
+        contents.filter((x?: ts.Expression): x is ts.Expression => !!x)
       )
     );
   }
@@ -105,7 +115,7 @@ export class CoreUtil {
   /**
    * Is declaration abstract?
    */
-  static isAbstract(node: ts.Declaration) {
+  static isAbstract(node: ts.Declaration): boolean {
     // eslint-disable-next-line no-bitwise
     return !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Abstract);
   }

package/src/util/declaration.ts

@@ -10,7 +10,7 @@ export class DeclarationUtil {
    * Searches upward from the node until it finds the variable declaration list,
    * and then checks the toString for `const `
    */
-  static isConstantDeclaration(node: ts.Node) {
+  static isConstantDeclaration(node: ts.Node): boolean {
     let s: ts.Node = node;
     while (s && !ts.isVariableDeclarationList(s)) {
       s = s.parent;
@@ -21,7 +21,7 @@ export class DeclarationUtil {
   /**
    * See if a declaration is public
    */
-  static isPublic(node: ts.Declaration) {
+  static isPublic(node: ts.Declaration): boolean {
     // eslint-disable-next-line no-bitwise
     return !(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.NonPublicAccessibilityModifier);
   }
@@ -57,8 +57,8 @@ export class DeclarationUtil {
    * Resolve the `ts.ObjectFlags`
    */
   static getObjectFlags(type: ts.Type): ts.ObjectFlags {
-    // @ts-ignore
-    return ts.getObjectFlags(type);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return (ts as unknown as { getObjectFlags(t: ts.Type): ts.ObjectFlags }).getObjectFlags(type);
   }
 
   /**
@@ -67,7 +67,9 @@ export class DeclarationUtil {
    * @param node
    * @returns
    */
-  static getAccessorPair(node: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration) {
+  static getAccessorPair(
+    node: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration
+  ): { getter?: ts.GetAccessorDeclaration, setter?: ts.SetAccessorDeclaration } {
     const acc = { getter: ts.isGetAccessorDeclaration(node) ? node : undefined, setter: ts.isSetAccessorDeclaration(node) ? node : undefined };
     if (ts.isClassDeclaration(node.parent)) {
       for (const el of node.parent.members) {

package/src/util/decorator.ts

@@ -10,10 +10,12 @@ export class DecoratorUtil {
    * Get identifier for a decorator
    */
   static getDecoratorIdent(d: ts.Decorator): ts.Identifier {
-    if (ts.isCallExpression(d.expression)) {
-      return d.expression.expression as ts.Identifier;
+    if (ts.isCallExpression(d.expression) && ts.isIdentifier(d.expression.expression)) {
+      return d.expression.expression;
     } else if (ts.isIdentifier(d.expression)) {
       return d.expression;
+    } else if (ts.isCallExpression(d.expression) && ts.isPropertyAccessExpression(d.expression.expression) && ts.isIdentifier(d.expression.expression.expression)) {
+      return d.expression.expression.expression;
     } else {
       throw new Error('No Identifier');
     }
@@ -22,7 +24,7 @@ export class DecoratorUtil {
   /**
    * Replace or add a decorator to a list of decorators
    */
-  static spliceDecorators(node: ts.Node, target: ts.Decorator | undefined, replacements: ts.Decorator[], idx = -1) {
+  static spliceDecorators(node: ts.Node, target: ts.Decorator | undefined, replacements: ts.Decorator[], idx = -1): ts.Decorator[] {
     if (idx < 0 && target) {
       idx = node.decorators?.indexOf(target) ?? -1;
     }
@@ -46,6 +48,7 @@ export class DecoratorUtil {
    * Find the primary argument of a call expression, or decorator.
    */
   static getArguments<T extends ts.Expression = ts.Expression>(node: ts.Decorator | undefined): T[] | undefined {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return node && ts.isCallExpression(node.expression) ? [...node.expression.arguments] as T[] : undefined;
   }
 }

package/src/util/doc.ts

@@ -18,14 +18,14 @@ export class DocUtil {
   /**
    * Read doc comment for node
    */
-  static getDocComment(o: ts.JSDoc | ts.JSDocTag, def?: string) {
+  static getDocComment(o: ts.JSDoc | ts.JSDocTag, def?: string): string | undefined {
     return (typeof o.comment === 'string' ? o.comment : undefined) ?? def;
   }
 
   /**
    * Read JS Docs from a `ts.Declaration`
    */
-  static describeDocs(node: ts.Declaration | ts.Type) {
+  static describeDocs(node: ts.Declaration | ts.Type): DeclDocumentation {
     if (node && !('getSourceFile' in node)) {
       node = DeclarationUtil.getPrimaryDeclarationNode(node);
     }
@@ -38,6 +38,7 @@ export class DocUtil {
     if (node) {
       const tags = ts.getJSDocTags(node);
       while (!this.hasJSDoc(node) && CoreUtil.hasOriginal(node)) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         node = node.original as ts.Declaration;
       }
 
@@ -80,7 +81,7 @@ export class DocUtil {
    * Read augments information
    * @param type
    */
-  static readAugments(type: ts.Type | ts.Symbol) {
+  static readAugments(type: ts.Type | ts.Symbol): string[] {
     return this.readDocTag(type, 'augments').map(x => x.replace(/^.*?([^` ]+).*?$/, (_, b) => b));
   }
 }

package/src/util/import.ts

@@ -12,7 +12,7 @@ export class ImportUtil {
   /*
    * useful for handling failed imports, but still transpiling
    */
-  static optionalResolve(file: string, base?: string) {
+  static optionalResolve(file: string, base?: string): string {
     file = base ? pathResolve(base, file) : file;
     try {
       return require.resolve(file);
@@ -24,7 +24,7 @@ export class ImportUtil {
   /**
    * Collect all imports for a source file, as a hash map
    */
-  static collectImports(src: ts.SourceFile) {
+  static collectImports(src: ts.SourceFile): Map<string, Import> {
     const pth = require.resolve(src.fileName);
     const base = PathUtil.toUnix(pth);
 

package/src/util/literal.ts

@@ -25,7 +25,9 @@ export class LiteralUtil {
   static fromLiteral(factory: ts.NodeFactory, val: unknown[]): ts.ArrayLiteralExpression;
   static fromLiteral(factory: ts.NodeFactory, val: string | boolean | number): ts.LiteralExpression;
   static fromLiteral(factory: ts.NodeFactory, val: unknown): ts.Node {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     if (val && (val as ts.Expression).kind) { // If already a node
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       return val as ts.Node;
     } else if (Array.isArray(val)) {
       val = factory.createArrayLiteralExpression(val.map(v => this.fromLiteral(factory, v)));
@@ -40,11 +42,13 @@ export class LiteralUtil {
     } else if (typeof val === 'boolean') {
       val = val ? factory.createTrue() : factory.createFalse();
     } else if (val === String || val === Number || val === Boolean || val === Date || val === RegExp) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       val = factory.createIdentifier((val as Function).name);
     } else {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const ov = val as object;
       const pairs: ts.PropertyAssignment[] = [];
-      for (const k of Object.keys(ov) as (keyof typeof ov)[]) {
+      for (const k of Object.keys(ov)) {
         if (ov[k] !== undefined) {
           pairs.push(
             factory.createPropertyAssignment(k, this.fromLiteral(factory, ov[k]))
@@ -53,13 +57,22 @@ export class LiteralUtil {
       }
       return factory.createObjectLiteralExpression(pairs);
     }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return val as ts.Expression;
   }
 
   /**
    * Convert a `ts.Node` to a JS literal
    */
-  static toLiteral(val: ts.Node, strict = true): unknown {
+  static toLiteral(val: ts.NullLiteral, strict?: boolean): null;
+  static toLiteral(val: ts.NumericLiteral, strict?: boolean): number;
+  static toLiteral(val: ts.StringLiteral, strict?: boolean): string;
+  static toLiteral(val: ts.BooleanLiteral, strict?: boolean): boolean;
+  static toLiteral(val: ts.ObjectLiteralExpression, strict?: boolean): object;
+  static toLiteral(val: ts.ArrayLiteralExpression, strict?: boolean): unknown[];
+  static toLiteral(val: undefined, strict?: boolean): undefined;
+  static toLiteral(val: ts.Node, strict?: boolean): unknown;
+  static toLiteral(val?: ts.Node, strict = true): unknown {
     if (!val) {
       throw new Error('Val is not defined');
     } else if (ts.isArrayLiteralExpression(val)) {
@@ -102,7 +115,7 @@ export class LiteralUtil {
   /**
    * Extend object literal, whether JSON or ts.ObjectLiteralExpression
    */
-  static extendObjectLiteral(factory: ts.NodeFactory, src: object | ts.Expression, ...rest: (object | ts.Expression)[]) {
+  static extendObjectLiteral(factory: ts.NodeFactory, src: object | ts.Expression, ...rest: (object | ts.Expression)[]): ts.ObjectLiteralExpression {
     let ret = this.fromLiteral(factory, src);
     if (rest.find(x => !!x)) {
       ret = factory.createObjectLiteralExpression([
@@ -116,7 +129,7 @@ export class LiteralUtil {
   /**
    * Get a value from the an object expression
    */
-  static getObjectValue(node: ts.Expression | undefined, key: string) {
+  static getObjectValue(node: ts.Expression | undefined, key: string): ts.Expression | undefined {
     if (node && ts.isObjectLiteralExpression(node) && node.properties) {
       for (const prop of node.properties) {
         if (prop.name!.getText() === key) {

package/src/util/log.ts

@@ -14,7 +14,7 @@ export class LogUtil {
   /**
    * Clean up `ts.Node` contents for logging
    */
-  static collapseNodes(all: unknown[]) {
+  static collapseNodes(all: unknown[]): unknown[] {
     return all.map(x => this.collapseNode(x));
   }
 
@@ -35,15 +35,16 @@ export class LogUtil {
     if (Array.isArray(x)) {
       return x.map(v => this.collapseNode(v, cache));
     } else {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const ox = x as object;
       const out: Record<string, unknown> = {};
-      for (const key of Object.keys(ox) as (keyof typeof x)[]) {
+      for (const key of Object.keys(ox)) {
         if (Util.isFunction(ox[key]) || exclude.has(key) || ox[key] === undefined) {
           continue;
         }
         try {
           out[key] = this.collapseNode(ox[key], cache);
-        } catch (err) {
+        } catch {
           return undefined;
         }
       }

package/src/visitor.ts

@@ -54,7 +54,7 @@ export class VisitorFactory<S extends State = State> {
   /**
    * Initialize internal mapping given a list of transformers
    */
-  #init(transformers: NodeTransformer<S, TransformerType, ts.Node>[]) {
+  #init(transformers: NodeTransformer<S, TransformerType, ts.Node>[]): void {
     for (const trn of transformers) {
       if (!this.#transformers.has(trn.type)) {
         this.#transformers.set(trn.type, {});
@@ -116,10 +116,13 @@ export class VisitorFactory<S extends State = State> {
           ret = CoreUtil.updateSource(context.factory, ret, statements);
         }
         return state.finalize(ret);
-      } catch (e) {
-        console.error('Failed transforming', { error: e, file: file.fileName });
-        const out = new Error(`Failed transforming: ${file.fileName}: ${e.message}`);
-        out.stack = e.stack;
+      } catch (err) {
+        if (!(err instanceof Error)) {
+          throw err;
+        }
+        console.error('Failed transforming', { error: err, file: file.fileName });
+        const out = new Error(`Failed transforming: ${file.fileName}: ${err.message}`);
+        out.stack = err.stack;
         throw out;
       } finally {
         ConsoleManager.clear(); // Reset logging
@@ -130,12 +133,13 @@ export class VisitorFactory<S extends State = State> {
   /**
    * Handle transformer that target both ascent and descent
    */
-  executePhaseAlways<T extends ts.Node>(state: S, set: TransformerSet<S>, phase: TransformPhase, node: T) {
+  executePhaseAlways<T extends ts.Node>(state: S, set: TransformerSet<S>, phase: TransformPhase, node: T): T | undefined {
     if (!set[phase]?.size) {
       return;
     }
 
     for (const all of set[phase]!.get('ALL') ?? []) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       node = (all[phase]!(state, node) as T) ?? node;
     }
     return node;
@@ -144,7 +148,7 @@ export class VisitorFactory<S extends State = State> {
   /**
    * Handle a single phase of transformation
    */
-  executePhase<T extends ts.Node>(state: S, set: TransformerSet<S>, phase: TransformPhase, node: T) {
+  executePhase<T extends ts.Node>(state: S, set: TransformerSet<S>, phase: TransformPhase, node: T): T | undefined {
     if (!set[phase]?.size) {
       return;
     }
@@ -169,6 +173,7 @@ export class VisitorFactory<S extends State = State> {
 
       // For all matching handlers, execute
       for (const item of values) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         node = (item[phase]!(state, node, dec) as T) ?? node;
       }
     }

package/test-support/util.ts

@@ -13,14 +13,14 @@ export class TransformerTestUtil {
   /**
    * Compile a single file from a folder
    */
-  static async compile(folder: string, file?: string) {
+  static async compile(folder: string, file?: string): Promise<string> {
 
     const tsconfigObj = await import('@travetto/boot/tsconfig.trv.json');
 
     const prog = ts.createProgram({
       options: ts.convertCompilerOptionsFromJson(tsconfigObj, '').options,
       rootNames: (await ScanFs.scanDir({ testFile: f => f.startsWith('src/') && f.endsWith('.ts') }, folder))
-        .filter(x => x.stats.isFile())
+        .filter(x => x.stats?.isFile())
         .filter(x => !file || x.file.endsWith(file))
         .map(x => x.file),
     });
@@ -30,7 +30,7 @@ export class TransformerTestUtil {
 
     const transformers =
       (await ScanFs.scanDir({ testFile: f => f.startsWith('support/transformer') }, folder))
-        .filter(x => x.stats.isFile())
+        .filter(x => x.stats?.isFile())
         .map(x => import(x.file).then(getAllTransformers));
 
     const visitor = new VisitorFactory(