ttsc 0.6.0 → 0.7.0

package/src/compiler/internal/compileProjectInMemory.ts

@@ -0,0 +1,189 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import type { ITtscCompilerContext } from "../../structures/ITtscCompilerContext";
+import type { ITtscCompilerDiagnostic } from "../../structures/ITtscCompilerDiagnostic";
+import type { ITtscProjectPluginConfig } from "../../structures/ITtscProjectPluginConfig";
+import type { ITtscParsedProjectConfig } from "../../structures/internal/ITtscParsedProjectConfig";
+import type { TtscBuildResult } from "../../structures/internal/TtscBuildResult";
+import { buildNativeCompiler } from "./buildNativeCompiler";
+import { readProjectConfig } from "./project/readProjectConfig";
+import { runBuild } from "./runBuild";
+
+/** Compile a project and capture emitted files without writing to the project tree. */
+export function compileProjectInMemory(options: ITtscCompilerContext): {
+  output: Record<string, string>;
+  result: TtscBuildResult;
+} {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const project = readProjectConfig({
+    cwd,
+    tsconfig: options.tsconfig,
+  });
+  if (configuredPlugins(options, project).length !== 0) {
+    return compileProjectWithPlugins(options, cwd, project);
+  }
+  const tsconfig = project.path;
+  const binary = buildNativeCompiler({
+    cacheBaseDir: path.dirname(tsconfig),
+    cacheDir: options.cacheDir,
+    packageRoot: packageRootDir(),
+  });
+  const res = spawnSync(
+    binary,
+    ["api-compile", "--cwd", path.dirname(tsconfig), "--tsconfig", tsconfig],
+    {
+      cwd: path.dirname(tsconfig),
+      encoding: "utf8",
+      env: { ...process.env, ...options.env },
+      maxBuffer: 1024 * 1024 * 256,
+      windowsHide: true,
+    },
+  );
+  if (res.error) {
+    throw new Error(
+      `ttsc: failed to spawn native compiler host ${binary}: ${res.error.message}`,
+    );
+  }
+
+  const output = parseNativeCompileOutput(res.stdout, res.stderr);
+  return {
+    output: output.output,
+    result: {
+      diagnostics: output.diagnostics,
+      status: res.status ?? 1,
+      stdout: "",
+      stderr: res.stderr,
+    },
+  };
+}
+
+function configuredPlugins(
+  options: ITtscCompilerContext,
+  project: ITtscParsedProjectConfig,
+): ITtscProjectPluginConfig[] {
+  if (options.plugins === false) {
+    return [];
+  }
+  const entries = options.plugins ?? project.compilerOptions.plugins;
+  return entries.filter((entry) => entry.enabled !== false);
+}
+
+function compileProjectWithPlugins(
+  options: ITtscCompilerContext,
+  cwd: string,
+  project: ITtscParsedProjectConfig,
+): {
+  output: Record<string, string>;
+  result: TtscBuildResult;
+} {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-api-output-"));
+  const tempOutDir = path.join(tempRoot, "out");
+  try {
+    const result = runBuild({
+      ...options,
+      cwd,
+      emit: true,
+      forceListEmittedFiles: true,
+      outDir: tempOutDir,
+      quiet: true,
+      structuredDiagnostics: true,
+      tsconfig: project.path,
+    });
+    return {
+      output: readOutputDirectory(tempOutDir, outputKeyMapper(project)),
+      result,
+    };
+  } finally {
+    fs.rmSync(tempRoot, { force: true, recursive: true });
+  }
+}
+
+function outputKeyMapper(
+  project: ITtscParsedProjectConfig,
+): (relativePath: string) => string {
+  const outDir = project.compilerOptions.outDir;
+  if (!outDir) {
+    return (relativePath) => relativePath;
+  }
+  const relativeOutDir = path.relative(project.root, outDir);
+  if (relativeOutDir !== "" && !relativeOutDir.startsWith("..")) {
+    const prefix = pathToKey(relativeOutDir);
+    return (relativePath) => path.posix.join(prefix, relativePath);
+  }
+  return (relativePath) => pathToKey(path.join(outDir, relativePath));
+}
+
+function readOutputDirectory(
+  directory: string,
+  keyOf: (relativePath: string) => string,
+): Record<string, string> {
+  const output: Record<string, string> = {};
+  if (!fs.existsSync(directory)) {
+    return output;
+  }
+  for (const file of listFiles(directory)) {
+    output[keyOf(pathToKey(path.relative(directory, file)))] =
+      fs.readFileSync(file, "utf8");
+  }
+  return output;
+}
+
+function listFiles(directory: string): string[] {
+  const out: string[] = [];
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    const location = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...listFiles(location));
+    } else if (entry.isFile()) {
+      out.push(location);
+    }
+  }
+  return out.sort();
+}
+
+function pathToKey(file: string): string {
+  return file.replace(/\\/g, "/");
+}
+
+function parseNativeCompileOutput(
+  stdout: string,
+  stderr: string,
+): {
+  diagnostics: ITtscCompilerDiagnostic[];
+  output: Record<string, string>;
+} {
+  try {
+    const parsed = JSON.parse(stdout) as {
+      diagnostics?: ITtscCompilerDiagnostic[];
+      output?: Record<string, string>;
+    };
+    return {
+      diagnostics: parsed.diagnostics ?? [],
+      output: parsed.output ?? {},
+    };
+  } catch {
+    throw new Error(
+      (stderr || stdout).trim() || "ttsc: native compiler host returned no output",
+    );
+  }
+}
+
+function packageRootDir(): string {
+  let current = path.resolve(__dirname);
+  while (true) {
+    if (
+      fs.existsSync(path.join(current, "package.json")) &&
+      fs.existsSync(path.join(current, "go.mod"))
+    ) {
+      return fs.realpathSync.native?.(current) ?? fs.realpathSync(current);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error("ttsc: package root not found for native compiler build");
+    }
+    current = parent;
+  }
+}

