@travetto/transformer 3.0.0-rc.8 → 3.0.0

package/README.md

@@ -6,14 +6,21 @@
 **Install: @travetto/transformer**
 ```bash
 npm install @travetto/transformer
+
+# or
+
+yarn add @travetto/transformer
 ```
 
 This module provides support for enhanced AST transformations, and declarative transformer registration, with common patterns to support all the transformers used throughout the framework. Transformations are located by `support/transformer.<name>.ts` as the filename. 
 
-The module is primarily aimed at extremely advanced usages for things that cannot be detected at runtime.  The [Registry](https://github.com/travetto/travetto/tree/main/module/registry#readme "Patterns and utilities for handling registration of metadata and functionality for run-time use") module already has knowledge of all `class`es and `field`s, and is able to listen to changes there.  Many of the modules build upon work by some of the foundational transformers defined in [Registry](https://github.com/travetto/travetto/tree/main/module/registry#readme "Patterns and utilities for handling registration of metadata and functionality for run-time use"), [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.") and [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.").  These all center around defining a registry of classes, and associated type information.
+The module is primarily aimed at extremely advanced usages for things that cannot be detected at runtime.  The [Registry](https://github.com/travetto/travetto/tree/main/module/registry#readme "Patterns and utilities for handling registration of metadata and functionality for run-time use") module already has knowledge of all `class`es and `field`s, and is able to listen to changes there.  Many of the modules build upon work by some of the foundational transformers defined in [Manifest](https://github.com/travetto/travetto/tree/main/module/manifest#readme "Support for project indexing, manifesting, along with file watching"), [Registry](https://github.com/travetto/travetto/tree/main/module/registry#readme "Patterns and utilities for handling registration of metadata and functionality for run-time use"), [Schema](https://github.com/travetto/travetto/tree/main/module/schema#readme "Data type registry for runtime validation, reflection and binding.") and [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.").  These all center around defining a registry of classes, and associated type information.
 
 Because working with the [Typescript](https://typescriptlang.org) API can be delicate (and open to breaking changes), creating new transformers should be done cautiously. 
 
+## Monorepos and Idempotency
+Within the framework, any build or compile step will target the entire workspace, and for mono-repo projects, will include all modules.  The optimization this provides is great, but comes with a strict requirement that all compilation processes need to be idempotent.  This means that compiling a module directly, versus as a dependency should always produce the same output. This produces a requirement that all transformers are opt-in by the source code, and which transformers are needed in a file should be code-evident.  This also means that no transformers are optional, as that could produce different output depending on the dependency graph for a given module.
+
 ## Custom Transformer
 
 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.  
@@ -28,7 +35,7 @@ export class MakeUpper {
 
   @OnProperty()
   static handleProperty(state: TransformerState, node: ts.PropertyDeclaration): ts.PropertyDeclaration {
-    if (!state.file.includes('doc/src')) {
+    if (!state.importName.startsWith('@travetto/transformer/doc/upper')) {
       return node;
     }
     return state.factory.updatePropertyDeclaration(
@@ -43,7 +50,7 @@ export class MakeUpper {
 
   @OnClass()
   static handleClass(state: TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    if (!state.file.includes('doc/src')) {
+    if (!state.importName.startsWith('@travetto/transformer/doc/upper')) {
       return node;
     }
     return state.factory.updateClassDeclaration(
@@ -58,7 +65,7 @@ export class MakeUpper {
 
   @OnMethod()
   static handleMethod(state: TransformerState, node: ts.MethodDeclaration): ts.MethodDeclaration {
-    if (!state.file.includes('doc/src')) {
+    if (!state.importName.startsWith('@travetto/transformer/doc/upper')) {
       return node;
     }
     return state.factory.updateMethodDeclaration(
@@ -77,3 +84,40 @@ export class MakeUpper {
 ```
 
 **Note**: This should be a strong indicator that it is very easy to break code in unexpected ways.
+
+**Code: Sample Input**
+```typescript
+export class Test {
+  name: string;
+  age: number;
+  dob: Date;
+
+  computeAge(): void {
+    this['age'] = (Date.now() - this.dob.getTime());
+  }
+}
+```
+
+**Code: Sample Output**
+```javascript
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST = void 0;
+const tslib_1 = require("tslib");
+const Ⲑ_root_index_1 = tslib_1.__importStar(require("@travetto/manifest/src/root-index.js"));
+const Ⲑ_decorator_1 = tslib_1.__importStar(require("@travetto/registry/src/decorator.js"));
+var ᚕf = "@travetto/transformer/doc/upper.js";
+let TEST = class TEST {
+    static Ⲑinit = Ⲑ_root_index_1.RootIndex.registerFunction(TEST, ᚕf, 649563175, { COMPUTEAGE: { hash: 1286718349 } }, false, false);
+    NAME;
+    AGE;
+    DOB;
+    COMPUTEAGE() {
+        this['AGE'] = (Date.now() - this.DOB.getTime());
+    }
+};
+TEST = tslib_1.__decorate([
+    Ⲑ_decorator_1.Register()
+], TEST);
+exports.TEST = TEST;
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "3.0.0-rc.8",
+  "version": "3.0.0",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "typescript",
@@ -24,9 +24,9 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/manifest": "^3.0.0-rc.4",
-    "tslib": "^2.4.1",
-    "typescript": "^4.9.4"
+    "@travetto/manifest": "^3.0.0",
+    "tslib": "^2.5.0",
+    "typescript": "^4.9.5"
   },
   "travetto": {
     "displayName": "Transformation",

package/src/importer.ts

@@ -2,13 +2,12 @@ import ts from 'typescript';
 
 import { PackageUtil, path } from '@travetto/manifest';
 
-import { AnyType, ExternalType } from './resolver/types';
+import { AnyType, TransformResolver, ExternalType } from './resolver/types';
 import { ImportUtil } from './util/import';
 import { CoreUtil } from './util/core';
 import { Import } from './types/shared';
 import { LiteralUtil } from './util/literal';
 import { DeclarationUtil } from './util/declaration';
-import { TransformerIndex } from './manifest-index';
 
 const D_OR_D_TS_EXT_RE = /[.]d([.]ts)?$/;
 
@@ -22,12 +21,12 @@ export class ImportManager {
   #idx: Record<string, number> = {};
   #ids = new Map<string, string>();
   #importName: string;
-  #index: TransformerIndex;
+  #resolver: TransformResolver;
 
-  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, index: TransformerIndex) {
+  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, resolver: TransformResolver) {
     this.#imports = ImportUtil.collectImports(source);
-    this.#index = index;
-    this.#importName = index.getImportName(source.fileName);
+    this.#resolver = resolver;
+    this.#importName = this.#resolver.getFileImportName(source.fileName);
   }
 
   #getImportFile(spec?: ts.Expression): string | undefined {
@@ -40,7 +39,7 @@ export class ImportManager {
     const fileOrImport = this.#getImportFile(spec);
     if (
       fileOrImport &&
-      (fileOrImport.startsWith('.') || this.#index.getFromImport(fileOrImport)) &&
+      (fileOrImport.startsWith('.') || this.#resolver.isKnownFile(fileOrImport)) &&
       !/[.]([mc]?js|ts|json)$/.test(fileOrImport)
     ) {
       return LiteralUtil.fromLiteral(this.factory, `${fileOrImport}.js`);
@@ -48,17 +47,13 @@ export class ImportManager {
     return spec;
   }
 
-  #rewriteImportClause(
-    spec: ts.Expression | undefined,
-    clause: ts.ImportClause | undefined,
-    checker: ts.TypeChecker
-  ): ts.ImportClause | undefined {
+  #rewriteImportClause(spec: ts.Expression | undefined, clause: ts.ImportClause | undefined): ts.ImportClause | undefined {
     if (!(spec && clause?.namedBindings && ts.isNamedImports(clause.namedBindings))) {
       return clause;
     }
 
     const fileOrImport = this.#getImportFile(spec);
-    if (!(fileOrImport && (fileOrImport.startsWith('.') || this.#index.getFromImport(fileOrImport)))) {
+    if (!(fileOrImport && (fileOrImport.startsWith('.') || this.#resolver.isKnownFile(fileOrImport)))) {
       return clause;
     }
 
@@ -67,7 +62,7 @@ export class ImportManager {
     // Remove all type only imports
     for (const el of bindings.elements) {
       if (!el.isTypeOnly) {
-        const type = checker.getTypeAtLocation(el.name);
+        const type = this.#resolver.getType(el.name);
         const objFlags = DeclarationUtil.getObjectFlags(type);
         const typeFlags = type.getFlags();
         if (objFlags || typeFlags !== 1) {
@@ -106,7 +101,7 @@ export class ImportManager {
    * Import a file if needed, and record it's identifier
    */
   importFile(file: string, name?: string): Import {
-    file = this.#index.getImportName(file);
+    file = this.#resolver.getFileImportName(file);
 
     // Allow for node classes to be imported directly
     if (/@types\/node/.test(file)) {
@@ -178,7 +173,7 @@ export class ImportManager {
     }
   }
 
-  finalizeImportExportExtension(ret: ts.SourceFile, checker: ts.TypeChecker): ts.SourceFile {
+  finalizeImportExportExtension(ret: ts.SourceFile): ts.SourceFile {
     const toAdd: ts.Statement[] = [];
 
     for (const stmt of ret.statements) {
@@ -198,7 +193,7 @@ export class ImportManager {
           toAdd.push(this.factory.updateImportDeclaration(
             stmt,
             stmt.modifiers,
-            this.#rewriteImportClause(stmt.moduleSpecifier, stmt.importClause, checker)!,
+            this.#rewriteImportClause(stmt.moduleSpecifier, stmt.importClause)!,
             this.#rewriteModuleSpecifier(stmt.moduleSpecifier)!,
             stmt.assertClause
           ));
@@ -213,9 +208,9 @@ export class ImportManager {
   /**
    * Reset the imports into the source file
    */
-  finalize(ret: ts.SourceFile, checker: ts.TypeChecker): ts.SourceFile {
+  finalize(ret: ts.SourceFile): ts.SourceFile {
     ret = this.finalizeNewImports(ret) ?? ret;
-    ret = this.finalizeImportExportExtension(ret, checker) ?? ret;
+    ret = this.finalizeImportExportExtension(ret) ?? ret;
     return ret;
   }
 

package/src/manager.ts

@@ -1,12 +1,11 @@
 import ts from 'typescript';
 
-import { ManifestRoot } from '@travetto/manifest';
+import { ManifestIndex, path, RootIndex } from '@travetto/manifest';
 
 import { NodeTransformer } from './types/visitor';
 import { VisitorFactory } from './visitor';
 import { TransformerState } from './state';
 import { getAllTransformers } from './register';
-import { TransformerIndex } from './manifest-index';
 
 /**
  * Manages the typescript transformers
@@ -19,26 +18,35 @@ export class TransformerManager {
    * @param manifest
    * @returns
    */
-  static async create(transformerFiles: string[], manifest: ManifestRoot): Promise<TransformerManager> {
+  static async create(manifestIndex: ManifestIndex): Promise<TransformerManager> {
+    const transformerFiles = Object.values(manifestIndex.manifest.modules).flatMap(
+      x => (x.files.$transformer ?? []).map(([f]) =>
+        path.resolve(manifestIndex.manifest.workspacePath, x.sourceFolder, f)
+      )
+    );
+
     const transformers: NodeTransformer<TransformerState>[] = [];
-    const idx = new TransformerIndex('.', manifest);
 
     for (const file of transformerFiles) { // Exclude based on blacklist
-      const entry = idx.getEntry(file)!;
-      transformers.push(...getAllTransformers(await import(file), entry.module));
+      const entry = RootIndex.getEntry(file)!;
+      transformers.push(...getAllTransformers(await import(entry.import), entry.module));
+    }
+
+    for (const x of transformers) {
+      process.send?.(['debug', `Loaded Transformer: ${x.key}#${x.type}`]);
     }
 
     // Prepare a new visitor factory with a given type checker
-    return new TransformerManager(transformers, idx);
+    return new TransformerManager(manifestIndex, transformers);
   }
 
   #cached: ts.CustomTransformers | undefined;
   #transformers: NodeTransformer<TransformerState>[];
-  #index: TransformerIndex;
+  #manifestIndex: ManifestIndex;
 
-  constructor(transformers: NodeTransformer<TransformerState>[], index: TransformerIndex) {
+  constructor(manifestIndex: ManifestIndex, transformers: NodeTransformer<TransformerState>[]) {
     this.#transformers = transformers;
-    this.#index = index;
+    this.#manifestIndex = manifestIndex;
   }
 
   /**
@@ -47,7 +55,7 @@ export class TransformerManager {
    */
   init(checker: ts.TypeChecker): void {
     const visitor = new VisitorFactory(
-      (ctx, src) => new TransformerState(src, ctx.factory, checker, this.#index, ctx.getCompilerOptions()),
+      (ctx, src) => new TransformerState(src, ctx.factory, checker, this.#manifestIndex),
       this.#transformers
     );
 

package/src/resolver/builder.ts

@@ -1,14 +1,14 @@
 /* eslint-disable no-bitwise */
 import ts from 'typescript';
 
-import { ManifestIndex, path } from '@travetto/manifest';
+import { path } from '@travetto/manifest';
 
 import { DocUtil } from '../util/doc';
 import { CoreUtil } from '../util/core';
 import { DeclarationUtil } from '../util/declaration';
 import { LiteralUtil } from '../util/literal';
 
-import { Type, AnyType, UnionType, Checker } from './types';
+import { Type, AnyType, UnionType, TransformResolver } from './types';
 import { CoerceUtil } from './coerce';
 
 /**
@@ -38,7 +38,7 @@ type Category = 'void' | 'undefined' | 'concrete' | 'unknown' | 'tuple' | 'shape
 /**
  * Type categorizer, input for builder
  */
-export function TypeCategorize(checker: ts.TypeChecker, type: ts.Type, index: ManifestIndex): { category: Category, type: ts.Type } {
+export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { category: Category, type: ts.Type } {
   const flags = type.getFlags();
   const objectFlags = DeclarationUtil.getObjectFlags(type) ?? 0;
 
@@ -68,7 +68,7 @@ export function TypeCategorize(checker: ts.TypeChecker, type: ts.Type, index: Ma
     const sourceFile = source.fileName;
     if (sourceFile?.includes('@types/node/globals') || sourceFile?.includes('typescript/lib')) {
       return { category: 'literal', type };
-    } else if (sourceFile?.endsWith('.d.ts') && !index.getFromSource(sourceFile)) {
+    } else if (sourceFile?.endsWith('.d.ts') && !resolver.isKnownFile(sourceFile)) {
       return { category: 'unknown', type };
     } else if (!resolvedType.isClass()) { // Not a real type
       return { category: 'shape', type: resolvedType };
@@ -97,26 +97,26 @@ export function TypeCategorize(checker: ts.TypeChecker, type: ts.Type, index: Ma
  */
 export const TypeBuilder: {
   [K in Category]: {
-    build(checker: Checker, type: ts.Type, alias?: ts.Symbol): AnyType | undefined;
+    build(resolver: TransformResolver, type: ts.Type, alias?: ts.Symbol): AnyType | undefined;
     finalize?(type: Type<K>): AnyType;
   }
 } = {
   unknown: {
-    build: (checker, type) => undefined
+    build: (resolver, type) => undefined
   },
   undefined: {
-    build: (checker, type) => ({ key: 'literal', name: 'undefined', ctor: undefined })
+    build: (resolver, type) => ({ key: 'literal', name: 'undefined', ctor: undefined })
   },
   void: {
-    build: (checker, type) => ({ key: 'literal', name: 'void', ctor: undefined })
+    build: (resolver, type) => ({ key: 'literal', name: 'void', ctor: undefined })
   },
   tuple: {
-    build: (checker, type) => ({ key: 'tuple', tsTupleTypes: checker.getAllTypeArguments(type), subTypes: [] })
+    build: (resolver, type) => ({ key: 'tuple', tsTupleTypes: resolver.getAllTypeArguments(type), subTypes: [] })
   },
   literal: {
-    build: (checker, type) => {
+    build: (resolver, type) => {
       // Handle void/undefined
-      const name = checker.getTypeAsString(type) ?? '';
+      const name = resolver.getTypeAsString(type) ?? '';
       const complexName = CoreUtil.getSymbol(type)?.getName() ?? '';
 
       if (name in GLOBAL_SIMPLE) {
@@ -137,21 +137,21 @@ export const TypeBuilder: {
           key: 'literal',
           name: cons.name,
           ctor: cons,
-          tsTypeArguments: checker.getAllTypeArguments(type)
+          tsTypeArguments: resolver.getAllTypeArguments(type)
         };
       }
     }
   },
   external: {
-    build: (checker, type) => {
+    build: (resolver, type) => {
       const name = CoreUtil.getSymbol(type)?.getName();
-      const importName = checker.getIndex().getImportName(type);
-      const tsTypeArguments = checker.getAllTypeArguments(type);
+      const importName = resolver.getTypeImportName(type)!;
+      const tsTypeArguments = resolver.getAllTypeArguments(type);
       return { key: 'external', name, importName, tsTypeArguments };
     }
   },
   union: {
-    build: (checker, uType: ts.UnionType) => {
+    build: (resolver, uType: ts.UnionType) => {
       let undefinable = false;
       let nullable = false;
       const remainder = uType.types.filter(ut => {
@@ -177,15 +177,20 @@ export const TypeBuilder: {
     }
   },
   shape: {
-    build: (checker, type, alias?) => {
+    build: (resolver, type, alias?) => {
       const tsFieldTypes: Record<string, ts.Type> = {};
       const name = CoreUtil.getSymbol(alias ?? type)?.getName();
-      const importName = checker.getIndex().getImportName(type);
-      const tsTypeArguments = checker.getAllTypeArguments(type);
-      for (const member of checker.getPropertiesOfType(type)) {
+      const importName = resolver.getTypeImportName(type) ?? '<unknown>';
+      const tsTypeArguments = resolver.getAllTypeArguments(type);
+      const props = resolver.getPropertiesOfType(type);
+      if (props.length === 0) {
+        return { key: 'unknown', name, importName };
+      }
+
+      for (const member of props) {
         const dec = DeclarationUtil.getPrimaryDeclarationNode(member);
         if (DeclarationUtil.isPublic(dec)) { // If public
-          const memberType = checker.getType(dec);
+          const memberType = resolver.getType(dec);
           if (
             !member.getName().includes('@') && // if not a symbol
             !memberType.getCallSignatures().length // if not a function
@@ -198,7 +203,7 @@ export const TypeBuilder: {
     }
   },
   concrete: {
-    build: (checker, type) => {
+    build: (resolver, type) => {
       const [tag] = DocUtil.readDocTag(type, 'concrete');
       if (tag) {
         // eslint-disable-next-line prefer-const
@@ -215,10 +220,10 @@ export const TypeBuilder: {
             ?.getSourceFile().fileName ?? '';
 
           if (importName === '.') {
-            importName = checker.getIndex().getImportName(rawSourceFile);
+            importName = resolver.getFileImportName(rawSourceFile);
           } else {
             const base = path.dirname(rawSourceFile);
-            importName = checker.getIndex().getImportName(path.resolve(base, importName));
+            importName = resolver.getFileImportName(path.resolve(base, importName));
           }
         }
         return { key: 'external', name, importName };

package/src/resolver/service.ts

@@ -1,21 +1,23 @@
 import ts from 'typescript';
 
-import type { AnyType, Checker } from './types';
+import { ManifestIndex, path } from '@travetto/manifest';
+
+import type { AnyType, TransformResolver } from './types';
 import { TypeCategorize, TypeBuilder } from './builder';
 import { VisitCache } from './cache';
 import { DocUtil } from '../util/doc';
-import { TransformerIndex } from '../manifest-index';
+import { DeclarationUtil } from '../util/declaration';
 
 /**
- * Type resolver
+ * Implementation of TransformResolver
  */
-export class TypeResolver implements Checker {
+export class SimpleResolver implements TransformResolver {
   #tsChecker: ts.TypeChecker;
-  #index: TransformerIndex;
+  #manifestIndex: ManifestIndex;
 
-  constructor(tsChecker: ts.TypeChecker, idx: TransformerIndex) {
+  constructor(tsChecker: ts.TypeChecker, manifestIndex: ManifestIndex) {
     this.#tsChecker = tsChecker;
-    this.#index = idx;
+    this.#manifestIndex = manifestIndex;
   }
 
   /**
@@ -26,8 +28,38 @@ export class TypeResolver implements Checker {
     return this.#tsChecker;
   }
 
-  getIndex(): TransformerIndex {
-    return this.#index;
+  /**
+   * Resolve an import name (e.g. @module/path/file) for a file
+   */
+  getFileImportName(file: string, removeExt?: boolean): string {
+    let sourceFile = path.toPosix(file);
+
+    if (!sourceFile.endsWith('.js') && !sourceFile.endsWith('.ts')) {
+      sourceFile = `${sourceFile}.ts`;
+    }
+
+    const imp =
+      this.#manifestIndex.getEntry(/[.]ts$/.test(sourceFile) ? sourceFile : `${sourceFile}.js`)?.import ??
+      this.#manifestIndex.getFromImport(sourceFile.replace(/^.*node_modules\//, '').replace(/[.]ts$/, ''))?.import ??
+      file;
+
+    return removeExt ? imp.replace(/[.]js$/, '') : imp;
+  }
+
+  /**
+   * Resolve an import name (e.g. @module/path/file) for a type
+   */
+  getTypeImportName(type: ts.Type, removeExt?: boolean): string | undefined {
+    const ogSource = DeclarationUtil.getPrimaryDeclarationNode(type)?.getSourceFile()?.fileName;
+    return ogSource ? this.getFileImportName(ogSource, removeExt) : undefined;
+  }
+
+  /**
+   * Is the file/import known to the index, helpful for determine ownership
+   */
+  isKnownFile(fileOrImport: string): boolean {
+    return (this.#manifestIndex.getFromSource(fileOrImport) !== undefined) ||
+      (this.#manifestIndex.getFromImport(fileOrImport) !== undefined);
   }
 
   /**
@@ -72,7 +104,7 @@ export class TypeResolver implements Checker {
   /**
    * Resolve an `AnyType` from a `ts.Type` or a `ts.Node`
    */
-  resolveType(node: ts.Type | ts.Node): AnyType {
+  resolveType(node: ts.Type | ts.Node, importName: string): AnyType {
     const visited = new VisitCache();
     const resolve = (resType: ts.Type, alias?: ts.Symbol, depth = 0): AnyType => {
 
@@ -80,7 +112,7 @@ export class TypeResolver implements Checker {
         throw new Error('Object structure too nested');
       }
 
-      const { category, type } = TypeCategorize(this.#tsChecker, resType, this.#index);
+      const { category, type } = TypeCategorize(this, resType);
       const { build, finalize } = TypeBuilder[category];
 
       let result = build(this, type, alias);
@@ -124,7 +156,7 @@ export class TypeResolver implements Checker {
       if (!(err instanceof Error)) {
         throw err;
       }
-      console.error('Unable to resolve type', err.stack);
+      console.error(`Unable to resolve type in ${importName}`, err.stack);
       return { key: 'literal', ctor: Object, name: 'object' };
     }
   }

package/src/resolver/types.ts

@@ -1,7 +1,5 @@
 import type ts from 'typescript';
 
-import { TransformerIndex } from '../manifest-index';
-
 /**
  * Base type for a simplistic type structure
  */
@@ -153,10 +151,12 @@ export type AnyType = TupleType | ShapeType | UnionType | LiteralType | External
 /**
  * Simple interface for checked methods
  */
-export interface Checker {
+export interface TransformResolver {
+  isKnownFile(file: string): boolean;
+  getFileImportName(file: string, removeExt?: boolean): string;
+  getTypeImportName(type: ts.Type, removeExt?: boolean): string | undefined;
   getAllTypeArguments(type: ts.Type): ts.Type[];
   getPropertiesOfType(type: ts.Type): ts.Symbol[];
   getTypeAsString(type: ts.Type): string | undefined;
   getType(node: ts.Node): ts.Type;
-  getIndex(): TransformerIndex;
 }

package/src/state.ts

@@ -1,10 +1,10 @@
 import ts from 'typescript';
 
-import { path } from '@travetto/manifest';
+import { ManifestIndex, path } from '@travetto/manifest';
 
 import { ExternalType, AnyType } from './resolver/types';
 import { State, DecoratorMeta, Transformer, ModuleNameⲐ } from './types/visitor';
-import { TypeResolver } from './resolver/service';
+import { SimpleResolver } from './resolver/service';
 import { ImportManager } from './importer';
 import { Import } from './types/shared';
 
@@ -14,7 +14,6 @@ import { DeclarationUtil } from './util/declaration';
 import { CoreUtil } from './util/core';
 import { LiteralUtil } from './util/literal';
 import { SystemUtil } from './util/system';
-import { TransformerIndex } from './manifest-index';
 
 function hasOriginal(n: unknown): n is { original: ts.Node } {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -32,38 +31,23 @@ function hasEscapedName(n: unknown): n is { name: { escapedText: string } } {
 export class TransformerState implements State {
   static SYNTHETIC_EXT = 'Ⲑsyn';
 
-  #resolver: TypeResolver;
+  #resolver: SimpleResolver;
   #imports: ImportManager;
-  #index: TransformerIndex;
+  #fileIdent: ts.Identifier;
+  #manifestIndex: ManifestIndex;
   #syntheticIdentifiers = new Map<string, ts.Identifier>();
   #decorators = new Map<string, ts.PropertyAccessExpression>();
-  #options: ts.CompilerOptions;
   added = new Map<number, ts.Statement[]>();
   importName: string;
   file: string;
 
-  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, checker: ts.TypeChecker, index: TransformerIndex, options: ts.CompilerOptions) {
-    this.#index = index;
-    this.#imports = new ImportManager(source, factory, index);
-    this.#resolver = new TypeResolver(checker, index);
+  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, checker: ts.TypeChecker, manifestIndex: ManifestIndex) {
+    this.#manifestIndex = manifestIndex;
+    this.#resolver = new SimpleResolver(checker, manifestIndex);
+    this.#imports = new ImportManager(source, factory, this.#resolver);
     this.file = path.toPosix(this.source.fileName);
-    this.importName = this.#index.getImportName(this.file, true);
-    this.#options = options;
-  }
 
-  /**
-   * Are we building ESM Output?
-   */
-  isEsmOutput(): boolean {
-    return this.#options.module !== ts.ModuleKind.CommonJS;
-  }
-
-  /**
-   * Allow access to resolver
-   * @private
-   */
-  getResolver(): TypeResolver {
-    return this.#resolver;
+    this.importName = this.#resolver.getFileImportName(this.file, true);
   }
 
   /**
@@ -84,7 +68,7 @@ export class TransformerState implements State {
    * Resolve an `AnyType` from a `ts.Type` or `ts.Node`
    */
   resolveType(node: ts.Type | ts.Node): AnyType {
-    const resolved = this.#resolver.resolveType(node);
+    const resolved = this.#resolver.resolveType(node, this.importName);
     this.#imports.importFromResolved(resolved);
     return resolved;
   }
@@ -96,7 +80,7 @@ export class TransformerState implements State {
     const resolved = this.resolveType(node);
     if (resolved.key !== 'external') {
       const file = node.getSourceFile().fileName;
-      const src = this.#index.getImportName(file);
+      const src = this.#resolver.getFileImportName(file);
       throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${src}`);
     }
     return resolved;
@@ -163,8 +147,8 @@ export class TransformerState implements State {
       this.#resolver.getType(ident)
     );
     const src = decl?.getSourceFile().fileName;
-    const mod = src ? this.#index.getImportName(src, true) : undefined;
-    const file = this.#index.getFromImport(mod ?? '')?.output;
+    const mod = src ? this.#resolver.getFileImportName(src, true) : undefined;
+    const file = this.#manifestIndex.getFromImport(mod ?? '')?.outputFile;
     const targets = DocUtil.readAugments(this.#resolver.getType(ident));
     const module = file ? mod : undefined;
     const name = ident ?
@@ -228,7 +212,7 @@ export class TransformerState implements State {
    * Finalize the source file for emission
    */
   finalize(ret: ts.SourceFile): ts.SourceFile {
-    ret = this.#imports.finalize(ret, this.#resolver.getChecker());
+    ret = this.#imports.finalize(ret);
     return ret;
   }
 
@@ -279,18 +263,16 @@ export class TransformerState implements State {
    * Get filename identifier, regardless of module system
    */
   getFilenameIdentifier(): ts.Expression {
-    return this.isEsmOutput() ?
-      this.createAccess('import', 'meta', 'url') :
-      this.createIdentifier('__filename');
-  }
-
-  /**
-   * Get the entry file identifier, supports both ESM and commonjs
-   */
-  getEntryFileIdentifier(): ts.Expression {
-    return this.isEsmOutput() ?
-      this.createAccess('process', 'argv', 1) :
-      this.createAccess('require', 'main', 'filename');
+    if (this.#fileIdent === undefined) {
+      this.#fileIdent = this.createIdentifier('ᚕf');
+      const decl = this.factory.createVariableDeclaration(this.#fileIdent, undefined, undefined,
+        this.fromLiteral(this.#resolver.getFileImportName(this.source.fileName) ?? this.source.fileName)
+      );
+      this.addStatements([
+        this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([decl]))
+      ], -1);
+    }
+    return this.#fileIdent;
   }
 
   /**
@@ -357,7 +339,7 @@ export class TransformerState implements State {
         (m): m is ts.MethodDeclaration => ts.isMethodDeclaration(m) && ts.isIdentifier(m.name) && m.name.escapedText === method
       );
     } else {
-      const props = this.getResolver().getPropertiesOfType(cls);
+      const props = this.#resolver.getPropertiesOfType(cls);
       for (const prop of props) {
         const decl = prop.declarations?.[0];
         if (decl && prop.escapedName === method && ts.isMethodDeclaration(decl)) {

package/src/types/shared.ts

@@ -1,4 +1,4 @@
-import type { default as ts } from 'typescript';
+import type ts from 'typescript';
 
 /**
  * Param documentation

package/src/util/declaration.ts

@@ -57,8 +57,8 @@ export class DeclarationUtil {
    * Resolve the `ts.ObjectFlags`
    */
   static getObjectFlags(type: ts.Type): ts.ObjectFlags {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (ts as unknown as { getObjectFlags(t: ts.Type): ts.ObjectFlags }).getObjectFlags(type);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, no-bitwise
+    return (ts as unknown as { getObjectFlags(t: ts.Type): ts.ObjectFlags }).getObjectFlags(type) & ~(ts.NodeFlags.ThisNodeOrAnySubNodesHasError);
   }
 
   /**

package/src/util/log.ts

@@ -36,7 +36,8 @@ export class LogUtil {
       // 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)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      for (const key of Object.keys(ox) as (keyof typeof ox)[]) {
         if (Object.getPrototypeOf(ox[key]) === Function.prototype || exclude.has(key) || ox[key] === undefined) {
           continue;
         }

package/src/visitor.ts

@@ -89,12 +89,11 @@ export class VisitorFactory<S extends State = State> {
         const changed = state.added.size;
         let statements: ts.NodeArray<ts.Statement> | ts.Statement[] = ret.statements;
         while (state.added.size) {
-          for (const [k, all] of [...state.added].sort(([idxA], [idxB]) => idxB - idxA)) {
-            const idx = k === -1 ? state.added.size : k;
+          for (const [idx, all] of [...state.added].sort(([idxA], [idxB]) => idxB - idxA)) {
             statements = [
-              ...statements.slice(0, idx),
+              ...statements.slice(0, Math.max(idx, 0)),
               ...all.map(v => this.visit(state, context, v)),
-              ...statements.slice(idx)
+              ...statements.slice(Math.max(idx, 0))
             ];
             state.added.delete(idx);
           }

package/src/manifest-index.ts

@@ -1,29 +0,0 @@
-import ts from 'typescript';
-
-import { ManifestIndex, path } from '@travetto/manifest';
-import { DeclarationUtil } from './util/declaration';
-
-/**
- * Specific logic for the transformer
- */
-export class TransformerIndex extends ManifestIndex {
-
-  /**
-   * Resolve import name for a given type
-   */
-  getImportName(type: ts.Type | string, removeExt = false): string {
-    const ogSource = typeof type === 'string' ? type : DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile().fileName;
-    let sourceFile = path.toPosix(ogSource);
-
-    if (!sourceFile.endsWith('.js') && !sourceFile.endsWith('.ts')) {
-      sourceFile = `${sourceFile}.ts`;
-    }
-
-    const imp =
-      this.getEntry(/[.]ts$/.test(sourceFile) ? sourceFile : `${sourceFile}.js`)?.import ??
-      this.getFromImport(sourceFile.replace(/^.*node_modules\//, '').replace(/[.]ts$/, ''))?.import ??
-      ogSource;
-
-    return removeExt ? imp.replace(/[.]js$/, '') : imp;
-  }
-}