@travetto/compiler 3.0.0-rc.1 → 3.0.0-rc.12

package/support/transpile.ts

@@ -0,0 +1,185 @@
+import path from 'path';
+import fs from 'fs/promises';
+import os from 'os';
+import cp from 'child_process';
+import { createRequire } from 'module';
+
+import { DeltaEvent, ManifestContext, ManifestRoot, Package } from '@travetto/manifest';
+
+type ModFile = { input: string, output: string, stale: boolean };
+
+const SRC_REQ = createRequire(path.resolve('node_modules'));
+const recentStat = (stat: { ctimeMs: number, mtimeMs: number }): number => Math.max(stat.ctimeMs, stat.mtimeMs);
+
+export type CompilerLogEvent = [level: 'info' | 'debug' | 'warn', message: string];
+type WithLogger<T> = (log: (...ev: CompilerLogEvent) => void) => Promise<T>;
+type LogConfig = { args?: string[], basic?: boolean };
+const isCompilerLogEvent = (o: unknown): o is CompilerLogEvent => o !== null && o !== undefined && Array.isArray(o);
+
+const LEVELS = { warn: true, debug: /^debug$/.test(process.env.TRV_BUILD ?? ''), info: !/^warn$/.test(process.env.TRV_BUILD ?? '') };
+const SCOPE_MAX = 15;
+
+/**
+ * Transpile utilities for launching
+ */
+export class TranspileUtil {
+  static #optCache: Record<string, {}> = {};
+
+  static log(scope: string, args: string[], ...[level, msg]: CompilerLogEvent): void {
+    const message = msg.replaceAll(process.cwd(), '.');
+    LEVELS[level] && console.debug(new Date().toISOString(), `[${scope.padEnd(SCOPE_MAX, ' ')}]`, ...args, message);
+  }
+
+  /**
+   * With logger
+   */
+  static withLogger<T>(scope: string, op: WithLogger<T>): Promise<T>;
+  static withLogger<T>(scope: string, opts: LogConfig, op: WithLogger<T>): Promise<T>;
+  static withLogger<T>(scope: string, opts: LogConfig | WithLogger<T>, op?: WithLogger<T>): Promise<T> {
+    const cfg = { basic: true, ...typeof opts === 'function' ? {} : opts };
+    const go = typeof opts === 'function' ? opts : op!;
+    const log = this.log.bind(null, scope, cfg.args ?? []);
+    cfg.basic && log('debug', 'Started');
+    return go(log).finally(() => cfg.basic && log('debug', 'Completed'));
+  }
+
+  /**
+   * Write text file, and ensure folder exists
+   */
+  static writeTextFile = (file: string, content: string): Promise<void> =>
+    fs.mkdir(path.dirname(file), { recursive: true }).then(() => fs.writeFile(file, content));
+
+  /**
+   * Returns the compiler options
+   */
+  static async getCompilerOptions(ctx: ManifestContext): Promise<{}> {
+    if (!(ctx.workspacePath in this.#optCache)) {
+      let tsconfig = path.resolve(ctx.workspacePath, 'tsconfig.json');
+
+      if (!await fs.stat(tsconfig).then(_ => true, _ => false)) {
+        tsconfig = SRC_REQ.resolve('@travetto/compiler/tsconfig.trv.json');
+      }
+
+      const ts = (await import('typescript')).default;
+
+      const { options } = ts.parseJsonSourceFileConfigFileContent(
+        ts.readJsonConfigFile(tsconfig, ts.sys.readFile), ts.sys, ctx.workspacePath
+      );
+
+      options.allowJs = true;
+      options.resolveJsonModule = true;
+      options.sourceRoot = ctx.workspacePath;
+      options.rootDir = ctx.workspacePath;
+      options.outDir = path.resolve(ctx.workspacePath);
+
+      try {
+        options.module = ctx.moduleType === 'commonjs' ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext;
+      } catch { }
+
+      this.#optCache[ctx.workspacePath] = options;
+    }
+    return this.#optCache[ctx.workspacePath];
+  }
+
+  /**
+   * Output a file, support for ts, js, and package.json
+   */
+  static async transpileFile(ctx: ManifestContext, inputFile: string, outputFile: string): Promise<void> {
+    if (inputFile.endsWith('.ts') || inputFile.endsWith('.js')) {
+      const compilerOut = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules');
+
+      const text = (await fs.readFile(inputFile, 'utf8'))
+        .replace(/from '([.][^']+)'/g, (_, i) => `from '${i.replace(/[.]js$/, '')}.js'`)
+        .replace(/from '(@travetto\/(.*?))'/g, (_, i, s) => `from '${path.resolve(compilerOut, `${i}${s.includes('/') ? '.js' : '/__index__.js'}`)}'`);
+
+      const ts = (await import('typescript')).default;
+      const content = ts.transpile(text, await this.getCompilerOptions(ctx), inputFile);
+      await this.writeTextFile(outputFile, content);
+    } else if (inputFile.endsWith('package.json')) {
+      const pkg: Package = JSON.parse(await fs.readFile(inputFile, 'utf8'));
+      const main = pkg.main?.replace(/[.]ts$/, '.js');
+      const files = pkg.files?.map(x => x.replace('.ts', '.js'));
+
+      const content = JSON.stringify({ ...pkg, main, type: ctx.moduleType, files }, null, 2);
+      await this.writeTextFile(outputFile, content);
+    }
+  }
+
+  /**
+   * Scan directory to find all project sources for comparison
+   */
+  static async getModuleSources(ctx: ManifestContext, module: string, seed: string[]): Promise<ModFile[]> {
+    const inputFolder = (ctx.mainModule === module) ?
+      process.cwd() :
+      path.dirname(SRC_REQ.resolve(`${module}/package.json`));
+
+    const folders = seed.filter(x => !/[.]/.test(x)).map(x => path.resolve(inputFolder, x));
+    const files = seed.filter(x => /[.]/.test(x)).map(x => path.resolve(inputFolder, x));
+
+    while (folders.length) {
+      const sub = folders.pop();
+      if (!sub) {
+        continue;
+      }
+
+      for (const file of await fs.readdir(sub).catch(() => [])) {
+        if (file.startsWith('.')) {
+          continue;
+        }
+        const resolvedInput = path.resolve(sub, file);
+        const stat = await fs.stat(resolvedInput);
+
+        if (stat.isDirectory()) {
+          folders.push(resolvedInput);
+        } else if (file.endsWith('.d.ts')) {
+          // Do nothing
+        } else if (file.endsWith('.ts') || file.endsWith('.js')) {
+          files.push(resolvedInput);
+        }
+      }
+    }
+
+    const outputFolder = path.resolve(ctx.workspacePath, ctx.compilerFolder, 'node_modules', module);
+    const out: ModFile[] = [];
+    for (const input of files) {
+      const output = input.replace(inputFolder, outputFolder).replace(/[.]ts$/, '.js');
+      const inputTs = await fs.stat(input).then(recentStat, () => 0);
+      if (inputTs) {
+        const outputTs = await fs.stat(output).then(recentStat, () => 0);
+        await fs.mkdir(path.dirname(output), { recursive: true, });
+        out.push({ input, output, stale: inputTs > outputTs });
+      }
+    }
+
+    return out;
+  }
+
+  /**
+   * Run compiler
+   */
+  static async runCompiler(ctx: ManifestContext, manifest: ManifestRoot, changed: DeltaEvent[], watch = false): Promise<void> {
+    const compiler = path.resolve(ctx.workspacePath, ctx.compilerFolder);
+    const main = path.resolve(compiler, 'node_modules', '@travetto/compiler/support/compiler-entry.js');
+    const deltaFile = path.resolve(os.tmpdir(), `manifest-delta.${Date.now()}.${Math.random()}.json`);
+
+    const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(ev =>
+      path.resolve(manifest.workspacePath, manifest.modules[ev.module].sourceFolder, ev.file)
+    );
+
+    await this.writeTextFile(deltaFile, changedFiles.join('\n'));
+
+    await this.withLogger('compiler-exec', async log => {
+      await new Promise((res, rej) =>
+        cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
+          env: {
+            ...process.env,
+            TRV_MANIFEST: path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule),
+          },
+          stdio: [0, 1, 2, 'ipc'],
+        })
+          .on('message', msg => isCompilerLogEvent(msg) && log(...msg))
+          .on('exit', code => (code !== null && code > 0) ? rej() : res(null))
+      );
+    });
+  }
+}

