@travetto/compiler 8.0.0-alpha.2 → 8.0.0-alpha.21

package/src/state.ts

@@ -1,25 +1,29 @@
-import type { CompilerHost, SourceFile, CompilerOptions, Program, ScriptTarget } from 'typescript';
-
-import { path, ManifestModuleUtil, type ManifestModule, type ManifestRoot, type ManifestIndex, type ManifestModuleFolderType } from '@travetto/manifest';
+import fs from 'node:fs';
+
+import type { CompilerHost, CompilerOptions, Program, ScriptTarget, SourceFile } from 'typescript';
+
+import {
+  type ManifestIndex,
+  type ManifestModule,
+  type ManifestModuleFolderType,
+  ManifestModuleUtil,
+  type ManifestRoot,
+  path
+} from '@travetto/manifest';
 import type { TransformerManager } from '@travetto/transformer';
 
-import { CompilerUtil } from './util.ts';
-import type { CompileEmitError, CompileStateEntry } from './types.ts';
 import { CommonUtil } from './common.ts';
 import { tsProxy as ts, tsProxyInit } from './ts-proxy.ts';
-
+import type { CompileStateEntry } from './types.ts';
+import { CompilerUtil } from './util.ts';
 
 const TYPINGS_FOLDER_KEYS = new Set<ManifestModuleFolderType>(['$index', 'support', 'src', '$package']);
 
 export class CompilerState implements CompilerHost {
-
   static async get(idx: ManifestIndex): Promise<CompilerState> {
     return new CompilerState().init(idx);
   }
 
-  /** @private */
-  constructor() { }
-
   #outputPath: string;
   #typingsPath: string;
   #sourceFiles = new Set<string>();
@@ -40,10 +44,43 @@ export class CompilerState implements CompilerHost {
   #program: Program;
 
   #readFile(sourceFile: string): string | undefined {
-    return ts.sys.readFile(this.#sourceToEntry.get(sourceFile)?.sourceFile ?? sourceFile);
+    const location = this.#sourceToEntry.get(sourceFile)?.sourceFile ?? sourceFile;
+    try {
+      return ts.sys.readFile(location, 'utf8');
+    } catch {
+      try {
+        return fs.readFileSync(location, 'utf8');
+      } catch {}
+    }
+    return undefined;
+  }
+
+  #writeFile(location: string, text: string, bom?: boolean): void {
+    try {
+      ts.sys.writeFile(location, text, bom);
+    } catch {
+      fs.mkdirSync(path.dirname(location), { recursive: true });
+      fs.writeFileSync(location, text, 'utf8');
+    }
+  }
+
+  #fileExists(location: string): boolean {
+    try {
+      return ts.sys.fileExists(location);
+    } catch {
+      return fs.existsSync(location);
+    }
   }
 
