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

package/src/resolver/builder.ts

@@ -19,8 +19,8 @@ const isMappedType = (type: string | undefined): type is MappedType['operation']
 const getMappedFields = (type: ts.Type): string[] | undefined => {
   if (type.isStringLiteral()) {
     return [type.value];
-  } else if (type.isUnion() && type.types.every(t => t.isStringLiteral())) {
-    return type.types.map(t => t.value);
+  } else if (type.isUnion() && type.types.every(subType => subType.isStringLiteral())) {
+    return type.types.map(subType => subType.value);
   }
 };
 
@@ -82,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 { }
@@ -101,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 };
@@ -113,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 };
     }
   }
@@ -160,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 });
           }
         }
       }
@@ -207,7 +207,7 @@ export const TypeBuilder: {
     build: (resolver, type) => {
       const name = CoreUtil.getSymbol(type)?.getName();
       const source = DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile();
-      return { key: 'foreign', name, source: source.fileName };
+      return { key: 'foreign', name, source: source.fileName, classId: `${source.fileName.split('node_modules/')[1]}+${name}` };
     }
   },
   managed: {
@@ -223,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' };
@@ -247,14 +247,19 @@ 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;
     }
@@ -266,8 +271,8 @@ export const TypeBuilder: {
       let operation: string | undefined;
       let name: string | undefined;
 
-      const decls = DeclarationUtil.getDeclarations(type).filter(x => ts.isTypeAliasDeclaration(x));
-      const ref = decls[0]?.type;
+      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;
@@ -298,20 +303,20 @@ export const TypeBuilder: {
       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;
@@ -333,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 === '.') {
@@ -346,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');
   }
 
   /**
@@ -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/resolver/types.ts

@@ -191,6 +191,10 @@ export interface ForeignType extends Type<'foreign'> {
    * Primary source file
    */
   source: string;
+  /**
+   * Unique class identifier
+   */
+  classId: string;
 }
 
 /**

package/src/state.ts

@@ -15,16 +15,16 @@ 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';
@@ -35,7 +35,7 @@ const FOREIGN_TYPE_REGISTRY_FILE = '@travetto/runtime/src/function';
 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>();
@@ -93,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;
   }
@@ -136,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);
   }
 
   /**
@@ -147,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);
   }
@@ -164,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 };
     }
   }
 
@@ -188,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) : [];
   }
 
   /**
@@ -201,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;
@@ -241,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);
   }
 
   /**
@@ -268,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);
   }
 
   /**
@@ -284,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;
   }
 
   /**
@@ -309,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;
   }
 
   /**
@@ -379,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;
         }
       }
     }
@@ -403,13 +403,13 @@ export class TransformerState implements State {
   /**
    * Produce a foreign target type
    */
-  getForeignTarget(ret: ForeignType): ts.Expression {
+  getForeignTarget(type: ForeignType): ts.Expression {
     const file = this.importFile(FOREIGN_TYPE_REGISTRY_FILE);
     return this.factory.createCallExpression(this.createAccess(
-      file.ident,
+      file.identifier,
       this.factory.createIdentifier('foreignType'),
     ), [], [
-      this.fromLiteral(`${ret.source.split('node_modules/')[1]}+${ret.name}`)
+      this.fromLiteral(type.classId)
     ]);
   }
 
@@ -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';

package/src/util/core.ts

@@ -8,25 +8,24 @@ export class CoreUtil {
   /**
    * See if inbound node has an original property
    */
-  static hasOriginal(o: ts.Node): o is (ts.Node & { original: ts.Node }) {
-    return 'original' in o && !!o.original;
+  static hasOriginal(value: ts.Node): value is (ts.Node & { original: ts.Node }) {
+    return 'original' in value && !!value.original;
   }
 
   /**
    * See if type has target
    */
-  static hasTarget(o: ts.Type): o is (ts.Type & { target: ts.Type }) {
-    return 'target' in o && !!o.target;
+  static hasTarget(value: ts.Type): value is (ts.Type & { target: ts.Type }) {
+    return 'target' in value && !!value.target;
   }
 
   /**
    * Get code range of node
-   * @param m
    */
-  static getRangeOf<T extends ts.Node>(source: ts.SourceFile, o: T | undefined): [start: number, end: number] | undefined {
-    if (o && o.pos >= 0) {
-      const start = ts.getLineAndCharacterOfPosition(source, o.getStart(source));
-      const end = ts.getLineAndCharacterOfPosition(source, o.getEnd());
+  static getRangeOf<T extends ts.Node>(source: ts.SourceFile, value: T | undefined): [start: number, end: number] | undefined {
+    if (value && value.pos >= 0) {
+      const start = ts.getLineAndCharacterOfPosition(source, value.getStart(source));
+      const end = ts.getLineAndCharacterOfPosition(source, value.getEnd());
       return [start.line + 1, end.line + 1];
     }
   }
@@ -34,7 +33,10 @@ export class CoreUtil {
   /**
    * Find the primary argument of a call expression, or decorator.
    */
-  static findArgument<T extends ts.Expression = ts.Expression>(node: ts.CallExpression | undefined, pred: (x: ts.Expression) => x is T): T | undefined {
+  static findArgument<T extends ts.Expression = ts.Expression>(
+    node: ts.CallExpression | undefined,
+    pred: (expr: ts.Expression) => expr is T
+  ): T | undefined {
     if (node && node.arguments && node.arguments.length) {
       return node.arguments.find(pred);
     }
@@ -52,10 +54,10 @@ export class CoreUtil {
   /**
    * Create a static field for a class
    */
-  static createStaticField(factory: ts.NodeFactory, name: string, val: ts.Expression): ts.PropertyDeclaration {
+  static createStaticField(factory: ts.NodeFactory, name: string, value: ts.Expression): ts.PropertyDeclaration {
     return factory.createPropertyDeclaration(
       [factory.createToken(ts.SyntaxKind.StaticKeyword)],
-      name, undefined, undefined, val
+      name, undefined, undefined, value
     );
   }
 
@@ -74,12 +76,12 @@ export class CoreUtil {
 
   /**
    * Updates source
-   * @param src
+   * @param source
    * @param statements
    */
-  static updateSource(factory: ts.NodeFactory, src: ts.SourceFile, statements: ts.NodeArray<ts.Statement> | ts.Statement[]): ts.SourceFile {
+  static updateSource(factory: ts.NodeFactory, source: ts.SourceFile, statements: ts.NodeArray<ts.Statement> | ts.Statement[]): ts.SourceFile {
     return factory.updateSourceFile(
-      src, statements, src.isDeclarationFile, src.referencedFiles, src.typeReferenceDirectives, src.hasNoDefaultLib
+      source, statements, source.isDeclarationFile, source.referencedFiles, source.typeReferenceDirectives, source.hasNoDefaultLib
     );
   }
 
@@ -96,9 +98,9 @@ export class CoreUtil {
       first = factory.createIdentifier(first);
     }
     return items.reduce<ts.Expression>(
-      (acc, p) => typeof p === 'number' ?
-        factory.createElementAccessExpression(acc, p) :
-        factory.createPropertyAccessExpression(acc, p),
+      (expr, value) => typeof value === 'number' ?
+        factory.createElementAccessExpression(expr, value) :
+        factory.createPropertyAccessExpression(expr, value),
       factory.createPropertyAccessExpression(first, second)
     );
   }
@@ -111,7 +113,7 @@ export class CoreUtil {
       factory.createCallExpression(
         name,
         undefined,
-        contents.filter(x => !!x)
+        contents.filter(expr => !!expr)
       )
     );
   }