@ttsc/unplugin 0.28.5 → 0.29.0

package/src/core/projectDiscovery.ts

@@ -0,0 +1,256 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/** Filesystem facts required to discover an implicit TypeScript project. */
+export interface TtscProjectDiscoveryFilesystem {
+  /** Override path parsing when the observed filesystem is not the host. */
+  platform?: NodeJS.Platform;
+  /** Read metadata while following links, like an ordinary config-file open. */
+  stat(
+    location: string,
+  ): Pick<fs.Stats, "isFile"> & Partial<Pick<fs.Stats, "isDirectory">>;
+}
+
+/** Directory enumeration required to discover every implicit child project. */
+export interface TtscProjectTreeDiscoveryFilesystem extends TtscProjectDiscoveryFilesystem {
+  /** Enumerate one lexical directory and identify child directory links. */
+  readdir(
+    location: string,
+  ): readonly (Pick<fs.Dirent, "isDirectory" | "name"> &
+    Partial<Pick<fs.Dirent, "isSymbolicLink">>)[];
+  /** Resolve physical directory identity for cycle-safe linked traversal. */
+  realpath?(location: string): string;
+}
+
+/** One exact file predicate consulted by nearest-project discovery. */
+export interface TtscProjectTsconfigCandidate {
+  readonly file: string;
+  readonly fileExists: boolean;
+}
+
+/** The selected config and the predicates that selected it. */
+export interface TtscProjectTsconfigDiscovery {
+  readonly candidates: readonly TtscProjectTsconfigCandidate[];
+  readonly file: string | undefined;
+}
+
+const HOST_PROJECT_DISCOVERY_FILESYSTEM: TtscProjectDiscoveryFilesystem =
+  Object.freeze({
+    stat: fs.statSync,
+  });
+
+const HOST_PROJECT_TREE_DISCOVERY_FILESYSTEM: TtscProjectTreeDiscoveryFilesystem =
+  Object.freeze({
+    readdir: (location: string) =>
+      fs.readdirSync(location, { withFileTypes: true }),
+    realpath: fs.realpathSync.native,
+    stat: fs.statSync,
+  });
+
+/** Directories deliberately outside the shared lexical project walk. */
+export function isIgnoredProjectDirectory(name: string): boolean {
+  // The residue of what used to be a fifteen-name list, kept to the VCS store,
+  // the package manager's tree, and ttsc's own plugin cache. Everything else
+  // is decided by the resolved project policy rather than a directory-name
+  // guess (samchon/ttsc#1307).
+  return name === ".git" || name === ".ttsc" || name === "node_modules";
+}
+
+/**
+ * Find the nearest ancestor `tsconfig.json` that is proven to be a file.
+ *
+ * A directory, broken link, permission failure, or any other unprovable
+ * candidate cannot terminate the walk. `stat` deliberately follows links, so a
+ * link to a regular file retains its lexical config spelling.
+ */
+export function findNearestProjectTsconfig(
+  startDirectory: string,
+  filesystem: TtscProjectDiscoveryFilesystem = HOST_PROJECT_DISCOVERY_FILESYSTEM,
+): string | undefined {
+  return findNearestProjectTsconfigImpl(startDirectory, filesystem);
+}
+
+/**
+ * Find the nearest config and retain the exact predicate observations used to
+ * select it. A cache host must not rediscover these candidates later: a file
+ * can disappear only for selection and return before that second observation.
+ */
+export function discoverNearestProjectTsconfig(
+  startDirectory: string,
+  filesystem: TtscProjectDiscoveryFilesystem = HOST_PROJECT_DISCOVERY_FILESYSTEM,
+): TtscProjectTsconfigDiscovery {
+  const candidates: TtscProjectTsconfigCandidate[] = [];
+  return {
+    candidates,
+    file: findNearestProjectTsconfigImpl(
+      startDirectory,
+      filesystem,
+      candidates,
+    ),
+  };
+}
+
+/** Shared walk with optional observation retention for cache hosts. */
+function findNearestProjectTsconfigImpl(
+  startDirectory: string,
+  filesystem: TtscProjectDiscoveryFilesystem,
+  candidates?: TtscProjectTsconfigCandidate[],
+): string | undefined {
+  const paths =
+    filesystem.platform === undefined
+      ? path
+      : filesystem.platform === "win32"
+        ? path.win32
+        : path.posix;
+  let current = paths.resolve(startDirectory);
+  while (true) {
+    const candidate = paths.join(current, "tsconfig.json");
+    let fileExists = false;
+    try {
+      fileExists = filesystem.stat(candidate).isFile();
+    } catch {
+      // An implicit candidate is selectable only when its file kind is proven.
+    }
+    candidates?.push({ file: candidate, fileExists });
+    if (fileExists) {
+      return candidate;
+    }
+    const parent = paths.dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}
+
+/**
+ * Find every regular `tsconfig.json` below one project root.
+ *
+ * The traversal retains lexical project spellings while following child
+ * directory links and junctions. A physical ancestor set cuts cycles without
+ * collapsing two independent aliases of the same project. An incomplete
+ * traversal is reported rather than returned as a complete project map, so a
+ * cache-key caller can refuse reuse.
+ */
+export function findProjectTsconfigs(
+  root: string,
+  filesystem: TtscProjectTreeDiscoveryFilesystem = HOST_PROJECT_TREE_DISCOVERY_FILESYSTEM,
+): { candidates: string[]; complete: boolean; files: string[] } {
+  const paths =
+    filesystem.platform === undefined
+      ? path
+      : filesystem.platform === "win32"
+        ? path.win32
+        : path.posix;
+  type PendingDirectory = {
+    ancestors: ReadonlySet<string>;
+    directory: string;
+    physicalAncestorsComplete: boolean;
+  };
+  const rootDirectory = paths.resolve(root);
+  const rootIdentity = projectDirectoryIdentity(
+    rootDirectory,
+    filesystem,
+    paths,
+  );
+  const pending: PendingDirectory[] = [
+    {
+      ancestors: new Set([
+        rootIdentity ??
+          canonicalProjectPath(rootDirectory, filesystem.platform),
+      ]),
+      directory: rootDirectory,
+      physicalAncestorsComplete:
+        filesystem.realpath === undefined || rootIdentity !== undefined,
+    },
+  ];
+  const candidates: string[] = [];
+  const files: string[] = [];
+  let complete =
+    filesystem.realpath === undefined || rootIdentity !== undefined;
+  while (pending.length !== 0) {
+    const current = pending.pop()!;
+    const directory = current.directory;
+    let entries: readonly (Pick<fs.Dirent, "isDirectory" | "name"> &
+      Partial<Pick<fs.Dirent, "isSymbolicLink">>)[];
+    try {
+      entries = filesystem.readdir(directory);
+    } catch {
+      complete = false;
+      continue;
+    }
+    for (const entry of entries) {
+      if (isIgnoredProjectDirectory(entry.name)) continue;
+      const child = paths.join(directory, entry.name);
+      const linked = entry.isSymbolicLink?.() === true;
+      let directoryEntry = entry.isDirectory();
+      if (!directoryEntry && linked) {
+        try {
+          directoryEntry = filesystem.stat(child).isDirectory?.() === true;
+        } catch (error) {
+          const code = (error as NodeJS.ErrnoException).code;
+          if (code !== "ENOENT" && code !== "ENOTDIR") complete = false;
+          continue;
+        }
+      }
+      if (!directoryEntry) continue;
+      const identity = projectDirectoryIdentity(child, filesystem, paths);
+      const physicalAncestorsComplete =
+        current.physicalAncestorsComplete &&
+        (filesystem.realpath === undefined || identity !== undefined);
+      if (filesystem.realpath !== undefined && identity === undefined) {
+        complete = false;
+      }
+      if (linked && (identity === undefined || !physicalAncestorsComplete)) {
+        complete = false;
+        continue;
+      }
+      const stableIdentity =
+        identity ?? canonicalProjectPath(child, filesystem.platform);
+      if (current.ancestors.has(stableIdentity)) continue;
+      pending.push({
+        ancestors: new Set([...current.ancestors, stableIdentity]),
+        directory: child,
+        physicalAncestorsComplete,
+      });
+    }
+    const candidate = paths.join(directory, "tsconfig.json");
+    candidates.push(candidate);
+    try {
+      if (filesystem.stat(candidate).isFile()) {
+        files.push(candidate);
+      }
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") {
+        complete = false;
+      }
+    }
+  }
+  candidates.sort();
+  files.sort();
+  return { candidates, complete, files };
+}
+
+function projectDirectoryIdentity(
+  directory: string,
+  filesystem: TtscProjectTreeDiscoveryFilesystem,
+  paths: typeof path.posix | typeof path.win32,
+): string | undefined {
+  if (filesystem.realpath === undefined) return undefined;
+  try {
+    return canonicalProjectPath(
+      paths.resolve(filesystem.realpath(directory)),
+      filesystem.platform,
+    );
+  } catch {
+    return undefined;
+  }
+}
+
+function canonicalProjectPath(
+  location: string,
+  platform: NodeJS.Platform | undefined,
+): string {
+  return platform === "win32" ? location.toLowerCase() : location;
+}

