ttsc 0.19.3 → 0.20.0

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

@@ -0,0 +1,209 @@
+import fs from "node:fs";
+
+/**
+ * Attributed JSON / JSONC readers for every configuration file ttsc owns.
+ *
+ * A bare `JSON.parse` failure reports a byte offset in an unnamed file, which
+ * is unusable exactly where attribution matters most: an `extends` chain, where
+ * any ancestor could be the source, and a watch session, which reprints the
+ * same line on every save. Every ttsc-owned configuration read goes through
+ * these helpers so the failure names its file and position in ttsc's own
+ * diagnostic voice, like the neighbouring `ttsc: extended tsconfig not found:
+ * …`.
+ *
+ * Comment, trailing-comma, and BOM removal is length-preserving (each removed
+ * character becomes a space, each removed newline stays a newline), so the line
+ * and column the JSON parser reports are the position in the file the user
+ * actually edited rather than in a shortened intermediate string.
+ */
+
+/**
+ * Read and parse a strict-JSON configuration file (`package.json`), naming it
+ * on failure.
+ *
+ * A leading UTF-8 BOM is accepted, matching the tsconfig reader that closed
+ * issue #216: the two readers are consulted for the same project and
+ * disagreeing about a byte order mark would only surprise the user who hit it.
+ */
+export function readJsonFile(file: string): unknown {
+  const text = stripLeadingBom(fs.readFileSync(file, "utf8"));
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`ttsc: failed to parse ${file}: ${describe(error)}`);
+  }
+}
+
+/**
+ * Read and parse a JSONC (JSON with comments and trailing commas) configuration
+ * file — tsconfig.json, jsconfig.json — naming it on failure.
+ */
+export function readJsoncFile(file: string): unknown {
+  const text = fs.readFileSync(file, "utf8");
+  try {
+    return parseJsonc(text);
+  } catch (error) {
+    throw new Error(`ttsc: failed to parse ${file}: ${describe(error)}`);
+  }
+}
+
+/**
+ * Parse a JSONC string by blanking comments and trailing commas before handing
+ * off to `JSON.parse`. Callers hold a path, so they go through
+ * {@link readJsoncFile} and their failures are attributed.
+ */
+function parseJsonc(input: string): unknown {
+  return JSON.parse(stripTrailingCommas(stripComments(stripLeadingBom(input))));
+}
+
+/** Render a parse failure's message without the `Error:` noise around it. */
+function describe(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Replace a leading UTF-8 BOM with a space. JSON ignores leading whitespace, so
+ * blanking rather than removing keeps every later offset equal to the offset in
+ * the original file. A BOM anywhere else is left in place and still rejected,
+ * which is the behaviour issue #216 pinned.
+ */
+function stripLeadingBom(input: string): string {
+  return input.charCodeAt(0) === 0xfeff ? ` ${input.slice(1)}` : input;
+}
+
+/**
+ * Blank `//` line comments and `/* block comments *\/` in a JSONC string,
+ * writing a space for every removed character and preserving newlines.
+ * Correctly handles strings that contain comment-like character sequences by
+ * tracking string boundaries and escape characters.
+ */
+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;
+        output += "  ";
+        i += 1;
+        continue;
+      }
+      output += blank(current);
+      continue;
+    }
+    if (inLineComment) {
+      if (current === "\n") {
+        inLineComment = false;
+        output += current;
+        continue;
+      }
+      output += blank(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 = true;
+      quote = current;
+      output += current;
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      inLineComment = true;
+      output += "  ";
+      i += 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      inBlockComment = true;
+      output += "  ";
+      i += 1;
+      continue;
+    }
+    output += current;
+  }
+  return output;
+}
+
+/** Keep a newline as a newline; every other removed character becomes a space. */
+function blank(current: string): string {
+  return current === "\n" ? "\n" : " ";
+}
+
+/**
+ * Blank trailing commas before `}` or `]` in a JSON string (after comments have
+ * already been blanked). Handles string boundaries and escape characters to
+ * avoid touching commas inside string values.
+ */
+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 === "]") {
+        output += " ";
+        continue;
+      }
+    }
+    output += current;
+  }
+  return output;
+}
+
+/**
+ * Return the first non-whitespace character at or after position `from` in
+ * `input`, or `undefined` when only whitespace remains. Used by
+ * `stripTrailingCommas` to detect whether a comma is trailing.
+ */
+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/src/compiler/internal/project/readProjectConfig.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import type { ITtscProjectPluginConfig } from "../../../structures/ITtscProjectPluginConfig";
 import type { ITtscParsedProjectConfig } from "../../../structures/internal/ITtscParsedProjectConfig";
 import type { ITtscProjectLocatorOptions } from "../../../structures/internal/ITtscProjectLocatorOptions";
