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

package/src/util/declaration.ts

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { CoreUtil } from './core.ts';
 
-const isNamed = (o: ts.Declaration): o is ts.Declaration & { name: ts.Node } => 'name' in o && !!o.name;
+const isNamed = (value: ts.Declaration): value is ts.Declaration & { name: ts.Node } => 'name' in value && !!value.name;
 
 /**
  * Declaration utils
@@ -13,11 +13,11 @@ export class DeclarationUtil {
    * and then checks the toString for `const `
    */
   static isConstantDeclaration(node: ts.Node): boolean {
-    let s: ts.Node = node;
-    while (s && !ts.isVariableDeclarationList(s)) {
-      s = s.parent;
+    let root: ts.Node = node;
+    while (root && !ts.isVariableDeclarationList(root)) {
+      root = root.parent;
     }
-    return s?.getText().startsWith('const '); // Cheap out on check, ts is being weird
+    return root?.getText().startsWith('const '); // Cheap out on check, ts is being weird
   }
 
   /**
@@ -33,24 +33,24 @@ export class DeclarationUtil {
    * Find declaration for a type, symbol or a declaration
    */
   static getDeclarations(type: ts.Type | ts.Symbol | ts.Declaration[]): ts.Declaration[] {
-    let decls: ts.Declaration[] = [];
+    let declarations: ts.Declaration[] = [];
     if (Array.isArray(type)) {
-      decls = type;
+      declarations = type;
     } else {
-      decls = CoreUtil.getSymbol(type)?.getDeclarations?.() ?? [];
+      declarations = CoreUtil.getSymbol(type)?.getDeclarations?.() ?? [];
     }
-    return decls.filter(x => !!x);
+    return declarations.filter(declaration => !!declaration);
   }
 
   /**
    * Find primary declaration out of a list of declarations
    */
   static getPrimaryDeclarationNode(node: ts.Type | ts.Symbol): ts.Declaration {
-    const decls = this.getDeclarations(node);
-    if (!decls.length) {
+    const declarations = this.getDeclarations(node);
+    if (!declarations.length) {
       throw new Error('No declarations found for type');
     }
-    return decls[0];
+    return declarations[0];
   }
 
   /**
@@ -64,7 +64,7 @@ export class DeclarationUtil {
    * Resolve the `ts.ObjectFlags`
    */
   static getObjectFlags(type: ts.Type): ts.ObjectFlags {
-    const _ts: typeof ts & { getObjectFlags?(t: ts.Type): ts.ObjectFlags } = ts;
+    const _ts: typeof ts & { getObjectFlags?(node: ts.Type): ts.ObjectFlags } = ts;
     // eslint-disable-next-line no-bitwise
     return _ts.getObjectFlags!(type) & ~(ts.NodeFlags.ThisNodeOrAnySubNodesHasError);
   }
@@ -78,27 +78,27 @@ export class DeclarationUtil {
   static getAccessorPair(
     node: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration
   ): { getter?: ts.GetAccessorDeclaration, setter?: ts.SetAccessorDeclaration } {
-    const acc = { getter: ts.isGetAccessorDeclaration(node) ? node : undefined, setter: ts.isSetAccessorDeclaration(node) ? node : undefined };
+    const pair = { getter: ts.isGetAccessorDeclaration(node) ? node : undefined, setter: ts.isSetAccessorDeclaration(node) ? node : undefined };
     if (ts.isClassDeclaration(node.parent)) {
-      for (const el of node.parent.members) {
-        if (el.name && el.name.getText() === node.name.getText()) {
-          if (ts.isGetAccessor(el)) {
-            acc.getter = el;
-          } else if (ts.isSetAccessor(el)) {
-            acc.setter = el;
+      for (const member of node.parent.members) {
+        if (member.name && member.name.getText() === node.name.getText()) {
+          if (ts.isGetAccessor(member)) {
+            pair.getter = member;
+          } else if (ts.isSetAccessor(member)) {
+            pair.setter = member;
           }
-          if (acc.getter && acc.setter) {
-            return acc;
+          if (pair.getter && pair.setter) {
+            return pair;
           }
         }
       }
     }
-    return acc;
+    return pair;
   }
 
   static isStatic(node: ts.Declaration): boolean {
     if ('modifiers' in node && Array.isArray(node.modifiers)) {
-      return node.modifiers?.some(x => x.kind === ts.SyntaxKind.StaticKeyword) ?? false;
+      return node.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.StaticKeyword) ?? false;
     }
     return false;
   }

package/src/util/decorator.ts

@@ -6,17 +6,17 @@ import { CoreUtil } from './core.ts';
  */
 export class DecoratorUtil {
 
-  static #getIdentFromExpression(e: ts.Expression): ts.Identifier {
-    if (ts.isCallExpression(e) && ts.isIdentifier(e.expression)) {
-      return e.expression;
-    } else if (ts.isIdentifier(e)) {
-      return e;
-    } else if (ts.isCallExpression(e) && ts.isPropertyAccessExpression(e.expression) && ts.isIdentifier(e.expression.expression)) {
-      return e.expression.expression;
-    } else if (ts.isPropertyAccessExpression(e) && ts.isCallExpression(e.expression) && ts.isIdentifier(e.expression.expression)) {
-      return e.expression.expression;
-    } else if (ts.isParenthesizedExpression(e)) {
-      return this.#getIdentFromExpression(e.expression);
+  static #getIdentFromExpression(expr: ts.Expression): ts.Identifier {
+    if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+      return expr.expression;
+    } else if (ts.isIdentifier(expr)) {
+      return expr;
+    } else if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression) && ts.isIdentifier(expr.expression.expression)) {
+      return expr.expression.expression;
+    } else if (ts.isPropertyAccessExpression(expr) && ts.isCallExpression(expr.expression) && ts.isIdentifier(expr.expression.expression)) {
+      return expr.expression.expression;
+    } else if (ts.isParenthesizedExpression(expr)) {
+      return this.#getIdentFromExpression(expr.expression);
     } else {
       throw new Error('No Identifier');
     }
@@ -25,12 +25,12 @@ export class DecoratorUtil {
   /**
    * Get identifier for a decorator
    */
-  static getDecoratorIdent(d: ts.Decorator): ts.Identifier {
-    const ident = this.#getIdentFromExpression(d.expression);
-    if (!ident) {
+  static getDecoratorIdentifier(decorator: ts.Decorator): ts.Identifier {
+    const identifier = this.#getIdentFromExpression(decorator.expression);
+    if (!identifier) {
       throw new Error('No Identifier');
     } else {
-      return ident;
+      return identifier;
     }
   }
 
@@ -44,7 +44,7 @@ export class DecoratorUtil {
     if (idx < 0 && target) {
       idx = node.modifiers?.indexOf(target) ?? -1;
     }
-    const out = (node.modifiers ?? []).filter(x => x !== target);
+    const out = (node.modifiers ?? []).filter(modifier => modifier !== target);
     if (idx < 0) {
       out.push(...replacements);
     } else {

package/src/util/doc.ts

@@ -11,15 +11,15 @@ export class DocUtil {
   /**
    * See if node has js docs
    */
-  static hasJSDoc(o: ts.Node): o is (ts.Node & { jsDoc: ts.JSDoc[] }) {
-    return 'jsDoc' in o && o.jsDoc !== null && o.jsDoc !== undefined && Array.isArray(o.jsDoc) && o.jsDoc.length > 0;
+  static hasJSDoc(node: ts.Node): node is (ts.Node & { jsDoc: ts.JSDoc[] }) {
+    return 'jsDoc' in node && node.jsDoc !== null && node.jsDoc !== undefined && Array.isArray(node.jsDoc) && node.jsDoc.length > 0;
   }
 
   /**
    * Read doc comment for node
    */
-  static getDocComment(o: ts.JSDoc | ts.JSDocTag, def?: string): string | undefined {
-    return (typeof o.comment === 'string' ? o.comment : undefined) ?? def;
+  static getDocComment(node: ts.JSDoc | ts.JSDocTag, def?: string): string | undefined {
+    return (typeof node.comment === 'string' ? node.comment : undefined) ?? def;
   }
 
   /**
@@ -72,8 +72,8 @@ export class DocUtil {
   static readDocTag(type: ts.Type | ts.Symbol, name: string): string[] {
     const tags = CoreUtil.getSymbol(type)?.getJsDocTags() ?? [];
     return tags
-      .filter(el => el.name === name && !!el.text)
-      .map(el => el.text!.map(x => x.text).join('')); // Join all text
+      .filter(tag => tag.name === name && !!tag.text)
+      .map(tag => tag.text!.map(part => part.text).join('')); // Join all text
   }
 
   /**
@@ -81,7 +81,7 @@ export class DocUtil {
    */
   static hasDocTag(type: ts.Type | ts.Symbol, name: string): boolean {
     const tags = CoreUtil.getSymbol(type)?.getJsDocTags() ?? [];
-    return tags.some(el => el.name === name);
+    return tags.some(tag => tag.name === name);
   }
 
 
@@ -90,7 +90,7 @@ export class DocUtil {
    * @param type
    */
   static readAugments(type: ts.Type | ts.Symbol): string[] {
-    return this.readDocTag(type, 'augments').map(x => x.replace(/^.*?([^` ]+).*?$/, (_, b) => b));
+    return this.readDocTag(type, 'augments').map(line => line.replace(/^.*?([^` ]+).*?$/, (_, b) => b));
   }
 
   /**
@@ -98,6 +98,6 @@ export class DocUtil {
    * @param type
    */
   static readExample(type: ts.Type | ts.Symbol): string[] {
-    return this.readDocTag(type, 'example').map(x => x.replace(/^.*?([^` ]+).*?$/, (_, b) => b));
+    return this.readDocTag(type, 'example').map(line => line.replace(/^.*?([^` ]+).*?$/, (_, b) => b));
   }
 }

package/src/util/import.ts

@@ -31,24 +31,24 @@ export class ImportUtil {
   /**
    * Collect all imports for a source file, as a hash map
    */
-  static collectImports(src: ts.SourceFile): Map<string, Import> {
+  static collectImports(source: ts.SourceFile): Map<string, Import> {
     // TODO: Replace with manifest reverse lookup
-    const base = path.toPosix(src.fileName);
+    const base = path.toPosix(source.fileName);
 
     const imports = new Map<string, Import>();
 
-    for (const stmt of src.statements) {
-      if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier)) {
-        const resolved = this.optionalResolve(stmt.moduleSpecifier.text, base);
+    for (const statement of source.statements) {
+      if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+        const resolved = this.optionalResolve(statement.moduleSpecifier.text, base);
 
-        if (stmt.importClause) {
-          if (stmt.importClause.namedBindings) {
-            const bindings = stmt.importClause.namedBindings;
+        if (statement.importClause) {
+          if (statement.importClause.namedBindings) {
+            const bindings = statement.importClause.namedBindings;
             if (ts.isNamespaceImport(bindings)) {
-              imports.set(bindings.name.text, { path: resolved, ident: bindings.name, stmt });
+              imports.set(bindings.name.text, { path: resolved, identifier: bindings.name, statement });
             } else if (ts.isNamedImports(bindings)) {
-              for (const n of bindings.elements) {
-                imports.set(n.name.text, { path: resolved, ident: n.name, stmt });
+              for (const element of bindings.elements) {
+                imports.set(element.name.text, { path: resolved, identifier: element.name, statement });
               }
             }
           }

package/src/util/literal.ts

@@ -3,17 +3,17 @@ import ts from 'typescript';
 import { transformCast, TemplateLiteral } from '../types/shared.ts';
 
 const TypedObject: {
-  keys<T = unknown, K extends keyof T = keyof T>(o: T): K[];
+  keys<T = unknown, K extends keyof T = keyof T>(value: T): K[];
 } & ObjectConstructor = Object;
 
-function isNode(n: unknown): n is ts.Node {
-  return !!n && typeof n === 'object' && 'kind' in n;
+function isNode(value: unknown): value is ts.Node {
+  return !!value && typeof value === 'object' && 'kind' in value;
 }
 
 const KNOWN_FNS = new Set<unknown>([String, Number, Boolean, Date, RegExp]);
 
-function isKnownFn(n: unknown): n is Function {
-  return KNOWN_FNS.has(n);
+function isKnownFn(value: unknown): value is Function {
+  return KNOWN_FNS.has(value);
 }
 
 /**
@@ -34,96 +34,96 @@ export class LiteralUtil {
   /**
    * Convert literal to a `ts.Node` type
    */
-  static fromLiteral<T extends ts.Expression>(factory: ts.NodeFactory, val: T): T;
-  static fromLiteral(factory: ts.NodeFactory, val: undefined): ts.Identifier;
-  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): 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;
-    } else if (Array.isArray(val)) {
-      val = factory.createArrayLiteralExpression(val.map(v => this.fromLiteral(factory, v)));
-    } else if (val === undefined) {
-      val = factory.createIdentifier('undefined');
-    } else if (val === null) {
-      val = factory.createNull();
-    } else if (typeof val === 'string') {
-      val = factory.createStringLiteral(val);
-    } else if (typeof val === 'number') {
-      const res = factory.createNumericLiteral(Math.abs(val));
-      val = val < 0 ? factory.createPrefixMinus(res) : res;
-    } else if (typeof val === 'boolean') {
-      val = val ? factory.createTrue() : factory.createFalse();
-    } else if (val instanceof RegExp) {
-      val = factory.createRegularExpressionLiteral(`/${val.source}/${val.flags ?? ''}`);
-    } else if (isKnownFn(val)) {
-      val = factory.createIdentifier(val.name);
+  static fromLiteral<T extends ts.Expression>(factory: ts.NodeFactory, value: T): T;
+  static fromLiteral(factory: ts.NodeFactory, value: undefined): ts.Identifier;
+  static fromLiteral(factory: ts.NodeFactory, value: null): ts.NullLiteral;
+  static fromLiteral(factory: ts.NodeFactory, value: object): ts.ObjectLiteralExpression;
+  static fromLiteral(factory: ts.NodeFactory, value: unknown[]): ts.ArrayLiteralExpression;
+  static fromLiteral(factory: ts.NodeFactory, value: string): ts.StringLiteral;
+  static fromLiteral(factory: ts.NodeFactory, value: number): ts.NumericLiteral;
+  static fromLiteral(factory: ts.NodeFactory, value: boolean): ts.BooleanLiteral;
+  static fromLiteral(factory: ts.NodeFactory, value: unknown): ts.Node {
+    if (isNode(value)) { // If already a node
+      return value;
+    } else if (Array.isArray(value)) {
+      value = factory.createArrayLiteralExpression(value.map(element => this.fromLiteral(factory, element)));
+    } else if (value === undefined) {
+      value = factory.createIdentifier('undefined');
+    } else if (value === null) {
+      value = factory.createNull();
+    } else if (typeof value === 'string') {
+      value = factory.createStringLiteral(value);
+    } else if (typeof value === 'number') {
+      const number = factory.createNumericLiteral(Math.abs(value));
+      value = value < 0 ? factory.createPrefixMinus(number) : number;
+    } else if (typeof value === 'boolean') {
+      value = value ? factory.createTrue() : factory.createFalse();
+    } else if (value instanceof RegExp) {
+      value = factory.createRegularExpressionLiteral(`/${value.source}/${value.flags ?? ''}`);
+    } else if (isKnownFn(value)) {
+      value = factory.createIdentifier(value.name);
     } else {
-      const ov = val;
+      const ov = value;
       const pairs: ts.PropertyAssignment[] = [];
-      for (const k of TypedObject.keys(ov)) {
-        if (ov[k] !== undefined) {
+      for (const key of TypedObject.keys(ov)) {
+        if (ov[key] !== undefined) {
           pairs.push(
-            factory.createPropertyAssignment(k, this.fromLiteral(factory, ov[k]))
+            factory.createPropertyAssignment(key, this.fromLiteral(factory, ov[key]))
           );
         }
       }
       return factory.createObjectLiteralExpression(pairs);
     }
-    return transformCast(val);
+    return transformCast(value);
   }
 
   /**
    * Convert a `ts.Node` to a JS literal
    */
-  static toLiteral(val: ts.NullLiteral, strict?: boolean): null;
-  static toLiteral(val: ts.NumericLiteral, strict?: boolean): number;
-  static toLiteral(val: ts.StringLiteral, strict?: boolean): string;
-  static toLiteral(val: ts.BooleanLiteral, strict?: boolean): boolean;
-  static toLiteral(val: ts.ObjectLiteralExpression, strict?: boolean): object;
-  static toLiteral(val: ts.ArrayLiteralExpression, strict?: boolean): unknown[];
-  static toLiteral(val: undefined, strict?: boolean): undefined;
-  static toLiteral(val: ts.Node, strict?: boolean): unknown;
-  static toLiteral(val?: ts.Node, strict = true): unknown {
-    if (!val) {
-      throw new Error('Val is not defined');
-    } else if (ts.isArrayLiteralExpression(val)) {
-      return val.elements.map(x => this.toLiteral(x, strict));
-    } else if (ts.isIdentifier(val)) {
-      if (val.getText() === 'undefined') {
+  static toLiteral(value: ts.NullLiteral, strict?: boolean): null;
+  static toLiteral(value: ts.NumericLiteral, strict?: boolean): number;
+  static toLiteral(value: ts.StringLiteral, strict?: boolean): string;
+  static toLiteral(value: ts.BooleanLiteral, strict?: boolean): boolean;
+  static toLiteral(value: ts.ObjectLiteralExpression, strict?: boolean): object;
+  static toLiteral(value: ts.ArrayLiteralExpression, strict?: boolean): unknown[];
+  static toLiteral(value: undefined, strict?: boolean): undefined;
+  static toLiteral(value: ts.Node, strict?: boolean): unknown;
+  static toLiteral(value?: ts.Node, strict = true): unknown {
+    if (!value) {
+      throw new Error('Value is not defined');
+    } else if (ts.isArrayLiteralExpression(value)) {
+      return value.elements.map(item => this.toLiteral(item, strict));
+    } else if (ts.isIdentifier(value)) {
+      if (value.getText() === 'undefined') {
         return undefined;
       } else if (!strict) {
-        return val.getText();
+        return value.getText();
       }
-    } else if (val.kind === ts.SyntaxKind.NullKeyword) {
+    } else if (value.kind === ts.SyntaxKind.NullKeyword) {
       return null;
-    } else if (ts.isStringLiteral(val)) {
-      return val.text;
-    } else if (ts.isNumericLiteral(val)) {
-      const txt = val.text;
+    } else if (ts.isStringLiteral(value)) {
+      return value.text;
+    } else if (ts.isNumericLiteral(value)) {
+      const txt = value.text;
       if (txt.includes('.')) {
         return parseFloat(txt);
       } else {
         return parseInt(txt, 10);
       }
-    } else if (ts.isPrefixUnaryExpression(val) && val.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(val.operand)) {
-      const txt = val.operand.text;
+    } else if (ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(value.operand)) {
+      const txt = value.operand.text;
       if (txt.includes('.')) {
         return -parseFloat(txt);
       } else {
         return -parseInt(txt, 10);
       }
-    } else if (val.kind === ts.SyntaxKind.FalseKeyword) {
+    } else if (value.kind === ts.SyntaxKind.FalseKeyword) {
       return false;
-    } else if (val.kind === ts.SyntaxKind.TrueKeyword) {
+    } else if (value.kind === ts.SyntaxKind.TrueKeyword) {
       return true;
-    } else if (ts.isObjectLiteralExpression(val)) {
+    } else if (ts.isObjectLiteralExpression(value)) {
       const out: Record<string, unknown> = {};
-      for (const pair of val.properties) {
+      for (const pair of value.properties) {
         if (ts.isPropertyAssignment(pair)) {
           out[pair.name.getText()] = this.toLiteral(pair.initializer, strict);
         }
@@ -131,19 +131,19 @@ export class LiteralUtil {
       return out;
     }
     if (strict) {
-      throw new Error(`Not a valid input, should be a valid ts.Node: ${val.kind}`);
+      throw new Error(`Not a valid input, should be a valid ts.Node: ${value.kind}`);
     }
   }
 
   /**
    * Extend object literal, whether JSON or ts.ObjectLiteralExpression
    */
-  static extendObjectLiteral(factory: ts.NodeFactory, src: object | ts.Expression, ...rest: (object | ts.Expression)[]): ts.ObjectLiteralExpression {
-    let literal = this.fromLiteral(factory, src);
-    if (rest.find(x => !!x)) {
+  static extendObjectLiteral(factory: ts.NodeFactory, source: object | ts.Expression, ...rest: (object | ts.Expression)[]): ts.ObjectLiteralExpression {
+    let literal = this.fromLiteral(factory, source);
+    if (rest.find(item => !!item)) {
       literal = factory.createObjectLiteralExpression([
         factory.createSpreadAssignment(literal),
-        ...(rest.filter(x => !!x).map(r => factory.createSpreadAssignment(this.fromLiteral(factory, r))))
+        ...(rest.filter(item => !!item).map(expression => factory.createSpreadAssignment(this.fromLiteral(factory, expression))))
       ]);
     }
     return literal;
@@ -154,12 +154,12 @@ export class LiteralUtil {
    */
   static getObjectValue(node: ts.Expression | undefined, key: string): ts.Expression | undefined {
     if (node && ts.isObjectLiteralExpression(node) && node.properties) {
-      for (const prop of node.properties) {
-        if (prop.name!.getText() === key) {
-          if (ts.isPropertyAssignment(prop)) {
-            return prop.initializer;
-          } else if (ts.isShorthandPropertyAssignment(prop)) {
-            return prop.name;
+      for (const property of node.properties) {
+        if (property.name!.getText() === key) {
+          if (ts.isPropertyAssignment(property)) {
+            return property.initializer;
+          } else if (ts.isShorthandPropertyAssignment(property)) {
+            return property.name;
           }
         }
       }
@@ -172,20 +172,20 @@ export class LiteralUtil {
    */
   static templateLiteralToRegex(template: TemplateLiteral, exact = true): string {
     const out: string[] = [];
-    for (const el of template.values) {
-      if (el === Number) {
+    for (const value of template.values) {
+      if (value === Number) {
         out.push('\\d+');
-      } else if (el === Boolean) {
+      } else if (value === Boolean) {
         out.push('(?:true|false)');
-      } else if (el === String) {
+      } else if (value === String) {
         out.push('.+');
-      } else if (typeof el === 'string' || typeof el === 'number' || typeof el === 'boolean') {
-        out.push(`${el}`);
+      } else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        out.push(`${value}`);
       } else {
-        out.push(`(?:${this.templateLiteralToRegex(transformCast(el), false)})`);
+        out.push(`(?:${this.templateLiteralToRegex(transformCast(value), false)})`);
       }
     }
-    const body = out.join(template.op === 'and' ? '' : '|');
+    const body = out.join(template.operation === 'and' ? '' : '|');
     if (exact) {
       return `^(?:${body})$`;
     } else {

package/src/util/log.ts

@@ -5,7 +5,7 @@ const exclude = new Set([
   'nextContainer', 'modifierFlagsCache', 'declaredProperties'
 ]);
 
-const TypedObject: { keys<T = unknown, K extends keyof T = keyof T>(o: T): K[] } & ObjectConstructor = Object;
+const TypedObject: { keys<T = unknown, K extends keyof T = keyof T>(value: T): K[] } & ObjectConstructor = Object;
 
 /**
  * Utilities for logging typescript nodes
@@ -15,27 +15,27 @@ export class LogUtil {
    * Clean up `ts.Node` contents for logging
    */
   static collapseNodes(all: unknown[]): unknown[] {
-    return all.map(x => this.collapseNode(x));
+    return all.map(value => this.collapseNode(value));
   }
 
   /**
    * Clean up `ts.Node` contents for logging
    */
-  static collapseNode(x: unknown, cache: Set<unknown> = new Set()): unknown {
-    if (!x || !(typeof x === 'object' || typeof x === 'function')) {
-      return x;
+  static collapseNode(value: unknown, cache: Set<unknown> = new Set()): unknown {
+    if (!value || !(typeof value === 'object' || typeof value === 'function')) {
+      return value;
     }
 
-    if (cache.has(x)) {
+    if (cache.has(value)) {
       return;
     } else {
-      cache.add(x);
+      cache.add(value);
     }
 
-    if (Array.isArray(x)) {
-      return x.map(v => this.collapseNode(v, cache));
+    if (Array.isArray(value)) {
+      return value.map(node => this.collapseNode(node, cache));
     } else {
-      const ox = x;
+      const ox = value;
       const out: Record<string, unknown> = {};
       for (const key of TypedObject.keys(ox)) {
         if (ox[key] === null || ox[key] === undefined || Object.getPrototypeOf(ox[key]) === Function.prototype || exclude.has(key)) {