ttsc 0.3.1 → 0.4.0-dev.20260424

package/src/project.ts

@@ -0,0 +1,330 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+
+export interface ProjectLocatorOptions {
+  cwd?: string;
+  file?: string;
+  tsconfig?: string;
+}
+
+export interface ProjectPluginConfig {
+  enabled?: boolean;
+  transform?: string;
+  [key: string]: unknown;
+}
+
+export interface ParsedProjectConfig {
+  compilerOptions: {
+    outDir?: string;
+    plugins: ProjectPluginConfig[];
+  };
+  path: string;
+  root: string;
+}
+
+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: ProjectLocatorOptions = {}): 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: ProjectLocatorOptions = {}): 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: ProjectLocatorOptions = {}): ParsedProjectConfig {
+  const tsconfig = resolveProjectConfig(opts);
+  const root = path.dirname(tsconfig);
+  const compilerOptions = readResolvedCompilerOptions(tsconfig);
+  return {
+    compilerOptions: {
+      outDir: compilerOptions.outDir,
+      plugins: compilerOptions.plugins,
+    },
+    path: tsconfig,
+    root,
+  };
+}
+
+export interface CacheKeyInput {
+  file: string;
+  tsconfig: string;
+  version: string;
+  mode?: string;
+  extra?: readonly string[];
+}
+
+export function createTransformCacheKey(input: CacheKeyInput): 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 ProjectPluginConfig {
+  return typeof value === "object" && value !== null;
+}
+
+interface RawTsconfig {
+  extends?: unknown;
+  compilerOptions?: {
+    outDir?: unknown;
+    plugins?: unknown;
+  };
+}
+
+interface ResolvedCompilerOptions {
+  outDir?: string;
+  plugins: ProjectPluginConfig[];
+}
+
+function resolveRealPath(location: string): string {
+  try {
+    return fs.realpathSync(location);
+  } catch {
+    return location;
+  }
+}
+
+function readResolvedCompilerOptions(
+  tsconfig: string,
+  seen: Set<string> = new Set(),
+): ResolvedCompilerOptions {
+  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 RawTsconfig;
+  const own = parsed.compilerOptions;
+  const base =
+    typeof parsed.extends === "string"
+      ? readResolvedCompilerOptions(resolveExtendsConfig(canonical, parsed.extends), seen)
+      : { plugins: [] };
+  return {
+    outDir:
+      typeof own?.outDir === "string"
+        ? resolveAbsolutePath(path.dirname(canonical), own.outDir)
+        : base.outDir,
+    plugins: Array.isArray(own?.plugins)
+      ? own.plugins.filter(isProjectPluginConfig)
+      : base.plugins,
+  };
+}
+
+function resolveExtendsConfig(tsconfig: string, specifier: string): string {
+  const baseDir = path.dirname(tsconfig);
+  if (path.isAbsolute(specifier)) {
+    return resolveExistingExtendsPath(specifier);
+  }
+  if (isRelativePluginSpecifier(specifier)) {
+    return resolveExistingExtendsPath(path.resolve(baseDir, specifier));
+  }
+  const resolver = createRequire(tsconfig);
+  try {
+    return resolveRealPath(resolver.resolve(specifier));
+  } catch {
+    return resolveRealPath(resolver.resolve(`${specifier}.json`));
+  }
+}
+
+function resolveExistingExtendsPath(location: string): string {
+  const candidates = new Set<string>([
+    location,
+    `${location}.json`,
+    path.join(location, "tsconfig.json"),
+  ]);
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return resolveRealPath(candidate);
+    }
+  }
+  throw new Error(`ttsc: extended tsconfig not found: ${location}`);
+}
+
+function isRelativePluginSpecifier(specifier: string): boolean {
+  return (
+    specifier === "." ||
+    specifier === ".." ||
+    specifier.startsWith("./") ||
+    specifier.startsWith("../") ||
+    specifier.startsWith(".\\") ||
+    specifier.startsWith("..\\")
+  );
+}
+
+function parseJsonc(input: string): unknown {
+  return JSON.parse(stripTrailingCommas(stripComments(input)));
+}
+
+function stripComments(input: string): string {
+  let output = "";
+  let inBlockComment = false;
+  let inLineComment = false;
+  let inString = false;
+  let quote = "";
+  let escape = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const current = input[i]!;
+    const next = input[i + 1];
+
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (inLineComment) {
+      if (current === "\n") {
+        inLineComment = false;
+        output += current;
+      }
+      continue;
+    }
+    if (inString) {
+      output += current;
+      if (escape) {
+        escape = false;
+      } else if (current === "\\") {
+        escape = true;
+      } else if (current === quote) {
+        inString = false;
+        quote = "";
+      }
+      continue;
+    }
+
+    if ((current === '"' || current === "'") && !inString) {
+      inString = true;
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current == "/" && next === "/") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (current == "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    output += current;
+  }
+  return output;
+}
+
+function stripTrailingCommas(input: string): string {
+  let output = "";
+  let inString = false;
+  let quote = "";
+  let escape = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const current = input[i]!;
+    if (inString) {
+      output += current;
+      if (escape) {
+        escape = false;
+      } else if (current === "\\") {
+        escape = true;
+      } else if (current === quote) {
+        inString = false;
+        quote = "";
+      }
+      continue;
+    }
+
+    if (current === '"' || current === "'") {
+      inString = true;
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current === ",") {
+      const next = nextNonWhitespace(input, i + 1);
+      if (next === "}" || next === "]") {
+        continue;
+      }
+    }
+    output += current;
+  }
+  return output;
+}
+
+function nextNonWhitespace(input: string, from: number): string | undefined {
+  for (let i = from; i < input.length; i += 1) {
+    const current = input[i]!;
+    if (/\s/.test(current) === false) {
+      return current;
+    }
+  }
+  return undefined;
+}