+import { readJsonFile, readJsoncFile } from "./readConfigJson";
 import { resolveProjectIdentity } from "./resolveProjectConfig";
 
 /**
@@ -18,6 +19,7 @@ const PATH_OPTIONS = new Set(["baseUrl", "declarationDir", "rootDir"]);
  * projected into `ITtscParsedProjectConfig`.
  */
 type ResolvedCompilerOptions = {
+  configPaths: string[];
   options: Record<string, unknown>;
   /** Directory of the tsconfig that last declared each option key. */
   optionBaseDirs: Record<string, string>;
@@ -45,6 +47,7 @@ export function readProjectConfig(
   const root = identity.physicalProjectRoot;
   const compilerOptions = readResolvedCompilerOptions(tsconfig);
   return {
+    configPaths: compilerOptions.configPaths,
     compilerOptions: {
       ...compilerOptions.options,
       outDir: compilerOptions.outDir,
@@ -101,7 +104,7 @@ function readResolvedCompilerOptions(
   }
   seen.add(canonical);
   try {
-    const parsed = parseJsonc(fs.readFileSync(canonical, "utf8")) as {
+    const parsed = readJsoncFile(canonical) as {
       extends?: unknown;
       compilerOptions?: Record<string, unknown> & {
         outDir?: unknown;
@@ -134,6 +137,7 @@ function readResolvedCompilerOptions(
       ? ownPlugins.filter(isProjectPluginConfig)
       : base.plugins;
     return {
+      configPaths: uniquePaths([...base.configPaths, canonical]),
       optionBaseDirs,
       options,
       outDir:
@@ -174,6 +178,7 @@ function resolveBaseCompilerOptions(
   }
   if (!Array.isArray(extended)) {
     return {
+      configPaths: [],
       optionBaseDirs: {},
       options: {},
       pluginBaseDirs: [],
@@ -182,6 +187,7 @@ function resolveBaseCompilerOptions(
     };
   }
   let merged: ResolvedCompilerOptions = {
+    configPaths: [],
     optionBaseDirs: {},
     options: {},
     pluginBaseDirs: [],
@@ -197,6 +203,7 @@ function resolveBaseCompilerOptions(
       seen,
     );
     merged = {
+      configPaths: uniquePaths([...merged.configPaths, ...current.configPaths]),
       optionBaseDirs: {
         ...merged.optionBaseDirs,
         ...current.optionBaseDirs,
@@ -216,6 +223,10 @@ function resolveBaseCompilerOptions(
   return merged;
 }
 
+function uniquePaths(paths: readonly string[]): string[] {
+  return [...new Set(paths)];
+}
+
 /**
  * Resolve path-typed compiler options to absolute paths using the directory of
  * the tsconfig that declared each option (`baseDirs`).
@@ -272,9 +283,10 @@ function resolveExtendsConfig(tsconfig: string, specifier: string): string {
 /**
  * When `specifier` names a bare package root, resolve the config file its
  * `package.json#tsconfig` field selects (anchored at the package directory).
- * Returns `undefined` when the specifier is a subpath, the manifest is
- * unresolvable/unparsable, or it declares no `tsconfig` field, so the caller
- * falls back to Node entrypoint resolution.
+ * Returns `undefined` when the specifier is a subpath, the manifest cannot be
+ * resolved at all, or it declares no `tsconfig` field, so the caller falls back
+ * to Node entrypoint resolution. A manifest that resolves but does not parse
+ * throws, naming the file.
  */
 function resolvePackageManifestTsconfig(
   resolver: NodeRequire,
@@ -286,19 +298,38 @@ function resolvePackageManifestTsconfig(
   let manifestPath: string;
   try {
     manifestPath = resolver.resolve(`${specifier}/package.json`);
-  } catch {
-    return undefined;
-  }
-  let field: unknown;
-  try {
-    field = (
-      JSON.parse(stripLeadingBom(fs.readFileSync(manifestPath, "utf8"))) as {
-        tsconfig?: unknown;
-      }
-    ).tsconfig;
-  } catch {
+  } catch (error) {
+    // Node parses a package's manifest while resolving into it, so a malformed
+    // preset manifest fails here rather than at the read below. Swallowing it
+    // is what turned a broken manifest into the confusing downstream
+    // "Cannot find module 'example-preset.json'" from the `extends` fallback,
+    // which names a file that was never the problem. Node's own message names
+    // the real one, so report it in ttsc's voice instead of continuing.
+    if (
+      (error as NodeJS.ErrnoException | undefined)?.code ===
+      "ERR_INVALID_PACKAGE_CONFIG"
+    ) {
+      throw new Error(
+        `ttsc: failed to parse the package manifest of ${JSON.stringify(specifier)}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
     return undefined;
   }
+  // A manifest that exists but does not parse is a real configuration error,
+  // and it used to be swallowed here: the read returned `undefined`, the caller
+  // fell back to Node entrypoint resolution, and the user learned nothing about
+  // the file that actually broke. Report it instead.
+  //
+  // A manifest that parses to something other than an object carries no
+  // `tsconfig` field to read, so it falls back rather than throwing on a
+  // property access.
+  const manifest = readJsonFile(manifestPath);
+  const field =
+    typeof manifest === "object" && manifest !== null
+      ? (manifest as { tsconfig?: unknown }).tsconfig
+      : undefined;
   if (typeof field !== "string" || field.length === 0) {
     return undefined;
   }
@@ -318,23 +349,31 @@ function isBarePackageRoot(specifier: string): boolean {
 }
 
 /**
- * Given an on-disk location, try the path as-is, with `.json` appended, and as
- * a directory containing `tsconfig.json`. Returns the first match or throws.
+ * Given an on-disk location, try the path as-is and, unless it already ends in
+ * `.json`, with that extension appended. Only regular files are valid `extends`
+ * targets; TypeScript neither expands a directory into `tsconfig.json` nor
+ * probes a double `.json` suffix.
  */
 function resolveExistingExtendsPath(location: string): string {
-  const candidates = new Set<string>([
-    location,
-    `${location}.json`,
-    path.join(location, "tsconfig.json"),
-  ]);
+  const candidates = location.endsWith(".json")
+    ? [location]
+    : [location, `${location}.json`];
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
+    if (isFile(candidate)) {
       return resolveRealPath(candidate);
     }
   }
   throw new Error(`ttsc: extended tsconfig not found: ${location}`);
 }
 
+function isFile(location: string): boolean {
+  try {
+    return fs.statSync(location).isFile();
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Return true when `specifier` is a relative path reference: `.`, `..`, or a
  * string starting with `./`, `../`, `.\\`, or `..\\`.
@@ -349,138 +388,3 @@ function isRelativeSpecifier(specifier: string): boolean {
     specifier.startsWith("..\\")
   );
 }
-
-/**
- * Parse a JSONC (JSON with Comments) string by stripping comments and trailing
- * commas before handing off to `JSON.parse`.
- */
-function parseJsonc(input: string): unknown {
-  return JSON.parse(stripTrailingCommas(stripComments(stripLeadingBom(input))));
-}
-
-function stripLeadingBom(input: string): string {
-  return input.charCodeAt(0) === 0xfeff ? input.slice(1) : input;
-}
-
-/**
- * Remove `//` line comments and `/* block comments *\/` from a JSONC string.
- * Correctly handles strings that contain comment-like character sequences by
- * tracking string boundaries and escape characters.
- */
-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 = 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;
-}
-
-/**
- * Remove trailing commas before `}` or `]` from a JSON string (after comments
- * have already been stripped). Handles string boundaries and escape characters
- * to avoid removing commas inside string values.
- */
-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;
-}
-
-/**
- * Return the first non-whitespace character at or after position `from` in
- * `input`, or `undefined` when only whitespace remains. Used by
- * `stripTrailingCommas` to detect whether a comma is trailing.
- */
-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;
-}