@travetto/compiler 3.0.0-rc.13 → 3.0.0-rc.15

package/__index__.ts

@@ -1,3 +1,6 @@
 export * from './src/compiler';
 export * from './src/state';
-export * from './src/util';
+export * from './src/util';
+export * from './src/watch';
+export * from './src/log';
+export * from './src/types';

package/bin/trv.js

@@ -9,6 +9,8 @@ import { getManifestContext } from '@travetto/manifest/bin/context.js';
 
 const VALID_OPS = { watch: 'watch', build: 'build', clean: 'clean', manifest: 'manifest' };
 
+const COMPILER_FILES = [...['launcher', 'transpile', 'lock', 'log', 'lock-pinger'].map(x => `support/${x}.js`), 'package.json'];
+
 /**
  * @param {import('@travetto/manifest').ManifestContext} ctx
  * @return {Promise<import('@travetto/compiler/support/launcher').launch>}
@@ -17,7 +19,7 @@ const $getLauncher = async (ctx) => {
   const compPkg = createRequire(path.resolve('node_modules')).resolve('@travetto/compiler/package.json');
   const files = [];
 
-  for (const file of ['support/launcher.js', 'support/transpile.js', 'package.json']) {
+  for (const file of COMPILER_FILES) {
     const target = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', '@travetto/compiler', file);
     const src = compPkg.replace('package.json', file.replace(/[.]js$/, '.ts'));
 
@@ -30,13 +32,12 @@ const $getLauncher = async (ctx) => {
       await fs.mkdir(path.dirname(target), { recursive: true });
       const text = await fs.readFile(src, 'utf8');
       if (file.endsWith('.js')) {
-        let content = ts.transpile(text, {
-          target: ts.ScriptTarget.ES2020, module, esModuleInterop: true, allowSyntheticDefaultImports: true
-        });
-        if (ctx.moduleType === 'module') {
-          content = content.replace(/^((?:im|ex)port .*from '[.][^']+)(')/mg, (_, a, b) => `${a}.js${b}`)
-            .replace(/^(import [^\n]*from '[^.][^\n/]+[/][^\n/]+[/][^\n']+)(')/mg, (_, a, b) => `${a}.js${b}`);
-        }
+        const content = ts.transpile(
+          text,
+          { target: ts.ScriptTarget.ES2020, module, esModuleInterop: true, allowSyntheticDefaultImports: true }
+        )
+          .replace(/^((?:im|ex)port .*from '[.][^']+)(')/mg, (_, a, b) => `${a}.js${b}`)
+          .replace(/^(import [^\n]*from '[^.][^\n/]+[/][^\n/]+[/][^\n']+)(')/mg, (_, a, b) => `${a}.js${b}`);
         await fs.writeFile(target, content, 'utf8');
       } else {
         const pkg = JSON.parse(text);
@@ -57,11 +58,14 @@ const $getLauncher = async (ctx) => {
   const [op, args] = [VALID_OPS[process.argv[2]], process.argv.slice(3)];
 
   if (op === 'clean') {
-    for (const f of [ctx.outputFolder, ctx.compilerFolder]) {
+    const folders = process.argv.find(x => x === '--all' || x === '-a') ? [ctx.outputFolder, ctx.compilerFolder] : [ctx.outputFolder];
+    for (const f of folders) {
       await fs.rm(path.resolve(ctx.workspacePath, f), { force: true, recursive: true });
     }
-    return console.log(`Cleaned ${ctx.workspacePath}: [${ctx.outputFolder}, ${ctx.compilerFolder}]`);
+    return console.log(`Cleaned ${ctx.workspacePath}: [${folders.join(', ')}]`);
   }
 
-  return (await $getLauncher(ctx))(ctx, op, args);
+  const rootCtx = ctx.monoRepo ? await getManifestContext(ctx.workspacePath) : ctx;
+
+  return (await $getLauncher(ctx))(ctx, rootCtx, op, args);
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "3.0.0-rc.13",
+  "version": "3.0.0-rc.15",
   "description": "Compiler",
   "keywords": [
     "compiler",
@@ -31,12 +31,12 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.1.0",
-    "@travetto/manifest": "^3.0.0-rc.8",
-    "@travetto/terminal": "^3.0.0-rc.6",
-    "@travetto/transformer": "^3.0.0-rc.11"
+    "@travetto/manifest": "^3.0.0-rc.10",
+    "@travetto/terminal": "^3.0.0-rc.7",
+    "@travetto/transformer": "^3.0.0-rc.13"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0-rc.10"
+    "@travetto/cli": "^3.0.0-rc.12"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,37 +1,18 @@
-import util from 'util';
 import { install } from 'source-map-support';
+import timers from 'timers/promises';
 import ts from 'typescript';
 import fs from 'fs/promises';
 
 import { GlobalTerminal, TerminalProgressEvent } from '@travetto/terminal';
-import { RootIndex, watchFolders } from '@travetto/manifest';
-import { TransformerManager } from '@travetto/transformer';
+import { RootIndex } from '@travetto/manifest';
 
 import { CompilerUtil } from './util';
 import { CompilerState } from './state';
-import type { CompilerLogEvent } from '../support/transpile';
-
-export type TransformerProvider = {
-  init(checker: ts.TypeChecker): void;
-  get(): ts.CustomTransformers | undefined;
-};
-
-type EmitError = Error | readonly ts.Diagnostic[];
-type Emitter = (file: string, newProgram?: boolean) => Promise<EmitError | undefined>;
-type EmitEvent = { file: string, i: number, total: number, err?: EmitError };
-
-function log(level: 'info' | 'debug', message: string, ...args: unknown[]): void {
-  if (process.send) {
-    const ev: CompilerLogEvent = [level, util.format(message, ...args)];
-    process.send(ev);
-  } else {
-    // eslint-disable-next-line no-console
-    console[level](message, ...args);
-  }
-}
+import { CompilerWatcher } from './watch';
+import { Log } from './log';
+import { CompileEmitError, CompileEmitEvent, CompileEmitter } from './types';
 
-const debug = log.bind(null, 'debug');
-const info = log.bind(null, 'info');
+const PING_THRESHOLD = 1000;
 
 /**
  * Compilation support
@@ -45,78 +26,50 @@ export class Compiler {
     const [dirty, watch] = process.argv.slice(2);
     install();
     const dirtyFiles = (await fs.readFile(dirty, 'utf8')).split(/\n/).filter(x => !!x);
-    return new Compiler(dirtyFiles).run(watch === 'true');
+    return new Compiler().init(dirtyFiles).then(c => c.run(watch === 'true'));
   }
 
   #state: CompilerState;
   #dirtyFiles: string[];
 
-  constructor(dirtyFiles: string[]) {
-    this.#state = new CompilerState(RootIndex.manifest);
+  async init(dirtyFiles: string[]): Promise<this> {
+    this.#state = await CompilerState.get(RootIndex);
     this.#dirtyFiles = dirtyFiles[0] === '*' ?
       this.#state.getAllFiles() :
-      dirtyFiles.map(f => this.#state.resolveInput(f));
-  }
+      dirtyFiles.map(f => this.#state.getBySource(f)!.input);
 
-  get state(): CompilerState {
-    return this.#state;
+    return this;
   }
 
   /**
    * Watches local modules
    */