-  #writeExternalTypings(location: string, text: string, bom: boolean): void {
+  #directoryExists(location: string): boolean {
+    try {
+      return ts.sys.directoryExists(location);
+    } catch {
+      return fs.existsSync(location);
+    }
+  }
+
+  #writeExternalTypings(location: string, text: string, bom?: boolean): void {
     let core = location.replace('.map', '');
     if (!this.#outputToEntry.has(core)) {
       core = core.replace(ManifestModuleUtil.TYPINGS_EXT_REGEX, ManifestModuleUtil.OUTPUT_EXT);
@@ -52,7 +89,7 @@ export class CompilerState implements CompilerHost {
     if (entry) {
       const relative = this.#manifestIndex.getFromSource(entry.sourceFile)?.relativeFile;
       if (relative && TYPINGS_FOLDER_KEYS.has(ManifestModuleUtil.getFolderKey(relative))) {
-        ts.sys.writeFile(location.replace(this.#outputPath, this.#typingsPath), text, bom);
+        this.#writeFile(location.replace(this.#outputPath, this.#typingsPath), text, bom);
       }
     }
   }
@@ -60,7 +97,7 @@ export class CompilerState implements CompilerHost {
   async #initCompilerOptions(): Promise<CompilerOptions> {
     const tsconfigFile = CommonUtil.resolveWorkspace(this.#manifest, 'tsconfig.json');
     if (!ts.sys.fileExists(tsconfigFile)) {
-      ts.sys.writeFile(tsconfigFile, JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }, null, 2));
+      this.#writeFile(tsconfigFile, JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }, null, 2));
     }
 
     const { options } = ts.parseJsonSourceFileConfigFileContent(
@@ -72,9 +109,7 @@ export class CompilerState implements CompilerHost {
     return {
       ...options,
       noEmit: false,
-      emitDeclarationOnly: false,
       allowJs: true,
-      resolveJsonModule: true,
       sourceRoot: this.#manifest.workspace.path,
       rootDir: this.#manifest.workspace.path,
       moduleResolution: ts.ModuleResolutionKind.Bundler,
@@ -95,14 +130,14 @@ export class CompilerState implements CompilerHost {
     for (const module of this.#modules) {
       const base = module?.files ?? {};
       const files = [
-        ...base.bin ?? [],
-        ...base.src ?? [],
-        ...base.support ?? [],
-        ...base.doc ?? [],
-        ...base.test ?? [],
-        ...base.$transformer ?? [],
-        ...base.$index ?? [],
-        ...base.$package ?? []
+        ...(base.bin ?? []),
+        ...(base.src ?? []),
+        ...(base.support ?? []),
+        ...(base.doc ?? []),
+        ...(base.test ?? []),
+        ...(base.$transformer ?? []),
+        ...(base.$index ?? []),
+        ...(base.$package ?? [])
       ];
       for (const [file, type] of files) {
         if (ManifestModuleUtil.isSourceType(type)) {
@@ -133,52 +168,80 @@ export class CompilerState implements CompilerHost {
   }
 
   getArbitraryInputFile(): string {
-    const randomSource = this.#manifestIndex.getWorkspaceModules()
-      .filter(module => module.files.src?.length)[0]
-      .files.src[0].sourceFile;
+    const randomSource = this.#manifestIndex.getWorkspaceModules().filter(module => module.files.src?.length)[0].files.src[0].sourceFile;
 
     return this.getBySource(randomSource)!.sourceFile;
   }
 
-  async createProgram(force = false): Promise<Program> {
+  async getProgram(force = false): Promise<Program> {
     if (force || !this.#program) {
-      this.#program = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram: this.#program });
+      await this.initializeTypescript();
+      this.#program = ts.createProgram({
+        rootNames: this.getAllFiles(),
+        host: this,
+        options: this.#compilerOptions,
+        oldProgram: this.#program
+      });
       this.#transformerManager.init(this.#program.getTypeChecker());
       await CommonUtil.queueMacroTask();
     }
     return this.#program;
   }
 
-  async compileSourceFile(sourceFile: string, needsNewProgram = false): Promise<CompileEmitError | undefined> {
+  async compileSourceFile(sourceFile: string, needsNewProgram = false): Promise<string[] | undefined> {
     const output = this.#sourceToEntry.get(sourceFile)?.outputFile;
     if (!output) {
       return;
     }
 
-    const program = await this.createProgram(needsNewProgram);
-    try {
-      switch (ManifestModuleUtil.getFileType(sourceFile)) {
-        case 'typings':
-        case 'package-json':
-          this.writeFile(output, this.readFile(sourceFile)!, false), undefined;
-          break;
-        case 'js':
-          this.writeFile(output, ts.transpile(this.readFile(sourceFile)!, this.#compilerOptions), false);
-          break;
-        case 'ts': {
-          const result = program.emit(
-            program.getSourceFile(sourceFile)!,
-            (...args) => this.writeFile(args[0], args[1], args[2]), undefined, false,
-            this.#transformerManager.get()
-          );
-          return result?.diagnostics?.length ? result.diagnostics : undefined;
-        }
+    switch (ManifestModuleUtil.getFileType(sourceFile)) {
+      case 'package-json': {
+        const text = this.readFile(sourceFile)!;
+        const finalText = CompilerUtil.rewritePackageJSON(this.#manifest, text);
+        const location = this.#tscOutputFileToOuptut.get(output) ?? output;
+        this.#writeFile(location, finalText);
+        this.#writeExternalTypings(location, finalText);
+        break;
       }
-    } catch (error) {
-      if (error instanceof Error) {
-        return error;
-      } else {
-        throw error;
+      case 'js':
+      case 'typings':
+        this.writeFile(output, this.readFile(sourceFile)!);
+        break;
+      case 'ts': {
+        const program = await this.getProgram(needsNewProgram);
+        const tsSourceFile = program.getSourceFile(sourceFile)!;
+        program.emit(
+          tsSourceFile,
+          (...args) => this.writeFile(args[0], args[1], args[2]),
+          undefined,
+          false,
+          this.#transformerManager.get()
+        );
+        return [
+          ...program.getSemanticDiagnostics(tsSourceFile),
+          ...program.getSyntacticDiagnostics(tsSourceFile),
+          ...program.getDeclarationDiagnostics(tsSourceFile)
+        ]
+          .filter(d => d.category === ts.DiagnosticCategory.Error)
+          .map(diag => {
+            let message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+            if (
+              message.includes("is not under 'rootDir'") ||
+              message.includes("does not exist on type 'EnvDataCombinedType'") ||
+              message.startsWith('Could not find a declaration file for module') ||
+              message.startsWith("Cannot find module '@travetto") ||
+              message.startsWith("This JSX tag requires the module path '@travetto") ||
+              message.startsWith("JSX element implicitly has type 'any'")
+            ) {
+              return '';
+            }
+            if (diag.file) {
+              const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start!);
+              message = `${line + 1}:${character + 1} -- ${message}`;
+            }
+            return message;
+          })
+          .filter(Boolean);
       }
     }
   }
@@ -189,7 +252,11 @@ export class CompilerState implements CompilerHost {
 
   isCompilerFile(file: string): boolean {
     const entry = this.getBySource(file);
-    return (entry?.moduleFile && ManifestModuleUtil.getFileRole(entry.moduleFile) === 'compile') || entry?.module.roles.includes('compile') || false;
+    return (
+      (entry?.moduleFile && ManifestModuleUtil.getFileRole(entry.moduleFile) === 'compile') ||
+      entry?.module.roles.includes('compile') ||
+      false
+    );
   }
 
   registerInput(module: ManifestModule, moduleFile: string): CompileStateEntry {
@@ -263,40 +330,44 @@ export class CompilerState implements CompilerHost {
   }
 
   /* Start Compiler Host */
-  getCanonicalFileName(file: string): string { return file; }
-  getCurrentDirectory(): string { return this.#manifest.workspace.path; }
-  getDefaultLibFileName(options: CompilerOptions): string { return ts.getDefaultLibFileName(options); }
-  getNewLine(): string { return ts.sys.newLine; }
-  useCaseSensitiveFileNames(): boolean { return ts.sys.useCaseSensitiveFileNames; }
-  getDefaultLibLocation(): string { return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions)); }
+  getCanonicalFileName(file: string): string {
+    return file;
+  }
+  getCurrentDirectory(): string {
+    return this.#manifest.workspace.path;
+  }
+  getDefaultLibFileName(options: CompilerOptions): string {
+    return ts.getDefaultLibFileName(options);
+  }
+  getNewLine(): string {
+    return ts.sys.newLine;
+  }
+  useCaseSensitiveFileNames(): boolean {
+    return ts.sys.useCaseSensitiveFileNames;
+  }
+  getDefaultLibLocation(): string {
+    return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions));
+  }
 
   fileExists(sourceFile: string): boolean {
-    return this.#sourceToEntry.has(sourceFile) || ts.sys.fileExists(sourceFile);
+    return this.#sourceToEntry.has(sourceFile) || this.#fileExists(sourceFile);
   }
 
   directoryExists(sourceDirectory: string): boolean {
-    return this.#sourceDirectory.has(sourceDirectory) || ts.sys.directoryExists(sourceDirectory);
+    return this.#sourceDirectory.has(sourceDirectory) || this.#directoryExists(sourceDirectory);
   }
 
-  writeFile(
-    outputFile: string,
-    text: string,
-    bom: boolean
-  ): void {
-    if (outputFile.endsWith('package.json')) {
-      text = CompilerUtil.rewritePackageJSON(this.#manifest, text);
-    }
-
+  writeFile(outputFile: string, text: string, bom?: boolean): void {
     // JSX runtime shenanigans
     text = text.replace(/support\/jsx-runtime"/g, 'support/jsx-runtime.js"');
 
     const location = this.#tscOutputFileToOuptut.get(outputFile) ?? outputFile;
 
-    if (ManifestModuleUtil.TYPINGS_WITH_MAP_EXT_REGEX.test(outputFile) || outputFile.endsWith('package.json')) {
+    if (ManifestModuleUtil.TYPINGS_WITH_MAP_EXT_REGEX.test(outputFile)) {
       this.#writeExternalTypings(location, text, bom);
     }
 
-    ts.sys.writeFile(location, text, bom);
+    this.#writeFile(location, text, bom);
   }
 
   readFile(sourceFile: string): string | undefined {
@@ -311,4 +382,4 @@ export class CompilerState implements CompilerHost {
       return ts.createSourceFile(sourceFile, content ?? '', language);
     });
   }
-}
+}

package/src/ts-proxy.ts

@@ -1,11 +1,14 @@
-/* eslint-disable @typescript-eslint/consistent-type-assertions */
 import type ts from 'typescript';
 
 let state: typeof ts | undefined;
-export const tsProxyInit = (): Promise<unknown> => import('typescript').then(module => { state = module.default; });
+let promise: Promise<unknown> | undefined;
+export const tsProxyInit = (): Promise<unknown> =>
+  (promise ??= import('typescript').then(module => {
+    state = module.default;
+  }));
 
 export const tsProxy = new Proxy({}!, {
   get(_, prop: string): unknown {
     return state![prop as keyof typeof ts];
   }
-}) as typeof ts;
+}) as typeof ts;

package/src/types.ts

@@ -1,29 +1,32 @@
-import type ts from 'typescript';
-
 import type { ChangeEventType, ManifestModule } from '@travetto/manifest';
 
 export type CompilerStateType = 'startup' | 'init' | 'compile-start' | 'compile-end' | 'watch-start' | 'watch-end' | 'reset' | 'closed';
 export type CompilerLogLevel = 'info' | 'debug' | 'warn' | 'error';
 
-export type CompileEmitError = Error | readonly ts.Diagnostic[];
-export type CompileEmitter = (file: string, newProgram?: boolean) => Promise<CompileEmitError | undefined>;
-export type CompileEmitEvent = { file: string, i: number, total: number, error?: CompileEmitError, duration: number };
-export type CompileStateEntry = { sourceFile: string, tscOutputFile: string, outputFile?: string, module: ManifestModule, import: string, moduleFile: string };
-export type CompilerWatchEvent = { action: ChangeEventType, file: string, entry: CompileStateEntry, moduleFile: string };
+export type CompileEmitEvent = { file: string; i: number; total: number; errors?: string[]; duration: number };
+export type CompileStateEntry = {
+  sourceFile: string;
+  tscOutputFile: string;
+  outputFile?: string;
+  module: ManifestModule;
+  import: string;
+  moduleFile: string;
+};
+export type CompilerWatchEvent = { action: ChangeEventType; file: string; entry: CompileStateEntry; moduleFile: string };
 
-export type CompilerChangeEvent = { file: string, action: ChangeEventType, output: string, module: string, import: string, time: number };
-export type CompilerLogEvent = { level: CompilerLogLevel, message: string, time?: number, args?: unknown[], scope?: string };
-export type CompilerProgressEvent = { idx: number, total: number, message: string, operation: 'compile', complete?: boolean };
-export type CompilerStateEvent = { state: CompilerStateType, extra?: Record<string, unknown> };
-export type FileChangeEvent = { files: { file: string, action: ChangeEventType }[], time: number };
+export type CompilerChangeEvent = { file: string; action: ChangeEventType; output: string; module: string; import: string; time: number };
+export type CompilerLogEvent = { level: CompilerLogLevel; message: string; time?: number; args?: unknown[]; scope?: string };
+export type CompilerProgressEvent = { idx: number; total: number; message: string; operation: 'compile'; complete?: boolean };
+export type CompilerStateEvent = { state: CompilerStateType; extra?: Record<string, unknown> };
+export type FileChangeEvent = { files: { file: string; action: ChangeEventType }[]; time: number };
 
 export type CompilerEvent =
-  { type: 'file', payload: FileChangeEvent } |
-  { type: 'change', payload: CompilerChangeEvent } |
-  { type: 'log', payload: CompilerLogEvent } |
-  { type: 'progress', payload: CompilerProgressEvent } |
-  { type: 'state', payload: CompilerStateEvent } |
-  { type: 'all', payload: unknown };
+  | { type: 'file'; payload: FileChangeEvent }
+  | { type: 'change'; payload: CompilerChangeEvent }
+  | { type: 'log'; payload: CompilerLogEvent }
+  | { type: 'progress'; payload: CompilerProgressEvent }
+  | { type: 'state'; payload: CompilerStateEvent }
+  | { type: 'all'; payload: unknown };
 
 export type CompilerEventType = CompilerEvent['type'];
 export type CompilerEventPayload<V> = (CompilerEvent & { type: V })['payload'];
@@ -39,4 +42,4 @@ export type CompilerServerInfo = {
   env?: Record<string, string>;
 };
 
-export class CompilerReset extends Error { }
+export class CompilerReset extends Error {}

package/src/util.ts

@@ -1,15 +1,9 @@
 import { ManifestModuleUtil, type ManifestRoot, type Package } from '@travetto/manifest';
 
-import type { CompileEmitError } from './types.ts';
-import { tsProxy as ts } from './ts-proxy.ts';
-
-const nativeCwd = process.cwd();
-
 /**
  * Standard utilities for compiler
  */
 export class CompilerUtil {
-
   /**
    * Rewrites the package.json to target output file names, and pins versions
    * @param manifest
@@ -38,32 +32,6 @@ export class CompilerUtil {
     return JSON.stringify(pkg, null, 2);
   }
 
-  /**
-   * Build transpilation error
-   * @param filename The name of the file
-   * @param diagnostics The diagnostic errors
-   */
-  static buildTranspileError(filename: string, diagnostics: CompileEmitError): Error {
-    if (diagnostics instanceof Error) {
-      return diagnostics;
-    }
-
-    const errors: string[] = diagnostics.slice(0, 5).map(diag => {
-      const message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
-      if (diag.file) {
-        const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start!);
-        return ` @ ${diag.file.fileName.replace(nativeCwd, '.')}(${line + 1}, ${character + 1}): ${message}`;
-      } else {
-        return ` ${message}`;
-      }
-    });
-
-    if (diagnostics.length > 5) {
-      errors.push(`${diagnostics.length - 5} more ...`);
-    }
-    return new Error(`Transpiling ${filename.replace(nativeCwd, '.')} failed: \n${errors.join('\n')}`);
-  }
-
   /**
    * Naive hashing
    */
@@ -71,10 +39,9 @@ export class CompilerUtil {
     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);
   }
-}
+}