@akanjs/devkit 3.0.0-beta.19 → 3.0.0-beta.20

package/transforms/barrelAnalyzer.ts

@@ -1,44 +1,36 @@
 import path from "node:path";
 import { Logger } from "akanjs/common";
+import { parseNamedList } from "./moduleSyntax";
 
 export interface BarrelExportTarget {
-  /** Subpath specifier to emit in rewritten import, e.g. `akanjs/ui/Empty`. */
   subpath: string;
-  /** Name as it is exported by the leaf module. */
   originalName: string;
 }
 
 export type BarrelExportMap = Map<string, BarrelExportTarget>;
 
 export interface PackageEntry {
-  /** Package specifier (e.g. `akanjs/ui`). */
   pkgName: string;
   /** Absolute path of the barrel entry file. */
   entryFile: string;
-  /** Absolute directory used as the base for subpath computation. Typically dirname(entryFile). */
+  /** Absolute base directory for subpath computation, typically `dirname(entryFile)`. */
   pkgDir: string;
-  /** Preserve concrete file paths for package exports that do not support extensionless deep imports. */
+  /** Emit concrete file paths, for package exports that do not support extensionless deep imports. */
   preserveFilePath?: boolean;
 }
 
 export interface BarrelAnalyzerOptions {
   resolvePackage: (pkgName: string) => Promise<PackageEntry | null>;
-  /** Resolve a relative specifier from `fromFile` to an absolute file path on disk. */
+  /** Resolves to an absolute file path on disk. */
   resolveRelative?: (fromFile: string, relSpec: string) => Promise<string | null>;
 }
 
-// Re-export statements with an explicit source: `export { A, B as C } from "./x"`,
-// `export * from "./x"`, `export * as ns from "./x"`. We rely on `Transpiler.scan`
-// for the authoritative export name set; this regex only needs to give us the
-// name↔source mapping that scan doesn't expose.
+// `Transpiler.scan` gives the export names but not their sources; this regex supplies the name↔source mapping.
 const REEXPORT_RE =
   /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
 
-// Local named re-export without `from`: `export { A, B as C };`
-// `Transpiler.scan` currently omits these from its `exports` list so we keep a
-// small regex fallback. The lookahead sits immediately after `}` so that
-// greedy whitespace matching cannot backtrack past it — otherwise it would
-// also match `export type { X } from "./y"` statements.
+// `Transpiler.scan` omits `export { A, B as C };`. The lookahead sits right after `}` so whitespace backtracking
+// cannot also match `export type { X } from "./y"`.
 const LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
 
 const CANDIDATE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
@@ -64,68 +56,53 @@ export class BarrelAnalyzer {
 
   async #analyzeSafe(pkgName: string): Promise<BarrelExportMap | null> {
     try {
-      return await this.#analyzeUncached(pkgName);
+      const pkg = await this.#opts.resolvePackage(pkgName);
+      if (!pkg) return null;
+      const map: BarrelExportMap = new Map();
+      await this.#walk(pkg.entryFile, pkg, map, new Set());
+      return map;
     } catch (err) {
       this.#logger.error(`analyze failed for ${pkgName}: ${(err as Error).message}`);
       return null;
     }
   }
 
-  async #analyzeUncached(pkgName: string): Promise<BarrelExportMap | null> {
-    const pkg = await this.#opts.resolvePackage(pkgName);
-    if (!pkg) return null;
-    const map: BarrelExportMap = new Map();
-    const visited = new Set<string>();
-    await this.#walk(pkg.entryFile, pkg, map, visited);
-    return map;
-  }
-
   async #walk(absFile: string, pkg: PackageEntry, map: BarrelExportMap, visited: Set<string>): Promise<void> {
     if (visited.has(absFile)) return;
     visited.add(absFile);
-    const source = await readIfExists(absFile);
-    if (source === null) return;
+    const file = Bun.file(absFile);
+    if (!(await file.exists())) return;
+    const source = await file.text();
     const currentSubpath = this.#subpathFor(pkg, absFile);
     if (!currentSubpath) return;
 