package/test/native.test.ts

@@ -0,0 +1,60 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { resolveNativeBackend } = require("../src/native.ts");
+
+test("resolveNativeBackend accepts versioned native backend descriptors", () => {
+  const backend = resolveNativeBackend({
+    name: "native-test",
+    native: {
+      mode: "native-test",
+      binary: "/tmp/ttsc-native-test",
+      contractVersion: 1,
+      capabilities: ["rewrite", "diagnostics"],
+    },
+  });
+
+  assert.deepEqual(backend, {
+    mode: "native-test",
+    binary: "/tmp/ttsc-native-test",
+    contractVersion: 1,
+    capabilities: ["rewrite", "diagnostics"],
+  });
+});
+
+test("resolveNativeBackend keeps nativeMode/nativeBinary as a legacy alias", () => {
+  const backend = resolveNativeBackend({
+    name: "legacy-native-test",
+    nativeMode: "legacy-native-test",
+    nativeBinary: "/tmp/ttsc-legacy-native-test",
+  });
+
+  assert.deepEqual(backend, {
+    mode: "legacy-native-test",
+    binary: "/tmp/ttsc-legacy-native-test",
+    contractVersion: 1,
+  });
+});
+
+test("resolveNativeBackend rejects ambiguous native declarations", () => {
+  assert.throws(
+    () =>
+      resolveNativeBackend({
+        name: "bad-native-test",
+        native: { mode: "native-test" },
+        nativeMode: "native-test",
+      }),
+    /must use either native or nativeMode\/nativeBinary/,
+  );
+});
+
+test("resolveNativeBackend rejects unsupported native contract versions", () => {
+  assert.throws(
+    () =>
+      resolveNativeBackend({
+        name: "future-native-test",
+        native: { mode: "native-test", contractVersion: 2 },
+      }),
+    /unsupported native contract version 2/,
+  );
+});

package/test/package.test.ts

