ttsc 0.7.1 → 0.7.3

package/src/launcher/internal/prepareExecution.ts

@@ -1,12 +1,14 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 
 import { resolveEmittedJavaScript } from "../../compiler/internal/resolveEmittedJavaScript";
 import { runBuild } from "../../compiler/internal/runBuild";
-import { resolveProjectConfig } from "../../compiler/internal/project/resolveProjectConfig";
+import { readProjectConfig } from "../../compiler/internal/project/readProjectConfig";
 import type { TtscCommonOptions } from "../../structures/internal/TtscCommonOptions";
 
 const PROCESS_CACHE_KEY = String(process.pid);
+const MAX_VIRTUAL_PARENT_DEPTH = 3;
 
 /** Build the owning project and locate the emitted JavaScript entry for `ttsx`. */
 export function prepareExecution(
@@ -48,22 +50,45 @@ function createProjectContext(
   filename: string,
   options: NonNullable<Parameters<typeof prepareExecution>[1]>,
 ) {
-  const tsconfig = options.project
-    ? resolveProjectConfig({ cwd, tsconfig: path.resolve(cwd, options.project) })
-    : resolveProjectConfig({ cwd, file: filename });
-  const root = path.dirname(tsconfig);
+  const project = readProjectConfig(
+    options.project
+      ? { cwd, tsconfig: path.resolve(cwd, options.project) }
+      : { cwd, file: filename },
+  );
+  const tsconfig = project.path;
+  const root = project.root;
   const cacheDir =
-    options.cacheDir ?? path.join(root, "node_modules", ".cache", "ttsc", "ttsx");
+    options.cacheDir ??
+    path.join(root, "node_modules", ".cache", "ttsc", "ttsx");
+  const processDir = path.join(cacheDir, "project", PROCESS_CACHE_KEY);
+  const virtualRoot = path.join(processDir, "fs");
   return {
     tsconfig,
     root,
     cacheDir,
-    emitDir: path.join(cacheDir, "project", PROCESS_CACHE_KEY),
+    processDir,
+    virtualRoot,
+    emitDir: project.compilerOptions.outDir
+      ? virtualPath(virtualRoot, project.compilerOptions.outDir)
+      : virtualPath(virtualRoot, resolveRuntimeSourceRoot(project, filename)),
     built: false,
     emittedFiles: undefined as string[] | undefined,
   };
 }
 
+function resolveRuntimeSourceRoot(
+  project: ReturnType<typeof readProjectConfig>,
+  filename: string,
+): string {
+  const rootDir = project.compilerOptions.rootDir;
+  if (typeof rootDir === "string") {
+    return path.isAbsolute(rootDir)
+      ? rootDir
+      : path.resolve(project.root, rootDir);
+  }
+  return path.dirname(filename);
+}
+
 function buildProject(
   context: ReturnType<typeof createProjectContext>,
   options: NonNullable<Parameters<typeof prepareExecution>[1]>,
@@ -71,7 +96,8 @@ function buildProject(
   if (context.built) return;
 
   fs.mkdirSync(context.cacheDir, { recursive: true });
-  fs.rmSync(context.emitDir, { recursive: true, force: true });
+  fs.rmSync(context.processDir, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(context.emitDir), { recursive: true });
   const result = runBuild({
     binary: options.binary,
     cwd: context.root,
@@ -84,6 +110,7 @@ function buildProject(
     tsconfig: context.tsconfig,
   });
   if (result.status === 0) {
+    linkVirtualProjectLayout(context);
     context.built = true;
     context.emittedFiles =
       result.emittedFiles && result.emittedFiles.length !== 0
@@ -92,7 +119,7 @@ function buildProject(
     return;
   }
 
-  fs.rmSync(context.emitDir, { recursive: true, force: true });
+  fs.rmSync(context.processDir, { recursive: true, force: true });
   const detail = [
     `ttsx: project check failed for ${context.tsconfig}`,
     result.stderr || result.stdout,
@@ -102,6 +129,85 @@ function buildProject(
   throw new Error(detail);
 }
 
+function linkVirtualProjectLayout(
+  context: ReturnType<typeof createProjectContext>,
+): void {
+  for (const directory of collectLinkDirectories(context.root)) {
+    const virtualDirectory = virtualPath(context.virtualRoot, directory);
+    fs.mkdirSync(virtualDirectory, { recursive: true });
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const realEntry = path.join(directory, entry.name);
+      const virtualEntry = path.join(virtualDirectory, entry.name);
+      if (fs.existsSync(virtualEntry)) {
+        continue;
+      }
+      linkVirtualEntry(realEntry, virtualEntry, entry);
+    }
+  }
+}
+
+function linkVirtualEntry(
+  realEntry: string,
+  virtualEntry: string,
+  entry: fs.Dirent,
+): void {
+  if (entry.isDirectory()) {
+    fs.symlinkSync(
+      realEntry,
+      virtualEntry,
+      process.platform === "win32" ? "junction" : undefined,
+    );
+    return;
+  }
+  if (entry.isFile()) {
+    try {
+      fs.linkSync(realEntry, virtualEntry);
+    } catch {
+      fs.copyFileSync(realEntry, virtualEntry);
+    }
+    return;
+  }
+  fs.symlinkSync(realEntry, virtualEntry);
+}
+
+function collectLinkDirectories(projectRoot: string): string[] {
+  const out: string[] = [];
+  let current = projectRoot;
+  for (let depth = 0; depth <= MAX_VIRTUAL_PARENT_DEPTH; depth += 1) {
+    out.push(current);
+    if (
+      depth > 0 &&
+      (fs.existsSync(path.join(current, "pnpm-workspace.yaml")) ||
+        fs.existsSync(path.join(current, ".git")))
+    ) {
+      break;
+    }
+    const parent = path.dirname(current);
+    if (parent === current || isUnsafeVirtualParent(parent)) {
+      break;
+    }
+    current = parent;
+  }
+  return out.reverse();
+}
+
+function isUnsafeVirtualParent(directory: string): boolean {
+  const resolved = path.resolve(directory);
+  const root = path.parse(resolved).root;
+  return resolved === root || resolved === path.resolve(os.tmpdir());
+}
+
+function virtualPath(root: string, absolute: string): string {
+  const parsed = path.parse(path.resolve(absolute));
+  const label =
+    parsed.root === path.sep
+      ? "posix"
+      : parsed.root.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "") ||
+        "root";
+  const relative = path.relative(parsed.root, path.resolve(absolute));
+  return path.join(root, label, relative);
+}
+
 function looksLikeESM(output: string): boolean {
   if (
     /\bObject\.defineProperty\(exports\b/.test(output) ||

package/src/launcher/internal/runTtsc.ts

@@ -2,6 +2,7 @@ import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+import { TtscCompiler } from "../../TtscCompiler";
 import { resolveBinary } from "../../compiler/internal/resolveBinary";
 import { runBuild } from "../../compiler/internal/runBuild";
 import { runSingleFileEmit } from "../../compiler/internal/runSingleFileEmit";
@@ -35,6 +36,8 @@ export function runTtsc(
         return runCompatibleBuild(rest, true);
       case "clean":
         return runClean(rest);
+      case "prepare":
+        return runPrepare(rest);
       case "demo":
         return delegateToNative(argv);
       case "-p":
@@ -82,8 +85,34 @@ function runCompatibleBuild(
   return result.status;
 }
 
+function runPrepare(argv: readonly string[]): number {
+  const options = parseProjectArgs(argv);
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const compiler = new TtscCompiler({
+    cwd,
+    tsconfig: options.tsconfig,
+  });
+  const prepared = compiler.prepare();
+  if (prepared.length === 0) {
+    const projectRoot = path.dirname(
+      resolveProjectConfig({
+        cwd,
+        tsconfig: options.tsconfig,
+      }),
+    );
+    process.stdout.write(
+      `ttsc: no source plugins found under ${formatProjectPath(cwd, projectRoot)}\n`,
+    );
+    return 0;
+  }
+  for (const target of prepared) {
+    process.stdout.write(`ttsc: prepared ${formatProjectPath(cwd, target)}\n`);
+  }
+  return 0;
+}
+
 function runClean(argv: readonly string[]): number {
-  const options = parseCleanArgs(argv);
+  const options = parseProjectArgs(argv);
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const projectRoot = resolveCleanProjectRoot(cwd, options.tsconfig);
   const targets = [
@@ -106,7 +135,7 @@ function runClean(argv: readonly string[]): number {
     return 0;
   }
   for (const target of removed) {
-    process.stdout.write(`ttsc: removed ${formatCleanPath(cwd, target)}\n`);
+    process.stdout.write(`ttsc: removed ${formatProjectPath(cwd, target)}\n`);
   }
   return 0;
 }
@@ -120,7 +149,7 @@ function resolveCleanProjectRoot(cwd: string, tsconfig?: string): string {
   }
 }
 
-function formatCleanPath(cwd: string, target: string): string {
+function formatProjectPath(cwd: string, target: string): string {
   const relative = path.relative(cwd, target);
   if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
     return target;
@@ -174,7 +203,7 @@ function ensureExecutable(binary: string): void {
   }
 }
 
-function parseCleanArgs(argv: readonly string[]) {
+function parseProjectArgs(argv: readonly string[]) {
   let cwd: string | undefined;
   let tsconfig: string | undefined;
 
@@ -303,6 +332,7 @@ function printHelp(): void {
       "  ttsc -p tsconfig.json",
       "  ttsc --watch",
       "  ttsc --noEmit",
+      "  ttsc prepare [options]",
       "  ttsc clean [options]",
       "  ttsc version",
       "  ttsc --help",
@@ -328,6 +358,7 @@ function printHelp(): void {
       "Compatibility aliases:",
       "  ttsc build [options]       Same project build lane as `ttsc [options]`.",
       "  ttsc check [options]       Same as `ttsc --noEmit [options]`.",
+      "  ttsc prepare [options]     Build configured source-plugin binaries into cache.",
       "  ttsc clean [options]       Delete local source-plugin cache directories.",
     ].join("\n"),
   );

package/src/launcher/internal/runTtsx.ts

@@ -5,7 +5,9 @@ import * as path from "node:path";
 import { getCompilerVersionText } from "./getCompilerVersionText";
 import { prepareExecution } from "./prepareExecution";
 
-export function runTtsx(argv: readonly string[] = process.argv.slice(2)): number {
+export function runTtsx(
+  argv: readonly string[] = process.argv.slice(2),
+): number {
   try {
     return run(argv);
   } catch (error) {
@@ -53,8 +55,10 @@ function formatError(error: unknown): string {
 function parseCLI(argv: readonly string[]) {
   const preload: string[] = [];
   const passthroughIndex = argv.indexOf("--");
-  const head = passthroughIndex === -1 ? [...argv] : [...argv.slice(0, passthroughIndex)];
-  const passthrough = passthroughIndex === -1 ? [] : [...argv.slice(passthroughIndex + 1)];
+  const head =
+    passthroughIndex === -1 ? [...argv] : [...argv.slice(0, passthroughIndex)];
+  const passthrough =
+    passthroughIndex === -1 ? [] : [...argv.slice(passthroughIndex + 1)];
 
   let binary: string | undefined;
   let cacheDir: string | undefined;
@@ -151,7 +155,11 @@ function printHelp(): void {
 }
 
 function resolvePreload(cwd: string, preload: string): string {
-  if (preload.startsWith(".") || preload.startsWith("/") || preload.includes(path.sep)) {
+  if (
+    preload.startsWith(".") ||
+    preload.startsWith("/") ||
+    preload.includes(path.sep)
+  ) {
     return path.resolve(cwd, preload);
   }
   return preload;
@@ -180,7 +188,10 @@ function runPreparedEntry(
     );
   }
   const args = [
-    ...parsed.preload.flatMap((preload) => ["-r", resolvePreload(cwd, preload)]),
+    ...parsed.preload.flatMap((preload) => [
+      "-r",
+      resolvePreload(cwd, preload),
+    ]),
     execution.entryFile,
     ...parsed.passthrough,
   ];

package/src/plugin/internal/buildSourcePlugin.ts

@@ -155,7 +155,9 @@ function writeGoWork(scratchDir: string, useDirs: readonly string[]): void {
   fs.writeFileSync(path.join(scratchDir, "go.work"), goWork, "utf8");
 }
 
-function sourceBuildWorkspaceReplacements(useDirs: readonly string[]): string[] {
+function sourceBuildWorkspaceReplacements(
+  useDirs: readonly string[],
+): string[] {
   const ttscRoot = useDirs.find((dir) =>
     hasModulePath(dir, "github.com/samchon/ttsc/packages/ttsc"),
   );
@@ -308,7 +310,10 @@ function walkForGoMod(dir: string, out: string[]): void {
   }
 }
 
-function resolvePluginCacheRoot(projectRoot: string, cacheDir?: string): string {
+function resolvePluginCacheRoot(
+  projectRoot: string,
+  cacheDir?: string,
+): string {
   if (cacheDir) {
     return path.resolve(cacheDir, "plugins");
   }

package/test/platform.test.ts

@@ -1,8 +1,6 @@
 const assert = require("node:assert/strict");
 const test = require("node:test");
-const {
-  resolveBinary,
-} = require("../lib/compiler/internal/resolveBinary.js");
+const { resolveBinary } = require("../lib/compiler/internal/resolveBinary.js");
 
 test("resolveBinary prefers TTSC_BINARY absolute override", () => {
   const resolved = resolveBinary({

package/test/tsgo.test.ts

@@ -20,7 +20,12 @@ test("resolveTsgo accepts TTSC_TSGO_BINARY as an explicit compiler", () => {
 
 test("resolveTsgo resolves the consumer native-preview platform package", () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "ttsc-tsgo-test-"));
-  const nativeRoot = path.join(root, "node_modules", "@typescript", "native-preview");
+  const nativeRoot = path.join(
+    root,
+    "node_modules",
+    "@typescript",
+    "native-preview",
+  );
   const platformRoot = path.join(
     root,
     "node_modules",