@travetto/transformer 8.0.0-alpha.9 → 8.0.0

package/src/state.ts

@@ -1,17 +1,16 @@
 import ts from 'typescript';
 
-import { path, type ManifestIndex } from '@travetto/manifest';
+import { type ManifestIndex, path } from '@travetto/manifest';
 
-import type { ManagedType, AnyType, ForeignType, MappedType } from './resolver/types.ts';
-import { type State, type DecoratorMeta, type Transformer, ModuleNameSymbol } from './types/visitor.ts';
-import { SimpleResolver } from './resolver/service.ts';
 import { ImportManager } from './importer.ts';
+import { SimpleResolver } from './resolver/service.ts';
+import type { AnyType, ForeignType, ManagedType, MappedType } from './resolver/types.ts';
 import type { Import } from './types/shared.ts';
-
-import { DocUtil } from './util/doc.ts';
-import { DecoratorUtil } from './util/decorator.ts';
-import { DeclarationUtil } from './util/declaration.ts';
+import { type DecoratorMeta, ModuleNameSymbol, type State, type Transformer } from './types/visitor.ts';
 import { CoreUtil } from './util/core.ts';
+import { DeclarationUtil } from './util/declaration.ts';
+import { DecoratorUtil } from './util/decorator.ts';
+import { DocUtil } from './util/doc.ts';
 import { LiteralUtil } from './util/literal.ts';
 import { SystemUtil } from './util/system.ts';
 