package/src/core/sourceExtensions.ts

@@ -0,0 +1,47 @@
+/**
+ * The complete TypeScript source-extension contract shared by every adapter.
+ *
+ * Keep the loader beside the extension so filters, Bun's parser selection,
+ * Turbopack registration, and project discovery cannot drift independently.
+ */
+const TYPESCRIPT_TRANSFORM_SOURCES = [
+  { extension: ".ts", bunLoader: "ts" },
+  { extension: ".tsx", bunLoader: "tsx" },
+  { extension: ".mts", bunLoader: "ts" },
+  { extension: ".cts", bunLoader: "ts" },
+] as const;
+
+/** Every source extension accepted by the ttsc transform. */
+export const TYPESCRIPT_TRANSFORM_EXTENSIONS: readonly string[] =
+  TYPESCRIPT_TRANSFORM_SOURCES.map(({ extension }) => extension);
+
+/** The exact automatic and documented Turbopack rule set. */
+export const TYPESCRIPT_TURBOPACK_RULE_GLOBS: readonly string[] =
+  TYPESCRIPT_TRANSFORM_SOURCES.map(({ extension }) => `*${extension}`);
+
+const extensionAlternation =
+  TYPESCRIPT_TRANSFORM_EXTENSIONS.map(escapeRegExp).join("|");
+
+/** Matches exactly the TypeScript source extensions the transform accepts. */
+export const typescriptTransformSourcePattern = new RegExp(
+  `(?:${extensionAlternation})$`,
+);
+
+/** Bun's registration filter, additionally excluding virtual NUL ids. */
+export const bunTypeScriptTransformSourcePattern = new RegExp(
+  `^[^\\x00]*(?:${extensionAlternation})$`,
+);
+
+/** Select Bun's parser for an exact TypeScript transform source. */
+export function typescriptTransformBunLoader(
+  filePath: string,
+): "ts" | "tsx" | undefined {
+  return TYPESCRIPT_TRANSFORM_SOURCES.find(({ extension }) =>
+    filePath.endsWith(extension),
+  )?.bunLoader;
+}
+
+/** Escape a literal extension for a generated regular expression. */
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}