-    // Authoritative export names from Bun's transpiler. Filters type-only,
-    // comments, strings, etc. automatically. `export *` re-exports are NOT
-    // flooded here — they only show up as imports, so we recurse separately.
+    // scan leaves out `export *` names (they surface only as imports), so star re-exports are walked below.
     const authoritative = this.#scanExports(source, absFile);
-    // `default` is intentionally skipped — barrels rarely proxy defaults and
-    // rewriting `import X from "pkg"` requires different semantics.
+    // Barrels rarely proxy defaults, and rewriting `import X from "pkg"` needs different semantics.
     authoritative.delete("default");
 
-    // Names attributed to a specific leaf via `export ... from "./path"`.
-    // Everything left over in `authoritative` after this is treated as a local
-    // declaration at this file's own subpath.
     const attributed = new Set<string>();
+    const attribute = (listBody: string, subpath: string) => {
+      for (const item of parseNamedList(listBody)) {
+        if (item.isType || item.imported === "default" || !authoritative.has(item.local)) continue;
+        attributed.add(item.local);
+        if (!map.has(item.local)) map.set(item.local, { subpath, originalName: item.imported });
+      }
+    };
 
-    // Pass 1: `export { ... } from "./x"` and `export * [as ns] from "./x"`.
-    REEXPORT_RE.lastIndex = 0;
-    let m: RegExpExecArray | null = REEXPORT_RE.exec(source);
-    while (m !== null) {
+    // A module's own exports shadow the names its stars bring (ES), so every one is mapped before a star is walked.
+    const starSpecs: string[] = [];
+    for (const m of source.matchAll(REEXPORT_RE)) {
       const star = m[1];
       const nsAs = m[2];
       const namedList = m[3];
       const spec = m[5] ?? "";
-      m = REEXPORT_RE.exec(source);
       if (!isRelative(spec)) continue;
 
       if (star) {
-        if (nsAs) {
-          // `export * as ns from "./x"` exposes a namespace object that we
-          // cannot flatten into direct subpath imports. Ensure it's not misread
-          // as a local declaration.
-          authoritative.delete(nsAs);
-          continue;
-        }
-        const targetAbs = await this.#resolveRel(absFile, spec);
-        if (!targetAbs) continue;
-        // Recurse: target's exports will land in `map` with target's subpath.
-        // These names don't appear in this file's `authoritative` set, so the
-        // local-declaration pass below won't misattribute them.
-        await this.#walk(targetAbs, pkg, map, visited);
+        // A namespace re-export cannot be flattened into subpath imports, nor is it a local declaration.
+        if (nsAs) authoritative.delete(nsAs);
+        else starSpecs.push(spec);
         continue;
       }
 
@@ -133,49 +110,28 @@ export class BarrelAnalyzer {
         const targetAbs = await this.#resolveRel(absFile, spec);
         if (!targetAbs) continue;
         const targetSubpath = this.#subpathFor(pkg, targetAbs);
-        if (!targetSubpath) continue;
-        for (const item of parseNamedList(namedList)) {
-          if (item.isType) continue;
-          if (item.imported === "default") continue;
-          // Validate against scan — drops anything hidden behind `export type`
-          // or otherwise not actually exported at runtime.
-          if (!authoritative.has(item.local)) continue;
-          attributed.add(item.local);
-          if (!map.has(item.local)) {
-            map.set(item.local, { subpath: targetSubpath, originalName: item.imported });
-          }
-        }
+        if (targetSubpath) attribute(namedList, targetSubpath);
       }
     }
 
-    // Pass 2: `export { A, B as C };` (no `from`). scan omits these, so the
-    // regex is authoritative for this narrow case.
     LOCAL_NAMED_RE.lastIndex = 0;
     let n: RegExpExecArray | null = LOCAL_NAMED_RE.exec(source);
     while (n !== null) {
       const body = n[1] ?? "";
       n = LOCAL_NAMED_RE.exec(source);
-      for (const item of parseNamedList(body)) {
-        if (item.isType) continue;
-        if (item.imported === "default") continue;
-        // Validate against scan — ensures we don't treat commented-out or
-        // otherwise dead code as a real local re-export.
-        if (!authoritative.has(item.local)) continue;
-        attributed.add(item.local);
-        if (!map.has(item.local)) {
-          map.set(item.local, { subpath: currentSubpath, originalName: item.imported });
-        }
-      }
+      attribute(body, currentSubpath);
     }
 
-    // Pass 3: remaining authoritative names are local declarations defined in
-    // this file (const/function/class/...). scan already filtered out
-    // type-only and namespace-only exports for us.
     for (const name of authoritative) {
       if (attributed.has(name)) continue;
       if (map.has(name)) continue;
       map.set(name, { subpath: currentSubpath, originalName: name });
     }
+
+    for (const spec of starSpecs) {
+      const targetAbs = await this.#resolveRel(absFile, spec);
+      if (targetAbs) await this.#walk(targetAbs, pkg, map, visited);
+    }
   }
 
   #scanExports(source: string, absFile: string): Set<string> {
