ttsc 0.6.0 → 0.7.1

package/src/native.ts

@@ -1,64 +0,0 @@
-import type { ITtscNativeBackend } from "./structures/ITtscNativeBackend";
-import type { ITtscNativePluginShape } from "./structures/ITtscNativePluginShape";
-
-export type { ITtscNativeBackend } from "./structures/ITtscNativeBackend";
-export type { ITtscNativePluginContractVersion } from "./structures/ITtscNativePluginContractVersion";
-export type { ITtscNativePluginShape } from "./structures/ITtscNativePluginShape";
-export type { ITtscNativeRewriteMode } from "./structures/ITtscNativeRewriteMode";
-export type { ITtscNativeSource } from "./structures/ITtscNativeSource";
-
-export function resolveNativeBackend(
-  plugin: ITtscNativePluginShape,
-): ITtscNativeBackend | null {
-  if (plugin.native && (plugin.nativeMode || plugin.nativeBinary)) {
-    throw new Error(
-      `ttsc: plugin "${plugin.name}" must use either native or nativeMode/nativeBinary, not both`,
-    );
-  }
-  if (!plugin.native) {
-    if (
-      plugin.nativeBinary &&
-      (!plugin.nativeMode || plugin.nativeMode === "none")
-    ) {
-      throw new Error(
-        `ttsc: plugin "${plugin.name}" declared nativeBinary without a non-empty nativeMode`,
-      );
-    }
-    if (!plugin.nativeMode || plugin.nativeMode === "none") {
-      return null;
-    }
-    return {
-      binary: plugin.nativeBinary,
-      contractVersion: 1,
-      mode: plugin.nativeMode,
-    };
-  }
-
-  const backend = plugin.native;
-  if (!backend.mode || backend.mode === "none") {
-    throw new Error(
-      `ttsc: plugin "${plugin.name}" declared native without a non-empty mode`,
-    );
-  }
-  if (backend.contractVersion !== undefined && backend.contractVersion !== 1) {
-    throw new Error(
-      `ttsc: plugin "${plugin.name}" requested unsupported native contract version ${backend.contractVersion}`,
-    );
-  }
-  if (backend.source) {
-    if (backend.binary) {
-      throw new Error(
-        `ttsc: plugin "${plugin.name}" must use either native.binary or native.source, not both`,
-      );
-    }
-    if (typeof backend.source.dir !== "string" || backend.source.dir.length === 0) {
-      throw new Error(
-        `ttsc: plugin "${plugin.name}" native.source.dir must be a non-empty string`,
-      );
-    }
-  }
-  return {
-    ...backend,
-    contractVersion: backend.contractVersion ?? 1,
-  };
-}

package/src/platform.ts