package/src/{project.ts → compiler/internal/project/readProjectConfig.ts}

@@ -1,58 +1,17 @@
-import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 
-import type { ITtscCacheKeyInput } from "./structures/ITtscCacheKeyInput";
-import type { ITtscParsedProjectConfig } from "./structures/ITtscParsedProjectConfig";
-import type { ITtscProjectLocatorOptions } from "./structures/ITtscProjectLocatorOptions";
-import type { ITtscProjectPluginConfig } from "./structures/ITtscProjectPluginConfig";
+import type { ITtscProjectPluginConfig } from "../../../structures/ITtscProjectPluginConfig";
+import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
+import type { ITtscProjectLocatorOptions } from "../../../structures/internal/ITtscProjectLocatorOptions";
 
-export type { ITtscCacheKeyInput } from "./structures/ITtscCacheKeyInput";
-export type { ITtscParsedProjectConfig } from "./structures/ITtscParsedProjectConfig";
-export type { ITtscProjectLocatorOptions } from "./structures/ITtscProjectLocatorOptions";
-export type { ITtscProjectPluginConfig } from "./structures/ITtscProjectPluginConfig";
+import { resolveProjectConfig } from "./resolveProjectConfig";
 
-export function resolveWorkingDirectory(cwd?: string): string {
-  return path.resolve(cwd ?? process.cwd());
-}
-
-export function resolveAbsolutePath(cwd: string, target: string): string {
-  return path.isAbsolute(target) ? target : path.resolve(cwd, target);
-}
-
-export function resolveProjectConfig(opts: ITtscProjectLocatorOptions = {}): string {
-  const cwd = resolveWorkingDirectory(opts.cwd);
-  if (opts.tsconfig) {
-    const resolved = resolveAbsolutePath(cwd, opts.tsconfig);
-    if (!fs.existsSync(resolved)) {
-      throw new Error(`ttsc: tsconfig not found: ${resolved}`);
-    }
-    return resolveRealPath(resolved);
-  }
-
-  const start = opts.file
-    ? resolveRealPath(resolveAbsolutePath(cwd, opts.file))
-    : cwd;
-  const from = isDirectory(start) ? start : path.dirname(start);
-  const found = findUp(from, ["tsconfig.json", "jsconfig.json"]);
-  if (!found) {
-    throw new Error(
-      `ttsc: could not find tsconfig.json or jsconfig.json starting from ${from}`,
-    );
-  }
-  return resolveRealPath(found);
-}
-
-export function resolveProjectRoot(opts: ITtscProjectLocatorOptions = {}): string {
-  return path.dirname(resolveProjectConfig(opts));
-}
-
-export function defaultCacheDirectory(projectRoot: string, tool: string): string {
-  return path.join(projectRoot, "node_modules", ".cache", "ttsc", tool);
-}
-
-export function readProjectConfig(opts: ITtscProjectLocatorOptions = {}): ITtscParsedProjectConfig {
+/** Read the resolved project config subset used by ttsc. */
+export function readProjectConfig(
+  opts: ITtscProjectLocatorOptions = {},
+): ITtscParsedProjectConfig {
   const tsconfig = resolveProjectConfig(opts);
   const root = path.dirname(tsconfig);
   const compilerOptions = readResolvedCompilerOptions(tsconfig);
@@ -67,63 +26,12 @@ export function readProjectConfig(opts: ITtscProjectLocatorOptions = {}): ITtscP
   };
 }
 