package/tsconfig.trv.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "target": "esnext",
+    "moduleResolution": "node",
+    "lib": [
+      "es2022"
+    ],
+    "strict": true,
+    "esModuleInterop": true,
+    "strictPropertyInitialization": false,
+    "experimentalDecorators": true,
+    "noEmitOnError": false,
+    "noErrorTruncation": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "inlineSourceMap": false,
+    "removeComments": true,
+    "importHelpers": true,
+    "noEmitHelpers": true,
+    "outDir": "build/"
+  },
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 ArcSine Technologies
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/index.ts

@@ -1,3 +0,0 @@
-export * from './src/host';
-export * from './src/compiler';
-export * from './src/transformer';

package/src/host.ts

@@ -1,142 +0,0 @@
-import * as ts from 'typescript';
-import { readFileSync } from 'fs';
-import * as path from 'path';
-
-import { PathUtil, AppCache } from '@travetto/boot';
-import { SourceUtil } from '@travetto/boot/src/internal/source-util';
-import { SystemUtil } from '@travetto/boot/src/internal/system';
-import { TranspileUtil } from '@travetto/boot/src/internal/transpile-util';
-import { SourceIndex } from '@travetto/boot/src/internal/source';
-import { AppManifest } from '@travetto/base';
-
-/**
- * Manages the source code and typescript relationship.
- */
-export class SourceHost implements ts.CompilerHost {
-
-  #rootFiles = new Set<string>();
-  #hashes = new Map<string, number>();
-  #sources = new Map<string, ts.SourceFile>();
-  readonly contents = new Map<string, string>();
-
-  #trackFile(filename: string, content: string): void {
-    this.contents.set(filename, content);
-    this.#hashes.set(filename, SystemUtil.naiveHash(readFileSync(filename, 'utf8'))); // Get og content for hashing
-  }
-
-  getCanonicalFileName: (file: string) => string = (f: string) => f;
-  getCurrentDirectory: () => string = () => PathUtil.cwd;
-  getDefaultLibFileName: (opts: ts.CompilerOptions) => string = (opts: ts.CompilerOptions) => ts.getDefaultLibFileName(opts);
-  getNewLine: () => string = () => ts.sys.newLine;
-  useCaseSensitiveFileNames: () => boolean = () => ts.sys.useCaseSensitiveFileNames;
-  getDefaultLibLocation(): string {
-    return path.dirname(ts.getDefaultLibFilePath(TranspileUtil.compilerOptions));
-  }
-
-  /**
-   * Get root files
-   */
-  getRootFiles(): Set<string> {
-    if (!this.#rootFiles.size) {
-      // Only needed for compilation
-      this.#rootFiles = new Set(SourceIndex.findByFolders(AppManifest.source, 'required').map(x => x.file));
-    }
-    return this.#rootFiles;
-  }
-
-  /**
-   * Read file from disk, using the transpile pre-processor on .ts files
-   */
-  readFile(filename: string): string {
-    filename = PathUtil.toUnixTs(filename);
-    let content = ts.sys.readFile(filename);
-    if (content === undefined) {
-      throw new Error(`Unable to read file ${filename}`);
-    }
-    if (filename.endsWith(SourceUtil.EXT) && !filename.endsWith('.d.ts')) {
-      content = SourceUtil.preProcess(filename, content);
-    }
-    return content;
-  }
-
-  /**
-   * Write file to disk, and set value in cache as well
-   */
-  writeFile(filename: string, content: string): void {
-    filename = PathUtil.toUnixTs(filename);
-    this.#trackFile(filename, content);
-    AppCache.writeEntry(filename, content);
-  }
-
-  /**
-   * Fetch file
-   */
-  fetchFile(filename: string): void {
-    filename = PathUtil.toUnixTs(filename);
-    const cached = AppCache.readEntry(filename);
-    this.#trackFile(filename, cached);
-  }
-
-  /**
-   * Get a source file on demand
-   * @returns
-   */
-  getSourceFile(filename: string, __tgt: unknown, __onErr: unknown, force?: boolean): ts.SourceFile {
-    if (!this.#sources.has(filename) || force) {
-      const content = this.readFile(filename)!;
-      this.#sources.set(filename, ts.createSourceFile(filename, content ?? '',
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        (TranspileUtil.compilerOptions as ts.CompilerOptions).target!
-      ));
-    }
-    return this.#sources.get(filename)!;
-  }
-
-  /**
-   * See if a file exists
-   */
-  fileExists(filename: string): boolean {
-    filename = PathUtil.toUnixTs(filename);
-    return this.contents.has(filename) || ts.sys.fileExists(filename);
-  }
-
-  /**
-   * See if a file's hash code has changed
-   */
-  hashChanged(filename: string, content?: string): boolean {
-    content ??= readFileSync(filename, 'utf8');
-    // Let's see if they are really different
-    const hash = SystemUtil.naiveHash(content);
-    if (hash === this.#hashes.get(filename)) {
-      console.debug('Contents Unchanged', { filename });
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * Unload a file from the transpiler
-   */
-  unload(filename: string, unlink = true): void {
-    if (this.contents.has(filename)) {
-      AppCache.removeExpiredEntry(filename, unlink);
-
-      if (unlink && this.#hashes.has(filename)) {
-        this.#hashes.delete(filename);
-      }
-      this.#rootFiles.delete(filename);
-      this.contents.delete(filename);
-      this.#sources.delete(filename);
-    }
-  }
-
-  /**
-   * Reset the transpiler
-   */
-  reset(): void {
-    this.contents.clear();
-    this.#rootFiles.clear();
-    this.#hashes.clear();
-    this.#sources.clear();
-  }
-}

package/src/transformer.ts

@@ -1,75 +0,0 @@
-import * as ts from 'typescript';
-
-import { SourceIndex } from '@travetto/boot/src/internal/source';
-
-import {
-  NodeTransformer, VisitorFactory, TransformerState, getAllTransformers
-} from '@travetto/transformer'; // Narrow import to minimize scope
-
-type TransformerList = { before: ts.TransformerFactory<ts.SourceFile>[] };
-
-
-/**
- * Manages the typescript transformers
- */
-export class TransformerManager {
-
-  #cached: TransformerList | undefined;
-  #transformers: NodeTransformer<TransformerState>[] = [];
-
-  /**
-   * Read all transformers from disk under the pattern support/transformer.*
-   */
-  async init(): Promise<void> {
-    if (this.#cached) {
-      return;
-    }
-
-    // Modules
-    const found = SourceIndex.find({ folder: 'support', filter: /\/transformer.*[.]ts/ });
-
-    for (const entry of found) { // Exclude based on blacklist
-      this.#transformers.push(...getAllTransformers(await import(entry.file)));
-    }
-
-    console.debug('Transformers', {
-      order: this.#transformers.map(x => {
-        const flags = [
-          ...(x.target ? [] : ['all']),
-          ...(x.before ? ['before'] : []),
-          ...(x.after ? ['after'] : [])
-        ];
-        return { type: x.type, key: x.key, flags: flags.join(' ') };
-      })
-    });
-
-    // Prepare a new visitor factory with a given type checker
-  }
-
-  build(checker: ts.TypeChecker): void {
-    const visitor = new VisitorFactory(
-      (ctx, src) => new TransformerState(src, ctx.factory, checker),
-      this.#transformers
-    );
-
-    // Define transformers for the compiler
-    this.#cached = {
-      before: [visitor.visitor()]
-    };
-  }
-
-  /**
-   * Get typescript transformer object
-   */
-  getTransformers(): TransformerList | undefined {
-    return this.#cached!;
-  }
-
-  /**
-   * Reset state
-   */
-  reset(): void {
-    this.#transformers = [];
-    this.#cached = undefined;
-  }
-}

