ttsc 0.8.1 → 0.10.0

package/src/plugin/internal/loadProjectPlugins.ts

@@ -15,12 +15,25 @@ type TtscPluginFactory<T = ITtscProjectPluginConfig> = (
   context: ITtscPluginFactoryContext<T>,
 ) => ITtscPlugin;
 
+type ProjectPluginEntry = {
+  baseDir: string;
+  config: ITtscProjectPluginConfig;
+};
+
+type PackageManifest = {
+  dependencies?: Record<string, unknown>;
+  devDependencies?: Record<string, unknown>;
+  name?: unknown;
+  ttsc?: unknown;
+};
+
 export function loadProjectPlugins(options: {
   binary: string;
   cacheDir?: string;
   cwd?: string;
   entries?: readonly ITtscProjectPluginConfig[] | false;
   file?: string;
+  projectRoot?: string;
   tsconfig?: string;
 }): {
   nativePlugins: ITtscLoadedNativePlugin[];
@@ -29,13 +42,14 @@ export function loadProjectPlugins(options: {
   const project = readProjectConfig({
     cwd: options.cwd,
     file: options.file,
+    projectRoot: options.projectRoot,
     tsconfig: options.tsconfig,
   });
-  const entries =
+  const entries: ProjectPluginEntry[] =
     options.entries === false
       ? []
-      : [...(options.entries ?? project.compilerOptions.plugins)].filter(
-          (entry) => entry.enabled !== false,
+      : resolvePluginEntries(project, options.entries).filter(
+          (entry) => entry.config.enabled !== false,
         );
   if (entries.length === 0) {
     return {
@@ -51,7 +65,11 @@ export function loadProjectPlugins(options: {
     tsconfig: project.path,
   };
   const plugins = entries.map((entry) =>
-    loadPluginEntry(entry, { ...context, plugin: entry }),
+    loadPluginEntry(
+      entry.config,
+      { ...context, plugin: entry.config },
+      entry.baseDir,
+    ),
   );
 
   const nativePlugins: ITtscLoadedNativePlugin[] = [];
@@ -70,28 +88,258 @@ export function loadProjectPlugins(options: {
     });
     nativePlugins.push({
       binary,
-      config: entries[index]!,
+      config: entries[index]!.config,
       name: plugin.name,
       source: plugin.source,
       stage,
     });
   });
   return {
-    nativePlugins,
+    nativePlugins: orderNativePlugins(nativePlugins),
     project,
   };
 }
 
+export function hasProjectPluginEntries(
+  project: ITtscParsedProjectConfig,
+  entries?: readonly ITtscProjectPluginConfig[] | false,
+): boolean {
+  if (entries === false) {
+    return false;
+  }
+  return resolvePluginEntries(project, entries).some(
+    (entry) => entry.config.enabled !== false,
+  );
+}
+
+function resolvePluginEntries(
+  project: ITtscParsedProjectConfig,
+  entries?: readonly ITtscProjectPluginConfig[],
+): ProjectPluginEntry[] {
+  if (entries !== undefined) {
+    return entries.map((config) => ({
+      baseDir: project.root,
+      config,
+    }));
+  }
+  const configured = project.compilerOptions.plugins.map((config, index) => ({
+    baseDir: project.pluginBaseDirs[index] ?? project.root,
+    config,
+  }));
+  return [...configured, ...discoverPackagePluginEntries(project, configured)];
+}
+
+function discoverPackagePluginEntries(
+  project: ITtscParsedProjectConfig,
+  configured: readonly ProjectPluginEntry[],
+): ProjectPluginEntry[] {
+  const projectPackageJson = findNearestPackageJson(project.root);
+  if (projectPackageJson === undefined) {
+    return [];
+  }
+  const projectPackageRoot = path.dirname(projectPackageJson);
+  const projectManifest = readPackageManifest(projectPackageJson);
+  if (projectManifest === undefined) {
+    return [];
+  }
+
+  const configuredTransforms = createConfiguredTransformSet(configured);
+  const out: ProjectPluginEntry[] = [];
+  for (const name of directDependencyNames(projectManifest)) {
+    const packageJson = resolveDependencyPackageJson(name, projectPackageRoot);
+    if (packageJson === undefined) {
+      continue;
+    }
+    const manifest = readPackageManifest(packageJson);
+    const config = readPackagePluginConfig(name, manifest);
+    if (config === undefined || config.enabled === false) {
+      continue;
+    }
+    const packageRoot = path.dirname(packageJson);
+    const transform = config.transform;
+    if (typeof transform !== "string") {
+      continue;
+    }
+    const baseDir = isRelativePluginSpecifier(transform)
+      ? packageRoot
+      : projectPackageRoot;
+    const resolved = resolvePluginRequest(transform, baseDir);
+    if (hasConfiguredTransform(configuredTransforms, transform, resolved)) {
+      continue;
+    }
+    out.push({
+      baseDir,
+      config,
+    });
+    addConfiguredTransform(configuredTransforms, transform, resolved);
+  }
+  return out;
+}
+
+type ConfiguredTransformSet = {
+  raw: Set<string>;
+  resolved: Set<string>;
+};
+
+function createConfiguredTransformSet(
+  entries: readonly ProjectPluginEntry[],
+): ConfiguredTransformSet {
+  const raw = new Set<string>();
+  const resolved = new Set<string>();
+  for (const entry of entries) {
+    const transform = entry.config.transform;
+    if (typeof transform !== "string" || transform.length === 0) {
+      continue;
+    }
+    if (!isRelativePluginSpecifier(transform)) {
+      raw.add(transform);
+    }
+    try {
+      resolved.add(resolvePluginRequest(transform, entry.baseDir));
+    } catch {
+      // Keep the normal plugin loading error path for invalid explicit entries.
+    }
+  }
+  return { raw, resolved };
+}
+
+function hasConfiguredTransform(
+  configuredTransforms: ConfiguredTransformSet,
+  transform: string,
+  resolved: string,
+): boolean {
+  return (
+    configuredTransforms.resolved.has(resolved) ||
+    (!isRelativePluginSpecifier(transform) &&
+      configuredTransforms.raw.has(transform))
+  );
+}
+
+function addConfiguredTransform(
+  configuredTransforms: ConfiguredTransformSet,
+  transform: string,
+  resolved: string,
+): void {
+  if (!isRelativePluginSpecifier(transform)) {
+    configuredTransforms.raw.add(transform);
+  }
+  configuredTransforms.resolved.add(resolved);
+}
+
+function directDependencyNames(manifest: PackageManifest): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const dependencies of [
+    manifest.dependencies,
+    manifest.devDependencies,
+  ]) {
+    if (!isRecord(dependencies)) {
+      continue;
+    }
+    for (const name of Object.keys(dependencies)) {
+      if (seen.has(name)) {
+        continue;
+      }
+      seen.add(name);
+      out.push(name);
+    }
+  }
+  return out;
+}
+
+function resolveDependencyPackageJson(
+  name: string,
+  projectRoot: string,
+): string | undefined {
+  const direct = path.join(projectRoot, "node_modules", ...name.split("/"));
+  const directManifest = path.join(direct, "package.json");
+  if (fs.existsSync(directManifest)) {
+    return resolveRealPath(directManifest);
+  }
+  const projectPackage = path.join(projectRoot, "package.json");
+  const projectRequire = createRequire(projectPackage);
+  try {
+    return resolveRealPath(projectRequire.resolve(`${name}/package.json`));
+  } catch {
+    try {
+      return findNearestPackageJson(projectRequire.resolve(name));
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+function findNearestPackageJson(location: string): string | undefined {
+  let current = fs.statSync(location).isDirectory()
+    ? location
+    : path.dirname(location);
+  while (true) {
+    const manifest = path.join(current, "package.json");
+    if (fs.existsSync(manifest)) {
+      return resolveRealPath(manifest);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}
+
+function readPackageManifest(file: string): PackageManifest | undefined {
+  if (!fs.existsSync(file)) {
+    return undefined;
+  }
+  const parsed = JSON.parse(fs.readFileSync(file, "utf8")) as unknown;
+  return isRecord(parsed) ? (parsed as PackageManifest) : undefined;
+}
+
+function readPackagePluginConfig(
+  packageName: string,
+  manifest: PackageManifest | undefined,
+): ITtscProjectPluginConfig | undefined {
+  const ttsc = manifest?.ttsc;
+  if (!isRecord(ttsc) || !("plugin" in ttsc)) {
+    return undefined;
+  }
+  const plugin = ttsc.plugin;
+  if (!isRecord(plugin) || Array.isArray(plugin)) {
+    throw new Error(
+      `ttsc: package ${JSON.stringify(packageName)} declares invalid "ttsc.plugin"; expected an object`,
+    );
+  }
+  if (typeof plugin.transform !== "string" || plugin.transform.length === 0) {
+    throw new Error(
+      `ttsc: package ${JSON.stringify(packageName)} declares invalid "ttsc.plugin.transform"; expected a non-empty string`,
+    );
+  }
+  return { ...plugin } as ITtscProjectPluginConfig;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function orderNativePlugins(
+  plugins: readonly ITtscLoadedNativePlugin[],
+): ITtscLoadedNativePlugin[] {
+  return [
+    ...plugins.filter((plugin) => plugin.stage === "check"),
+    ...plugins.filter((plugin) => plugin.stage === "transform"),
+  ];
+}
+
 function loadPluginEntry(
   entry: ITtscProjectPluginConfig,
   context: ITtscPluginFactoryContext,
+  baseDir: string,
 ): 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 request = resolvePluginRequest(specifier, baseDir);
   const mod = require(request) as {
     createTtscPlugin?: TtscPluginFactory;
     default?: ITtscPlugin | TtscPluginFactory;
@@ -170,12 +418,20 @@ function isPluginStage(value: string): value is TtscPluginStage {
 
 function resolvePluginRequest(specifier: string, projectRoot: string): string {
   if (path.isAbsolute(specifier)) {
-    return specifier;
+    return resolveRealPath(specifier);
   }
   if (isRelativePluginSpecifier(specifier)) {
-    return path.resolve(projectRoot, specifier);
+    return resolveRealPath(path.resolve(projectRoot, specifier));
+  }
+  return resolveRealPath(require.resolve(specifier, { paths: [projectRoot] }));
+}
+
+function resolveRealPath(location: string): string {
+  try {
+    return fs.realpathSync(location);
+  } catch {
+    return location;
   }
-  return require.resolve(specifier, { paths: [projectRoot] });
 }
 
 function isRelativePluginSpecifier(specifier: string): boolean {

package/src/structures/ITtscCompilerContext.ts

@@ -35,6 +35,17 @@ export interface ITtscCompilerContext {
    */
   tsconfig?: string;
 
+  /**
+   * Project root override for generated config wrappers.
+   *
+   * Most callers should leave this unset so the project root is the directory
+   * containing {@link ITtscCompilerContext.tsconfig}. Embedders that synthesize
+   * a temporary config extending a real project config can set this to keep
+   * plugin resolution, cache paths, and native sidecar `--cwd` anchored to the
+   * real project.
+   */
+  projectRoot?: string;
+
   /**
    * Explicit TypeScript-Go executable for controlled embedding.
    *
@@ -73,9 +84,12 @@ export interface ITtscCompilerContext {
   /**
    * Plugin entries for this compiler instance.
    *
-   * - `undefined`: read `compilerOptions.plugins` from the project config.
-   * - `false`: ignore project plugins for this compiler instance.
-   * - array: use these plugin entries instead of the project config entries.
+   * - `undefined`: read project plugins from `compilerOptions.plugins` and
+   *   directly installed package markers.
+   * - `false`: ignore project config plugins and package markers for this
+   *   compiler instance.
+   * - array: use these plugin entries instead of project config entries and
+   *   package markers.
    *
    * Plugin entries are resolved once per operation from this instance context.
    * Per-call plugin overrides are intentionally not part of the public API.

package/src/structures/ITtscCompilerResult.ts

@@ -34,6 +34,11 @@ export namespace ITtscCompilerResult {
      */
     type: "success";
 
+    /**
+     * Non-fatal diagnostics reported during compilation.
+     */
+    diagnostics?: ITtscCompilerDiagnostic[];
+
     /**
      * The generated compiler output.
      *

package/src/structures/ITtscCompilerTransformation.ts

@@ -19,6 +19,9 @@ export namespace ITtscCompilerTransformation {
     /** Indicates that transformation completed without diagnostics. */
     type: "success";
 
+    /** Non-fatal diagnostics reported during transformation. */
+    diagnostics?: ITtscCompilerDiagnostic[];
+
     /** Transformed TypeScript source text keyed by project file path. */
     typescript: Record<string, string>;
   }

package/src/structures/ITtscPluginFactoryContext.ts

@@ -43,10 +43,13 @@ export interface ITtscPluginFactoryContext<T = ITtscProjectPluginConfig> {
   plugin: T;
 
   /**
-   * Directory containing the resolved tsconfig/jsconfig.
+   * Project root used as the native plugin working directory and package
+   * discovery base.
    *
-   * Relative plugin module specifiers and plugin source paths are resolved from
-   * this directory, matching TypeScript plugin config behavior.
+   * By default this is the directory containing the resolved tsconfig/jsconfig.
+   * Callers may override it when a wrapper config lives outside the project.
+   * Relative `source` paths returned by a plugin descriptor resolve from this
+   * directory.
    */
   projectRoot: string;
 

package/src/structures/ITtscProjectPluginConfig.ts

@@ -1,9 +1,10 @@
 /**
- * Raw `compilerOptions.plugins[]` entry read from tsconfig/jsconfig.
+ * Raw plugin entry read from `compilerOptions.plugins[]` or from a directly
+ * installed package's `package.json#ttsc.plugin` marker.
  *
- * This is the project-facing config shape that users write in
- * `tsconfig.json`. ttsc deliberately keeps it open-ended because plugin
- * packages own their own config fields.
+ * This is the project-facing config shape that users write in `tsconfig.json`
+ * or plugin packages expose through `package.json`. ttsc deliberately keeps it
+ * open-ended because plugin packages own their own config fields.
  *
  * ttsc interprets only two properties:
  *
@@ -28,9 +29,9 @@ export interface ITtscProjectPluginConfig {
   /**
    * Plugin module specifier, relative path, or absolute path to load.
    *
-   * Relative paths are resolved from the resolved project root, which is the
-   * directory containing the active tsconfig/jsconfig. Package specifiers are
-   * resolved with Node's package resolution from that same project root.
+   * Relative paths are resolved from the tsconfig/jsconfig file that declared
+   * the plugin entry. Package specifiers are resolved with Node's package
+   * resolution from that same directory.
    *
    * The loaded JavaScript module must export an {@link ITtscPlugin} descriptor
    * or a `createTtscPlugin(context)` factory. The Go implementation itself is

package/src/structures/internal/ITtscParsedProjectConfig.ts

@@ -11,6 +11,8 @@ export interface ITtscParsedProjectConfig {
   } & Record<string, unknown>;
   /** Absolute path to the resolved tsconfig/jsconfig. */
   path: string;
+  /** Directory that declared each inherited plugin entry. */
+  pluginBaseDirs: string[];
   /** Directory containing the resolved tsconfig/jsconfig. */
   root: string;
 }

package/src/structures/internal/ITtscProjectLocatorOptions.ts

@@ -4,6 +4,8 @@ export interface ITtscProjectLocatorOptions {
   cwd?: string;
   /** Source file used as the starting point for nearest-config discovery. */
   file?: string;
+  /** Project root override for generated tsconfig wrappers. */
+  projectRoot?: string;
   /** Explicit tsconfig/jsconfig path. */
   tsconfig?: string;
 }

package/src/structures/internal/TtscCommonOptions.ts

@@ -11,6 +11,8 @@ export interface TtscCommonOptions {
   binary?: string;
   /** Working directory for config discovery and relative file paths. */
   cwd?: string;
+  /** Project root override for generated tsconfig wrappers. */
+  projectRoot?: string;
   /** Environment variables merged over `process.env` for child processes. */
   env?: NodeJS.ProcessEnv;
   /** Explicit root directory for compiled source-plugin cache artifacts. */