@travetto/transformer 7.0.0-rc.0 → 7.0.0-rc.2

package/src/resolver/builder.ts

@@ -16,6 +16,14 @@ const UNDEFINED = Symbol();
 
 const MAPPED_TYPE_SET = new Set(['Omit', 'Pick', 'Required', 'Partial']);
 const isMappedType = (type: string | undefined): type is MappedType['operation'] => MAPPED_TYPE_SET.has(type!);
+const getMappedFields = (type: ts.Type): string[] | undefined => {
+  if (type.isStringLiteral()) {
+    return [type.value];
+  } else if (type.isUnion() && type.types.every(subType => subType.isStringLiteral())) {
+    return type.types.map(subType => subType.value);
+  }
+};
+
 /**
  * List of global types that can be parameterized
  */
@@ -74,7 +82,7 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
     try {
       const source = DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile();
       const sourceFile = source.fileName;
-      if (sourceFile && ManifestModuleUtil.TYPINGS_EXT_RE.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
+      if (sourceFile && ManifestModuleUtil.TYPINGS_EXT_REGEX.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
         return { category: 'foreign', type };
       }
     } catch { }
@@ -93,7 +101,7 @@ 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 && ManifestModuleUtil.TYPINGS_EXT_RE.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
+    } else if (sourceFile && ManifestModuleUtil.TYPINGS_EXT_REGEX.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
       return { category: 'foreign', type: resolvedType };
     } else if (!resolvedType.isClass()) { // Not a real type
       return { category: 'shape', type: resolvedType };
@@ -105,7 +113,7 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
   } else if (type.isLiteral()) {
     return { category: 'shape', type };
   } else if (objectFlags & ts.ObjectFlags.Mapped) { // Mapped types
-    if (type.getProperties().some(x => x.declarations || x.valueDeclaration)) {
+    if (type.getProperties().some(property => property.declarations || property.valueDeclaration)) {
       return { category: 'mapped', type };
     }
   }
@@ -117,7 +125,7 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
  */
 export const TypeBuilder: {
   [K in Category]: {
-    build(resolver: TransformResolver, type: ts.Type, alias?: ts.Symbol): AnyType | undefined;
+    build(resolver: TransformResolver, type: ts.Type, context: { alias?: ts.Symbol, node?: ts.Node }): AnyType | undefined;
     finalize?(type: Type<K>): AnyType;
   }
 } = {
@@ -152,7 +160,7 @@ export const TypeBuilder: {
             }
           }
           if (values.length > 0) {
-            return ({ key: 'template', template: { op: 'and', values }, ctor: String });
+            return ({ key: 'template', template: { operation: 'and', values }, ctor: String });
           }
         }
       }