package/support/dynamic.compiler.ts

@@ -1,72 +0,0 @@
-import { AppManifest, Class, ShutdownManager } from '@travetto/base';
-import { RetargettingProxy } from '@travetto/base/src/internal/proxy';
-import { FsUtil, PathUtil } from '@travetto/boot';
-import { ModuleUtil } from '@travetto/boot/src/internal/module-util';
-import { ModuleManager } from '@travetto/boot/src/internal/module';
-
-import { FilePresenceManager } from '@travetto/watch';
-
-import { Compiler } from '../src/compiler';
-
-/**
- * Wraps the compiler supporting real-time changes to files
- */
-export function init($Compiler: Class<typeof Compiler>): typeof $Compiler {
-  /**
-   * Extending the $Compiler class to add some functionality
-   */
-  const Cls = class extends $Compiler {
-    #modules = new Map<string, RetargettingProxy<unknown>>();
-
-    constructor(...args: unknown[]) {
-      super(...args);
-
-      ShutdownManager.onUnhandled(err => {
-        if (err && (err.message ?? '').includes('Cannot find module')) { // Handle module reloading
-          console.error('Cannot find module', { error: err });
-          return true;
-        }
-      }, 0);
-
-      // Proxy all file loads
-      ModuleUtil.addHandler((name, mod) => {
-        if (name.includes(PathUtil.cwd) && !name.includes('node_modules') && /src\//.test(name)) {
-          if (!this.#modules.has(name)) {
-            this.#modules.set(name, new RetargettingProxy(mod));
-          } else {
-            this.#modules.get(name)!.setTarget(mod);
-          }
-          return this.#modules.get(name)!.get();
-        } else {
-          return mod;
-        }
-      });
-
-      // Clear target on unload
-      ModuleManager.onUnload(f => this.#modules.get(f)?.setTarget(null));
-
-      new FilePresenceManager(
-        [...AppManifest.source.local, ...AppManifest.source.common]
-          .map(x => `./${x}`)
-          .filter(x => FsUtil.existsSync(x)),
-        {
-          ignoreInitial: true,
-          validFile: x => x.endsWith('.ts') && !x.endsWith('.d.ts')
-        }
-      ).on('all', ({ event, entry }) => {
-        switch (event) {
-          case 'added': this.added(entry.file); break;
-          case 'removed': this.removed(entry.file); break;
-          case 'changed': this.changed(entry.file); break;
-        }
-      });
-    }
-
-    reset(): void {
-      super.reset();
-      this.#modules.clear();
-    }
-  };
-
-  return Cls;
-}

package/support/phase.init.ts

@@ -1,13 +0,0 @@
-/**
- * Responsible for initializing the compiler
- */
-export const init = {
-  key: '@trv:compiler/init',
-  after: ['@trv:base/init'],
-  before: ['@trv:base/transpile'],
-  action: async (): Promise<void> => {
-    // Overrides the require behavior
-    const { Compiler } = await import('../src/compiler');
-    await Compiler.init();
-  }
-};

package/support/phase.reset.ts

@@ -1,10 +0,0 @@
-/**
- * Responsible for resetting the compiler
- */
-export const init = {
-  key: '@trv:compiler/reset',
-  action: async (): Promise<void> => {
-    const { Compiler } = await import('../src/compiler');
-    Compiler.reset();
-  }
-};