-  async #watchLocalModules(emit: Emitter): Promise<() => Promise<void>> {
-    const emitWithError = async (file: string): Promise<void> => {
+  #watchLocalModules(emit: CompileEmitter): Promise<() => Promise<void>> {
+    return new CompilerWatcher(this.#state).watchFiles(async file => {
       const err = await emit(file, true);
       if (err) {
-        info('Compilation Error', CompilerUtil.buildTranspileError(file, err));
+        Log.info('Compilation Error', CompilerUtil.buildTranspileError(file, err));
       } else {
-        info(`Compiled ${file.split('node_modules/')[1]}`);
+        Log.info(`Compiled ${file.split('node_modules/')[1]}`);
       }
-    };
-    const watcher = this.state.getWatcher({
-      create: emitWithError,
-      update: emitWithError,
-      delete: (outputFile) => fs.unlink(outputFile).catch(() => { })
-    });
-    return watchFolders(RootIndex.getLocalInputFolders(), watcher, {
-      filter: ev => ev.file.endsWith('.ts') || ev.file.endsWith('.js'),
-      ignore: ['node_modules']
+      return err;
     });
   }
 
-  async createTransformerProvider(): Promise<TransformerProvider> {
-    return TransformerManager.create(this.state.transformers);
-  }
-
   /**
    * Compile in a single pass, only emitting dirty files
    */