@@ -193,12 +149,12 @@ export class BarrelAnalyzer {
     const rel = path.relative(pkg.pkgDir, absFile);
     if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return null;
     if (pkg.preserveFilePath) return `${pkg.pkgName}/${rel.split(path.sep).join("/")}`;
-    const noExt = stripKnownExt(rel);
-    // index files collapse to the directory — but the barrel entry is itself an index.
-    // For nested `xxx/index.*`, callers are expected to import `@pkg/xxx` (not `xxx/index`).
-    const tail = collapseIndex(noExt);
-    if (tail === "") return pkg.pkgName;
-    return `${pkg.pkgName}/${tail.split(path.sep).join("/")}`;
+    const ext = CANDIDATE_EXTS.find((candidate) => rel.endsWith(candidate));
+    const parts = (ext ? rel.slice(0, -ext.length) : rel).split(path.sep);
+    // `xxx/index` collapses to `xxx`: callers import `@pkg/xxx`, never `@pkg/xxx/index`.
+    if (parts[parts.length - 1] === "index") parts.pop();
+    const tail = parts.join("/");
+    return tail === "" ? pkg.pkgName : `${pkg.pkgName}/${tail}`;
   }
 
   async #resolveRel(fromFile: string, relSpec: string): Promise<string | null> {
@@ -207,45 +163,10 @@ export class BarrelAnalyzer {
   }
 }
 
-interface NamedItem {
-  imported: string;
-  local: string;
-  isType: boolean;
-}
-
-const parseNamedList = (listBody: string): NamedItem[] => {
-  const out: NamedItem[] = [];
-  for (const raw of listBody.split(",")) {
-    const s = raw.trim();
-    if (!s) continue;
-    let rest = s;
-    let isType = false;
-    if (rest.startsWith("type ")) {
-      isType = true;
-      rest = rest.slice(5).trim();
-    }
-    const asMatch = /^(\w+)\s+as\s+(\w+)$/.exec(rest);
-    if (asMatch) {
-      out.push({ imported: asMatch[1] ?? "", local: asMatch[2] ?? "", isType });
-      continue;
-    }
-    if (/^\w+$/.test(rest)) {
-      out.push({ imported: rest, local: rest, isType });
-    }
-  }
-  return out;
-};
-
 const isRelative = (spec: string): boolean => {
   return spec.startsWith("./") || spec.startsWith("../") || spec === "." || spec === "..";
 };
 
-const readIfExists = async (absFile: string): Promise<string | null> => {
-  const file = Bun.file(absFile);
-  if (!(await file.exists())) return null;
-  return file.text();
-};
-
 const defaultResolveRelative = async (fromFile: string, relSpec: string): Promise<string | null> => {
   const baseDir = path.dirname(fromFile);
   const joined = path.resolve(baseDir, relSpec);
@@ -263,16 +184,3 @@ const defaultResolveRelative = async (fromFile: string, relSpec: string): Promis
   }
   return null;
 };
-
-const stripKnownExt = (relPath: string): string => {
-  for (const ext of CANDIDATE_EXTS) {
-    if (relPath.endsWith(ext)) return relPath.slice(0, -ext.length);
-  }
-  return relPath;
-};
-
-const collapseIndex = (relPathNoExt: string): string => {
-  const parts = relPathNoExt.split(path.sep);
-  if (parts[parts.length - 1] === "index") parts.pop();
-  return parts.join(path.sep);
-};