@travetto/transformer 6.0.0-rc.1 → 6.0.0-rc.3

package/README.md

@@ -33,12 +33,13 @@ import { OnProperty, TransformerState, OnMethod, OnClass } from '@travetto/trans
 
 export class MakeUpper {
 
+  static isValid(state: TransformerState): boolean {
+    return state.importName !== '@travetto/transformer/doc/upper.ts';
+  }
+
   @OnProperty()
   static handleProperty(state: TransformerState, node: ts.PropertyDeclaration): ts.PropertyDeclaration {
-    if (!state.importName.startsWith('@travetto/transformer/doc/upper')) {
-      return node;
-    }
-    return state.factory.updatePropertyDeclaration(
+    return !this.isValid(state) ? node : state.factory.updatePropertyDeclaration(
       node,
       node.modifiers,
       node.name.getText().toUpperCase(),
@@ -50,10 +51,7 @@ export class MakeUpper {
 
   @OnClass()
   static handleClass(state: TransformerState, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    if (!state.importName.startsWith('@travetto/transformer/doc/upper')) {
-      return node;
-    }
-    return state.factory.updateClassDeclaration(
+    return !this.isValid(state) ? node : state.factory.updateClassDeclaration(
       node,
       node.modifiers,
       state.createIdentifier(node.name!.getText().toUpperCase()),
@@ -65,10 +63,7 @@ export class MakeUpper {
 
   @OnMethod()
   static handleMethod(state: TransformerState, node: ts.MethodDeclaration): ts.MethodDeclaration {
-    if (!state.importName.startsWith('@travetto/transformer/doc/upper')) {
-      return node;
-    }
-    return state.factory.updateMethodDeclaration(
+    return !this.isValid(state) ? node : state.factory.updateMethodDeclaration(
       node,
       node.modifiers,
       undefined,

package/__index__.ts

@@ -1,15 +1,19 @@
-export * from './src/state';
-export * from './src/visitor';
-export * from './src/register';
-export * from './src/types/visitor';
-export * from './src/types/shared';
-export type { AnyType } from './src/resolver/types';
-export * from './src/manager';
+export * from './src/state.ts';
+export * from './src/visitor.ts';
+export * from './src/register.ts';
+export * from './src/types/visitor.ts';
+export * from './src/types/shared.ts';
+export * from './src/manager.ts';
 
-export * from './src/util/core';
-export * from './src/util/declaration';
-export * from './src/util/decorator';
-export * from './src/util/doc';
-export * from './src/util/literal';
-export * from './src/util/log';
-export * from './src/util/system';
+export * from './src/util/core.ts';
+export * from './src/util/declaration.ts';
+export * from './src/util/decorator.ts';
+export * from './src/util/doc.ts';
+export * from './src/util/literal.ts';
+export * from './src/util/log.ts';
+export * from './src/util/system.ts';
+
+export type {
+  AnyType, ForeignType, ManagedType, PointerType, LiteralType, ShapeType,
+  CompositionType, TupleType, UnknownType, TemplateType
+} from './src/resolver/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/transformer",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0-rc.3",
   "description": "Functionality for AST transformations, with transformer registration, and general utils",
   "keywords": [
     "typescript",
@@ -24,9 +24,9 @@
     "directory": "module/transformer"
   },
   "dependencies": {
-    "@travetto/manifest": "^6.0.0-rc.1",
+    "@travetto/manifest": "^6.0.0-rc.2",
     "tslib": "^2.8.1",
-    "typescript": "^5.7.3"
+    "typescript": "^5.8.3"
   },
   "travetto": {
     "displayName": "Transformation",

package/src/importer.ts

@@ -2,12 +2,12 @@ import ts from 'typescript';
 
 import { ManifestModuleUtil, PackageUtil, path } from '@travetto/manifest';
 
-import { AnyType, TransformResolver, ManagedType } 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 { AnyType, TransformResolver, ManagedType } from './resolver/types.ts';
+import { ImportUtil } from './util/import.ts';
+import { CoreUtil } from './util/core.ts';
+import { Import } from './types/shared.ts';
+import { LiteralUtil } from './util/literal.ts';
+import { DeclarationUtil } from './util/declaration.ts';
 
 const D_OR_D_TS_EXT_RE = /[.]d([.]ts)?$/;
 
@@ -34,19 +34,12 @@ export class ImportManager {
     this.factory = factory;
   }
 
-  #rewriteModuleSpecifier(spec: ts.Expression | undefined): ts.Expression | undefined {
-    if (spec && ts.isStringLiteral(spec) && this.isUntypedImport(spec)) {
-      return LiteralUtil.fromLiteral(this.factory, `${spec.text.replace(/['"]/g, '')}.js`);
-    }
-    return spec;
-  }
-
   #rewriteImportClause(spec: ts.Expression | undefined, clause: ts.ImportClause | undefined): ts.ImportClause | undefined {
     if (!(spec && clause?.namedBindings && ts.isNamedImports(clause.namedBindings))) {
       return clause;
     }
 
-    if (spec && ts.isStringLiteral(spec) && !this.isKnownImport(spec)) {
+    if (spec && ts.isStringLiteral(spec) && !this.#isKnownImport(spec)) {
       return clause;
     }
 
@@ -80,7 +73,7 @@ export class ImportManager {
    * Is a known import an untyped file access
    * @param fileOrImport
    */
-  isKnownImport(fileOrImport: ts.StringLiteral | string | undefined): boolean {
+  #isKnownImport(fileOrImport: ts.StringLiteral | string | undefined): boolean {
     if (fileOrImport && typeof fileOrImport !== 'string') {
       if (ts.isStringLiteral(fileOrImport)) {
         fileOrImport = fileOrImport.text.replace(/['"]g/, '');
@@ -95,13 +88,22 @@ export class ImportManager {
   }
 
   /**
-   * Is a file or import an untyped file access
-   * @param fileOrImport
+   * Normalize module specifier
    */
-  isUntypedImport(fileOrImport: ts.StringLiteral | string | undefined): boolean {
-    return this.isKnownImport(fileOrImport) &&
-      !/[.](([mc]?[jt]s)|json)['"]?$/
-        .test(typeof fileOrImport === 'string' ? fileOrImport : fileOrImport!.text);
+  normalizeModuleSpecifier<T extends ts.Expression | undefined>(spec: T): T {
+    if (spec && ts.isStringLiteral(spec) && this.#isKnownImport(spec.text)) {
+      const specText = spec.text.replace(/['"]/g, '');
+
+      const type = ManifestModuleUtil.getFileType(specText);
+      if (type === 'js' || type === 'ts') {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return LiteralUtil.fromLiteral(this.factory, ManifestModuleUtil.withOutputExtension(specText)) as unknown as T;
+      } else {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return LiteralUtil.fromLiteral(this.factory, `${specText}${ManifestModuleUtil.OUTPUT_EXT}`) as unknown as T;
+      }
+    }
+    return spec;
   }
 
   /**
@@ -126,7 +128,7 @@ export class ImportManager {
   importFile(file: string, name?: string): Import {
     file = this.#resolver.getFileImportName(file);
 
-    if (file.endsWith('.ts') && !file.endsWith('.d.ts')) {
+    if (file.endsWith(ManifestModuleUtil.SOURCE_DEF_EXT) && !file.endsWith(ManifestModuleUtil.TYPINGS_EXT)) {
       file = ManifestModuleUtil.withOutputExtension(file);
     }
 
@@ -211,7 +213,7 @@ export class ImportManager {
             stmt.modifiers,
             stmt.isTypeOnly,
             stmt.exportClause,
-            this.#rewriteModuleSpecifier(stmt.moduleSpecifier),
+            this.normalizeModuleSpecifier(stmt.moduleSpecifier),
             stmt.attributes
           ));
         }
@@ -221,7 +223,7 @@ export class ImportManager {
             stmt,
             stmt.modifiers,
             this.#rewriteImportClause(stmt.moduleSpecifier, stmt.importClause)!,
-            this.#rewriteModuleSpecifier(stmt.moduleSpecifier)!,
+            this.normalizeModuleSpecifier(stmt.moduleSpecifier)!,
             stmt.attributes
           ));
         }
@@ -235,10 +237,10 @@ export class ImportManager {
   /**
    * Reset the imports into the source file
    */
-  finalize(ret: ts.SourceFile): ts.SourceFile {
-    ret = this.finalizeNewImports(ret) ?? ret;
-    ret = this.finalizeImportExportExtension(ret) ?? ret;
-    return ret;
+  finalize(src: ts.SourceFile): ts.SourceFile {
+    let node = this.finalizeNewImports(src) ?? src;
+    node = this.finalizeImportExportExtension(node) ?? node;
+    return node;
   }
 
   /**

package/src/manager.ts

@@ -2,10 +2,10 @@ import ts from 'typescript';
 
 import { ManifestIndex, ManifestModuleUtil } from '@travetto/manifest';
 
-import { NodeTransformer } from './types/visitor';
-import { VisitorFactory } from './visitor';
-import { TransformerState } from './state';
-import { getAllTransformers } from './register';
+import { NodeTransformer } from './types/visitor.ts';
+import { VisitorFactory } from './visitor.ts';
+import { TransformerState } from './state.ts';
+import { getAllTransformers } from './register.ts';
 
 /**
  * Manages the typescript transformers

package/src/register.ts

@@ -1,10 +1,10 @@
 import ts from 'typescript';
 
-import { DecoratorMeta, NodeTransformer, State, TransformPhase, TransformerType, Transformer, ModuleNameSymbol } from './types/visitor';
+import { DecoratorMeta, NodeTransformer, State, TransformPhase, TransformerType, Transformer, ModuleNameSymbol } from './types/visitor.ts';
 
-const HandlersProp = Symbol.for('@travetto/transformer:handlers');
+const HandlersSymbol = Symbol();
 
-type TransformerWithHandlers = Transformer & { [HandlersProp]?: NodeTransformer[] };
+type TransformerWithHandlers = Transformer & { [HandlersSymbol]?: NodeTransformer[] };
 
 function isTransformer(x: unknown): x is Transformer {
   return x !== null && x !== undefined && typeof x === 'function';
@@ -14,13 +14,13 @@ function isTransformer(x: unknown): x is Transformer {
  * Get all transformers
  * @param obj Object to search for transformers
  */
-export function getAllTransformers(obj: Record<string, { [HandlersProp]?: NodeTransformer[] }>, module: string): NodeTransformer[] {
+export function getAllTransformers(obj: Record<string, { [HandlersSymbol]?: NodeTransformer[] }>, module: string): NodeTransformer[] {
   return Object.values(obj)
     .flatMap(x => {
       if (isTransformer(x)) {
         x[ModuleNameSymbol] = module;
       }
-      return (x[HandlersProp] ?? []);
+      return (x[HandlersSymbol] ?? []);
     })
     .map(handler => ({
       ...handler,
@@ -31,7 +31,7 @@ export function getAllTransformers(obj: Record<string, { [HandlersProp]?: NodeTr
 
 // Store handlers in class
 function storeHandler(cls: TransformerWithHandlers, fn: Function, phase: TransformPhase, type: TransformerType, target?: string[]): void {
-  (cls[HandlersProp] ??= []).push({ key: fn.name, [phase]: fn.bind(cls), type, target });
+  (cls[HandlersSymbol] ??= []).push({ key: fn.name, [phase]: fn.bind(cls), type, target });
 }
 
 /**
@@ -133,6 +133,24 @@ export function OnClass(...target: string[]) {
   ): void => storeHandler(inst, d.value!, 'before', 'class', target);
 }
 
+/**
+ * Listens for a `ts.TypeAliasDeclaration` on descent
+ */
+export function OnTypeAlias(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
+  ): void => storeHandler(inst, d.value!, 'before', 'type', target);
+}
+
+/**
+ * Listens for a `ts.InterfaceDeclaration` on descent
+ */
+export function OnInterface(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
+  ): void => storeHandler(inst, d.value!, 'before', 'interface', target);
+}
+
 /**
  * Listens for a `ts.CallExpression`, on ascent
  */
@@ -212,4 +230,23 @@ 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>
   ): void => storeHandler(inst, d.value!, 'after', 'class', target);
-}
+}
+
+
+/**
+ * Listens for a `ts.TypeAliasDeclaration` on ascent
+ */
+export function AfterTypeAlias(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
+  ): void => storeHandler(inst, d.value!, 'after', 'type', target);
+}
+
+/**
+ * Listens for a `ts.InterfaceDeclaration` on ascent
+ */
+export function AfterInterface(...target: string[]) {
+  return <S extends State = State, R extends ts.Node = ts.Node>(
+    inst: Transformer, __: unknown, d: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
+  ): void => storeHandler(inst, d.value!, 'after', 'interface', target);
+}

package/src/resolver/builder.ts

@@ -1,18 +1,18 @@
 /* eslint-disable no-bitwise */
 import ts from 'typescript';
 
-import { path } from '@travetto/manifest';
+import { path, ManifestModuleUtil } from '@travetto/manifest';
 
-import { DocUtil } from '../util/doc';
-import { CoreUtil } from '../util/core';
-import { DeclarationUtil } from '../util/declaration';
-import { LiteralUtil } from '../util/literal';
-import { transformCast, TemplateLiteralPart } from '../types/shared';
+import { DocUtil } from '../util/doc.ts';
+import { CoreUtil } from '../util/core.ts';
+import { DeclarationUtil } from '../util/declaration.ts';
+import { LiteralUtil } from '../util/literal.ts';
+import { transformCast, TemplateLiteralPart } from '../types/shared.ts';
 
-import { Type, AnyType, CompositionType, TransformResolver, TemplateType } from './types';
-import { CoerceUtil } from './coerce';
+import { Type, AnyType, CompositionType, TransformResolver, TemplateType } from './types.ts';
+import { CoerceUtil } from './coerce.ts';
 
-const TYPINGS_RE = /[.]d[.][cm]?ts$/;
+const UNDEFINED = Symbol();
 
 /**
  * List of global types that can be parameterized
@@ -30,6 +30,7 @@ const GLOBAL_COMPLEX: Record<string, Function> = {
 /**
  * List of global types that are simple
  */
+const UNDEFINED_GLOBAL = { undefined: 1, void: 1, null: 1 };
 const SIMPLE_NAMES: Record<string, string> = { String: 'string', Number: 'number', Boolean: 'boolean', Object: 'object' };
 const GLOBAL_SIMPLE: Record<string, Function> = {
   RegExp, Date, Number, Boolean, String, Function, Object, Error,
@@ -37,9 +38,8 @@ const GLOBAL_SIMPLE: Record<string, Function> = {
 };
 
 type Category =
-  'void' | 'undefined' | 'concrete' | 'unknown' |
   'tuple' | 'shape' | 'literal' | 'template' | 'managed' |
-  'composition' | 'foreign';
+  'composition' | 'foreign' | 'concrete' | 'unknown';
 
 /**
  * Type categorizer, input for builder
@@ -48,21 +48,31 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
   const flags = type.getFlags();
   const objectFlags = DeclarationUtil.getObjectFlags(type) ?? 0;
 
-  if (flags & ts.TypeFlags.Void) {
-    return { category: 'void', type };
-  } else if (flags & ts.TypeFlags.Undefined) {
-    return { category: 'undefined', type };
-  } else if (DocUtil.readDocTag(type, 'concrete').length) {
+  if (flags & (ts.TypeFlags.TemplateLiteral)) {
+    return { category: 'template', type };
+  } else if (flags & (
+    ts.TypeFlags.BigIntLike |
+    ts.TypeFlags.BooleanLike |
+    ts.TypeFlags.NumberLike |
+    ts.TypeFlags.StringLike |
+    ts.TypeFlags.Null |
+    ts.TypeFlags.Undefined |
+    ts.TypeFlags.Void
+  )) {
+    return { category: 'literal', type };
+  } else if (DocUtil.hasDocTag(type, 'concrete')) {
     return { category: 'concrete', type };
   } else if (flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) { // Any or unknown
     return { category: 'unknown', type };
   } else if (objectFlags & ts.ObjectFlags.Reference && !CoreUtil.getSymbol(type)) { // Tuple type?
     return { category: 'tuple', type };
+  } else if (type.isUnionOrIntersection()) {
+    return { category: 'composition', type };
   } else if (objectFlags & ts.ObjectFlags.Anonymous) {
     try {
       const source = DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile();
       const sourceFile = source.fileName;
-      if (sourceFile && TYPINGS_RE.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
+      if (sourceFile && ManifestModuleUtil.TYPINGS_EXT_RE.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
         return { category: 'foreign', type };
       }
     } catch { }
@@ -72,7 +82,7 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
     if (CoreUtil.hasTarget(resolvedType)) {
       resolvedType = resolvedType.target;
       // If resolved target has a concrete type
-      if (DocUtil.readDocTag(resolvedType, 'concrete').length) {
+      if (DocUtil.hasDocTag(resolvedType, 'concrete')) {
         return { category: 'concrete', type: resolvedType };
       }
     }
@@ -81,31 +91,21 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
     const sourceFile = source.fileName;
     if (sourceFile?.includes('typescript/lib')) {
       return { category: 'literal', type };
-    } else if (sourceFile && TYPINGS_RE.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
+    } else if (sourceFile && ManifestModuleUtil.TYPINGS_EXT_RE.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
       return { category: 'foreign', type: resolvedType };
     } else if (!resolvedType.isClass()) { // Not a real type
       return { category: 'shape', type: resolvedType };
     } else {
       return { category: 'managed', type: resolvedType };
     }
-  } else if (flags & (ts.TypeFlags.TemplateLiteral)) {
-    return { category: 'template', type };
-  } else if (flags & (
-    ts.TypeFlags.BigIntLike |
-    ts.TypeFlags.BooleanLike |
-    ts.TypeFlags.NumberLike |
-    ts.TypeFlags.StringLike |
-    ts.TypeFlags.Void | ts.TypeFlags.Undefined
-  )) {
-    return { category: 'literal', type };
-  } else if (type.isUnionOrIntersection()) {
-    return { category: 'composition', type };
   } else if (objectFlags & ts.ObjectFlags.Tuple) {
     return { category: 'tuple', type };
   } else if (type.isLiteral()) {
     return { category: 'shape', type };
   } else if ((objectFlags & ts.ObjectFlags.Mapped)) { // Mapped types: Pick, Omit, Exclude, Retain
-    return { category: 'shape', type };
+    if (type.getProperties().some(x => x.declarations || x.valueDeclaration)) {
+      return { category: 'shape', type };
+    }
   }
   return { category: 'literal', type };
 }
@@ -120,13 +120,10 @@ export const TypeBuilder: {
   }
 } = {
   unknown: {
-    build: (resolver, type) => ({ key: 'unknown' })
-  },
-  undefined: {
-    build: (resolver, type) => ({ key: 'literal', name: 'undefined', ctor: undefined })
-  },
-  void: {
-    build: (resolver, type) => ({ key: 'literal', name: 'void', ctor: undefined })
+    build: (resolver, type) => {
+      const optional = UNDEFINED in type;
+      return { key: 'unknown', nullable: optional, undefinable: optional };
+    }
   },
   tuple: {
     build: (resolver, type) => ({ key: 'tuple', tsTupleTypes: resolver.getAllTypeArguments(type), subTypes: [] })
@@ -166,16 +163,18 @@ export const TypeBuilder: {
       const name = resolver.getTypeAsString(type) ?? '';
       const complexName = CoreUtil.getSymbol(type)?.getName() ?? '';
 
-      if (name in GLOBAL_SIMPLE) {
+      if (name in UNDEFINED_GLOBAL) {
+        return { key: 'literal', ctor: undefined, name };
+      } else if (name in GLOBAL_SIMPLE) {
         const cons = GLOBAL_SIMPLE[name];
-        const ret = LiteralUtil.isLiteralType(type) ? CoerceUtil.coerce(type.value, transformCast(cons), false) :
+        const literal = LiteralUtil.isLiteralType(type) ? CoerceUtil.coerce(type.value, transformCast(cons), false) :
           undefined;
 
         return {
           key: 'literal',
           ctor: cons,
           name: SIMPLE_NAMES[cons.name] ?? cons.name,
-          value: ret
+          value: literal
         };
       } else if (complexName in GLOBAL_COMPLEX) {
         const cons = GLOBAL_COMPLEX[complexName];
@@ -225,6 +224,11 @@ export const TypeBuilder: {
     },
     finalize: (type: CompositionType) => {
       const { undefinable, nullable, subTypes } = type;
+
+      if (subTypes.length === 0) { // We have an unknown type?
+        return { key: 'unknown', nullable, undefinable };
+      }
+
       const [first] = subTypes;
 
       if (first.key === 'template') {
@@ -253,7 +257,7 @@ export const TypeBuilder: {
       const tsTypeArguments = resolver.getAllTypeArguments(type);
       const props = resolver.getPropertiesOfType(type);
       if (props.length === 0) {
-        return { key: 'literal', name: 'Object', ctor: Object };
+        return { key: 'literal', name: 'Object', ctor: Object, importName };
       }
 
       for (const member of props) {
@@ -264,6 +268,9 @@ export const TypeBuilder: {
             !member.getName().includes('@') && // if not a symbol
             !memberType.getCallSignatures().length // if not a function
           ) {
+            if ((ts.isPropertySignature(dec) || ts.isPropertyDeclaration(dec)) && !!dec.questionToken) {
+              Object.defineProperty(memberType, UNDEFINED, { value: true });
+            }
             tsFieldTypes[member.getName()] = memberType;
           }
         }
@@ -273,26 +280,34 @@ export const TypeBuilder: {
   },
   concrete: {
     build: (resolver, type) => {
+      if (!DocUtil.hasDocTag(type, 'concrete')) {
+        return;
+      }
+
       const [tag] = DocUtil.readDocTag(type, 'concrete');
-      if (tag) {
-        // eslint-disable-next-line prefer-const
-        let [importName, name] = tag.split('#');
+      let [importName, name] = tag?.split('#') ?? [];
 
-        // Resolving relative to source file
-        if (!importName || importName.startsWith('.')) {
-          const rawSourceFile: string = DeclarationUtil.getDeclarations(type)
-            ?.find(x => ts.getAllJSDocTags(x, (t): t is ts.JSDocTag => t.tagName.getText() === 'concrete').length)
-            ?.getSourceFile().fileName ?? '';
+      // Resolving relative to source file
+      if (!importName || importName.startsWith('.')) {
+        const rawSourceFile: string = DeclarationUtil.getDeclarations(type)
+          ?.find(x => ts.getAllJSDocTags(x, (t): t is ts.JSDocTag => t.tagName.getText() === 'concrete').length)
+          ?.getSourceFile().fileName ?? '';
 
-          if (!importName || importName === '.') {
-            importName = resolver.getFileImportName(rawSourceFile);
-          } else {
-            const base = path.dirname(rawSourceFile);
-            importName = resolver.getFileImportName(path.resolve(base, importName));
-          }
+        if (!importName || importName === '.') {
+          importName = resolver.getFileImportName(rawSourceFile);
+        } else {
+          const base = path.dirname(rawSourceFile);
+          importName = resolver.getFileImportName(path.resolve(base, importName));
         }
-        return { key: 'managed', name, importName };
       }
+
+      // Convert name to $Concrete suffix if not provided
+      if (!name) {
+        const [decl] = DeclarationUtil.getDeclarations(type).filter(x => ts.isInterfaceDeclaration(x) || ts.isTypeAliasDeclaration(x));
+        name = `${decl.name.text}$Concrete`;
+      }
+
+      return { key: 'managed', name, importName };
     }
   }
 };

package/src/resolver/cache.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import type { AnyType } from './types';
+import type { AnyType } from './types.ts';
 
 /**
  * Cache for handling recursive checks

package/src/resolver/coerce.ts

@@ -50,19 +50,19 @@ export class CoerceUtil {
 
     switch (type) {
       case Date: {
-        const res = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
+        const value = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
           new Date(parseInt(`${input}`, 10)) : new Date(`${input}`);
-        if (strict && Number.isNaN(res.getTime())) {
+        if (strict && Number.isNaN(value.getTime())) {
           throw new Error(`Invalid date value: ${input}`);
         }
-        return res;
+        return value;
       }
       case Number: {
-        const res = `${input}`.includes('.') ? parseFloat(`${input}`) : parseInt(`${input}`, 10);
-        if (strict && Number.isNaN(res)) {
+        const value = `${input}`.includes('.') ? parseFloat(`${input}`) : parseInt(`${input}`, 10);
+        if (strict && Number.isNaN(value)) {
           throw new Error(`Invalid numeric value: ${input}`);
         }
-        return res;
+        return value;
       }
       case BigInt: {
         try {

package/src/resolver/service.ts

@@ -2,12 +2,12 @@ import ts from 'typescript';
 
 import { path, ManifestIndex, ManifestModuleUtil, IndexedFile } from '@travetto/manifest';
 
-import type { AnyType, TransformResolver } from './types';
-import { TypeCategorize, TypeBuilder } from './builder';
-import { VisitCache } from './cache';
-import { DocUtil } from '../util/doc';
-import { DeclarationUtil } from '../util/declaration';
-import { transformCast } from '../types/shared';
+import type { AnyType, TransformResolver } from './types.ts';
+import { TypeCategorize, TypeBuilder } from './builder.ts';
+import { VisitCache } from './cache.ts';
+import { DocUtil } from '../util/doc.ts';
+import { DeclarationUtil } from '../util/declaration.ts';
+import { transformCast } from '../types/shared.ts';
 
 /**
  * Implementation of TransformResolver
@@ -38,10 +38,12 @@ export class SimpleResolver implements TransformResolver {
     const type = ManifestModuleUtil.getFileType(file);
 
     if (type !== 'js' && type !== 'ts') {
-      sourceFile = `${sourceFile}.ts`;
+      sourceFile = `${sourceFile}${ManifestModuleUtil.SOURCE_DEF_EXT}`;
     }
 
-    return this.#manifestIndex.getEntry(ManifestModuleUtil.getFileType(sourceFile) === 'ts' ? sourceFile : `${sourceFile}.js`) ??
+    const sourceType = ManifestModuleUtil.getFileType(sourceFile);
+
+    return this.#manifestIndex.getEntry((sourceType === 'ts' || sourceType === 'js') ? sourceFile : undefined!) ??
       this.#manifestIndex.getFromImport(ManifestModuleUtil.withoutSourceExtension(sourceFile).replace(/^.*node_modules\//, ''));
   }
 
@@ -132,7 +134,7 @@ export class SimpleResolver implements TransformResolver {
         result.comment = DocUtil.describeDocs(type).description;
 
         if ('tsTypeArguments' in result) {
-          result.typeArguments = result.tsTypeArguments!.map((elType, i) => resolve(elType, type.aliasSymbol, depth + 1));
+          result.typeArguments = result.tsTypeArguments!.map((elType) => resolve(elType, type.aliasSymbol, depth + 1));
           delete result.tsTypeArguments;
         }
         if ('tsFieldTypes' in result) {
@@ -144,7 +146,7 @@ export class SimpleResolver implements TransformResolver {
           delete result.tsFieldTypes;
         }
         if ('tsSubTypes' in result) {
-          result.subTypes = result.tsSubTypes!.map((elType, i) => resolve(elType, type.aliasSymbol, depth + 1));
+          result.subTypes = result.tsSubTypes!.map((elType) => resolve(elType, type.aliasSymbol, depth + 1));
           delete result.tsSubTypes;
         }
         if (finalize) {

package/src/resolver/types.ts

@@ -1,5 +1,5 @@
 import type ts from 'typescript';
-import { TemplateLiteral } from '../types/shared';
+import { TemplateLiteral } from '../types/shared.ts';
 
 /**
  * Base type for a simplistic type structure

package/src/state.ts

@@ -2,18 +2,18 @@ import ts from 'typescript';
 
 import { path, ManifestIndex } from '@travetto/manifest';
 
-import { ManagedType, AnyType } from './resolver/types';
-import { State, DecoratorMeta, Transformer, ModuleNameSymbol } from './types/visitor';
-import { SimpleResolver } from './resolver/service';
-import { ImportManager } from './importer';
-import { Import } from './types/shared';
-
-import { DocUtil } from './util/doc';
-import { DecoratorUtil } from './util/decorator';
-import { DeclarationUtil } from './util/declaration';
-import { CoreUtil } from './util/core';
-import { LiteralUtil } from './util/literal';
-import { SystemUtil } from './util/system';
+import { ManagedType, AnyType, ForeignType } from './resolver/types.ts';
+import { State, DecoratorMeta, Transformer, ModuleNameSymbol } from './types/visitor.ts';
+import { SimpleResolver } from './resolver/service.ts';
+import { ImportManager } from './importer.ts';
+import { Import } from './types/shared.ts';
+
+import { DocUtil } from './util/doc.ts';
+import { DecoratorUtil } from './util/decorator.ts';
+import { DeclarationUtil } from './util/declaration.ts';
+import { CoreUtil } from './util/core.ts';
+import { LiteralUtil } from './util/literal.ts';
+import { SystemUtil } from './util/system.ts';
 
 function hasOriginal(n: ts.Node): n is ts.Node & { original: ts.Node } {
   return !!n && !n.parent && 'original' in n && !!n.original;
@@ -49,17 +49,16 @@ export class TransformerState implements State {
     this.#resolver = new SimpleResolver(checker, manifestIndex);
     this.#imports = new ImportManager(source, factory, this.#resolver);
     this.file = path.toPosix(source.fileName);
-    this.importName = this.#resolver.getFileImportName(this.file, true);
+    this.importName = this.#resolver.getFileImportName(this.file);
     this.source = source;
     this.factory = factory;
   }
 
   /**
-   * Is a file or an import file path known by the framework, but missing an extensions
-   * @param fileOrImport
+   * Rewrite module specifier normalizing output
    */
-  isUntypedImport(fileOrImport: ts.StringLiteral | string | undefined): boolean {
-    return this.#imports.isUntypedImport(fileOrImport);
+  normalizeModuleSpecifier<T extends ts.Expression | undefined>(spec: T): T {
+    return this.#imports.normalizeModuleSpecifier(spec);
   }
 
   /**
@@ -223,9 +222,8 @@ export class TransformerState implements State {
   /**
    * Finalize the source file for emission
    */
-  finalize(ret: ts.SourceFile): ts.SourceFile {
-    ret = this.#imports.finalize(ret);
-    return ret;
+  finalize(source: ts.SourceFile): ts.SourceFile {
+    return this.#imports.finalize(source);
   }
 
   /**
@@ -295,6 +293,7 @@ export class TransformerState implements State {
    * @param module
    */
   findDecorator(mod: string | Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
+    module = module?.replace(/[.]ts$/, ''); // Replace extension if exists
     mod = typeof mod === 'string' ? mod : mod[ModuleNameSymbol]!;
     const target = `${mod}:${name}`;
     const list = this.getDecoratorList(node);
@@ -388,4 +387,39 @@ export class TransformerState implements State {
   getFileImportName(file: string): string {
     return this.#resolver.getFileImportName(file);
   }
+
+  /**
+   * Produce a foreign target type
+   */
+  getForeignTarget(ret: ForeignType): ts.Expression {
+    return this.fromLiteral({
+      Ⲑid: `${ret.source.split('node_modules/')[1]}+${ret.name}`
+    });
+  }
+
+  /**
+   * Return a concrete type the given type of a node
+   */
+  getConcreteType(node: ts.Node): ts.Expression {
+    const type = this.resolveType(node);
+
+    if (type.key === 'managed') {
+      return this.getOrImport(type);
+    } else if (type.key === 'foreign') {
+      return this.getForeignTarget(type);
+    } else {
+      const file = node.getSourceFile().fileName;
+      const src = this.getFileImportName(file);
+      throw new Error(`Unable to import non-external type: ${node.getText()} ${type.key}: ${src}`);
+    }
+  }
+
+  /**
+   * Get apparent type of requested field
+   */
+  getApparentTypeOfField(value: ts.Type, field: string): AnyType | undefined {
+    const checker = this.#resolver.getChecker();
+    const props = checker.getApparentType(value).getApparentProperties().find(x => x.escapedName === field);
+    return props ? this.resolveType(checker.getTypeOfSymbol(props)) : undefined;
+  }
 }

package/src/types/visitor.ts

@@ -24,7 +24,7 @@ export type TransformPhase = 'before' | 'after';
 
 export type TransformerType =
   'class' | 'method' | 'property' | 'getter' | 'setter' | 'parameter' |
-  'static-method' | 'call' | 'function' | 'file';
+  'static-method' | 'call' | 'function' | 'file' | 'type' | 'interface';
 
 export const ModuleNameSymbol = Symbol.for('@travetto/transformer:id');
 

package/src/util/declaration.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { CoreUtil } from './core';
+import { CoreUtil } from './core.ts';
 
 /**
  * Declaration utils

package/src/util/decorator.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { CoreUtil } from './core';
+import { CoreUtil } from './core.ts';
 
 /**
  * Utilities for dealing with decorators

package/src/util/doc.ts

@@ -1,8 +1,8 @@
 import ts from 'typescript';
 
-import { transformCast, DeclDocumentation } from '../types/shared';
-import { CoreUtil } from './core';
-import { DeclarationUtil } from './declaration';
+import { transformCast, DeclDocumentation } from '../types/shared.ts';
+import { CoreUtil } from './core.ts';
+import { DeclarationUtil } from './declaration.ts';
 
 /**
  * Utilities for dealing with docs
@@ -76,6 +76,15 @@ export class DocUtil {
       .map(el => el.text!.map(x => x.text).join('')); // Join all text
   }
 
+  /**
+   * Has JS Doc tags for a type
+   */
+  static hasDocTag(type: ts.Type | ts.Symbol, name: string): boolean {
+    const tags = CoreUtil.getSymbol(type)?.getJsDocTags() ?? [];
+    return tags.some(el => el.name === name);
+  }
+
+
   /**
    * Read augments information
    * @param type

package/src/util/import.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 
 import { path, ManifestModuleUtil, PackageUtil } from '@travetto/manifest';
 
-import { Import } from '../types/shared';
+import { Import } from '../types/shared.ts';
 
 /**
  * Import utilities

package/src/util/literal.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { transformCast, TemplateLiteral } from '../types/shared';
+import { transformCast, TemplateLiteral } from '../types/shared.ts';
 
 const TypedObject: {
   keys<T = unknown, K extends keyof T = keyof T>(o: T): K[];
@@ -39,7 +39,9 @@ export class LiteralUtil {
   static fromLiteral(factory: ts.NodeFactory, val: null): ts.NullLiteral;
   static fromLiteral(factory: ts.NodeFactory, val: object): ts.ObjectLiteralExpression;
   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: string): ts.StringLiteral;
+  static fromLiteral(factory: ts.NodeFactory, val: number): ts.NumericLiteral;
+  static fromLiteral(factory: ts.NodeFactory, val: boolean): ts.BooleanLiteral;
   static fromLiteral(factory: ts.NodeFactory, val: unknown): ts.Node {
     if (isNode(val)) { // If already a node
       return val;
@@ -137,14 +139,14 @@ export class LiteralUtil {
    * Extend object literal, whether JSON or ts.ObjectLiteralExpression
    */
   static extendObjectLiteral(factory: ts.NodeFactory, src: object | ts.Expression, ...rest: (object | ts.Expression)[]): ts.ObjectLiteralExpression {
-    let ret = this.fromLiteral(factory, src);
+    let literal = this.fromLiteral(factory, src);
     if (rest.find(x => !!x)) {
-      ret = factory.createObjectLiteralExpression([
-        factory.createSpreadAssignment(ret),
+      literal = factory.createObjectLiteralExpression([
+        factory.createSpreadAssignment(literal),
         ...(rest.filter(x => !!x).map(r => factory.createSpreadAssignment(this.fromLiteral(factory, r))))
       ]);
     }
-    return ret;
+    return literal;
   }
 
   /**

package/src/visitor.ts

@@ -2,8 +2,8 @@ import ts from 'typescript';
 
 import { ManifestModuleFolderType, ManifestModuleUtil } from '@travetto/manifest';
 
-import { DecoratorMeta, TransformerType, NodeTransformer, TransformerSet, State, TransformPhase } from './types/visitor';
-import { CoreUtil } from './util/core';
+import { DecoratorMeta, TransformerType, NodeTransformer, TransformerSet, State, TransformPhase } from './types/visitor.ts';
+import { CoreUtil } from './util/core.ts';
 
 const COMPILER_SRC = new Set<ManifestModuleFolderType>(['support', 'src', '$index']);
 
@@ -35,6 +35,10 @@ export class VisitorFactory<S extends State = State> {
       return 'setter';
     } else if (ts.isSourceFile(node)) {
       return 'file';
+    } else if (ts.isInterfaceDeclaration(node)) {
+      return 'interface';
+    } else if (ts.isTypeAliasDeclaration(node)) {
+      return 'type';
     }
   }
 
@@ -58,7 +62,7 @@ export class VisitorFactory<S extends State = State> {
         this.#transformers.set(trn.type, {});
       }
       const set = this.#transformers.get(trn.type)!;
-      const targets = trn.target && trn.target.length ? trn.target : ['ALL'];
+      const targets = trn.target && trn.target.length ? trn.target : ['__all__'];
 
       for (const target of targets) {
         for (const phase of ['before', 'after'] as const) {
@@ -96,13 +100,13 @@ export class VisitorFactory<S extends State = State> {
           return state.finalize(file);
         }
 
-        let ret = this.visit(state, context, file);
+        let node = this.visit(state, context, file);
 
         // Process added content
         const changed = state.added.size;
-        let statements: ts.NodeArray<ts.Statement> | ts.Statement[] = ret.statements;
+        let statements: ts.NodeArray<ts.Statement> | ts.Statement[] = node.statements;
         while (state.added.size) {
-          for (const [idx, all] of [...state.added].sort(([idxA], [idxB]) => idxB - idxA)) {
+          for (const [idx, all] of [...state.added].toSorted(([idxA], [idxB]) => idxB - idxA)) {
             statements = [
               ...statements.slice(0, Math.max(idx, 0)),
               ...all.map(v => this.visit(state, context, v)),
@@ -113,9 +117,9 @@ export class VisitorFactory<S extends State = State> {
         }
 
         if (changed) {
-          ret = CoreUtil.updateSource(context.factory, ret, statements);
+          node = CoreUtil.updateSource(context.factory, node, statements);
         }
-        return state.finalize(ret);
+        return state.finalize(node);
       } catch (err) {
         if (!(err instanceof Error)) {
           throw err;
@@ -136,7 +140,7 @@ export class VisitorFactory<S extends State = State> {
       return;
     }
 
-    for (const all of set[phase]!.get('ALL') ?? []) {
+    for (const all of set[phase]!.get('__all__') ?? []) {
       node = all[phase]!<T>(state, node) ?? node;
     }
     return node;