ttsc 0.20.1 → 0.22.0

package/src/compiler/internal/project/readProjectConfig.ts

@@ -12,7 +12,14 @@ import { resolveProjectIdentity } from "./resolveProjectConfig";
  * Compiler option keys whose values are file-system paths that must be resolved
  * relative to the tsconfig that declares them, not the project root.
  */
-const PATH_OPTIONS = new Set(["baseUrl", "declarationDir", "rootDir"]);
+const PATH_OPTIONS = new Set([
+  "baseUrl",
+  "declarationDir",
+  "outFile",
+  "rootDir",
+  "tsBuildInfoFile",
+]);
+const CONFIG_DIR_TEMPLATE = "${configDir}";
 
 /**
  * Intermediate type used during `extends`-chain resolution before the result is
@@ -35,9 +42,11 @@ type ResolvedCompilerOptions = {
  *
  * Follows `extends` chains (including arrays) and merges compiler options with
  * later configs taking precedence. Path-typed options (`baseUrl`,
- * `declarationDir`, `rootDir`) are resolved relative to the config that
- * declares them. The `outDir` is resolved to an absolute path. Plugins are
- * inherited from the nearest ancestor that declares them.
+ * `declarationDir`, `outFile`, `rootDir`, `tsBuildInfoFile`) are resolved
+ * relative to the config that declares them. `${configDir}` paths are resolved
+ * against the final consuming config after the extends chain is merged. The
+ * `outDir` is resolved to an absolute path. Plugins are inherited from the
+ * nearest ancestor that declares them.
  */
 export function readProjectConfig(
   opts: ITtscProjectLocatorOptions = {},
@@ -45,7 +54,11 @@ export function readProjectConfig(
   const identity = resolveProjectIdentity(opts);
   const tsconfig = identity.physicalConfigPath;
   const root = identity.physicalProjectRoot;
-  const compilerOptions = readResolvedCompilerOptions(tsconfig);
+  const compilerOptions = readResolvedCompilerOptions(
+    tsconfig,
+    new Set(),
+    path.dirname(tsconfig),
+  );
   return {
     configPaths: compilerOptions.configPaths,
     compilerOptions: {
@@ -97,6 +110,7 @@ function resolveAbsolutePath(cwd: string, target: string): string {
 function readResolvedCompilerOptions(
   tsconfig: string,
   seen: Set<string> = new Set(),
+  configDir = path.dirname(tsconfig),
 ): ResolvedCompilerOptions {
   const canonical = resolveRealPath(tsconfig);
   if (seen.has(canonical)) {
@@ -112,7 +126,12 @@ function readResolvedCompilerOptions(
       };
     };
     const own = parsed.compilerOptions;
-    const base = resolveBaseCompilerOptions(canonical, parsed.extends, seen);
+    const base = resolveBaseCompilerOptions(
+      canonical,
+      parsed.extends,
+      seen,
+      configDir,
+    );
     const ownBaseDir = path.dirname(canonical);
     const ownOptionBaseDirs =
       own === undefined
@@ -130,6 +149,7 @@ function readResolvedCompilerOptions(
         ...(own ?? {}),
       },
       optionBaseDirs,
+      configDir,
     );
     const ownPlugins = own?.plugins;
     const pluginsDeclared = Array.isArray(ownPlugins);
@@ -142,7 +162,7 @@ function readResolvedCompilerOptions(
       options,
       outDir:
         typeof own?.outDir === "string"
-          ? resolveAbsolutePath(ownBaseDir, own.outDir)
+          ? resolveCompilerOptionPath(ownBaseDir, configDir, own.outDir)
           : base.outDir,
       pluginBaseDirs: pluginsDeclared
         ? plugins.map(() => ownBaseDir)
@@ -169,11 +189,13 @@ function resolveBaseCompilerOptions(
   tsconfig: string,
   extended: unknown,
   seen: Set<string>,
+  configDir: string,
 ): ResolvedCompilerOptions {
   if (typeof extended === "string") {
     return readResolvedCompilerOptions(
       resolveExtendsConfig(tsconfig, extended),
       seen,
+      configDir,
     );
   }
   if (!Array.isArray(extended)) {
@@ -201,6 +223,7 @@ function resolveBaseCompilerOptions(
     const current = readResolvedCompilerOptions(
       resolveExtendsConfig(tsconfig, specifier),
       seen,
+      configDir,
     );
     merged = {
       configPaths: uniquePaths([...merged.configPaths, ...current.configPaths]),
@@ -234,18 +257,49 @@ function uniquePaths(paths: readonly string[]): string[] {
 function resolvePathOptions(
   options: Record<string, unknown>,
   baseDirs: Record<string, string>,
+  configDir: string,
 ): Record<string, unknown> {
   const resolved = { ...options };
   for (const key of PATH_OPTIONS) {
     const value = resolved[key];
     const baseDir = baseDirs[key];
     if (typeof value === "string" && baseDir !== undefined) {
-      resolved[key] = resolveAbsolutePath(baseDir, value);
+      resolved[key] = resolveCompilerOptionPath(baseDir, configDir, value);
     }
   }
   return resolved;
 }
 
+/**
+ * Resolve an ordinary path from the config that declares it, but substitute a
+ * leading `${configDir}` from the final config consuming the merged preset.
+ */
+function resolveCompilerOptionPath(
+  declaringDir: string,
+  configDir: string,
+  value: string,
+): string {
+  if (
+    value.slice(0, CONFIG_DIR_TEMPLATE.length).toLowerCase() !==
+    CONFIG_DIR_TEMPLATE.toLowerCase()
+  ) {
+    return resolveAbsolutePath(declaringDir, value);
+  }
+  // The compiler picks the base directory from a case-insensitive prefix but
+  // substitutes only the exact spelling, so a mis-cased template still anchors
+  // here while staying in the path as written. Both halves are reproduced: this
+  // function exists to say where the compiler will put the file, and a value
+  // the compiler leaves literal is not ours to interpret.
+  //
+  // The exact spelling becomes "./" before the result is normalized, which
+  // keeps the value relative even when its remainder resembles an absolute
+  // Windows path. Either config-file separator is accepted on every host.
+  const substituted = value.startsWith(CONFIG_DIR_TEMPLATE)
+    ? `./${value.slice(CONFIG_DIR_TEMPLATE.length)}`
+    : value;
+  return resolveAbsolutePath(configDir, substituted.replaceAll("\\", "/"));
+}
+
 /**
  * Resolve an `extends` specifier to an absolute path using the same rules as
  * TypeScript's config resolution:

package/src/compiler/internal/residentCheckProcess.ts

@@ -0,0 +1,279 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { type Interface, createInterface } from "node:readline";
+
+import type { TtscBuildResult } from "../../structures/internal/TtscBuildResult";
+import { normalizeRequestTimeoutMs } from "./residentTransformProcess";
+
+const STDERR_TAIL_LIMIT = 64 * 1024;
+const REPLY_ECHO_LIMIT = 200;
+const TERMINATION_GRACE_MS = 1_000;
+
+export interface ResidentCheckProcessOptions {
+  args: readonly string[];
+  binary: string;
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  requestTimeoutMs?: number;
+}
+
+export interface ResidentCheckRequest {
+  changed?: readonly string[];
+  external?: readonly string[];
+  invalidate?: boolean;
+}
+
+export interface ResidentCheckTelemetry {
+  pid: number;
+  programLoads: number;
+  programUpdates: number;
+  reused: boolean;
+}
+
+export type ResidentCheckResult = TtscBuildResult & {
+  telemetry: ResidentCheckTelemetry;
+};
+
+type PendingRequest = {
+  reject(reason: Error): void;
+  resolve(result: ResidentCheckResult): void;
+  timer: NodeJS.Timeout;
+};
+
+/**
+ * FIFO JSON-line client for a check-stage `check-serve` sidecar.
+ *
+ * A watch session serializes cycles, but the client still queues replies so a
+ * caller cannot accidentally pair a late response with the next request. Any
+ * framing failure retires the process; the launcher then falls back to the
+ * ordinary one-shot command for that cycle.
+ */
+export class ResidentCheckProcess {
+  private readonly child: ChildProcess;
+  private readonly pending: PendingRequest[] = [];
+  private readonly reader: Interface;
+  private readonly requestTimeoutMs: number;
+  private failure: Error | undefined;
+  private stderr = "";
+
+  public constructor(options: ResidentCheckProcessOptions) {
+    this.requestTimeoutMs = normalizeRequestTimeoutMs(options.requestTimeoutMs);
+    this.child = spawn(options.binary, [...options.args], {
+      cwd: options.cwd,
+      env: options.env,
+      windowsHide: true,
+    });
+    const stdin = this.child.stdin;
+    const stdout = this.child.stdout;
+    if (stdin === null || stdout === null) {
+      this.child.kill();
+      throw new Error("ttsc: resident check host has no stdio pipes");
+    }
+    this.reader = createInterface({ input: stdout });
+    this.reader.on("line", (line) => this.onLine(line));
+    this.reader.on("close", () => {
+      if (this.failure === undefined) this.fail(this.exitError());
+    });
+    this.child.stderr?.on("data", (chunk: Buffer | string) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      this.stderr = (this.stderr + text).slice(-STDERR_TAIL_LIMIT);
+    });
+    this.child.on("error", (error) => this.fail(error));
+    stdin.on("error", (error) => this.fail(error));
+    stdout.on("error", (error) => this.fail(error));
+    this.child.stderr?.on("error", () => {});
+  }
+
+  public request(payload: ResidentCheckRequest): Promise<ResidentCheckResult> {
+    if (this.failure !== undefined) return Promise.reject(this.failure);
+    const stdin = this.child.stdin;
+    if (stdin === null || stdin.destroyed) {
+      return Promise.reject(
+        new Error("ttsc: resident check host stdin is closed"),
+      );
+    }
+    let line: string;
+    try {
+      line = `${JSON.stringify(payload)}\n`;
+    } catch (error) {
+      return Promise.reject(asError(error));
+    }
+    return new Promise<ResidentCheckResult>((resolve, reject) => {
+      const pending: PendingRequest = {
+        reject,
+        resolve,
+        timer: setTimeout(() => {
+          const detail = stderrSuffix(this.stderr);
+          const timeout = new Error(
+            `ttsc: resident check request timed out after ${String(
+              this.requestTimeoutMs,
+            )} ms${detail}`,
+          );
+          this.settle(pending, timeout);
+          this.fail(timeout);
+        }, this.requestTimeoutMs),
+      };
+      pending.timer.unref();
+      this.pending.push(pending);
+      try {
+        stdin.write(line, (error) => {
+          if (error === null || error === undefined) return;
+          this.settle(pending, error);
+          this.fail(error);
+        });
+      } catch (error) {
+        const reason = asError(error);
+        this.settle(pending, reason);
+        this.fail(reason);
+      }
+    });
+  }
+
+  public dispose(): void {
+    if (this.failure !== undefined) return;
+    this.fail(new Error("ttsc: resident check host disposed"));
+  }
+
+  private onLine(line: string): void {
+    if (this.failure !== undefined || line.trim().length === 0) return;
+    const pending = this.pending[0];
+    if (pending === undefined) {
+      this.fail(
+        new Error("ttsc: resident check host sent an unsolicited reply"),
+      );
+      return;
+    }
+    const result = parseResidentCheckResult(line);
+    if (result === undefined) {
+      const error = new Error(
+        `ttsc: resident check host sent a malformed reply: ${echoLine(line)}`,
+      );
+      this.settle(pending, error);
+      this.fail(error);
+      return;
+    }
+    this.settle(pending, result);
+  }
+
+  private settle(
+    pending: PendingRequest,
+    result: Error | ResidentCheckResult,
+  ): void {
+    const index = this.pending.indexOf(pending);
+    if (index === -1) return;
+    this.pending.splice(index, 1);
+    clearTimeout(pending.timer);
+    if (result instanceof Error) pending.reject(result);
+    else pending.resolve(result);
+  }
+
+  private fail(error: Error): void {
+    if (this.failure !== undefined) return;
+    this.failure = error;
+    while (this.pending.length !== 0) {
+      this.settle(this.pending[0]!, error);
+    }
+    this.terminate();
+  }
+
+  private terminate(): void {
+    const stdin = this.child.stdin;
+    if (stdin !== null && !stdin.destroyed) stdin.destroy();
+    if (this.child.exitCode !== null || this.child.signalCode !== null) return;
+    try {
+      this.child.kill();
+    } catch {
+      return;
+    }
+    const force = setTimeout(() => {
+      if (this.child.exitCode !== null || this.child.signalCode !== null)
+        return;
+      try {
+        this.child.kill("SIGKILL");
+      } catch {
+        // The host exited between the liveness check and forced termination.
+      }
+    }, TERMINATION_GRACE_MS);
+    force.unref();
+    this.child.once("exit", () => clearTimeout(force));
+  }
+
+  private exitError(): Error {
+    const detail = this.stderr.trim();
+    if (detail.length !== 0) return new Error(detail);
+    const signal =
+      this.child.signalCode === null ? "" : `, signal ${this.child.signalCode}`;
+    return new Error(
+      `ttsc: resident check host exited (code ${
+        this.child.exitCode ?? "null"
+      }${signal})`,
+    );
+  }
+}
+
+function parseResidentCheckResult(
+  line: string,
+): ResidentCheckResult | undefined {
+  let value: unknown;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return undefined;
+  }
+  if (
+    !isRecord(value) ||
+    typeof value.status !== "number" ||
+    !Number.isInteger(value.status)
+  ) {
+    return undefined;
+  }
+  if (typeof value.stdout !== "string" || typeof value.stderr !== "string") {
+    return undefined;
+  }
+  const telemetry = value.telemetry;
+  if (
+    !isRecord(telemetry) ||
+    typeof telemetry.pid !== "number" ||
+    !Number.isSafeInteger(telemetry.pid) ||
+    typeof telemetry.programLoads !== "number" ||
+    !Number.isSafeInteger(telemetry.programLoads) ||
+    typeof telemetry.programUpdates !== "number" ||
+    !Number.isSafeInteger(telemetry.programUpdates) ||
+    typeof telemetry.reused !== "boolean"
+  ) {
+    return undefined;
+  }
+  return {
+    diagnostics: [],
+    status: value.status,
+    stderr: value.stderr,
+    stdout: value.stdout,
+    telemetry: {
+      pid: telemetry.pid,
+      programLoads: telemetry.programLoads,
+      programUpdates: telemetry.programUpdates,
+      reused: telemetry.reused,
+    },
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function echoLine(line: string): string {
+  const trimmed = line.trim();
+  return JSON.stringify(
+    trimmed.length <= REPLY_ECHO_LIMIT
+      ? trimmed
+      : `${trimmed.slice(0, REPLY_ECHO_LIMIT)}…`,
+  );
+}
+
+function stderrSuffix(stderr: string): string {
+  const detail = stderr.trim();
+  return detail.length === 0 ? "" : `: ${detail}`;
+}
+
+function asError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error));
+}

package/src/compiler/internal/resolveEmittedJavaScript.ts

@@ -10,7 +10,8 @@ import { isOutsideRelativePath } from "./paths";
  *
  * 1. Try to derive the exact output path by mirroring the source's relative
  *    position inside `projectRoot` into `outDir`, applying the correct JS
- *    extension (`.js` / `.mjs` / `.cjs`). Use this path if it exists on disk.
+ *    extension (`.js` / `.jsx` / `.mjs` / `.cjs`). Use this path if it exists
+ *    on disk.
  * 2. Fall back to scoring each candidate in `emittedFiles` (or a recursive
  *    directory scan of `outDir`) by the number of trailing path-stem segments
  *    shared with the source file name, and pick the highest-scoring existing
@@ -25,13 +26,23 @@ export function resolveEmittedJavaScript(options: {
   projectRoot: string;
   sourceFile: string;
 }): string | null {
-  const exact = resolveExactEmittedFile(
+  const exact = resolveExactEmittedFiles(
     options.outDir,
     options.projectRoot,
     options.sourceFile,
   );
-  if (exact && fs.existsSync(exact)) {
-    return exact;
+  const emitted = new Set(
+    options.emittedFiles?.map((file) => emittedPathKey(file)) ?? [],
+  );
+  for (const candidate of exact) {
+    if (emitted.has(emittedPathKey(candidate)) && fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  for (const candidate of exact) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
   }
 
   // Score the pre-computed emit list first (cheap). When it yields nothing —
@@ -81,22 +92,24 @@ function bestStemMatch(
 
 /**
  * Derive the exact output path for `sourceFile` by mirroring its position
- * relative to `projectRoot` into `outDir`. Returns `null` when the source is
- * not inside the project root or when the path cannot be determined.
+ * relative to `projectRoot` into `outDir`. Returns no candidates when the
+ * source is not inside the project root or when the path cannot be determined.
  */
-function resolveExactEmittedFile(
+function resolveExactEmittedFiles(
   outDir: string,
   projectRoot: string,
   sourceFile: string,
-): string | null {
+): string[] {
   const relative = path.relative(projectRoot, sourceFile);
   if (relative === "" || isOutsideRelativePath(relative)) {
-    return null;
+    return [];
   }
-  return path.resolve(
-    outDir,
-    relative.slice(0, relative.length - path.extname(relative).length) +
-      emittedJavaScriptExtension(sourceFile),
+  const stem = relative.slice(
+    0,
+    relative.length - path.extname(relative).length,
+  );
+  return emittedJavaScriptExtensions(sourceFile).map((extension) =>
+    path.resolve(outDir, stem + extension),
   );
 }
 
@@ -149,21 +162,30 @@ function sharedSourceStemSegments(outPath: string, srcPath: string): number {
 }
 
 /**
- * Map a TypeScript source extension to its JavaScript output counterpart.
- * `.mts` → `.mjs`, `.cts` → `.cjs`, everything else → `.js`.
+ * Map a source extension to every JavaScript output counterpart tsgo can use.
+ * JSX preserve mode writes `.tsx`/`.jsx` inputs as `.jsx`; all other JSX modes
+ * write `.js`.
  */
-function emittedJavaScriptExtension(filename: string): string {
+function emittedJavaScriptExtensions(filename: string): readonly string[] {
   switch (path.extname(filename).toLowerCase()) {
     case ".mts":
-      return ".mjs";
+      return [".mjs"];
     case ".cts":
-      return ".cjs";
+      return [".cjs"];
+    case ".tsx":
+    case ".jsx":
+      return [".js", ".jsx"];
     default:
-      return ".js";
+      return [".js"];
   }
 }
 
-/** Return true when `filename` has a `.js`, `.mjs`, or `.cjs` extension. */
+/** Return true when `filename` has a JavaScript output extension. */
 function isJavaScriptOutput(filename: string): boolean {
-  return /\.(?:[cm]?js)$/i.test(filename);
+  return /\.(?:[cm]?js|jsx)$/i.test(filename);
+}
+
+function emittedPathKey(filename: string): string {
+  const resolved = path.resolve(filename);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }