@emeryld/rrroutes-export 1.0.8 → 1.0.9

package/dist/index.mjs

@@ -1340,9 +1340,11 @@ async function runExportFinalizedLeavesCli(argv) {
 import fs2 from "fs/promises";
 import os from "os";
 import path4 from "path";
+import crypto from "crypto";
 import { execFile as execFileCallback, spawn as spawn2 } from "child_process";
 import { promisify } from "util";
 import { pathToFileURL as pathToFileURL2 } from "url";
+import ts2 from "typescript";
 var execFile = promisify(execFileCallback);
 var CHANGESET_CFG_FIELDS = [
   "summary",
@@ -1825,96 +1827,213 @@ async function pathExists(filePath) {
     return false;
   }
 }
-async function createMissingJsImportShims(worktreeDir) {
-  const shimWrites = [];
-  const filesToScan = [];
-  const skipNames = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build"]);
+function isTypeScriptModule(modulePath) {
+  const ext = path4.extname(modulePath).toLowerCase();
+  return ext === ".ts" || ext === ".tsx" || ext === ".mts" || ext === ".cts";
+}
+function isJavaScriptModule(modulePath) {
+  const ext = path4.extname(modulePath).toLowerCase();
+  return ext === ".js" || ext === ".mjs" || ext === ".cjs";
+}
+async function resolveSnapshotTsconfig(worktreeDir, modulePath, tsconfigOverride) {
+  if (tsconfigOverride) {
+    const resolved = path4.resolve(worktreeDir, tsconfigOverride);
+    if (!await pathExists(resolved)) {
+      throw new Error(`tsconfig not found: ${resolved}`);
+    }
+    return resolved;
+  }
+  let current = path4.dirname(modulePath);
+  const normalizedRoot = normalizePath(path4.resolve(worktreeDir));
+  while (true) {
+    const candidate = path4.join(current, "tsconfig.json");
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) break;
+    if (!normalizePath(parent).startsWith(normalizedRoot)) break;
+    current = parent;
+  }
+  throw new Error(
+    `Unable to resolve tsconfig for TypeScript module: ${modulePath}. Pass --tsconfig to override.`
+  );
+}
+function toEmittedModulePath(moduleRel) {
+  const normalized = normalizePath(moduleRel);
+  if (normalized.endsWith(".mts")) return normalized.slice(0, -4) + ".mjs";
+  if (normalized.endsWith(".cts")) return normalized.slice(0, -4) + ".cjs";
+  if (normalized.endsWith(".tsx")) return normalized.slice(0, -4) + ".js";
+  if (normalized.endsWith(".ts")) return normalized.slice(0, -3) + ".js";
+  return normalized;
+}
+function buildCompileCacheKey(commitSha, moduleRel, tsconfigPath, tsconfigStat) {
+  return crypto.createHash("sha1").update(commitSha).update("\n").update(normalizePath(moduleRel)).update("\n").update(normalizePath(tsconfigPath)).update("\n").update(String(tsconfigStat.mtimeMs)).update("\n").update(String(tsconfigStat.size)).digest("hex");
+}
+async function collectFilesRecursive(rootDir) {
+  const files = [];
   const walk = async (dir) => {
     const entries = await fs2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
+      const target = path4.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (skipNames.has(entry.name)) continue;
-        await walk(path4.join(dir, entry.name));
+        await walk(target);
         continue;
       }
-      if (!entry.isFile()) continue;
-      if (!/\\.(ts|tsx|mts)$/.test(entry.name)) continue;
-      filesToScan.push(path4.join(dir, entry.name));
-    }
-  };
-  await walk(worktreeDir);
-  const importRegexes = [
-    /\\bfrom\\s+['\"](\\.[^'\"]+\\.js)['\"]/g,
-    /\\bimport\\(\\s*['\"](\\.[^'\"]+\\.js)['\"]\\s*\\)/g,
-    /\\brequire\\(\\s*['\"](\\.[^'\"]+\\.js)['\"]\\s*\\)/g
-  ];
-  const seen = /* @__PURE__ */ new Set();
-  for (const filePath of filesToScan) {
-    const content = await fs2.readFile(filePath, "utf8");
-    for (const regex of importRegexes) {
-      regex.lastIndex = 0;
-      let match = regex.exec(content);
-      while (match) {
-        const specifier = match[1];
-        const resolvedJs = path4.resolve(path4.dirname(filePath), specifier);
-        if (seen.has(resolvedJs)) {
-          match = regex.exec(content);
-          continue;
-        }
-        seen.add(resolvedJs);
-        if (await pathExists(resolvedJs)) {
-          match = regex.exec(content);
-          continue;
-        }
-        const tsCandidates = [
-          resolvedJs.replace(/\\.js$/, ".ts"),
-          resolvedJs.replace(/\\.js$/, ".mts"),
-          resolvedJs.replace(/\\.js$/, ".tsx")
-        ];
-        let targetTs;
-        for (const candidate of tsCandidates) {
-          if (await pathExists(candidate)) {
-            targetTs = candidate;
-            break;
-          }
-        }
-        if (targetTs) {
-          const relImport = normalizePath(path4.relative(path4.dirname(resolvedJs), targetTs));
-          const importPath = relImport.startsWith(".") ? relImport : `./${relImport}`;
-          const shim = `export * from '${importPath}'
-import * as __all from '${importPath}'
-export default ('default' in __all ? __all.default : __all)
-`;
-          await fs2.mkdir(path4.dirname(resolvedJs), { recursive: true });
-          await fs2.writeFile(resolvedJs, shim, "utf8");
-          shimWrites.push(resolvedJs);
-        }
-        match = regex.exec(content);
+      if (entry.isFile()) {
+        files.push(target);
       }
     }
+  };
+  if (await pathExists(rootDir)) {
+    await walk(rootDir);
   }
-  return shimWrites;
+  return files;
+}
+function suffixMatchScore(candidate, wanted) {
+  const left = normalizePath(candidate).split("/");
+  const right = normalizePath(wanted).split("/");
+  let score = 0;
+  while (score < left.length && score < right.length) {
+    const a = left[left.length - 1 - score];
+    const b = right[right.length - 1 - score];
+    if (a !== b) break;
+    score += 1;
+  }
+  return score;
+}
+async function resolveEmittedEntryPath(emitRoot, moduleRel) {
+  const expected = path4.resolve(emitRoot, toEmittedModulePath(moduleRel));
+  if (await pathExists(expected)) {
+    return expected;
+  }
+  const wantedRel = toEmittedModulePath(moduleRel);
+  const wantedBase = path4.posix.basename(normalizePath(wantedRel));
+  const files = await collectFilesRecursive(emitRoot);
+  const candidates = files.filter(
+    (file) => path4.posix.basename(normalizePath(file)) === wantedBase
+  );
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  candidates.sort(
+    (a, b) => suffixMatchScore(b, wantedRel) - suffixMatchScore(a, wantedRel)
+  );
+  return candidates[0];
+}
+async function compileSnapshotEntry(options) {
+  const log = options.log ?? (() => void 0);
+  const tsconfigStat = await fs2.stat(options.tsconfigPath);
+  const cacheKey = buildCompileCacheKey(
+    options.commitSha,
+    options.moduleRel,
+    options.tsconfigPath,
+    { mtimeMs: tsconfigStat.mtimeMs, size: tsconfigStat.size }
+  );
+  const emitRoot = path4.join(options.cacheRoot, cacheKey, "dist");
+  let emittedEntry = path4.resolve(emitRoot, toEmittedModulePath(options.moduleRel));
+  if (!options.noCache && await pathExists(emittedEntry)) {
+    log(`[changelog] compile cache hit: ${options.commitSha.slice(0, 12)}`);
+    return emittedEntry;
+  }
+  log(
+    `[changelog] compile cache ${options.noCache ? "disabled" : "miss"}: ${options.commitSha.slice(0, 12)}`
+  );
+  await fs2.rm(path4.join(options.cacheRoot, cacheKey), { recursive: true, force: true }).catch(
+    () => void 0
+  );
+  await fs2.mkdir(emitRoot, { recursive: true });
+  const readResult = ts2.readConfigFile(options.tsconfigPath, ts2.sys.readFile);
+  if (readResult.error) {
+    throw new Error(ts2.flattenDiagnosticMessageText(readResult.error.messageText, "\n"));
+  }
+  const parsed = ts2.parseJsonConfigFileContent(
+    readResult.config,
+    ts2.sys,
+    path4.dirname(options.tsconfigPath)
+  );
+  const compilerOptions = {
+    ...parsed.options,
+    noEmit: false,
+    declaration: false,
+    declarationMap: false,
+    sourceMap: false,
+    inlineSourceMap: false,
+    composite: false,
+    incremental: false,
+    tsBuildInfoFile: void 0,
+    outDir: emitRoot
+  };
+  const program = ts2.createProgram([options.modulePath], compilerOptions);
+  const emitResult = program.emit();
+  const diagnostics = ts2.getPreEmitDiagnostics(program).concat(emitResult.diagnostics).filter((diagnostic) => diagnostic.category === ts2.DiagnosticCategory.Error);
+  if (diagnostics.length > 0) {
+    const host = {
+      getCanonicalFileName: (fileName) => fileName,
+      getCurrentDirectory: () => options.worktreeDir,
+      getNewLine: () => "\n"
+    };
+    const message = ts2.formatDiagnosticsWithColorAndContext(diagnostics.slice(0, 20), host);
+    throw new Error(
+      `TypeScript snapshot compile failed for ${options.moduleRel} at ${options.commitSha.slice(0, 12)}:
+${message}`
+    );
+  }
+  emittedEntry = await resolveEmittedEntryPath(emitRoot, options.moduleRel) ?? emittedEntry;
+  if (!await pathExists(emittedEntry)) {
+    throw new Error(
+      `Compiled snapshot entry was not emitted: ${emittedEntry}. Check module/tsconfig compatibility.`
+    );
+  }
+  log(`[changelog] compiled snapshot entry: ${emittedEntry}`);
+  return emittedEntry;
+}
+async function loadSnapshotExport(options) {
+  return loadChangelogInput(options.entryPath, options.exportName);
 }
 async function createSnapshot(repoRoot, moduleRel, exportName, commit, tempRoot, tsconfigRel, exportOptions, log) {
   const worktreeDir = path4.join(tempRoot, `wt-${commit.sha.slice(0, 12)}`);
   await runGit(repoRoot, ["worktree", "add", "--detach", worktreeDir, commit.sha]);
   try {
     await ensureWorktreeDependencies(repoRoot, worktreeDir);
-    const shimmedFiles = await createMissingJsImportShims(worktreeDir);
-    if (shimmedFiles.length > 0) {
-      log?.(
-        `[changelog] created ${shimmedFiles.length} missing .js import shim(s) in ${commit.sha.slice(0, 12)}`
+    const modulePath = path4.resolve(worktreeDir, moduleRel);
+    let snapshotRuntimePath = modulePath;
+    let resolvedTsconfigPath;
+    if (isTypeScriptModule(modulePath)) {
+      resolvedTsconfigPath = await resolveSnapshotTsconfig(
+        worktreeDir,
+        modulePath,
+        tsconfigRel
+      );
+      log?.(`[changelog] using tsconfig: ${resolvedTsconfigPath}`);
+      const compileCacheRoot = path4.resolve(
+        exportOptions?.cacheDir ?? path4.join(os.tmpdir(), "rrroutes-export-changelog-cache")
+      );
+      snapshotRuntimePath = await compileSnapshotEntry({
+        worktreeDir,
+        moduleRel,
+        modulePath,
+        tsconfigPath: resolvedTsconfigPath,
+        commitSha: commit.sha,
+        cacheRoot: compileCacheRoot,
+        noCache: exportOptions?.noCache,
+        log
+      });
+    } else if (!isJavaScriptModule(modulePath)) {
+      throw new Error(
+        `Unsupported module extension for changelog snapshots: ${modulePath}`
       );
     }
-    const modulePath = path4.resolve(worktreeDir, moduleRel);
-    const tsconfigPath = tsconfigRel ? path4.resolve(worktreeDir, tsconfigRel) : void 0;
-    const input = await loadChangelogInput(modulePath, exportName);
+    const input = await loadSnapshotExport({
+      entryPath: snapshotRuntimePath,
+      exportName
+    });
     const payload = await exportFinalizedLeaves(input, {
       includeSource: true,
       sourceModulePath: modulePath,
       sourceExportName: exportName,
-      tsconfigPath,
-      ...exportOptions
+      tsconfigPath: resolvedTsconfigPath ?? (tsconfigRel ? path4.resolve(worktreeDir, tsconfigRel) : void 0),
+      handlers: exportOptions?.handlers
     });
     const routesByKey = toRouteSnapshots(payload);
     const sourceObjectsById = toSourceObjectSnapshots(routesByKey);
@@ -2239,6 +2358,11 @@ var __private = {
   resolveCommitWindow,
   resolveCommitPath,
   filterCommits,
+  resolveSnapshotTsconfig,
+  toEmittedModulePath,
+  buildCompileCacheKey,
+  compileSnapshotEntry,
+  loadSnapshotExport,
   toRouteSnapshots,
   toSourceObjectSnapshots,
   diffSnapshots,
@@ -2249,6 +2373,7 @@ var __private = {
 import path5 from "path";
 function parseFinalizedLeavesChangelogCliArgs(argv) {
   const args = /* @__PURE__ */ new Map();
+  let noCache = false;
   for (let i = 0; i < argv.length; i += 1) {
     const key = argv[i];
     if (key === "--") continue;
@@ -2256,6 +2381,10 @@ function parseFinalizedLeavesChangelogCliArgs(argv) {
     if (key === "--with-source") {
       continue;
     }
+    if (key === "--no-cache") {
+      noCache = true;
+      continue;
+    }
     const value = argv[i + 1];
     if (!value || value.startsWith("--")) {
       throw new Error(`Missing value for ${key}`);
@@ -2274,7 +2403,9 @@ function parseFinalizedLeavesChangelogCliArgs(argv) {
     htmlFile: args.get("--html") ?? void 0,
     tsconfigPath: args.get("--tsconfig") ?? void 0,
     from: args.get("--from") ?? void 0,
-    to: args.get("--to") ?? void 0
+    to: args.get("--to") ?? void 0,
+    cacheDir: args.get("--cache-dir") ?? void 0,
+    noCache
   };
 }
 async function runExportFinalizedLeavesChangelogCli(argv) {
@@ -2292,6 +2423,8 @@ async function runExportFinalizedLeavesChangelogCli(argv) {
     from: args.from,
     to: args.to,
     includeSource: true,
+    cacheDir: args.cacheDir,
+    noCache: args.noCache,
     log
   };
   log("[changelog-cli] starting changelog export");