@@ -1,151 +0,0 @@
-/**
- * Platform detection and helper-binary resolution for ttsc.
- *
- * This is the tested implementation used by the ttsc launcher after build.
- * Keep it pure and dependency-free so it can be unit-tested without spawning
- * any child process.
- *
- * The platform packages now ship a small compatibility helper, not the
- * TypeScript-Go compiler. Compiler calls resolve the consuming project's
- * `@typescript/native-preview` through `tsgo.ts`.
- *
- * Helper resolution order:
- *
- *   1. `TTSC_BINARY` environment variable (absolute path). Highest priority —
- *      lets local devs or CI point at an ad-hoc build without touching
- *      node_modules.
- *   2. `@ttsc/{platform}-{arch}/bin/ttsc{.exe}` optional dependency.
- *      Standard distribution path for compatibility helper commands.
- *   3. A package-local `native/ttsc-native` helper. Used by this
- *      repository's local `pnpm run build` output before the
- *      platform packages exist on npm.
- *
- * If every strategy fails, `resolveBinary` returns `null` so the caller can print a
- * detailed install hint.
- */
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-import type { ITtscResolveOptions } from "./structures/ITtscResolveOptions";
-
-export type { ITtscResolveOptions } from "./structures/ITtscResolveOptions";
-
-/** Canonical key `{platform}-{arch}` used in the binary package name. */
-export function platformKey(opts: ITtscResolveOptions = {}): string {
-  const platform = opts.platform ?? process.platform;
-  const arch = opts.arch ?? process.arch;
-  return `${platform}-${arch}`;
-}
-
-/** Helper binary filename for the current platform (`.exe` on Windows, else none). */
-export function binaryName(opts: ITtscResolveOptions = {}): string {
-  const platform = opts.platform ?? process.platform;
-  return platform === "win32" ? "ttsc.exe" : "ttsc";
-}
-
-/**
- * Resolve the optional-dependency module request string for the current
- * platform. Separated from actual resolution so we can log the request when
- * the dependency is missing.
- */
-export function platformPackageRequest(opts: ITtscResolveOptions = {}): string {
-  const key = platformKey(opts);
-  const bin = binaryName(opts);
-  return `@ttsc/${key}/bin/${bin}`;
-}
-
-/** The list of platform keys the package currently ships. */
-export const SUPPORTED_PLATFORMS: readonly string[] = Object.freeze([
-  "linux-x64",
-  "linux-arm",
-  "linux-arm64",
-  "darwin-x64",
-  "darwin-arm64",
-  "win32-x64",
-  "win32-arm64",
-]);
-
-/** True if the given platform key is in the supported list. */
-export function isSupported(key: string): boolean {
-  return SUPPORTED_PLATFORMS.includes(key);
-}
-
-/**
- * Resolve an absolute path to the ttsc helper using the documented priority
- * order. Returns `null` when every strategy fails — the launcher then prints
- * the install hint and exits non-zero.
- */
-export function resolveBinary(opts: ITtscResolveOptions = {}): string | null {
-  const env = opts.env ?? process.env;
-
-  // 1. Env override. Absolute path is required; a relative value is ignored so
-  //    tests can't accidentally resolve something outside the intended tree.
-  if (env.TTSC_BINARY && path.isAbsolute(env.TTSC_BINARY)) {
-    return env.TTSC_BINARY;
-  }
-
-  // 2. Platform-specific optional dependency (the published distribution path).
-  const resolver = opts.resolver ?? ((req: string) => require.resolve(req));
-  try {
-    return resolver(platformPackageRequest(opts));
-  } catch {
-    /* fall through */
-  }
-
-  // 3. Package-local fallback: <package>/native/ttsc-native.
-  if (opts.localBinaryLookup) {
-    const local = opts.localBinaryLookup();
-    if (local) return local;
-  } else {
-    const local = defaultLocalBinaryPath(opts);
-    if (local) return local;
-  }
-
-  return null;
-}
-
-/**
- * Human-readable message shown when no binary can be located. Pure string —
- * the launcher writes it to stderr.
- */
-export function installHint(opts: ITtscResolveOptions = {}): string {
-  const key = platformKey(opts);
-  const pkg = `@ttsc/${key}`;
-  const supported = SUPPORTED_PLATFORMS.join(", ");
-  return [
-    `ttsc: platform-specific helper binary not found (${pkg}).`,
-    `Platform: ${opts.platform ?? process.platform}/${opts.arch ?? process.arch}.`,
-    ``,
-    `Resolution order:`,
-    `  1. TTSC_BINARY env var (absolute path)`,
-    `  2. ${pkg} optional dependency`,
-    `  3. ./native/ttsc-native (local workspace build)`,
-    ``,
-    `Try:`,
-    `  npm install --include=optional ${pkg}`,
-    `  pnpm install --shamefully-hoist`,
-    ``,
-    `Supported platforms: ${supported}.`,
-    `If your platform is not in that list, open an issue at`,
-    `https://github.com/samchon/ttsc/issues.`,
-  ].join("\n");
-}
-
-function defaultLocalBinaryPath(opts: ITtscResolveOptions): string | null {
-  const root = packageRootDir(opts);
-  const candidate = path.resolve(
-    root,
-    "..",
-    "native",
-    (opts.platform ?? process.platform) === "win32" ? "ttsc-native.exe" : "ttsc-native",
-  );
-  return fs.existsSync(candidate) ? candidate : null;
-}
-
-function packageRootDir(opts: ITtscResolveOptions = {}): string {
-  if (opts.moduleDir) {
-    return fs.realpathSync.native?.(opts.moduleDir) ?? fs.realpathSync(opts.moduleDir);
-  }
-  return fs.realpathSync.native?.(__dirname) ?? fs.realpathSync(__dirname);
-}

package/src/plugin.ts