@@ -23,7 +22,7 @@ function hasEscapedName(node: ts.Node): node is ts.Node & { name: { escapedText:
   return !!node && 'name' in node && typeof node.name === 'object' && !!node.name && 'escapedText' in node.name && !!node.name.escapedText;
 }
 
-function isRedefinableDeclaration(node: ts.Node): node is ts.InterfaceDeclaration | ts.ClassDeclaration | ts.FunctionDeclaration {
+function canRedeclare(node: ts.Node): node is ts.InterfaceDeclaration | ts.ClassDeclaration | ts.FunctionDeclaration {
   return ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node);
 }
 
@@ -105,9 +104,12 @@ export class TransformerState implements State {
   typeToIdentifier(node: ts.Type | AnyType): ts.Identifier | ts.PropertyAccessExpression | undefined {
     const type = 'flags' in node ? this.resolveType(node) : node;
     switch (type.key) {
-      case 'literal': return this.factory.createIdentifier(type.ctor!.name);
-      case 'managed': return this.getOrImport(type);
-      case 'shape': return;
+      case 'literal':
+        return this.factory.createIdentifier(type.ctor!.name);
+      case 'managed':
+        return this.getOrImport(type);
+      case 'shape':
+        return;
     }
   }
 
@@ -173,9 +175,7 @@ export class TransformerState implements State {
     const targets = DocUtil.readAugments(type);
     const example = DocUtil.readExample(type);
     const module = file ? moduleImport : undefined;
-    const name = identifier ?
-      identifier.escapedText?.toString()! :
-      undefined;
+    const name = identifier ? identifier.escapedText?.toString() : undefined;
 
     if (identifier && name) {
       return { decorator, identifier, file, module, targets, name, options: example };
@@ -186,9 +186,9 @@ export class TransformerState implements State {
    * Get list of all #decorators for a node
    */
   getDecoratorList(node: ts.Node): DecoratorMeta[] {
-    return ts.canHaveDecorators(node) ? (ts.getDecorators(node) ?? [])
-      .map(decorator => this.getDecoratorMeta(decorator))
-      .filter(metadata => !!metadata) : [];
+    return ts.canHaveDecorators(node)
+      ? (ts.getDecorators(node) ?? []).map(decorator => this.getDecoratorMeta(decorator)).filter(metadata => !!metadata)
+      : [];
   }
 
   /**
@@ -257,7 +257,11 @@ export class TransformerState implements State {
   /**
    * Create property access
    */
-  createAccess(first: string | ts.Expression, second: string | ts.Identifier, ...items: (string | number | ts.Identifier)[]): ts.Expression {
+  createAccess(
+    first: string | ts.Expression,
+    second: string | ts.Identifier,
+    ...items: (string | number | ts.Identifier)[]
+  ): ts.Expression {
     return CoreUtil.createAccess(this.factory, first, second, ...items);
   }
 
@@ -298,12 +302,16 @@ export class TransformerState implements State {
   getModuleIdentifier(): ts.Expression {
     if (this.#moduleIdentifier === undefined) {
       this.#moduleIdentifier = this.factory.createUniqueName('Δm');
-      const declaration = this.factory.createVariableDeclaration(this.#moduleIdentifier, undefined, undefined,
+      const declaration = this.factory.createVariableDeclaration(
+        this.#moduleIdentifier,
+        undefined,
+        undefined,
         this.fromLiteral(this.getModuleIdentifierTarget())
       );
-      this.addStatements([
-        this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([declaration], ts.NodeFlags.Const))
-      ], -1);
+      this.addStatements(
+        [this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([declaration], ts.NodeFlags.Const))],
+        -1
+      );
     }
     return this.#moduleIdentifier;
   }
@@ -320,7 +328,7 @@ export class TransformerState implements State {
     const targetScope = typeof input === 'string' ? input : input[ModuleNameSymbol]!;
     const target = `${targetScope}:${name}`;
     const list = this.getDecoratorList(node);
-    return list.find(item => item.targets?.includes(target) && (!module || item.name === name && item.module === module))?.decorator;
+    return list.find(item => item.targets?.includes(target) && (!module || (item.name === name && item.module === module)))?.decorator;
   }
 
   /**
@@ -341,10 +349,11 @@ export class TransformerState implements State {
       const tgt = DeclarationUtil.getPrimaryDeclarationNode(type.original!);
       const fileName = tgt.getSourceFile().fileName;
 
-      if (fileName === this.source.fileName) { // if in same file suffix with location
+      if (fileName === this.source.fileName) {
+        // if in same file suffix with location
         let child: ts.Node = tgt;
         while (child && !ts.isSourceFile(child)) {
-          if (isRedefinableDeclaration(child) || ts.isMethodDeclaration(child) || ts.isParameter(child)) {
+          if (canRedeclare(child) || ts.isMethodDeclaration(child) || ts.isParameter(child)) {
             if (child.name) {
               unique.push(child.name.getText());
             }
@@ -362,7 +371,8 @@ export class TransformerState implements State {
       unique = [type.name ?? 'unknown']; // Type is only unique piece
     }
 
-    if (unique.length) { // Make unique to file
+    if (unique.length) {
+      // Make unique to file
       unique.unshift(this.#resolver.getFileImportName(this.source.fileName));
       return `${name}__${SystemUtil.naiveHashString(unique.join(':'), 12)}${suffix || ''}`;
     } else {
@@ -390,7 +400,8 @@ export class TransformerState implements State {
   findMethodByName(cls: ts.ClassLikeDeclaration | ts.Type, method: string): ts.MethodDeclaration | undefined {
     if ('getSourceFile' in cls) {
       return cls.members.find(
-        (value): value is ts.MethodDeclaration => ts.isMethodDeclaration(value) && ts.isIdentifier(value.name) && value.name.escapedText === method
+        (value): value is ts.MethodDeclaration =>
+          ts.isMethodDeclaration(value) && ts.isIdentifier(value.name) && value.name.escapedText === method
       );
     } else {
       const properties = this.#resolver.getPropertiesOfType(cls);
@@ -416,12 +427,11 @@ export class TransformerState implements State {
    */
   getForeignTarget(typeOrClassId: ForeignType | string): ts.Expression {
     const file = this.importFile(FOREIGN_TYPE_REGISTRY_FILE);
-    return this.factory.createCallExpression(this.createAccess(
-      file.identifier,
-      this.factory.createIdentifier('foreignType'),
-    ), [], [
-      this.fromLiteral(typeof typeOrClassId === 'string' ? typeOrClassId : typeOrClassId.classId)
-    ]);
+    return this.factory.createCallExpression(
+      this.createAccess(file.identifier, this.factory.createIdentifier('foreignType')),
+      [],
+      [this.fromLiteral(typeof typeOrClassId === 'string' ? typeOrClassId : typeOrClassId.classId)]
+    );
   }
 
   /**
@@ -456,7 +466,10 @@ export class TransformerState implements State {
    */
   getApparentTypeOfField(value: ts.Type, field: string): AnyType | undefined {
     const checker = this.#resolver.getChecker();
-    const properties = checker.getApparentType(value).getApparentProperties().find(property => property.escapedName === field);
+    const properties = checker
+      .getApparentType(value)
+      .getApparentProperties()
+      .find(property => property.escapedName === field);
     return properties ? this.resolveType(checker.getTypeOfSymbol(properties)) : undefined;
   }
-}
+}

package/src/types/shared.ts

@@ -14,6 +14,7 @@ export interface ParamDocumentation {
 export interface DeclDocumentation {
   return?: string;
   description?: string;
+  examples?: string[];
   params?: ParamDocumentation[];
 }
 
@@ -28,9 +29,8 @@ export type Import = {
 
 /** Template Literal Types */
 export type TemplateLiteralPart = string | NumberConstructor | StringConstructor | BooleanConstructor | BigIntConstructor;
-export type TemplateLiteral = { operation: '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
   return input as T;
-}
+}

package/src/types/visitor.ts

@@ -24,8 +24,18 @@ export type State = {
 export type TransformPhase = 'before' | 'after';
 
 export type TransformerType =
-  'class' | 'method' | 'property' | 'getter' | 'setter' | 'parameter'
-  | 'static-method' | 'call' | 'function' | 'file' | 'type' | 'interface'
+  | 'class'
+  | 'method'
+  | 'property'
+  | 'getter'
+  | 'setter'
+  | 'parameter'
+  | 'static-method'
+  | 'call'
+  | 'function'
+  | 'file'
+  | 'type'
+  | 'interface'
   | 'constructor';
 
 export const ModuleNameSymbol = Symbol.for('@travetto/transformer:id');
@@ -43,4 +53,4 @@ export interface NodeTransformer<S extends State = State, T extends TransformerT
   target?: string[];
   before?<Z extends ts.Node = ts.Node>(state: S, node: N, dm?: DecoratorMeta): Z | undefined;
   after?<Z extends ts.Node = ts.Node>(state: S, node: N, dm?: DecoratorMeta): Z | undefined;
-}
+}

package/src/util/core.ts

@@ -4,18 +4,17 @@ import ts from 'typescript';
  * Core utilities util
  */
 export class CoreUtil {
-
   /**
    * See if inbound node has an original property
    */
-  static hasOriginal(value: ts.Node): value is (ts.Node & { original: ts.Node }) {
+  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(value: ts.Type): value is (ts.Type & { target: ts.Type }) {
+  static hasTarget(value: ts.Type): value is ts.Type & { target: ts.Type } {
     return 'target' in value && !!value.target;
   }
 
@@ -37,7 +36,7 @@ export class CoreUtil {
     node: ts.CallExpression | undefined,
     pred: (expr: ts.Expression) => expr is T
   ): T | undefined {
-    if (node && node.arguments && node.arguments.length) {
+    if (node?.arguments?.length) {
       return node.arguments.find(pred);
     }
   }
@@ -46,7 +45,7 @@ export class CoreUtil {
    * Find the first argument of a call expression, or decorator.
    */
   static firstArgument(node: ts.CallExpression | undefined): ts.Expression | undefined {
-    if (node && node!.arguments && node!.arguments.length) {
+    if (node?.arguments?.length) {
       return node.arguments[0];
     }
   }
@@ -55,10 +54,7 @@ export class CoreUtil {
    * Create a static field for a class
    */
   static createStaticField(factory: ts.NodeFactory, name: string, value: ts.Expression): ts.PropertyDeclaration {
-    return factory.createPropertyDeclaration(
-      [factory.createToken(ts.SyntaxKind.StaticKeyword)],
-      name, undefined, undefined, value
-    );
+    return factory.createPropertyDeclaration([factory.createToken(ts.SyntaxKind.StaticKeyword)], name, undefined, undefined, value);
   }
 
   /**
@@ -79,9 +75,18 @@ export class CoreUtil {
    * @param source
    * @param statements
    */
-  static updateSource(factory: ts.NodeFactory, source: 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(
-      source, statements, source.isDeclarationFile, source.referencedFiles, source.typeReferenceDirectives, source.hasNoDefaultLib
+      source,
+      statements,
+      source.isDeclarationFile,
+      source.referencedFiles,
+      source.typeReferenceDirectives,
+      source.hasNoDefaultLib
     );
   }
 
@@ -98,9 +103,10 @@ export class CoreUtil {
       first = factory.createIdentifier(first);
     }
     return items.reduce<ts.Expression>(
-      (expr, value) => typeof value === 'number' ?
-        factory.createElementAccessExpression(expr, value) :
-        factory.createPropertyAccessExpression(expr, value),
+      (expr, value) =>
+        typeof value === 'number'
+          ? factory.createElementAccessExpression(expr, value)
+          : factory.createPropertyAccessExpression(expr, value),
       factory.createPropertyAccessExpression(first, second)
     );
   }
@@ -122,7 +128,6 @@ export class CoreUtil {
    * Is declaration abstract?
    */
   static isAbstract(node: ts.Declaration): boolean {
-    // eslint-disable-next-line no-bitwise
     return !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Abstract);
   }
-}
+}

package/src/util/declaration.ts

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+
 import { CoreUtil } from './core.ts';
 
 const isNamed = (value: ts.Declaration): value is ts.Declaration & { name: ts.Node } => 'name' in value && !!value.name;
@@ -7,7 +8,6 @@ const isNamed = (value: ts.Declaration): value is ts.Declaration & { name: ts.No
  * Declaration utils
  */
 export class DeclarationUtil {
-
   /**
    * Searches upward from the node until it finds the variable declaration list,
    * and then checks the toString for `const `
@@ -24,9 +24,10 @@ export class DeclarationUtil {
    * See if a declaration is public
    */
   static isPublic(node: ts.Declaration): boolean {
-    // eslint-disable-next-line no-bitwise
-    return !(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.NonPublicAccessibilityModifier) &&
-      (!isNamed(node) || !ts.isPrivateIdentifier(node.name));
+    return (
+      !(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.NonPublicAccessibilityModifier) &&
+      (!isNamed(node) || !ts.isPrivateIdentifier(node.name))
+    );
   }
 
   /**
@@ -65,8 +66,7 @@ export class DeclarationUtil {
    */
   static getObjectFlags(type: ts.Type): ts.ObjectFlags {
     const _ts: typeof ts & { getObjectFlags?(node: ts.Type): ts.ObjectFlags } = ts;
-    // eslint-disable-next-line no-bitwise
-    return _ts.getObjectFlags!(type) & ~(ts.NodeFlags.ThisNodeOrAnySubNodesHasError);
+    return _ts.getObjectFlags!(type) & ~ts.NodeFlags.ThisNodeOrAnySubNodesHasError;
   }
 
   /**
@@ -75,10 +75,14 @@ export class DeclarationUtil {
    * @param node
    * @returns
    */
-  static getAccessorPair(
-    node: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration
-  ): { getter?: ts.GetAccessorDeclaration, setter?: ts.SetAccessorDeclaration } {
-    const pair = { getter: ts.isGetAccessorDeclaration(node) ? node : undefined, setter: ts.isSetAccessorDeclaration(node) ? node : undefined };
+  static getAccessorPair(node: ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): {
+    getter?: ts.GetAccessorDeclaration;
+    setter?: ts.SetAccessorDeclaration;
+  } {
+    const pair = {
+      getter: ts.isGetAccessorDeclaration(node) ? node : undefined,
+      setter: ts.isSetAccessorDeclaration(node) ? node : undefined
+    };
     if (ts.isClassDeclaration(node.parent)) {
       for (const member of node.parent.members) {
         if (member.name && member.name.getText() === node.name.getText()) {
@@ -102,4 +106,58 @@ export class DeclarationUtil {
     }
     return false;
   }
-}
+
+  /**
+   * Ensures a constructor exists in the class declaration, synthesizing one if necessary
+   */
+  static ensureConstructor(factory: ts.NodeFactory, node: ts.ClassDeclaration): ts.ClassDeclaration {
+    const hasCons = node.members.some(member => ts.isConstructorDeclaration(member));
+    if (hasCons) {
+      return node;
+    }
+
+    const hasParent = node.heritageClauses?.some(clause => clause.token === ts.SyntaxKind.ExtendsKeyword);
+    const newConsStatements: ts.Statement[] = [];
+    let parameters: ts.ParameterDeclaration[] = [];
+    if (hasParent) {
+      parameters = [
+        factory.createParameterDeclaration(
+          undefined,
+          factory.createToken(ts.SyntaxKind.DotDotDotToken),
+          factory.createIdentifier('args'),
+          undefined,
+          factory.createArrayTypeNode(factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)),
+          undefined
+        )
+      ];
+      newConsStatements.push(
+        factory.createExpressionStatement(
+          factory.createCallExpression(factory.createSuper(), undefined, [factory.createSpreadElement(factory.createIdentifier('args'))])
+        )
+      );
+    }
+    const newCons = factory.createConstructorDeclaration(undefined, parameters, factory.createBlock(newConsStatements, true));
+    return factory.updateClassDeclaration(node, node.modifiers, node.name, node.typeParameters, node.heritageClauses, [
+      ...node.members,
+      newCons
+    ]);
+  }
+
+  /**
+   * Calculates the insertion index for constructor statements (after super call, if exists)
+   */
+  static getConstructorInsertIndex(node: ts.ConstructorDeclaration): number {
+    if (node.body) {
+      const first = node.body.statements[0];
+      if (
+        first &&
+        ts.isExpressionStatement(first) &&
+        ts.isCallExpression(first.expression) &&
+        first.expression.expression.kind === ts.SyntaxKind.SuperKeyword
+      ) {
+        return 1;
+      }
+    }
+    return 0;
+  }
+}

package/src/util/decorator.ts

@@ -1,11 +1,11 @@
 import ts from 'typescript';
+
 import { CoreUtil } from './core.ts';
 
 /**
  * Utilities for dealing with decorators
  */
 export class DecoratorUtil {
-
   static #getIdentFromExpression(expr: ts.Expression): ts.Identifier {
     if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
       return expr.expression;
@@ -66,4 +66,4 @@ export class DecoratorUtil {
   static getArguments(node: ts.Decorator | undefined): ts.Expression[] | undefined {
     return node && ts.isCallExpression(node.expression) ? [...node.expression.arguments] : undefined;
   }
-}
+}

package/src/util/doc.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { transformCast, type DeclDocumentation } from '../types/shared.ts';
+import { type DeclDocumentation, transformCast } from '../types/shared.ts';
 import { CoreUtil } from './core.ts';
 import { DeclarationUtil } from './declaration.ts';
 
@@ -11,7 +11,7 @@ export class DocUtil {
   /**
    * See if node has js docs
    */
-  static hasJSDoc(node: ts.Node): node is (ts.Node & { jsDoc: ts.JSDoc[] }) {
+  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;
   }
 
@@ -26,21 +26,22 @@ export class DocUtil {
    * Read JS Docs from a `ts.Declaration`
    */
   static describeDocs(node: ts.Declaration | ts.Type): DeclDocumentation {
-    let toDescribe = (node && !('getSourceFile' in node)) ?
-      DeclarationUtil.getOptionalPrimaryDeclarationNode(node) : node;
+    let toDescribe = node && !('getSourceFile' in node) ? DeclarationUtil.getOptionalPrimaryDeclarationNode(node) : node;
 
     const out: DeclDocumentation = {
       description: undefined,
       return: undefined,
+      examples: undefined,
       params: []
     };
 
     if (toDescribe) {
-      const tags = ts.getJSDocTags(toDescribe);
       while (!this.hasJSDoc(toDescribe) && CoreUtil.hasOriginal(toDescribe)) {
         toDescribe = transformCast<ts.Declaration>(toDescribe.original);
       }
 
+      const tags = ts.getJSDocTags(toDescribe);
+
       const docs = this.hasJSDoc(toDescribe) ? toDescribe.jsDoc : undefined;
 
       if (docs) {
@@ -50,15 +51,17 @@ export class DocUtil {
         }
       }
 
-      if (tags && tags.length) {
+      if (tags?.length) {
         for (const tag of tags) {
           if (ts.isJSDocReturnTag(tag)) {
             out.return = this.getDocComment(tag, out.return);
           } else if (ts.isJSDocParameterTag(tag)) {
             out.params!.push({
-              name: tag.name && tag.name.getText(),
+              name: tag.name?.getText(),
               description: this.getDocComment(tag, '')!
             });
+          } else if (tag.tagName.getText() === 'example') {
+            (out.examples ??= []).push(this.getDocComment(tag, '')!);
           }
         }
       }
@@ -71,9 +74,7 @@ export class DocUtil {
    */
   static readDocTag(type: ts.Type | ts.Symbol, name: string): string[] {
     const tags = CoreUtil.getSymbol(type)?.getJsDocTags() ?? [];
-    return tags
-      .filter(tag => tag.name === name && !!tag.text)
-      .map(tag => tag.text!.map(part => part.text).join('')); // Join all text
+    return tags.filter(tag => tag.name === name && !!tag.text).map(tag => tag.text!.map(part => part.text).join('')); // Join all text
   }
 
   /**
@@ -99,4 +100,4 @@ export class DocUtil {
   static readExample(type: ts.Type | ts.Symbol): string[] {
     return this.readDocTag(type, 'example').map(line => line.replace(/^.*?([^` ]+).*?$/, (_, b) => b));
   }
-}
+}

package/src/util/import.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { path, ManifestModuleUtil, PackageUtil } from '@travetto/manifest';
+import { ManifestModuleUtil, PackageUtil, path } from '@travetto/manifest';
 
 import type { Import } from '../types/shared.ts';
 
@@ -58,4 +58,4 @@ export class ImportUtil {
 
     return imports;
   }
-}
+}

package/src/util/literal.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { transformCast, type TemplateLiteral } from '../types/shared.ts';
+import { type TemplateLiteral, transformCast } from '../types/shared.ts';
 
 const TypedObject: {
   keys<T = unknown, K extends keyof T = keyof T>(value: T): K[];
@@ -20,14 +20,12 @@ function isKnownFn(value: unknown): value is Function {
  * Utilities for dealing with literals
  */
 export class LiteralUtil {
-
   /**
    * Determine if a type is a literal type
    * @param type
    */
   static isLiteralType(type: ts.Type): type is ts.LiteralType {
     const flags = type.getFlags();
-    // eslint-disable-next-line no-bitwise
     return (flags & (ts.TypeFlags.BooleanLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.StringLiteral)) > 0;
   }
 
@@ -43,7 +41,8 @@ export class LiteralUtil {
   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
+    if (isNode(value)) {
+      // If already a node
       return value;
     } else if (Array.isArray(value)) {
       value = factory.createArrayLiteralExpression(value.map(element => this.fromLiteral(factory, element)));
@@ -69,9 +68,7 @@ export class LiteralUtil {
       const pairs: ts.PropertyAssignment[] = [];
       for (const key of TypedObject.keys(ov)) {
         if (ov[key] !== undefined) {
-          pairs.push(
-            factory.createPropertyAssignment(key, this.fromLiteral(factory, ov[key]))
-          );
+          pairs.push(factory.createPropertyAssignment(key, this.fromLiteral(factory, ov[key])));
         }
       }
       return factory.createObjectLiteralExpression(pairs);
@@ -142,12 +139,16 @@ export class LiteralUtil {
   /**
    * Extend object literal, whether JSON or ts.ObjectLiteralExpression
    */
-  static extendObjectLiteral(factory: ts.NodeFactory, source: object | ts.Expression, ...rest: (object | ts.Expression)[]): ts.ObjectLiteralExpression {
+  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(item => !!item).map(expression => factory.createSpreadAssignment(this.fromLiteral(factory, expression))))
+        ...rest.filter(item => !!item).map(expression => factory.createSpreadAssignment(this.fromLiteral(factory, expression)))
       ]);
     }
     return literal;
@@ -198,4 +199,4 @@ export class LiteralUtil {
       return body;
     }
   }
-}
+}

package/src/util/log.ts

@@ -1,8 +1,26 @@
 const exclude = new Set([
-  'parent', 'checker', 'end', 'pos', 'id', 'source', 'sourceFile', 'getSourceFile',
-  'statements', 'stringIndexInfo', 'numberIndexInfo', 'instantiations', 'thisType',
-  'members', 'properties', 'outerTypeParameters', 'exports', 'transformFlags', 'flowNode',
-  'nextContainer', 'modifierFlagsCache', 'declaredProperties'
+  'parent',
+  'checker',
+  'end',
+  'pos',
+  'id',
+  'source',
+  'sourceFile',
+  'getSourceFile',
+  'statements',
+  'stringIndexInfo',
+  'numberIndexInfo',
+  'instantiations',
+  'thisType',
+  'members',
+  'properties',
+  'outerTypeParameters',
+  'exports',
+  'transformFlags',
+  'flowNode',
+  'nextContainer',
+  'modifierFlagsCache',
+  'declaredProperties'
 ]);
 
 const TypedObject: { keys<T = unknown, K extends keyof T = keyof T>(value: T): K[] } & ObjectConstructor = Object;
@@ -50,4 +68,4 @@ export class LogUtil {
       return out;
     }
   }
-}
+}

package/src/util/system.ts

@@ -1,13 +1,11 @@
 export class SystemUtil {
-
   /**
    * Naive hashing
    */
   static naiveHash(text: string): number {
     let hash = 5381;
 
-    for (let i = 0; i < text.length; i++) {
-      // eslint-disable-next-line no-bitwise
+    for (let i = 0; i < text.length; i += 1) {
       hash = (hash * 33) ^ text.charCodeAt(i);
     }
 
@@ -17,4 +15,4 @@ export class SystemUtil {
   static naiveHashString(text: string, length: number): string {
     return this.naiveHash(text).toString().padStart(length, '0').substring(0, length);
   }
-}
+}