-  async getCompiler(): Promise<Emitter> {
+  async getCompiler(): Promise<CompileEmitter> {
     let program: ts.Program;
 
-    const transformers = await this.createTransformerProvider();
-    const options = await this.state.getCompilerOptions();
-    const host = this.state.getCompilerHost(options);
-
-    const emit = async (file: string, needsNewProgram = program === undefined): Promise<EmitError | undefined> => {
+    const emit = async (inputFile: string, needsNewProgram = program === undefined): Promise<CompileEmitError | undefined> => {
       try {
         if (needsNewProgram) {
-          program = ts.createProgram({ rootNames: this.#state.getAllFiles(), host, options, oldProgram: program });
-          transformers.init(program.getTypeChecker());
+          program = this.#state.createProgram(program);
         }
-        if (file.endsWith('.json')) {
-          host.writeFile(file, host.readFile(file)!, false);
-        } else if (file.endsWith('.js')) {
-          host.writeFile(file, ts.transpile(host.readFile(file)!, options), false);
-        } else {
-          const result = program.emit(
-            program.getSourceFile(file)!, host.writeFile, undefined, false, transformers.get()
-          );
-
-          if (result.diagnostics?.length) {
-            return result.diagnostics;
-          }
+        const result = this.#state.writeInputFile(program, inputFile);
+        if (result?.diagnostics?.length) {
+          return result.diagnostics;
         }
       } catch (err) {
         if (err instanceof Error) {
@@ -133,28 +86,28 @@ export class Compiler {
   /**
    * Emit all files as a stream
    */
-  async * emit(files: string[], emitter: Emitter): AsyncIterable<EmitEvent> {
+  async * emit(files: string[], emitter: CompileEmitter): AsyncIterable<CompileEmitEvent> {
     let i = 0;
     for (const file of files) {
       const err = await emitter(file);
       const imp = file.replace(/.*node_modules\//, '');
       yield { file: imp, i: i += 1, err, total: files.length };
     }
-    debug(`Compiled ${i} files`);
+    Log.debug(`Compiled ${i} files`);
   }
 
   /**
    * Run the compiler
    */
   async run(watch?: boolean): Promise<void> {
-    debug('Compilation started');
+    Log.debug('Compilation started');
 
     const emitter = await this.getCompiler();
     let failed = false;
 
-    debug('Compiler loaded');
+    Log.debug('Compiler loaded');
 
-    const resolveEmittedFile = ({ file, total, i, err }: EmitEvent): TerminalProgressEvent => {
+    const resolveEmittedFile = ({ file, total, i, err }: CompileEmitEvent): TerminalProgressEvent => {
       if (err) {
         failed = true;
         console.error(CompilerUtil.buildTranspileError(file, err));
@@ -165,21 +118,29 @@ export class Compiler {
     if (this.#dirtyFiles.length) {
       await GlobalTerminal.trackProgress(this.emit(this.#dirtyFiles, emitter), resolveEmittedFile, { position: 'bottom' });
       if (failed) {
-        debug('Compilation failed');
+        Log.debug('Compilation failed');
         process.exit(1);
       } else {
-        debug('Compilation succeeded');
+        Log.debug('Compilation succeeded');
       }
+    } else if (watch) {
+      // Prime compiler before complete
+      const resolved = this.#state.getArbitraryInputFile();
+      await emitter(resolved, true);
     }
 
+    process.send?.('build-complete');
+
     if (watch) {
-      if (!this.#dirtyFiles.length) {
-        const resolved = this.state.resolveInput(RootIndex.getModule('@travetto/manifest')!.files.src[0].sourceFile);
-        await emitter(resolved, true);
-      }
-      info('Watch is ready');
+      Log.info('Watch is ready');
       await this.#watchLocalModules(emitter);
-      await new Promise(r => setTimeout(r, 1000 * 60 * 60 * 24));
+      for await (const _ of timers.setInterval(PING_THRESHOLD)) {
+        if (!await fs.stat(this.#state.resolveOutputFile('.')).catch(() => false)) { // Output removed
+          process.send?.('restart');
+        } else {
+          process.send?.('ping');
+        }
+      }
     }
   }
 }

package/src/log.ts

@@ -0,0 +1,18 @@
+import util from 'util';
+
+import type { CompilerLogEvent } from '../support/log';
+
+function log(level: 'info' | 'debug', message: string, ...args: unknown[]): void {
+  if (process.send) {
+    const ev: CompilerLogEvent = [level, util.format(message, ...args)];
+    process.send(ev);
+  } else {
+    // eslint-disable-next-line no-console
+    console[level](message, ...args);
+  }
+}
+
+export const Log = {
+  debug: log.bind(null, 'debug'),
+  info: log.bind(null, 'info')
+};