@akanjs/devkit 3.0.0-beta.24 → 3.0.0-beta.26

package/frontendBuild/csrDevModuleCompiler.ts

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { CSR_DEV_ROUTE_PREFIX } from "akanjs/server/hmr/csrDevManifest";
 import type { BunPlugin } from "bun";
 import type { App } from "../commandDecorators";
 import { CsrDevPaths } from "./csrDevPaths";
@@ -23,6 +22,21 @@ export interface CsrDevModuleCompilerOptions {
   resolver: CsrDevResolver;
   context: CsrDevContext;
   outDir: string;
+  /** Where the dev server serves `outDir`: an imported asset's URL starts with it. */
+  routePrefix: string;
+}
+
+export interface CsrDevCompileOptions {
+  /** Stop before building an npm module the graph does not know yet, and name it instead. */
+  refuseNewVendor?: boolean;
+  /** Stop at an import no recorded resolution answers, instead of running the resolution build (a whole-app build). */
+  refusePrepass?: boolean;
+}
+
+export interface CsrDevCompileResult {
+  modules: CsrDevCompiledModule[];
+  refusedVendors: string[];
+  unresolved: string[];
 }
 
 //* Every module becomes its own CJS factory: one Bun.build with each import external, so a save re-runs only the
@@ -40,21 +54,37 @@ export class CsrDevModuleCompiler {
   readonly #resolver: CsrDevResolver;
   readonly #context: CsrDevContext;
   readonly #outDir: string;
+  readonly #routePrefix: string;
+  readonly #assets = new Set<string>();
 
-  constructor({ app, paths, resolver, context, outDir }: CsrDevModuleCompilerOptions) {
+  constructor({ app, paths, resolver, context, outDir, routePrefix }: CsrDevModuleCompilerOptions) {
     this.#app = app;
     this.#paths = paths;
     this.#resolver = resolver;
     this.#context = context;
     this.#outDir = outDir;
+    this.#routePrefix = routePrefix;
+  }
+
+  /** Every asset file this compiler wrote into the registry directory. */
+  get assets(): string[] {
+    return [...this.#assets];
   }
 
-  async compile(startFiles: string[], known: Set<string>): Promise<CsrDevCompiledModule[]> {
+  async compile(
+    startFiles: string[],
+    known: Set<string>,
+    { refuseNewVendor = false, refusePrepass = false }: CsrDevCompileOptions = {},
+  ): Promise<CsrDevCompileResult> {
     const compiled = new Map<string, CsrDevCompiledModule>();
     const seen = new Set([...known, ...startFiles]);
     let frontier = [...new Set(startFiles)];
     while (frontier.length > 0) {
+      const refusedVendors = refuseNewVendor ? frontier.filter((file) => CsrDevPaths.isVendorFile(file)) : [];
+      if (refusedVendors.length > 0) return { modules: [...compiled.values()], refusedVendors, unresolved: [] };
       const round = await this.#compileRound(frontier);
+      if (round.misses.length > 0 && !this.#resolver.prepassDone && refusePrepass)
+        return { modules: [...compiled.values()], refusedVendors: [], unresolved: round.misses };
       if (round.misses.length > 0 && !this.#resolver.prepassDone) {
         this.#app.verbose(`[csr-dev] ${round.misses.length} unresolved import(s); rerunning the resolution build`);
         await this.#resolver.prepass();
@@ -76,7 +106,7 @@ export class CsrDevModuleCompiler {
       this.#app.verbose(
         `[csr-dev] ${fallbacks.size} import(s) outside the browser build's graph resolved with Bun's runtime resolver: ${[...fallbacks].slice(0, 5).join(", ")}${fallbacks.size > 5 ? ", ..." : ""}`,
       );
-    return [...compiled.values()];
+    return { modules: [...compiled.values()], refusedVendors: [], unresolved: [] };
   }
 
   async #compileRound(files: string[]): Promise<Omit<BuildRound, "tangled">> {
@@ -100,9 +130,12 @@ export class CsrDevModuleCompiler {
   }
 
   async #bunBuild(files: string[], vendor: boolean): Promise<BuildRound> {
-    const mtimes = new Map(files.map((file) => [file, CsrDevPaths.mtimeOf(file)]));
+    //? Keyed as the output is: by the disk's spelling, which a case-only rename leaves apart from the requested path.
+    const mtimes = new Map(files.map((file) => [CsrDevPaths.realpath(file), CsrDevPaths.mtimeOf(file)]));
     const hashes = new Map(
-      await Promise.all(files.map(async (file) => [file, vendor ? "" : await CsrDevPaths.hashOf(file)] as const)),
+      await Promise.all(
+        files.map(async (file) => [CsrDevPaths.realpath(file), vendor ? "" : await CsrDevPaths.hashOf(file)] as const),
+      ),
     );
     const misses: string[] = [];
     const result = await Bun.build({
@@ -113,7 +146,7 @@ export class CsrDevModuleCompiler {
       reactFastRefresh: !vendor,
       sourcemap: vendor ? "none" : "external",
       naming: { entry: "[dir]/[name].[ext]", asset: "assets/[name]-[hash].[ext]" },
-      publicPath: CSR_DEV_ROUTE_PREFIX,
+      publicPath: this.#routePrefix,
       metafile: true,
       env: "AKAN_PUBLIC_*",
       define: this.#context.define,
@@ -128,7 +161,9 @@ export class CsrDevModuleCompiler {
     const tangled: string[] = [];
     for (const artifact of result.outputs) {
       if (artifact.kind === "asset") {
-        await Bun.write(path.join(this.#outDir, artifact.path), artifact);
+        const assetPath = path.join(this.#outDir, artifact.path);
+        await Bun.write(assetPath, artifact);
+        this.#assets.add(assetPath);
         continue;
       }
       if (artifact.kind !== "entry-point") continue;
@@ -167,13 +202,20 @@ export class CsrDevModuleCompiler {
             if (CsrDevPaths.isVendorFile(args.path)) return undefined;
             const normalized = RouteClientBuilder.normalizeNamedDefaultFunctionForFastRefresh(
               await Bun.file(args.path).text(),
+              { path: args.path },
             );
             return normalized ? { contents: normalized, loader: "tsx" } : undefined;
           });
         build.onResolve({ filter: /.*/ }, (args) => {
           if (args.kind === "entry-point-build" || !args.importer) return undefined;
+          if (this.#context.externals?.includes(args.path))
+            return { path: `${CsrDevPaths.vendorPrefix}${args.path}`, external: true };
           const importer = CsrDevPaths.realpath(args.importer);
-          const target = this.#resolver.resolve(importer, args.path);
+          const target = this.#resolver.resolve(
+            importer,
+            args.path,
+            args.kind === "require-call" || args.kind === "require-resolve" ? "require" : "import",
+          );
           if (target === CsrDevResolver.inline) return undefined;
           if (target === null) {
             misses.push(`${args.path} from ${this.#paths.idOf(importer)}`);
@@ -220,11 +262,15 @@ export class CsrDevModuleCompiler {
   static #factory(id: string, code: string): { factory: string; helpers: CsrDevSharedHelpers | null } {
     const prefix = CsrDevPaths.modulePrefix;
     let patched = code.replaceAll(`import("${prefix}`, `__akanImport("${prefix}`).replace(/^\/\/# debugId=.*$/m, "");
+    //? A file esbuild already bundled (mermaid's parser chunks) defines its own helper under the same name, below Bun's
+    //? preamble, and Bun then emits none. Only a copy there is exempt: one in the preamble is Bun's own, changed.
+    const marker = patched.search(/^\/\/ /m);
+    const body = marker < 0 ? "" : patched.slice(marker);
     for (const [name, params, method] of CsrDevModuleCompiler.#helperPatches) {
       const definition = `var ${name} = ${params} => {`;
       if (patched.includes(definition))
         patched = patched.replace(definition, `var ${name} = __akan.${method}, __bun${name} = ${params} => {`);
-      else if (patched.includes(`${name}(`))
+      else if (patched.includes(`${name}(`) && !new RegExp(`\\b(?:var|let|const|function)\\s+${name}\\b`).test(body))
         throw new Error(
           `[csr-dev] ${id}: Bun's ${name} helper no longer reads "${definition}"; CsrDevModuleCompiler must follow`,
         );