@@ -215,11 +223,11 @@ export const TypeBuilder: {
       let undefinable = false;
       let nullable = false;
       const remainder = uType.types.filter(ut => {
-        const u = (ut.getFlags() & (ts.TypeFlags.Undefined)) > 0;
-        const n = (ut.getFlags() & (ts.TypeFlags.Null)) > 0;
-        undefinable ||= u;
-        nullable ||= n;
-        return !(u || n);
+        const isUndefined = (ut.getFlags() & (ts.TypeFlags.Undefined)) > 0;
+        const isNull = (ut.getFlags() & (ts.TypeFlags.Null)) > 0;
+        undefinable ||= isUndefined;
+        nullable ||= isNull;
+        return !(isUndefined || isNull);
       });
       const name = CoreUtil.getSymbol(uType)?.getName();
       return { key: 'composition', name, undefinable, nullable, tsSubTypes: remainder, subTypes: [], operation: uType.isUnion() ? 'or' : 'and' };
@@ -239,77 +247,76 @@ export const TypeBuilder: {
           ctor: String,
           nullable: type.nullable,
           undefinable: type.undefinable,
-          template: { op: 'or', values: subTypes.map(x => transformCast<TemplateType>(x).template!) }
+          template: { operation: 'or', values: subTypes.map(subType => transformCast<TemplateType>(subType).template!) }
         };
       } else if (subTypes.length === 1) {
         return { undefinable, nullable, ...first };
-      } else if (first.key === 'literal' && subTypes.every(el => el.name === first.name)) { // We have a common
+      } else if (first.key === 'literal' && subTypes.every(item => item.name === first.name)) { // We have a common
         type.commonType = first;
-      } else if (type.operation === 'and' && first.key === 'shape' && subTypes.every(el => el.key === 'shape')) { // All shapes
-        return { importName: first.importName, name: first.name, key: 'shape', fieldTypes: subTypes.reduce((acc, x) => ({ ...acc, ...x.fieldTypes }), {}) };
+      } else if (type.operation === 'and' && first.key === 'shape' && subTypes.every(item => item.key === 'shape')) { // All shapes
+        return {
+          importName: first.importName,
+          name: first.name,
+          key: 'shape',
+          fieldTypes: subTypes.reduce((map, subType) => ({ ...map, ...subType.fieldTypes }), {})
+        };
       }
       return type;
     }
   },
   mapped: {
-    build: (resolver, type, alias) => {
+    build: (resolver, type, context) => {
       let mainType: ts.Type | undefined;
       let fields: string[] | undefined;
       let operation: string | undefined;
+      let name: string | undefined;
 
-      const decls = DeclarationUtil.getDeclarations(type).filter(x => ts.isTypeAliasDeclaration(x));
-      if (decls.length > 0) {
-        const ref = decls[0].type;
-        if (ts.isTypeReferenceNode(ref) && ref.typeArguments && ref.typeArguments.length > 0) {
-          const [first, second] = ref.typeArguments;
-          mainType = resolver.getType(first);
-          operation = ref.typeName.getText();
-          if (second) {
-            const resolved = resolver.getType(second);
-            if (resolved.isStringLiteral()) {
-              fields = [resolved.value];
-            } else if (resolved.isUnion() && resolved.types.every(t => t.isStringLiteral())) {
-              fields = resolved.types.map(t => t.value);
-            }
-          }
-        }
-      } else {
-        mainType = type.aliasTypeArguments?.[0]!;
-        operation = type.aliasSymbol?.escapedName.toString();
-        fields = type.getApparentProperties().map(p => p.getName());
+      const declarations = DeclarationUtil.getDeclarations(type).filter(declaration => ts.isTypeAliasDeclaration(declaration));
+      const ref = declarations[0]?.type;
+
+      if (ref && ts.isTypeReferenceNode(ref) && ref.typeArguments && ref.typeArguments.length > 0) {
+        const [first, second] = ref.typeArguments;
+        mainType = resolver.getType(first);
+        operation = ref.typeName.getText();
+        name = resolver.getTypeAsString(type)!;
+        fields = !second ? [] : getMappedFields(resolver.getType(second));
+      } else if (type.aliasTypeArguments && type.aliasSymbol) {
+        mainType = type.aliasTypeArguments[0];
+        operation = type.aliasSymbol.escapedName.toString();
+        fields = (type.aliasTypeArguments.length > 1) ? getMappedFields(type.aliasTypeArguments[1]) : [];
+        name = `${resolver.getTypeAsString(mainType)!}_${operation}_${fields?.join('_')}`;
       }
 
       if (!isMappedType(operation) || fields === undefined || !mainType || !mainType.isClass()) {
-        return TypeBuilder.shape.build(resolver, type, alias);
+        return TypeBuilder.shape.build(resolver, type, context);
       }
 
       const importName = resolver.getTypeImportName(mainType) ?? '<unknown>';
       const mappedClassName = resolver.getTypeAsString(mainType)!;
-      const name = resolver.getTypeAsString(type)!;
 
       return { key: 'mapped', name, original: mainType, operation, importName, mappedClassName, fields };
     }
   },
   shape: {
-    build: (resolver, type, alias?) => {
+    build: (resolver, type, context) => {
       const tsFieldTypes: Record<string, ts.Type> = {};
-      const name = CoreUtil.getSymbol(alias ?? type)?.getName();
+      const name = CoreUtil.getSymbol(context?.alias ?? type)?.getName();
       const importName = resolver.getTypeImportName(type) ?? '<unknown>';
       const tsTypeArguments = resolver.getAllTypeArguments(type);
-      const props = resolver.getPropertiesOfType(type);
-      if (props.length === 0) {
+      const properties = resolver.getPropertiesOfType(type);
+      if (properties.length === 0) {
         return { key: 'literal', name: 'Object', ctor: Object, importName };
       }
 
-      for (const member of props) {
-        const dec = DeclarationUtil.getPrimaryDeclarationNode(member);
-        if (DeclarationUtil.isPublic(dec)) { // If public
-          const memberType = resolver.getType(dec);
+      for (const member of properties) {
+        const decorator = DeclarationUtil.getPrimaryDeclarationNode(member);
+        if (DeclarationUtil.isPublic(decorator)) { // If public
+          const memberType = resolver.getType(decorator);
           if (
             !member.getName().includes('@') && // if not a symbol
             !memberType.getCallSignatures().length // if not a function
           ) {
-            if ((ts.isPropertySignature(dec) || ts.isPropertyDeclaration(dec)) && !!dec.questionToken) {
+            if ((ts.isPropertySignature(decorator) || ts.isPropertyDeclaration(decorator)) && !!decorator.questionToken) {
               Object.defineProperty(memberType, UNDEFINED, { value: true });
             }
             tsFieldTypes[member.getName()] = memberType;
@@ -331,7 +338,7 @@ export const TypeBuilder: {
       // 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)
+          ?.find(declaration => ts.getAllJSDocTags(declaration, (node): node is ts.JSDocTag => node.tagName.getText() === 'concrete').length)
           ?.getSourceFile().fileName ?? '';
 
         if (!importName || importName === '.') {
@@ -344,8 +351,9 @@ export const TypeBuilder: {
 
       // 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`;
+        const [primaryDeclaration] = DeclarationUtil.getDeclarations(type)
+          .filter(declaration => ts.isInterfaceDeclaration(declaration) || ts.isTypeAliasDeclaration(declaration));
+        name = `${primaryDeclaration.name.text}$Concrete`;
       }
 
       return { key: 'managed', name, importName };

package/src/resolver/coerce.ts

@@ -4,12 +4,12 @@ export class CoerceUtil {
   /**
    * Is a value a plain JS object, created using {}
    */
-  static #isPlainObject(obj: unknown): obj is Record<string, unknown> {
-    return typeof obj === 'object' // separate from primitives
-      && obj !== undefined
-      && obj !== null         // is obvious
-      && obj.constructor === Object // separate instances (Array, DOM, ...)
-      && Object.prototype.toString.call(obj) === '[object Object]'; // separate build-in like Math
+  static #isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' // separate from primitives
+      && value !== undefined
+      && value !== null         // is obvious
+      && value.constructor === Object // separate instances (Array, DOM, ...)
+      && Object.prototype.toString.call(value) === '[object Object]'; // separate build-in like Math
   }
 
   /**

package/src/resolver/service.ts

@@ -73,10 +73,10 @@ export class SimpleResolver implements TransformResolver {
 
   /**
    * Get type from element
-   * @param el
+   * @param value
    */
-  getType(el: ts.Type | ts.Node): ts.Type {
-    return 'getSourceFile' in el ? this.#tsChecker.getTypeAtLocation(el) : el;
+  getType(value: ts.Type | ts.Node): ts.Type {
+    return 'getSourceFile' in value ? this.#tsChecker.getTypeAtLocation(value) : value;
   }
 
   /**
@@ -106,7 +106,8 @@ export class SimpleResolver implements TransformResolver {
    * Get list of properties
    */
   getPropertiesOfType(type: ts.Type): ts.Symbol[] {
-    return this.#tsChecker.getPropertiesOfType(type).filter(x => x.getName() !== '__proto__' && x.getName() !== 'prototype');
+    return this.#tsChecker.getPropertiesOfType(type)
+      .filter(property => property.getName() !== '__proto__' && property.getName() !== 'prototype');
   }
 
   /**
@@ -123,7 +124,7 @@ export class SimpleResolver implements TransformResolver {
       const { category, type } = TypeCategorize(this, resType);
       const { build, finalize } = TypeBuilder[category];
 
-      let result = build(this, type, alias);
+      let result = build(this, type, { alias, node: node && 'kind' in node ? node : undefined });
 
       // Convert via cache if needed
       result = visited.getOrSet(type, result);
@@ -161,11 +162,11 @@ export class SimpleResolver implements TransformResolver {
 
     try {
       return resolve(this.getType(node));
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw err;
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
       }
-      console.error(`Unable to resolve type in ${importName}`, err.stack);
+      console.error(`Unable to resolve type in ${importName}`, error.stack);
       return { key: 'literal', ctor: Object, name: 'object' };
     }
   }

package/src/state.ts

@@ -15,25 +15,27 @@ 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;
+function hasOriginal(node: ts.Node): node is ts.Node & { original: ts.Node } {
+  return !!node && !node.parent && 'original' in node && !!node.original;
 }
 
-function hasEscapedName(n: ts.Node): n is ts.Node & { name: { escapedText: string } } {
-  return !!n && 'name' in n && typeof n.name === 'object' && !!n.name && 'escapedText' in n.name && !!n.name.escapedText;
+function hasEscapedName(node: ts.Node): node is ts.Node & { name: { escapedText: string } } {
+  return !!node && 'name' in node && typeof node.name === 'object' && !!node.name && 'escapedText' in node.name && !!node.name.escapedText;
 }
 
-function isRedefinableDeclaration(x: ts.Node): x is ts.InterfaceDeclaration | ts.ClassDeclaration | ts.FunctionDeclaration {
-  return ts.isFunctionDeclaration(x) || ts.isClassDeclaration(x) || ts.isInterfaceDeclaration(x);
+function isRedefinableDeclaration(node: ts.Node): node is ts.InterfaceDeclaration | ts.ClassDeclaration | ts.FunctionDeclaration {
+  return ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node);
 }
 
+const FOREIGN_TYPE_REGISTRY_FILE = '@travetto/runtime/src/function';
+
 /**
  * Transformer runtime state
  */
 export class TransformerState implements State {
   #resolver: SimpleResolver;
   #imports: ImportManager;
-  #modIdent: ts.Identifier;
+  #moduleIdentifier: ts.Identifier;
   #manifestIndex: ManifestIndex;
   #syntheticIdentifiers = new Map<string, ts.Identifier>();
   #decorators = new Map<string, ts.PropertyAccessExpression>();
@@ -91,8 +93,8 @@ export class TransformerState implements State {
     const resolved = this.resolveType(node);
     if (resolved.key !== 'managed') {
       const file = node.getSourceFile().fileName;
-      const src = this.#resolver.getFileImportName(file);
-      throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${src}`);
+      const source = this.#resolver.getFileImportName(file);
+      throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${source}`);
     }
     return resolved;
   }
@@ -134,9 +136,9 @@ export class TransformerState implements State {
    */
   readDocTagList(node: ts.Declaration, name: string): string[] {
     return this.readDocTag(node, name)
-      .flatMap(x => x.split(/\s*,\s*/g))
-      .map(x => x.replace(/`/g, ''))
-      .filter(x => !!x);
+      .flatMap(tag => tag.split(/\s*,\s*/g))
+      .map(tag => tag.replace(/`/g, ''))
+      .filter(tag => !!tag);
   }
 
   /**
@@ -145,8 +147,8 @@ export class TransformerState implements State {
   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);
-      this.#decorators.set(name, this.factory.createPropertyAccessExpression(ref.ident, ident));
+      const identifier = this.factory.createIdentifier(name);
+      this.#decorators.set(name, this.factory.createPropertyAccessExpression(ref.identifier, identifier));
     }
     return this.#decorators.get(name);
   }
@@ -162,22 +164,22 @@ export class TransformerState implements State {
   /**
    * Read a decorator's metadata
    */
-  getDecoratorMeta(dec: ts.Decorator): DecoratorMeta | undefined {
-    const ident = DecoratorUtil.getDecoratorIdent(dec);
-    const type = this.#resolver.getType(ident);
-    const decl = DeclarationUtil.getOptionalPrimaryDeclarationNode(type);
-    const src = decl?.getSourceFile().fileName;
-    const mod = src ? this.#resolver.getFileImportName(src, true) : undefined;
+  getDecoratorMeta(decorator: ts.Decorator): DecoratorMeta | undefined {
+    const identifier = DecoratorUtil.getDecoratorIdentifier(decorator);
+    const type = this.#resolver.getType(identifier);
+    const declaration = DeclarationUtil.getOptionalPrimaryDeclarationNode(type);
+    const source = declaration?.getSourceFile().fileName;
+    const mod = source ? this.#resolver.getFileImportName(source, true) : undefined;
     const file = this.#manifestIndex.getFromImport(mod ?? '')?.outputFile;
     const targets = DocUtil.readAugments(type);
     const example = DocUtil.readExample(type);
     const module = file ? mod : undefined;
-    const name = ident ?
-      ident.escapedText?.toString()! :
+    const name = identifier ?
+      identifier.escapedText?.toString()! :
       undefined;
 
-    if (ident && name) {
-      return { dec, ident, file, module, targets, name, options: example };
+    if (identifier && name) {
+      return { decorator, identifier, file, module, targets, name, options: example };
     }
   }
 
@@ -186,8 +188,8 @@ export class TransformerState implements State {
    */
   getDecoratorList(node: ts.Node): DecoratorMeta[] {
     return ts.canHaveDecorators(node) ? (ts.getDecorators(node) ?? [])
-      .map(dec => this.getDecoratorMeta(dec))
-      .filter(x => !!x) : [];
+      .map(decorator => this.getDecoratorMeta(decorator))
+      .filter(meta => !!meta) : [];
   }
 
   /**
@@ -199,26 +201,26 @@ export class TransformerState implements State {
 
   /**
    * Register statement for inclusion in final output
-   * @param stmt
+   * @param added
    * @param before
    */
   addStatements(added: ts.Statement[], before?: ts.Node | number): void {
-    const stmts = this.source.statements.slice(0);
-    let idx = stmts.length + 1000;
+    const statements = this.source.statements.slice(0);
+    let idx = statements.length + 1000;
 
     if (before && typeof before !== 'number') {
-      let n = before;
-      if (hasOriginal(n)) {
-        n = n.original;
+      let node = before;
+      if (hasOriginal(node)) {
+        node = node.original;
       }
-      while (n && !ts.isSourceFile(n.parent) && n !== n.parent) {
-        n = n.parent;
+      while (node && !ts.isSourceFile(node.parent) && node !== node.parent) {
+        node = node.parent;
       }
-      if (!ts.isStatement(n)) {
+      if (!ts.isStatement(node)) {
         throw new Error('Unable to find statement at top level');
       }
-      if (n && ts.isSourceFile(n.parent) && stmts.indexOf(n) >= 0) {
-        idx = stmts.indexOf(n) - 1;
+      if (node && ts.isSourceFile(node.parent) && statements.indexOf(node) >= 0) {
+        idx = statements.indexOf(node) - 1;
       }
     } else if (before !== undefined) {
       idx = before;
@@ -239,21 +241,21 @@ export class TransformerState implements State {
   /**
    * From literal
    */
-  fromLiteral<T extends ts.Expression>(val: T): T;
-  fromLiteral(val: undefined): ts.Identifier;
-  fromLiteral(val: null): ts.NullLiteral;
-  fromLiteral(val: object): ts.ObjectLiteralExpression;
-  fromLiteral(val: unknown[]): ts.ArrayLiteralExpression;
-  fromLiteral(val: string | boolean | number): ts.LiteralExpression;
-  fromLiteral(val: unknown): ts.Node {
-    return LiteralUtil.fromLiteral(this.factory, val!);
+  fromLiteral<T extends ts.Expression>(value: T): T;
+  fromLiteral(value: undefined): ts.Identifier;
+  fromLiteral(value: null): ts.NullLiteral;
+  fromLiteral(value: object): ts.ObjectLiteralExpression;
+  fromLiteral(value: unknown[]): ts.ArrayLiteralExpression;
+  fromLiteral(value: string | boolean | number): ts.LiteralExpression;
+  fromLiteral(value: unknown): ts.Node {
+    return LiteralUtil.fromLiteral(this.factory, value!);
   }
 
   /**
    * Extend
    */
-  extendObjectLiteral(src: object | ts.Expression, ...rest: (object | ts.Expression)[]): ts.ObjectLiteralExpression {
-    return LiteralUtil.extendObjectLiteral(this.factory, src, ...rest);
+  extendObjectLiteral(source: object | ts.Expression, ...rest: (object | ts.Expression)[]): ts.ObjectLiteralExpression {
+    return LiteralUtil.extendObjectLiteral(this.factory, source, ...rest);
   }
 
   /**
@@ -266,8 +268,8 @@ export class TransformerState implements State {
   /**
    * Create a static field for a class
    */
-  createStaticField(name: string, val: ts.Expression): ts.PropertyDeclaration {
-    return CoreUtil.createStaticField(this.factory, name, val);
+  createStaticField(name: string, value: ts.Expression): ts.PropertyDeclaration {
+    return CoreUtil.createStaticField(this.factory, name, value);
   }
 
   /**
@@ -282,17 +284,17 @@ export class TransformerState implements State {
    * Get filename identifier, regardless of module system
    */
   getModuleIdentifier(): ts.Expression {
-    if (this.#modIdent === undefined) {
-      this.#modIdent = this.factory.createUniqueName('mod');
+    if (this.#moduleIdentifier === undefined) {
+      this.#moduleIdentifier = this.factory.createUniqueName('mod');
       const entry = this.#resolver.getFileImport(this.source.fileName);
-      const decl = this.factory.createVariableDeclaration(this.#modIdent, undefined, undefined,
+      const declaration = this.factory.createVariableDeclaration(this.#moduleIdentifier, undefined, undefined,
         this.fromLiteral([entry?.module, entry?.relativeFile ?? ''])
       );
       this.addStatements([
-        this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([decl]))
+        this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([declaration]))
       ], -1);
     }
-    return this.#modIdent;
+    return this.#moduleIdentifier;
   }
 
   /**
@@ -307,7 +309,7 @@ export class TransformerState implements State {
     mod = typeof mod === 'string' ? mod : mod[ModuleNameSymbol]!;
     const target = `${mod}:${name}`;
     const list = this.getDecoratorList(node);
-    return list.find(x => x.targets?.includes(target) && (!module || x.name === name && x.module === module))?.dec;
+    return list.find(meta => meta.targets?.includes(target) && (!module || meta.name === name && meta.module === module))?.decorator;
   }
 
   /**
@@ -377,14 +379,14 @@ 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): m is ts.MethodDeclaration => ts.isMethodDeclaration(m) && ts.isIdentifier(m.name) && m.name.escapedText === method
+        (value): value is ts.MethodDeclaration => ts.isMethodDeclaration(value) && ts.isIdentifier(value.name) && value.name.escapedText === method
       );
     } else {
-      const props = this.#resolver.getPropertiesOfType(cls);
-      for (const prop of props) {
-        const decl = prop.declarations?.[0];
-        if (decl && prop.escapedName === method && ts.isMethodDeclaration(decl)) {
-          return decl;
+      const properties = this.#resolver.getPropertiesOfType(cls);
+      for (const property of properties) {
+        const declaration = property.declarations?.[0];
+        if (declaration && property.escapedName === method && ts.isMethodDeclaration(declaration)) {
+          return declaration;
         }
       }
     }
@@ -401,15 +403,13 @@ export class TransformerState implements State {
   /**
    * Produce a foreign target type
    */
-  getForeignTarget(ret: ForeignType): ts.Expression {
-    return this.factory.createClassExpression([], undefined, undefined, undefined, [
-      this.factory.createPropertyDeclaration(
-        [this.factory.createModifier(ts.SyntaxKind.StaticKeyword)],
-        'Ⲑid',
-        undefined,
-        undefined,
-        this.fromLiteral(`${ret.source.split('node_modules/')[1]}+${ret.name}`)
-      )
+  getForeignTarget(type: ForeignType): ts.Expression {
+    const file = this.importFile(FOREIGN_TYPE_REGISTRY_FILE);
+    return this.factory.createCallExpression(this.createAccess(
+      file.identifier,
+      this.factory.createIdentifier('foreignType'),
+    ), [], [
+      this.fromLiteral(`${type.source.split('node_modules/')[1]}+${type.name}`)
     ]);
   }
 
@@ -425,8 +425,8 @@ export class TransformerState implements State {
       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}`);
+      const source = this.getFileImportName(file);
+      throw new Error(`Unable to import non-external type: ${node.getText()} ${type.key}: ${source}`);
     }
   }
 
@@ -435,7 +435,7 @@ export class TransformerState implements State {
    */
   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;
+    const properties = checker.getApparentType(value).getApparentProperties().find(property => property.escapedName === field);
+    return properties ? this.resolveType(checker.getTypeOfSymbol(properties)) : undefined;
   }
 }

package/src/types/shared.ts

@@ -22,13 +22,13 @@ export interface DeclDocumentation {
  */
 export type Import = {
   path: string;
-  ident: ts.Identifier;
-  stmt?: ts.ImportDeclaration;
+  identifier: ts.Identifier;
+  statement?: ts.ImportDeclaration;
 };
 
 /** Template Literal Types */
 export type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor;
-export type TemplateLiteral = { op: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
+export type TemplateLiteral = { operation: 'and' | 'or', values: (TemplateLiteralPart | TemplateLiteral)[] };
 
 export function transformCast<T>(input: unknown): T {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions

package/src/types/visitor.ts

@@ -4,8 +4,8 @@ import ts from 'typescript';
  * Decorator metadata
  */
 export type DecoratorMeta = {
-  dec: ts.Decorator;
-  ident: ts.Identifier;
+  decorator: ts.Decorator;
+  identifier: ts.Identifier;
   module?: string;
   file?: string;
   targets?: string[];
@@ -18,7 +18,7 @@ export type State = {
   importName: string;
   added: Map<number, ts.Statement[]>;
   getDecoratorList(node: ts.Node): DecoratorMeta[];
-  finalize(src: ts.SourceFile): ts.SourceFile;
+  finalize(source: ts.SourceFile): ts.SourceFile;
 };
 
 export type TransformPhase = 'before' | 'after';