@@ -0,0 +1,123 @@
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const test = require("node:test");
+
+const workspaceRoot = path.resolve(__dirname, "../../..");
+
+test("package metadata separates monorepo source exports from publish exports", () => {
+  for (const packageName of ["ttsc", "ttsx"]) {
+    const packageJson = readPackageJson(packageName);
+    assert.match(packageJson.main, /^src\/.+\.ts$/);
+    assert.match(packageJson.types, /^src\/.+\.ts$/);
+    assert.equal(packageJson.exports["."], "./src/index.ts");
+    assert.equal(packageJson.publishConfig.main, "lib/index.js");
+    assert.equal(packageJson.publishConfig.types, "lib/index.d.ts");
+    assert.equal(
+      packageJson.publishConfig.exports["."].types,
+      "./lib/index.d.ts",
+    );
+    assert.equal(
+      packageJson.publishConfig.exports["."].default,
+      "./lib/index.js",
+    );
+  }
+});
+
+test("ttsc exposes plugin helpers through the root package only", () => {
+  const packageJson = readPackageJson("ttsc");
+  assert.equal(packageJson.exports["./plugin"], undefined);
+  assert.equal(packageJson.publishConfig.exports["./plugin"], undefined);
+  assert.equal(
+    fs.existsSync(path.join(workspaceRoot, "packages", "ttsc", "src", "plugin.ts")),
+    true,
+  );
+  assert.equal(
+    fs.existsSync(path.join(workspaceRoot, "packages", "ttsc", "src", "index.ts")),
+    true,
+  );
+});
+
+test("ttsc declares platform packages as optional dependencies", () => {
+  const packageJson = readPackageJson("ttsc");
+  const expected = [
+    "@ttsc/linux-x64",
+    "@ttsc/linux-arm64",
+    "@ttsc/darwin-x64",
+    "@ttsc/darwin-arm64",
+    "@ttsc/win32-x64",
+    "@ttsc/win32-arm64",
+  ];
+
+  assert.deepEqual(
+    Object.keys(packageJson.optionalDependencies).sort(),
+    expected.toSorted(),
+  );
+  for (const name of expected) {
+    assert.equal(packageJson.optionalDependencies[name], "workspace:*");
+  }
+  assert.equal(packageJson.files.includes("native"), false);
+});
+
+test("published package file lists keep TypeScript and Go sources", () => {
+  const ttsc = readPackageJson("ttsc");
+  for (const entry of [
+    "cmd",
+    "driver",
+    "shim",
+    "src",
+    "test",
+    "tools",
+    "go.mod",
+    "go.sum",
+  ]) {
+    assert.equal(
+      ttsc.files.includes(entry),
+      true,
+      `ttsc files must include ${entry}`,
+    );
+  }
+  for (const entry of ["native", "node_modules", "THIRD-PARTY-LICENSES.md"]) {
+    assert.equal(
+      ttsc.files.includes(entry),
+      false,
+      `ttsc files must not include ${entry}`,
+    );
+  }
+  assert.equal(ttsc.files.includes("tsconfig.json"), false);
+
+  const ttsx = readPackageJson("ttsx");
+  assert.equal(ttsx.files.includes("src"), true, "ttsx files must include src");
+  assert.equal(ttsx.files.includes("tsconfig.json"), false);
+});
+
+test("platform packages expose os cpu constrained native binaries", () => {
+  const matrix = {
+    "ttsc-linux-x64": ["@ttsc/linux-x64", "linux", "x64", "Linux x64"],
+    "ttsc-linux-arm64": ["@ttsc/linux-arm64", "linux", "arm64", "Linux arm64"],
+    "ttsc-darwin-x64": ["@ttsc/darwin-x64", "darwin", "x64", "macOS x64"],
+    "ttsc-darwin-arm64": ["@ttsc/darwin-arm64", "darwin", "arm64", "macOS arm64"],
+    "ttsc-win32-x64": ["@ttsc/win32-x64", "win32", "x64", "Windows x64"],
+    "ttsc-win32-arm64": ["@ttsc/win32-arm64", "win32", "arm64", "Windows arm64"],
+  };
+
+  for (const [dir, [name, os, cpu, label]] of Object.entries(matrix)) {
+    const packageJson = readPackageJson(dir);
+    assert.equal(packageJson.name, name);
+    assert.deepEqual(packageJson.os, [os]);
+    assert.deepEqual(packageJson.cpu, [cpu]);
+    assert.deepEqual(packageJson.files, ["bin", "package.json", "README.md"]);
+    assert.equal(packageJson.scripts.build, "node ../../scripts/build-platform-package.cjs");
+    assert.equal(packageJson.scripts.prepack, "pnpm run build");
+    assert.equal(packageJson.description.includes(label), true);
+  }
+});
+
+function readPackageJson(packageName) {
+  return JSON.parse(
+    fs.readFileSync(
+      path.join(workspaceRoot, "packages", packageName, "package.json"),
+      "utf8",
+    ),
+  );
+}

package/test/platform.test.ts

@@ -0,0 +1,58 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const {
+  binaryName,
+  installHint,
+  platformPackageRequest,
+  resolveBinary,
+} = require("../src/platform.ts");
+
+test("resolveBinary prefers TTSC_BINARY absolute override", () => {
+  const resolved = resolveBinary({
+    env: {
+      TTSC_BINARY: "/tmp/custom-ttsc",
+    },
+    localBinaryLookup: () => "/tmp/local-ttsc",
+    resolver: () => {
+      throw new Error("resolver should not be called when TTSC_BINARY is set");
+    },
+  });
+  assert.equal(resolved, "/tmp/custom-ttsc");
+});
+
+test("resolveBinary falls back to local binary when optional package is missing", () => {
+  const resolved = resolveBinary({
+    env: {},
+    localBinaryLookup: () => "/tmp/local-ttsc",
+    resolver: () => {
+      throw new Error("optional package missing");
+    },
+  });
+  assert.equal(resolved, "/tmp/local-ttsc");
+});
+
+test("resolveBinary returns null when only published and local binaries are missing", () => {
+  const resolved = resolveBinary({
+    env: {},
+    localBinaryLookup: () => null,
+    moduleDir: `${process.cwd()}/src`,
+    resolver: () => {
+      throw new Error("optional package missing");
+    },
+  });
+  assert.equal(resolved, null);
+});
+
+test("platform helpers describe the published package contract", () => {
+  assert.equal(binaryName({ platform: "win32" }), "ttsc.exe");
+  assert.equal(binaryName({ platform: "linux" }), "ttsc");
+  assert.equal(
+    platformPackageRequest({ platform: "linux", arch: "x64" }),
+    "@ttsc/linux-x64/bin/ttsc",
+  );
+
+  const hint = installHint({ platform: "linux", arch: "x64" });
+  assert.match(hint, /@ttsc\/linux-x64/);
+  assert.match(hint, /TTSC_BINARY env var/);
+  assert.doesNotMatch(hint, /ttsc-dev\.js/);
+});