-export function createTransformCacheKey(input: ITtscCacheKeyInput): string {
-  const hash = crypto.createHash("sha256");
-  hash.update("file\0");
-  hash.update(fs.readFileSync(input.file));
-  hash.update("\0tsconfig\0");
-  hash.update(fs.readFileSync(input.tsconfig));
-  hash.update(`\0version\0${input.version}`);
-  hash.update(`\0mode\0${input.mode ?? ""}`);
-  for (const item of input.extra ?? []) {
-    hash.update(`\0extra\0${item}`);
-  }
-  return hash.digest("hex");
-}
-
-function findUp(from: string, names: readonly string[]): string | null {
-  let current = path.resolve(from);
-  while (true) {
-    for (const name of names) {
-      const candidate = path.join(current, name);
-      if (fs.existsSync(candidate)) {
-        return candidate;
-      }
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-
-function isDirectory(location: string): boolean {
-  try {
-    return fs.statSync(location).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-function isProjectPluginConfig(value: unknown): value is ITtscProjectPluginConfig {
+function isProjectPluginConfig(
+  value: unknown,
+): value is ITtscProjectPluginConfig {
   return typeof value === "object" && value !== null;
 }
 
-interface ITtscRawTsconfig {
-  extends?: unknown;
-  compilerOptions?: Record<string, unknown> & {
-    outDir?: unknown;
-    plugins?: unknown;
-  };
-}
-
-interface ITtscResolvedCompilerOptions {
-  options: Record<string, unknown>;
-  outDir?: string;
-  plugins: ITtscProjectPluginConfig[];
-}
-
 function resolveRealPath(location: string): string {
   try {
     return fs.realpathSync(location);
@@ -132,21 +40,38 @@ function resolveRealPath(location: string): string {
   }
 }
 
+function resolveAbsolutePath(cwd: string, target: string): string {
+  return path.isAbsolute(target) ? target : path.resolve(cwd, target);
+}
+
 function readResolvedCompilerOptions(
   tsconfig: string,
   seen: Set<string> = new Set(),
-): ITtscResolvedCompilerOptions {
+): {
+  options: Record<string, unknown>;
+  outDir?: string;
+  plugins: ITtscProjectPluginConfig[];
+} {
   const canonical = resolveRealPath(tsconfig);
   if (seen.has(canonical)) {
     throw new Error(`ttsc: circular tsconfig extends detected: ${canonical}`);
   }
   seen.add(canonical);
 
-  const parsed = parseJsonc(fs.readFileSync(canonical, "utf8")) as ITtscRawTsconfig;
+  const parsed = parseJsonc(fs.readFileSync(canonical, "utf8")) as {
+    extends?: unknown;
+    compilerOptions?: Record<string, unknown> & {
+      outDir?: unknown;
+      plugins?: unknown;
+    };
+  };
   const own = parsed.compilerOptions;
   const base =
     typeof parsed.extends === "string"
-      ? readResolvedCompilerOptions(resolveExtendsConfig(canonical, parsed.extends), seen)
+      ? readResolvedCompilerOptions(
+          resolveExtendsConfig(canonical, parsed.extends),
+          seen,
+        )
       : { options: {}, plugins: [] };
   const options = {
     ...base.options,
@@ -169,7 +94,7 @@ function resolveExtendsConfig(tsconfig: string, specifier: string): string {
   if (path.isAbsolute(specifier)) {
     return resolveExistingExtendsPath(specifier);
   }
-  if (isRelativePluginSpecifier(specifier)) {
+  if (isRelativeSpecifier(specifier)) {
     return resolveExistingExtendsPath(path.resolve(baseDir, specifier));
   }
   const resolver = createRequire(tsconfig);
@@ -194,7 +119,7 @@ function resolveExistingExtendsPath(location: string): string {
   throw new Error(`ttsc: extended tsconfig not found: ${location}`);
 }
 
-function isRelativePluginSpecifier(specifier: string): boolean {
+function isRelativeSpecifier(specifier: string): boolean {
   return (
     specifier === "." ||
     specifier === ".." ||
@@ -248,18 +173,18 @@ function stripComments(input: string): string {
       continue;
     }
 
-    if ((current === '"' || current === "'") && !inString) {
+    if (current === '"' || current === "'") {
       inString = true;
       quote = current;
       output += current;
       continue;
     }
-    if (current == "/" && next === "/") {
+    if (current === "/" && next === "/") {
       inLineComment = true;
       i += 1;
       continue;
     }
-    if (current == "/" && next === "*") {
+    if (current === "/" && next === "*") {
       inBlockComment = true;
       i += 1;
       continue;

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

@@ -0,0 +1,67 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import type { ITtscProjectLocatorOptions } from "../../../structures/internal/ITtscProjectLocatorOptions";
+
+/** Resolve the tsconfig/jsconfig that owns a ttsc invocation. */
+export function resolveProjectConfig(
+  opts: ITtscProjectLocatorOptions = {},
+): string {
+  const cwd = path.resolve(opts.cwd ?? process.cwd());
+  if (opts.tsconfig) {
+    const resolved = resolveAbsolutePath(cwd, opts.tsconfig);
+    if (!fs.existsSync(resolved)) {
+      throw new Error(`ttsc: tsconfig not found: ${resolved}`);
+    }
+    return resolveRealPath(resolved);
+  }
+
+  const start = opts.file
+    ? resolveRealPath(resolveAbsolutePath(cwd, opts.file))
+    : cwd;
+  const from = isDirectory(start) ? start : path.dirname(start);
+  const found = findUp(from, ["tsconfig.json", "jsconfig.json"]);
+  if (!found) {
+    throw new Error(
+      `ttsc: could not find tsconfig.json or jsconfig.json starting from ${from}`,
+    );
+  }
+  return resolveRealPath(found);
+}
+
+function resolveAbsolutePath(cwd: string, target: string): string {
+  return path.isAbsolute(target) ? target : path.resolve(cwd, target);
+}
+
+function resolveRealPath(location: string): string {
+  try {
+    return fs.realpathSync(location);
+  } catch {
+    return location;
+  }
+}
+
+function findUp(from: string, names: readonly string[]): string | null {
+  let current = path.resolve(from);
+  while (true) {
+    for (const name of names) {
+      const candidate = path.join(current, name);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function isDirectory(location: string): boolean {
+  try {
+    return fs.statSync(location).isDirectory();
+  } catch {
+    return false;
+  }
+}

package/src/compiler/internal/resolveBinary.ts

@@ -0,0 +1,41 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** Resolve the ttsc helper binary path, or null when unavailable. */
+export function resolveBinary(
+  opts: { env?: NodeJS.ProcessEnv } = {},
+): string | null {
+  const env = opts.env ?? process.env;
+  if (env.TTSC_BINARY && path.isAbsolute(env.TTSC_BINARY)) {
+    return env.TTSC_BINARY;
+  }
+
+  try {
+    return require.resolve(
+      `@ttsc/${process.platform}-${process.arch}/bin/${process.platform === "win32" ? "ttsc.exe" : "ttsc"}`,
+    );
+  } catch {
+    /* fall through */
+  }
+
+  const local = defaultLocalBinaryPath();
+  if (local) return local;
+
+  return null;
+}
+
+function defaultLocalBinaryPath(): string | null {
+  const root = packageRootDir();
+  const candidate = path.resolve(
+    root,
+    "..",
+    "native",
+    process.platform === "win32" ? "ttsc-native.exe" : "ttsc-native",
+  );
+  return fs.existsSync(candidate) ? candidate : null;
+}
+
+function packageRootDir(): string {
+  const moduleDir = path.resolve(__dirname, "..", "..");
+  return fs.realpathSync.native?.(moduleDir) ?? fs.realpathSync(moduleDir);
+}

package/src/compiler/internal/resolveEmittedJavaScript.ts

@@ -0,0 +1,102 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** Locate the JavaScript file emitted for a TypeScript source file. */
+export function resolveEmittedJavaScript(options: {
+  emittedFiles?: readonly string[];
+  outDir: string;
+  projectRoot: string;
+  sourceFile: string;
+}): string | null {
+  const exact = resolveExactEmittedFile(
+    options.outDir,
+    options.projectRoot,
+    options.sourceFile,
+  );
+  if (exact && fs.existsSync(exact)) {
+    return exact;
+  }
+
+  let best: string | null = null;
+  let bestScore = 0;
+  for (const file of options.emittedFiles ?? listJavaScriptFiles(options.outDir)) {
+    if (!isJavaScriptOutput(file)) continue;
+    const score = sharedSourceStemSegments(file, options.sourceFile);
+    if (score > bestScore) {
+      best = file;
+      bestScore = score;
+    }
+  }
+  return best && fs.existsSync(best) ? best : null;
+}
+
+function resolveExactEmittedFile(
+  outDir: string,
+  projectRoot: string,
+  sourceFile: string,
+): string | null {
+  const relative = path.relative(projectRoot, sourceFile);
+  if (
+    relative === "" ||
+    relative.startsWith("..") ||
+    path.isAbsolute(relative)
+  ) {
+    return null;
+  }
+  return path.resolve(
+    outDir,
+    relative.slice(0, relative.length - path.extname(relative).length) +
+      emittedJavaScriptExtension(sourceFile),
+  );
+}
+
+function listJavaScriptFiles(root: string): string[] {
+  const out: string[] = [];
+  const stack = [root];
+  while (stack.length !== 0) {
+    const current = stack.pop()!;
+    if (!fs.existsSync(current)) continue;
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const next = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(next);
+      } else if (entry.isFile() && isJavaScriptOutput(next)) {
+        out.push(path.resolve(next));
+      }
+    }
+  }
+  return out;
+}
+
+function sharedSourceStemSegments(outPath: string, srcPath: string): number {
+  const trim = (location: string): string[] => {
+    const normalized = location.replace(/\\/g, "/");
+    return normalized
+      .slice(0, normalized.length - path.extname(normalized).length)
+      .split("/");
+  };
+  const a = trim(outPath);
+  const b = trim(srcPath);
+  const count = Math.min(a.length, b.length);
+  let shared = 0;
+  for (let i = 1; i <= count; i += 1) {
+    if (a[a.length - i] !== b[b.length - i]) break;
+    shared += 1;
+  }
+  return shared;
+}
+
+function emittedJavaScriptExtension(filename: string): string {
+  switch (path.extname(filename).toLowerCase()) {
+    case ".mts":
+      return ".mjs";
+    case ".cts":
+      return ".cjs";
+    default:
+      return ".js";
+  }
+}
+
+function isJavaScriptOutput(filename: string): boolean {
+  return /\.(?:[cm]?js)$/i.test(filename);
+}

package/src/{tsgo.ts → compiler/internal/resolveTsgo.ts}

@@ -2,21 +2,15 @@ import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 
-import type { ITtscResolvedTsgo } from "./structures/ITtscResolvedTsgo";
-import type { ITtscTsgoResolveOptions } from "./structures/ITtscTsgoResolveOptions";
 
-export type { ITtscResolvedTsgo } from "./structures/ITtscResolvedTsgo";
-export type { ITtscTsgoResolveOptions } from "./structures/ITtscTsgoResolveOptions";
-
-export function nativePreviewPlatformPackage(
-  opts: ITtscTsgoResolveOptions = {},
-): string {
-  return `@typescript/native-preview-${opts.platform ?? process.platform}-${
-    opts.arch ?? process.arch
-  }`;
-}
-
-export function resolveTsgo(opts: ITtscTsgoResolveOptions = {}): ITtscResolvedTsgo {
+/** Resolve the consumer project's TypeScript-Go preview binary. */
+export function resolveTsgo(
+  opts: {
+    binary?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+  } = {},
+) {
   const env = opts.env ?? process.env;
   const explicit = opts.binary ?? env.TTSC_TSGO_BINARY;
   if (explicit) {
@@ -34,12 +28,11 @@ export function resolveTsgo(opts: ITtscTsgoResolveOptions = {}): ITtscResolvedTs
   }
 
   const cwd = path.resolve(opts.cwd ?? process.cwd());
-  const resolver =
-    opts.resolver ??
-    ((request: string) => createRequire(path.join(cwd, "package.json")).resolve(request));
   let packageJson: string;
   try {
-    packageJson = resolver("@typescript/native-preview/package.json");
+    packageJson = createRequire(path.join(cwd, "package.json")).resolve(
+      "@typescript/native-preview/package.json",
+    );
   } catch {
     throw new Error(
       [
@@ -52,11 +45,13 @@ export function resolveTsgo(opts: ITtscTsgoResolveOptions = {}): ITtscResolvedTs
 
   const manifest = readPackageJson(packageJson);
   const packageRoot = path.dirname(packageJson);
-  const platformPackage = nativePreviewPlatformPackage(opts);
+  const platformPackage = `@typescript/native-preview-${process.platform}-${process.arch}`;
   const platformResolver = createRequire(packageJson);
   let platformPackageJson: string;
   try {
-    platformPackageJson = platformResolver.resolve(`${platformPackage}/package.json`);
+    platformPackageJson = platformResolver.resolve(
+      `${platformPackage}/package.json`,
+    );
   } catch {
     throw new Error(
       [
@@ -70,18 +65,20 @@ export function resolveTsgo(opts: ITtscTsgoResolveOptions = {}): ITtscResolvedTs
   const binary = path.join(
     platformRoot,
     "lib",
-    (opts.platform ?? process.platform) === "win32" ? "tsgo.exe" : "tsgo",
+    process.platform === "win32" ? "tsgo.exe" : "tsgo",
   );
   if (!fs.existsSync(binary)) {
     throw new Error(`ttsc: TypeScript-Go executable not found: ${binary}`);
   }
   return {
     binary,
-    gitHead: typeof manifest.gitHead === "string" ? manifest.gitHead : undefined,
+    gitHead:
+      typeof manifest.gitHead === "string" ? manifest.gitHead : undefined,
     packageJson,
     packageRoot,
     platformPackageJson,
-    version: typeof manifest.version === "string" ? manifest.version : "unknown",
+    version:
+      typeof manifest.version === "string" ? manifest.version : "unknown",
   };
 }