@travetto/transformer 3.0.0-rc.2 → 3.0.0-rc.21

package/src/state.ts

@@ -1,18 +1,19 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
-import { SystemUtil } from '@travetto/boot/src/internal/system';
-import { ModuleUtil } from '@travetto/boot/src/internal/module-util';
-import { Util } from '@travetto/base';
+import { ManifestIndex, path } from '@travetto/manifest';
 
 import { ExternalType, AnyType } from './resolver/types';
-import { State, DecoratorMeta, Transformer, TransformerId } from './types/visitor';
-import { TypeResolver } from './resolver/service';
+import { State, DecoratorMeta, Transformer, ModuleNameⲐ } from './types/visitor';
+import { SimpleResolver } from './resolver/service';
 import { ImportManager } from './importer';
+import { Import } from './types/shared';
+
 import { DocUtil } from './util/doc';
 import { DecoratorUtil } from './util/decorator';
 import { DeclarationUtil } from './util/declaration';
-import { CoreUtil, LiteralUtil } from './util';
-import { Import } from './types/shared';
+import { CoreUtil } from './util/core';
+import { LiteralUtil } from './util/literal';
+import { SystemUtil } from './util/system';
 
 function hasOriginal(n: unknown): n is { original: ts.Node } {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -28,28 +29,25 @@ function hasEscapedName(n: unknown): n is { name: { escapedText: string } } {
  * Transformer runtime state
  */
 export class TransformerState implements State {
-  static SYNTHETIC_EXT = 'ᚕsyn';
+  static SYNTHETIC_EXT = 'Ⲑsyn';
 
-  #resolver: TypeResolver;
+  #resolver: SimpleResolver;
   #imports: ImportManager;
+  #fileIdent: ts.Identifier;
+  #manifestIndex: ManifestIndex;
   #syntheticIdentifiers = new Map<string, ts.Identifier>();
   #decorators = new Map<string, ts.PropertyAccessExpression>();
-
   added = new Map<number, ts.Statement[]>();
-  module: string;
+  importName: string;
+  file: string;
 
-  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, checker: ts.TypeChecker) {
-    this.#imports = new ImportManager(source, factory);
-    this.#resolver = new TypeResolver(checker);
-    this.module = ModuleUtil.normalizePath(this.source.fileName);
-  }
+  constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, checker: ts.TypeChecker, manifestIndex: ManifestIndex) {
+    this.#manifestIndex = manifestIndex;
+    this.#resolver = new SimpleResolver(checker, manifestIndex);
+    this.#imports = new ImportManager(source, factory, this.#resolver);
+    this.file = path.toPosix(this.source.fileName);
 
-  /**
-   * Allow access to resolver
-   * @private
-   */
-  getResolver(): TypeResolver {
-    return this.#resolver;
+    this.importName = this.#resolver.getFileImportName(this.file, true);
   }
 
   /**
@@ -62,15 +60,15 @@ export class TransformerState implements State {
   /**
    * Import a given file
    */
-  importFile(file: string): Import {
-    return this.#imports.importFile(file);
+  importFile(file: string, name?: string): Import {
+    return this.#imports.importFile(file, name);
   }
 
   /**
    * Resolve an `AnyType` from a `ts.Type` or `ts.Node`
    */
   resolveType(node: ts.Type | ts.Node): AnyType {
-    const resolved = this.#resolver.resolveType(node);
+    const resolved = this.#resolver.resolveType(node, this.importName);
     this.#imports.importFromResolved(resolved);
     return resolved;
   }
@@ -81,7 +79,9 @@ export class TransformerState implements State {
   resolveExternalType(node: ts.Node): ExternalType {
     const resolved = this.resolveType(node);
     if (resolved.key !== 'external') {
-      throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${node.getSourceFile().fileName}`);
+      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}`);
     }
     return resolved;
   }
@@ -141,23 +141,24 @@ export class TransformerState implements State {
   /**
    * Read a decorator's metadata
    */
-  getDecoratorMeta(dec: ts.Decorator): DecoratorMeta {
+  getDecoratorMeta(dec: ts.Decorator): DecoratorMeta | undefined {
     const ident = DecoratorUtil.getDecoratorIdent(dec);
     const decl = DeclarationUtil.getPrimaryDeclarationNode(
       this.#resolver.getType(ident)
     );
-
-    return {
-      dec,
-      ident,
-      file: decl?.getSourceFile().fileName,
-      module: decl ? ModuleUtil.normalizePath(decl.getSourceFile().fileName) : undefined, // All #decorators will be absolute
-      targets: DocUtil.readAugments(this.#resolver.getType(ident)),
-      name: ident ?
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        ident.escapedText! as string :
-        undefined
-    };
+    const src = decl?.getSourceFile().fileName;
+    const mod = src ? this.#resolver.getFileImportName(src, true) : undefined;
+    const file = this.#manifestIndex.getFromImport(mod ?? '')?.outputFile;
+    const targets = DocUtil.readAugments(this.#resolver.getType(ident));
+    const module = file ? mod : undefined;
+    const name = ident ?
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ident.escapedText! as string :
+      undefined;
+
+    if (ident && name) {
+      return { dec, ident, file, module, targets, name };
+    }
   }
 
   /**
@@ -166,7 +167,7 @@ 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.ident) : [];
+      .filter((x): x is DecoratorMeta => !!x) : [];
   }
 
   /**
@@ -181,25 +182,30 @@ export class TransformerState implements State {
    * @param stmt
    * @param before
    */
-  addStatement(stmt: ts.Statement, before?: ts.Node): void {
+  addStatements(added: ts.Statement[], before?: ts.Node | number): void {
     const stmts = this.source.statements.slice(0);
-    let idx = stmts.length;
-    let n = before;
-    if (hasOriginal(n)) {
-      n = n.original;
-    }
-    while (n && !ts.isSourceFile(n.parent)) {
-      n = n.parent;
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const nStmt: ts.Statement = n as ts.Statement;
-    if (n && ts.isSourceFile(n.parent) && stmts.indexOf(nStmt) >= 0) {
-      idx = stmts.indexOf(nStmt) - 1;
+    let idx = stmts.length + 1000;
+
+    if (before && typeof before !== 'number') {
+      let n = before;
+      if (hasOriginal(n)) {
+        n = n.original;
+      }
+      while (n && !ts.isSourceFile(n.parent) && n !== n.parent) {
+        n = n.parent;
+      }
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const nStmt: ts.Statement = n as ts.Statement;
+      if (n && ts.isSourceFile(n.parent) && stmts.indexOf(nStmt) >= 0) {
+        idx = stmts.indexOf(nStmt) - 1;
+      }
+    } else if (before !== undefined) {
+      idx = before;
     }
     if (!this.added.has(idx)) {
       this.added.set(idx, []);
     }
-    this.added.get(idx)!.push(stmt);
+    this.added.get(idx)!.push(...added);
   }
 
   /**
@@ -210,15 +216,6 @@ export class TransformerState implements State {
     return ret;
   }
 
-  /**
-   * Get Filename as ᚕsrc
-   */
-  getFilenameAsSrc(): ts.CallExpression {
-    const ident = this.factory.createIdentifier('ᚕsrc');
-    ident.getSourceFile = (): ts.SourceFile => this.source;
-    return this.factory.createCallExpression(ident, [], [this.createIdentifier('__filename')]);
-  }
-
   /**
    * From literal
    */
@@ -243,7 +240,7 @@ export class TransformerState implements State {
   /**
    * Create property access
    */
-  createAccess(first: string | ts.Expression, second: string | ts.Identifier, ...items: (string | ts.Identifier)[]): ts.PropertyAccessExpression {
+  createAccess(first: string | ts.Expression, second: string | ts.Identifier, ...items: (string | number | ts.Identifier)[]): ts.Expression {
     return CoreUtil.createAccess(this.factory, first, second, ...items);
   }
 
@@ -262,6 +259,22 @@ export class TransformerState implements State {
     return this.factory.createIdentifier(typeof name === 'string' ? name : name.getText());
   }
 
+  /**
+   * Get filename identifier, regardless of module system
+   */
+  getFilenameIdentifier(): ts.Expression {
+    if (this.#fileIdent === undefined) {
+      this.#fileIdent = this.createIdentifier('ᚕf');
+      const decl = this.factory.createVariableDeclaration(this.#fileIdent, undefined, undefined,
+        this.fromLiteral(this.#resolver.getFileImportName(this.source.fileName) ?? this.source.fileName)
+      );
+      this.addStatements([
+        this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([decl]))
+      ], -1);
+    }
+    return this.#fileIdent;
+  }
+
   /**
    * Find decorator, relative to registered key
    * @param state
@@ -269,10 +282,11 @@ export class TransformerState implements State {
    * @param name
    * @param module
    */
-  findDecorator(cls: Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
-    const target = `${cls[TransformerId]}/${name}`;
-    return this.getDecoratorList(node)
-      .find(x => x.targets?.includes(target) && (!module || x.name === name && x.module === module))?.dec;
+  findDecorator(mod: string | Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
+    mod = typeof mod === 'string' ? mod : mod[ModuleNameⲐ]!;
+    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;
   }
 
   /**
@@ -291,7 +305,7 @@ export class TransformerState implements State {
       }
     } catch {
       // Determine type unique ident
-      unique = Util.uuid(type.name ? 5 : 10);
+      unique = SystemUtil.uuid(type.name ? 5 : 10);
     }
     // Otherwise read name with uuid
     let name = type.name && !type.name.startsWith('_') ? type.name : '';
@@ -325,7 +339,7 @@ export class TransformerState implements State {
         (m): m is ts.MethodDeclaration => ts.isMethodDeclaration(m) && ts.isIdentifier(m.name) && m.name.escapedText === method
       );
     } else {
-      const props = this.getResolver().getPropertiesOfType(cls);
+      const props = this.#resolver.getPropertiesOfType(cls);
       for (const prop of props) {
         const decl = prop.declarations?.[0];
         if (decl && prop.escapedName === method && ts.isMethodDeclaration(decl)) {

package/src/types/shared.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import type ts from 'typescript';
 
 /**
  * Param documentation

package/src/types/visitor.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 /**
  * Decorator metadata
@@ -14,7 +14,7 @@ export type DecoratorMeta = {
 
 export type State = {
   source: ts.SourceFile;
-  module: string;
+  importName: string;
   added: Map<number, ts.Statement[]>;
   getDecoratorList(node: ts.Node): DecoratorMeta[];
   finalize(src: ts.SourceFile): ts.SourceFile;
@@ -22,12 +22,14 @@ export type State = {
 
 export type TransformPhase = 'before' | 'after';
 
-export type TransformerType = 'class' | 'method' | 'property' | 'getter' | 'setter' | 'parameter' | 'static-method' | 'call' | 'function';
+export type TransformerType =
+  'class' | 'method' | 'property' | 'getter' | 'setter' | 'parameter' |
+  'static-method' | 'call' | 'function' | 'file';
 
-export const TransformerId = Symbol.for('@trv:transformer/id');
+export const ModuleNameⲐ = Symbol.for('@travetto/transformer:id');
 
 export type Transformer = {
-  [TransformerId]: string;
+  [ModuleNameⲐ]?: string;
   name: string;
 };
 

package/src/util/core.ts

@@ -1,9 +1,10 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 /**
  * Core utilities util
  */
 export class CoreUtil {
+
   /**
    * See if inbound node has an original property
    */
@@ -51,7 +52,6 @@ export class CoreUtil {
    */
   static createStaticField(factory: ts.NodeFactory, name: string, val: ts.Expression): ts.PropertyDeclaration {
     return factory.createPropertyDeclaration(
-      undefined,
       [factory.createToken(ts.SyntaxKind.StaticKeyword)],
       name, undefined, undefined, val
     );
@@ -88,13 +88,15 @@ export class CoreUtil {
     factory: ts.NodeFactory,
     first: string | ts.Expression,
     second: string | ts.Identifier,
-    ...items: (string | ts.Identifier)[]
-  ): ts.PropertyAccessExpression {
+    ...items: (string | number | ts.Identifier)[]
+  ): ts.Expression {
     if (typeof first === 'string') {
       first = factory.createIdentifier(first);
     }
-    return items.reduce(
-      (acc, p) => factory.createPropertyAccessExpression(acc, p),
+    return items.reduce<ts.Expression>(
+      (acc, p) => typeof p === 'number' ?
+        factory.createElementAccessExpression(acc, p) :
+        factory.createPropertyAccessExpression(acc, p),
       factory.createPropertyAccessExpression(first, second)
     );
   }

package/src/util/declaration.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 import { CoreUtil } from './core';
 
 /**
@@ -57,8 +57,8 @@ export class DeclarationUtil {
    * Resolve the `ts.ObjectFlags`
    */
   static getObjectFlags(type: ts.Type): ts.ObjectFlags {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (ts as unknown as { getObjectFlags(t: ts.Type): ts.ObjectFlags }).getObjectFlags(type);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, no-bitwise
+    return (ts as unknown as { getObjectFlags(t: ts.Type): ts.ObjectFlags }).getObjectFlags(type) & ~(ts.NodeFlags.ThisNodeOrAnySubNodesHasError);
   }
 
   /**

package/src/util/decorator.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 import { CoreUtil } from './core';
 
 /**

package/src/util/doc.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 import { DeclDocumentation } from '../types/shared';
 import { CoreUtil } from './core';

package/src/util/import.ts

@@ -1,7 +1,6 @@
-import * as ts from 'typescript';
-import { resolve as pathResolve } from 'path';
+import ts from 'typescript';
 
-import { PathUtil } from '@travetto/boot';
+import { PackageUtil, path } from '@travetto/manifest';
 
 import { Import } from '../types/shared';
 
@@ -13,9 +12,17 @@ export class ImportUtil {
    * useful for handling failed imports, but still transpiling
    */
   static optionalResolve(file: string, base?: string): string {
-    file = base ? pathResolve(base, file) : file;
+    if (base?.endsWith('.ts')) {
+      base = path.dirname(base);
+    }
+    if (base && file.startsWith('.')) {
+      return path.resolve(base, file);
+      // TODO: Replace with manifest reverse lookup
+    } else if (file.startsWith('@')) {
+      return path.resolve('node_modules', file);
+    }
     try {
-      return require.resolve(file);
+      return PackageUtil.resolveImport(file);
     } catch {
       return file;
     }
@@ -25,23 +32,23 @@ export class ImportUtil {
    * Collect all imports for a source file, as a hash map
    */
   static collectImports(src: ts.SourceFile): Map<string, Import> {
-    const pth = require.resolve(src.fileName);
-    const base = PathUtil.toUnix(pth);
+    // TODO: Replace with manifest reverse lookup
+    const base = path.toPosix(src.fileName);
 
     const imports = new Map<string, Import>();
 
     for (const stmt of src.statements) {
       if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier)) {
-        const path = this.optionalResolve(stmt.moduleSpecifier.text, base);
+        const resolved = this.optionalResolve(stmt.moduleSpecifier.text, base);
 
         if (stmt.importClause) {
           if (stmt.importClause.namedBindings) {
             const bindings = stmt.importClause.namedBindings;
             if (ts.isNamespaceImport(bindings)) {
-              imports.set(bindings.name.text, { path, ident: bindings.name, stmt });
+              imports.set(bindings.name.text, { path: resolved, ident: bindings.name, stmt });
             } else if (ts.isNamedImports(bindings)) {
               for (const n of bindings.elements) {
-                imports.set(n.name.text, { path, ident: n.name, stmt });
+                imports.set(n.name.text, { path: resolved, ident: n.name, stmt });
               }
             }
           }

package/src/util/literal.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 /**
  * Utilities for dealing with literals
@@ -48,7 +48,8 @@ export class LiteralUtil {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const ov = val as object;
       const pairs: ts.PropertyAssignment[] = [];
-      for (const k of Object.keys(ov)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      for (const k of Object.keys(ov) as (keyof typeof ov)[]) {
         if (ov[k] !== undefined) {
           pairs.push(
             factory.createPropertyAssignment(k, this.fromLiteral(factory, ov[k]))

package/src/util/log.ts

@@ -1,5 +1,3 @@
-import { Util } from '@travetto/base';
-
 const exclude = new Set([
   'parent', 'checker', 'end', 'pos', 'id', 'source', 'sourceFile', 'getSourceFile',
   'statements', 'stringIndexInfo', 'numberIndexInfo', 'instantiations', 'thisType',
@@ -22,7 +20,7 @@ export class LogUtil {
    * Clean up `ts.Node` contents for logging
    */
   static collapseNode(x: unknown, cache: Set<unknown> = new Set()): unknown {
-    if (!x || Util.isPrimitive(x)) {
+    if (!x || !(typeof x === 'object' || typeof x === 'function')) {
       return x;
     }
 
@@ -38,8 +36,9 @@ export class LogUtil {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const ox = x as object;
       const out: Record<string, unknown> = {};
-      for (const key of Object.keys(ox)) {
-        if (Util.isFunction(ox[key]) || exclude.has(key) || ox[key] === undefined) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      for (const key of Object.keys(ox) as (keyof typeof ox)[]) {
+        if (Object.getPrototypeOf(ox[key]) === Function.prototype || exclude.has(key) || ox[key] === undefined) {
           continue;
         }
         try {

package/src/util/system.ts

@@ -0,0 +1,31 @@
+import crypto from 'crypto';
+
+export class SystemUtil {
+
+  /**
+   * Generate a random UUID
+   * @param len The length of the uuid to generate
+   */
+  static uuid(len: number = 32): string {
+    const bytes = crypto.randomBytes(Math.ceil(len / 2));
+    // eslint-disable-next-line no-bitwise
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    // eslint-disable-next-line no-bitwise
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    return bytes.toString('hex').substring(0, len);
+  }
+
+  /**
+   * Naive hashing
+   */
+  static naiveHash(text: string): number {
+    let hash = 5381;
+
+    for (let i = 0; i < text.length; i++) {
+      // eslint-disable-next-line no-bitwise
+      hash = (hash * 33) ^ text.charCodeAt(i);
+    }
+
+    return Math.abs(hash);
+  }
+}

package/src/visitor.ts

@@ -1,11 +1,6 @@
-import * as ts from 'typescript';
-import { createWriteStream } from 'fs';
-
-import { ConsoleManager } from '@travetto/base/src/console';
-import { AppCache } from '@travetto/boot';
+import ts from 'typescript';
 
 import { DecoratorMeta, TransformerType, NodeTransformer, TransformerSet, State, TransformPhase } from './types/visitor';
-import { LogUtil } from './util/log';
 import { CoreUtil } from './util/core';
 
 /**
@@ -28,26 +23,24 @@ export class VisitorFactory<S extends State = State> {
       return 'class';
     } else if (ts.isParameter(node)) {
       return 'parameter';
-    } else if (ts.isFunctionDeclaration(node) || (ts.isFunctionExpression(node) && !ts.isArrowFunction(node))) {
+    } else if ((ts.isFunctionDeclaration(node) && node.body) || (ts.isFunctionExpression(node) && !ts.isArrowFunction(node))) {
       return 'function';
     } else if (ts.isGetAccessor(node)) {
       return 'getter';
     } else if (ts.isSetAccessor(node)) {
       return 'setter';
+    } else if (ts.isSourceFile(node)) {
+      return 'file';
     }
   }
 
   #transformers = new Map<TransformerType, TransformerSet<S>>();
-  #logTarget: string;
   #getState: (context: ts.TransformationContext, src: ts.SourceFile) => S;
-  #logger: Console | undefined;
 
   constructor(
     getState: (context: ts.TransformationContext, src: ts.SourceFile) => S,
-    transformers: NodeTransformer<S, TransformerType, ts.Node>[],
-    logTarget = 'compiler.log'
+    transformers: NodeTransformer<S, TransformerType, ts.Node>[]
   ) {
-    this.#logTarget = logTarget;
     this.#getState = getState;
     this.#init(transformers);
   }
@@ -79,26 +72,16 @@ export class VisitorFactory<S extends State = State> {
     }
   }
 
-  get logger(): Console {
-    this.#logger ??= new console.Console({
-      stdout: createWriteStream(AppCache.toEntryName(this.#logTarget), { flags: 'a' }),
-      inspectOptions: { depth: 4 },
-    });
-    return this.#logger;
-  }
-
   /**
    * Produce a visitor for a given a file
    */
   visitor(): ts.TransformerFactory<ts.SourceFile> {
     return (context: ts.TransformationContext) => (file: ts.SourceFile): ts.SourceFile => {
-      try {
-        const c = this.logger;
-        ConsoleManager.set({
-          onLog: (level, ctx, args) => c[level](level, ctx, ...LogUtil.collapseNodes(args))
-        });
+      if (!file.fileName.endsWith('.ts')) { // Skip all non-ts files
+        return file;
+      }
 
-        console.debug('Processing', { file: file.fileName, pid: process.pid });
+      try {
         const state = this.#getState(context, file);
         let ret = this.visit(state, context, file);
 
@@ -106,12 +89,11 @@ export class VisitorFactory<S extends State = State> {
         const changed = state.added.size;
         let statements: ts.NodeArray<ts.Statement> | ts.Statement[] = ret.statements;
         while (state.added.size) {
-          for (const [k, all] of [...state.added]) {
-            const idx = k === -1 ? state.added.size : k;
+          for (const [idx, all] of [...state.added].sort(([idxA], [idxB]) => idxB - idxA)) {
             statements = [
-              ...statements.slice(0, idx),
+              ...statements.slice(0, Math.max(idx, 0)),
               ...all.map(v => this.visit(state, context, v)),
-              ...statements.slice(idx)
+              ...statements.slice(Math.max(idx, 0))
             ];
             state.added.delete(idx);
           }
@@ -125,12 +107,10 @@ export class VisitorFactory<S extends State = State> {
         if (!(err instanceof Error)) {
           throw err;
         }
-        console.error('Failed transforming', { error: `${err.message}\n${err.stack}`, file: file.fileName });
+        console!.error('Failed transforming', { error: `${err.message}\n${err.stack}`, file: file.fileName });
         const out = new Error(`Failed transforming: ${file.fileName}: ${err.message}`);
         out.stack = err.stack;
         throw out;
-      } finally {
-        ConsoleManager.clear(); // Reset logging
       }
     };
   }

package/index.ts

@@ -1,7 +0,0 @@
-export * from './src/state';
-export * from './src/visitor';
-export * from './src/register';
-export * from './src/types/visitor';
-export * from './src/types/shared';
-export { AnyType } from './src/resolver/types';
-export * from './src/util';

package/src/util/index.ts

@@ -1,6 +0,0 @@
-export * from './core';
-export * from './declaration';
-export * from './decorator';
-export * from './doc';
-export * from './literal';
-export * from './log';