@@ -1,253 +0,0 @@
-import { createRequire } from "node:module";
-import fs from "node:fs";
-import path from "node:path";
-
-import type { ITtscLoadPluginsOptions } from "./structures/ITtscLoadPluginsOptions";
-import type { ITtscLoadedNativePlugin } from "./structures/ITtscLoadedNativePlugin";
-import type { ITtscLoadedPlugins } from "./structures/ITtscLoadedPlugins";
-import type { ITtscPlugin } from "./structures/ITtscPlugin";
-import type { ITtscPluginFactory } from "./structures/ITtscPluginFactory";
-import type { ITtscPluginFactoryContext } from "./structures/ITtscPluginFactoryContext";
-import type { ITtscPluginModule } from "./structures/ITtscPluginModule";
-import type { ITtscProjectPluginConfig } from "./structures/ITtscProjectPluginConfig";
-import { resolveNativeBackend } from "./native";
-import { readProjectConfig } from "./project";
-import { buildSourcePlugin } from "./source-build";
-
-export type { ITtscLoadPluginsOptions } from "./structures/ITtscLoadPluginsOptions";
-export type { ITtscLoadedNativePlugin } from "./structures/ITtscLoadedNativePlugin";
-export type { ITtscLoadedPlugins } from "./structures/ITtscLoadedPlugins";
-export type {
-  ITtscNativePluginContractVersion,
-  ITtscNativeRewriteMode,
-  ITtscNativeBackend,
-  ITtscNativeSource,
-} from "./native";
-export type { ITtscPlugin } from "./structures/ITtscPlugin";
-export type { ITtscPluginFactory } from "./structures/ITtscPluginFactory";
-export type { ITtscPluginFactoryContext } from "./structures/ITtscPluginFactoryContext";
-export type { ITtscPluginModule } from "./structures/ITtscPluginModule";
-
-export function definePlugin<T extends ITtscPluginModule>(plugin: T): T {
-  return plugin;
-}
-
-export function loadProjectPlugins(options: ITtscLoadPluginsOptions): ITtscLoadedPlugins {
-  const project = readProjectConfig({
-    cwd: options.cwd,
-    file: options.file,
-    tsconfig: options.tsconfig,
-  });
-  const entries =
-    options.entries === false
-      ? []
-      : [...(options.entries ?? project.compilerOptions.plugins)].filter(
-          (entry) => entry.enabled !== false,
-        );
-  if (entries.length === 0) {
-    return {
-      compatibilityFallback: false,
-      nativeBinary: null,
-      nativeBinaries: [],
-      nativePlugins: [],
-      plugins: [],
-      project,
-    };
-  }
-
-  const context = {
-    binary: options.binary,
-    cwd: path.resolve(options.cwd ?? process.cwd()),
-    projectRoot: project.root,
-    tsconfig: project.path,
-  };
-  const plugins = entries.map((entry) =>
-    loadPluginEntry(entry, { ...context, plugin: entry }),
-  );
-
-  const nativePlugins: ITtscLoadedNativePlugin[] = [];
-  const ttscVersion = readTtscVersion();
-  const tsgoVersion = readTsgoVersion(context.projectRoot);
-  plugins.forEach((plugin, index) => {
-    let backend = resolveNativeBackend(plugin);
-    if (!backend) {
-      return;
-    }
-    if (backend.source && !backend.binary) {
-      const built = buildSourcePlugin({
-        baseDir: context.projectRoot,
-        pluginName: plugin.name,
-        source: backend.source,
-        ttscVersion,
-        tsgoVersion,
-      });
-      backend = { ...backend, binary: built };
-    }
-    nativePlugins.push({ backend, config: entries[index]!, name: plugin.name });
-  });
-  if (nativePlugins.length !== plugins.length) {
-    const missing = plugins
-      .filter((plugin) => !resolveNativeBackend(plugin))
-      .map((plugin) => plugin.name)
-      .join(", ");
-    throw new Error(
-      `ttsc: every plugin must declare a native backend; missing native for ${missing}`,
-    );
-  }
-  return {
-    compatibilityFallback: false,
-    nativeBinary: nativePlugins[0]?.backend.binary ?? null,
-    nativeBinaries: [
-      ...new Set(
-        nativePlugins
-          .map((plugin) => plugin.backend.binary)
-          .filter((binary): binary is string => typeof binary === "string"),
-      ),
-    ],
-    nativePlugins,
-    plugins,
-    project,
-  };
-}
-
-function loadPluginEntry(
-  entry: ITtscProjectPluginConfig,
-  context: ITtscPluginFactoryContext,
-): ITtscPlugin {
-  const specifier = entry.transform;
-  if (typeof specifier !== "string" || specifier.length === 0) {
-    throw new Error(`ttsc: plugin entry is missing a string "transform" field`);
-  }
-
-  const request = resolvePluginRequest(specifier, context.projectRoot);
-  const mod = require(request) as {
-    createTtscPlugin?: ITtscPluginFactory;
-    default?: ITtscPluginModule;
-  } & Partial<Record<"plugin", ITtscPluginModule>>;
-  const candidate =
-    mod.createTtscPlugin ??
-    mod.default ??
-    mod.plugin ??
-    (mod as unknown as ITtscPluginModule);
-  if (typeof candidate === "function") {
-    const plugin = candidate(context);
-    if (!isTtscPlugin(plugin)) {
-      throw new Error(
-        `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
-      );
-    }
-    rejectJsTransformHooks(specifier, plugin);
-    return plugin;
-  }
-  if (isTtscPlugin(candidate)) {
-    rejectJsTransformHooks(specifier, candidate);
-    return candidate;
-  }
-  throw new Error(
-    `ttsc: plugin "${specifier}" does not export a valid ttsc plugin`,
-  );
-}
-
-function isTtscPlugin(value: unknown): value is ITtscPlugin {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    typeof (value as { name?: unknown }).name === "string"
-  );
-}
-
-function rejectJsTransformHooks(specifier: string, candidate: object): void {
-  if ("transformSource" in candidate || "transformOutput" in candidate) {
-    throw new Error(
-      `ttsc: plugin "${specifier}" declares unsupported JS transform hooks; ` +
-        "declare a native backend instead",
-    );
-  }
-}
-
-function resolvePluginRequest(specifier: string, projectRoot: string): string {
-  if (path.isAbsolute(specifier)) {
-    return specifier;
-  }
-  if (isRelativePluginSpecifier(specifier)) {
-    return path.resolve(projectRoot, specifier);
-  }
-  try {
-    return require.resolve(specifier, { paths: [projectRoot] });
-  } catch (error) {
-    const sourceFallback = resolveSourceCheckoutPlugin(specifier, projectRoot);
-    if (sourceFallback) {
-      return sourceFallback;
-    }
-    throw error;
-  }
-}
-
-function isRelativePluginSpecifier(specifier: string): boolean {
-  return (
-    specifier === "." ||
-    specifier === ".." ||
-    specifier.startsWith("./") ||
-    specifier.startsWith("../") ||
-    specifier.startsWith(".\\") ||
-    specifier.startsWith("..\\")
-  );
-}
-
-function resolveSourceCheckoutPlugin(
-  specifier: string,
-  projectRoot: string,
-): string | null {
-  const normalized = specifier.replace(/\\/g, "/");
-  const match = normalized.match(/^(.*)\/lib\/transform$/);
-  if (!match) {
-    return null;
-  }
-  try {
-    const packageJson = require.resolve(`${match[1]}/package.json`, {
-      paths: [projectRoot],
-    });
-    const packageRoot = path.dirname(packageJson);
-    const candidates = [
-      path.join(packageRoot, "lib", "transform.js"),
-      path.join(packageRoot, "src", "transform.ts"),
-      path.join(packageRoot, "bin", "ttsc-plugin.cjs"),
-    ];
-    return candidates.find((candidate) => fs.existsSync(candidate)) ?? null;
-  } catch {
-    return null;
-  }
-}
-
-let cachedTtscVersion: string | null = null;
-
-function readTtscVersion(): string {
-  if (cachedTtscVersion !== null) {
-    return cachedTtscVersion;
-  }
-  try {
-    const file = path.resolve(__dirname, "..", "package.json");
-    const pkg = JSON.parse(fs.readFileSync(file, "utf8")) as {
-      version?: string;
-    };
-    cachedTtscVersion = pkg.version ?? "0.0.0";
-  } catch {
-    cachedTtscVersion = "0.0.0";
-  }
-  return cachedTtscVersion;
-}
-
-function readTsgoVersion(projectRoot: string): string {
-  try {
-    const projectRequire = createRequire(path.join(projectRoot, "package.json"));
-    const pkgPath = projectRequire.resolve(
-      "@typescript/native-preview/package.json",
-    );
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8")) as {
-      version?: string;
-    };
-    return pkg.version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}