@reckona/mreact-router 0.0.87 → 0.0.88

package/src/module-runner.ts

@@ -1,11 +1,19 @@
 import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { dirname, join, sep } from "node:path";
+import { dirname, extname, isAbsolute, join, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { formatDiagnostic } from "@reckona/mreact-compiler";
 import type { ServerOutputMode } from "@reckona/mreact-shared/compiler-contract";
 import { transformCompilerModuleContext } from "@reckona/mreact-compiler/internal";
-import { runnerImport, type InlineConfig, type PluginOption } from "vite";
+import {
+  createRunnableDevEnvironment,
+  mergeConfig,
+  resolveConfig,
+  type InlineConfig,
+  type PluginOption,
+  type RunnableDevEnvironment,
+} from "vite";
 import { resolveWorkspacePackageFile } from "./workspace-packages.js";
 import {
   bundleRouterModule,
@@ -47,6 +55,10 @@ const maxServerSourceTransformCacheEntries = resolveRouterCacheLimit(
   512,
 );
 const serverSourceTransformCacheCounters = createRouterRuntimeCacheCounters();
+const packageTypeCache = new Map<string, string | undefined>();
+const runnerVirtualModulePrefix = "virtual:mreact-router-source/";
+const runnerVirtualModules = new Map<string, string>();
+let sharedRunnerEnvironment: Promise<RunnableDevEnvironment> | undefined;
 let fileImportVersion = 0;
 
 export function routerModuleRunnerRuntimeCacheStats(): RouterRuntimeCacheStat[] {
@@ -71,6 +83,7 @@ export async function importAppRouterSourceModule<T>(options: {
   code: string;
   externalizeAppSourceModuleDirs?: readonly string[] | undefined;
   label: string;
+  plugins?: readonly RouterCompatPlugin[] | undefined;
   resolveDir?: string | undefined;
   serverSourceTransform?: ServerSourceTransformOptions | undefined;
   sourcefile?: string | undefined;
@@ -110,6 +123,7 @@ async function importAppRouterSourceModuleWithoutCache<T>(options: {
   code: string;
   externalizeAppSourceModuleDirs?: readonly string[] | undefined;
   label: string;
+  plugins?: readonly RouterCompatPlugin[] | undefined;
   resolveDir?: string | undefined;
   serverSourceTransform?: ServerSourceTransformOptions | undefined;
   sourcefile?: string | undefined;
@@ -117,30 +131,108 @@ async function importAppRouterSourceModuleWithoutCache<T>(options: {
 }): Promise<T> {
   const code =
     options.resolveDir === undefined ? options.code : await bundleAppRouterSourceModule(options);
+  const sourcefile = options.sourcefile ?? join(options.resolveDir ?? process.cwd(), "module.js");
   const executableCode = withNodeRequireShimForEsmBundle({
-    code: withFileImportMetaUrl(
-      code,
-      options.sourcefile ?? join(options.resolveDir ?? process.cwd(), "module.js"),
-    ),
+    code: withFileImportMetaUrl(code, sourcefile),
+    filename: sourcefile,
     requireBaseDir:
       options.resolveDir ??
       (options.sourcefile === undefined ? undefined : dirname(options.sourcefile)),
   });
   const encodedLabel = encodeURIComponent(options.label.replace(/[^A-Za-z0-9_$.-]/g, "-"));
-  const url = `data:text/javascript;base64,${Buffer.from(executableCode).toString(
-    "base64",
-  )}#${encodedLabel}-${Date.now()}-${Math.random()}`;
-  const result = await runnerImport<T>(url, runnerConfig);
+  const publicId = `${runnerVirtualModulePrefix}${encodedLabel}-${Date.now()}-${Math.random()}.mjs`;
+  runnerVirtualModules.set(publicId, executableCode);
 
-  return result.module;
+  try {
+    return await importWithSharedRunner<T>(publicId, { invalidateEntry: true });
+  } finally {
+    runnerVirtualModules.delete(publicId);
+  }
 }
 
 export async function importAppRouterFileModule<T>(file: string): Promise<T> {
   fileImportVersion += 1;
   const url = `${pathToFileURL(file).href}?t=${Date.now()}${fileImportVersion}`;
-  const result = await runnerImport<T>(url, runnerConfig);
 
-  return result.module;
+  return await importWithSharedRunner<T>(url, { invalidateEntry: true });
+}
+
+async function importWithSharedRunner<T>(
+  moduleId: string,
+  options?: { invalidateEntry?: boolean | undefined },
+): Promise<T> {
+  const environment = await getSharedRunnerEnvironment();
+  const module = (await environment.runner.import(moduleId)) as T;
+
+  if (options?.invalidateEntry === true) {
+    const evaluatedModule =
+      environment.runner.evaluatedModules.getModuleByUrl(moduleId) ??
+      environment.runner.evaluatedModules.getModuleById(moduleId) ??
+      environment.runner.evaluatedModules.getModuleById(`\0${moduleId}`);
+
+    if (evaluatedModule !== undefined) {
+      environment.runner.evaluatedModules.invalidateModule(evaluatedModule);
+    }
+  }
+
+  return module;
+}
+
+async function getSharedRunnerEnvironment(): Promise<RunnableDevEnvironment> {
+  if (sharedRunnerEnvironment !== undefined) {
+    return await sharedRunnerEnvironment;
+  }
+
+  sharedRunnerEnvironment = createSharedRunnerEnvironment().catch((error) => {
+    sharedRunnerEnvironment = undefined;
+    throw error;
+  });
+
+  return await sharedRunnerEnvironment;
+}
+
+async function createSharedRunnerEnvironment(): Promise<RunnableDevEnvironment> {
+  const config = await resolveConfig(
+    mergeConfig(runnerConfig, {
+      cacheDir: process.cwd(),
+      configFile: false,
+      envDir: false,
+      environments: {
+        mreact_router: {
+          consumer: "server",
+          dev: { moduleRunnerTransform: true },
+          resolve: {
+            conditions: ["node"],
+            external: true,
+            mainFields: [],
+          },
+        },
+      },
+      plugins: [
+        {
+          name: "mreact-router-source-module",
+          resolveId(source) {
+            return runnerVirtualModules.has(source) ? `\0${source}` : undefined;
+          },
+          load(id) {
+            const source = id.startsWith("\0") ? id.slice(1) : id;
+
+            return source.startsWith(runnerVirtualModulePrefix)
+              ? runnerVirtualModules.get(source)
+              : undefined;
+          },
+        },
+      ],
+    } satisfies InlineConfig),
+    "serve",
+  );
+  const environment = createRunnableDevEnvironment("mreact_router", config, {
+    hot: false,
+    runnerOptions: { hmr: { logger: false } },
+  });
+  await environment.init();
+
+  return environment;
 }
 
 export async function importAppRouterBuiltFileModule<T>(options: {
@@ -181,6 +273,7 @@ export async function bundleAppRouterSourceModule(options: {
   code: string;
   externalizeAppSourceModuleDirs?: readonly string[] | undefined;
   label: string;
+  plugins?: readonly RouterCompatPlugin[] | undefined;
   resolveDir?: string | undefined;
   serverSourceTransform?: ServerSourceTransformOptions | undefined;
   sourcefile?: string | undefined;
@@ -197,6 +290,7 @@ export async function bundleAppRouterSourceModule(options: {
       ...(options.serverSourceTransform === undefined
         ? []
         : [serverSourceTransformPlugin(options.serverSourceTransform)]),
+      ...(options.plugins ?? []),
     ],
   });
   const code = output.code;
@@ -367,29 +461,471 @@ function withFileImportMetaUrl(source: string, filename: string): string {
 
 function withNodeRequireShimForEsmBundle(options: {
   code: string;
+  filename: string;
   requireBaseDir?: string | undefined;
 }): string {
   const requireBaseUrl = pathToFileURL(
     join(options.requireBaseDir ?? process.cwd(), "__mreact_require_shim.cjs"),
   ).href;
-  const code = options.code.replaceAll(
+  const rewritten = rewriteNodeModulesExternalImports(options.code);
+  const code = rewritten.code.replaceAll(
     "createRequire(import.meta.url)",
     `createRequire(${JSON.stringify(requireBaseUrl)})`,
   );
+  const needsFilenameGlobalShim = needsCommonJsFilenameGlobalShim(options.code);
+  const needsRequireShim = needsNodeRequireShim(options.code);
 
-  if (!needsNodeRequireShim(options.code)) {
+  if (
+    !rewritten.needsNativeImport &&
+    !rewritten.needsRequire &&
+    !needsFilenameGlobalShim &&
+    !needsRequireShim
+  ) {
     return code;
   }
 
-  return `import { createRequire as __mreactCreateRequire } from "node:module";
-const require = __mreactCreateRequire(${JSON.stringify(requireBaseUrl)});
-${code}`;
+  return `${rewritten.needsNativeImport ? 'const __mreactNativeImport = Function("specifier", "return import(specifier)");\n' : ""}${needsFilenameGlobalShim ? `const __filename = ${JSON.stringify(options.filename)};
+const __dirname = ${JSON.stringify(dirname(options.filename))};
+` : ""}${rewritten.needsRequire || needsRequireShim ? `import { createRequire as __mreactCreateRequire } from "node:module";
+const __mreactRequire = __mreactCreateRequire(${JSON.stringify(requireBaseUrl)});
+const require = __mreactRequire;
+` : ""}${code}`;
+}
+
+function needsCommonJsFilenameGlobalShim(code: string): boolean {
+  return /\b__(?:filename|dirname)\b/.test(code);
 }
 
 function needsNodeRequireShim(code: string): boolean {
   return code.includes("Dynamic require of") && /\b__require\s*=/.test(code);
 }
 
+function rewriteNodeModulesExternalImports(code: string): {
+  code: string;
+  needsNativeImport: boolean;
+  needsRequire: boolean;
+} {
+  const nativeImportBindings = new Map<string, string>();
+  let needsNativeImport = false;
+  let needsRequire = false;
+  let importIndex = 0;
+  const importFromPattern = /^import\s+([^;\n]+?)\s+from\s+(["'])([^"']+)\2;?$/gm;
+  const sideEffectImportPattern = /^import\s+(["'])([^"']+)\1;?$/gm;
+  const withRewrittenImports = code.replace(
+    importFromPattern,
+    (statement: string, clause: string, _quote: string, specifier: string) => {
+      const file = nodeModulesExternalImportPath(specifier);
+
+      if (file === undefined || !isNodeImportableModuleFile(file)) {
+        return statement;
+      }
+
+      if (isNodeCommonJsModuleFile(file)) {
+        needsRequire = true;
+        const requireExpression = `__mreactRequire(${JSON.stringify(file)})`;
+        return commonJsImportClauseToRequireStatements(
+          clause.trim(),
+          requireExpression,
+          importIndex++,
+        );
+      }
+
+      needsNativeImport = true;
+      const rewritten = esmImportClauseToNativeImportStatements(clause.trim(), specifier, importIndex++);
+      for (const [name, replacement] of rewritten.bindings) {
+        nativeImportBindings.set(name, replacement);
+      }
+
+      return rewritten.code;
+    },
+  );
+  const rewrittenCode = withRewrittenImports.replace(
+    sideEffectImportPattern,
+    (statement: string, _quote: string, specifier: string) => {
+      const file = nodeModulesExternalImportPath(specifier);
+
+      if (file === undefined || !isNodeImportableModuleFile(file)) {
+        return statement;
+      }
+
+      if (isNodeCommonJsModuleFile(file)) {
+        needsRequire = true;
+        return `__mreactRequire(${JSON.stringify(file)});`;
+      }
+
+      needsNativeImport = true;
+      return `await __mreactNativeImport(${JSON.stringify(specifier)});`;
+    },
+  );
+
+  return {
+    code:
+      nativeImportBindings.size === 0
+        ? rewrittenCode
+        : replaceImportedIdentifiers(rewrittenCode, nativeImportBindings),
+    needsNativeImport,
+    needsRequire,
+  };
+}
+
+function nodeModulesExternalImportPath(specifier: string): string | undefined {
+  const file = externalImportFilePath(specifier);
+
+  if (file === undefined || !isNodeModulesPath(file)) {
+    return undefined;
+  }
+
+  return file;
+}
+
+function externalImportFilePath(specifier: string): string | undefined {
+  if (specifier.startsWith("file://")) {
+    try {
+      return fileURLToPath(specifier);
+    } catch {
+      return undefined;
+    }
+  }
+
+  return isAbsolute(specifier) ? specifier : undefined;
+}
+
+function isNodeModulesPath(file: string): boolean {
+  return file.split(sep).includes("node_modules");
+}
+
+function isNodeImportableModuleFile(file: string): boolean {
+  const extension = extname(file);
+
+  return extension === ".cjs" || extension === ".mjs" || extension === ".js" || extension === ".node";
+}
+
+function isNodeCommonJsModuleFile(file: string): boolean {
+  const extension = extname(file);
+
+  if (extension === ".cjs" || extension === ".cts" || extension === ".node") {
+    return true;
+  }
+
+  if (extension === ".mjs" || extension === ".mts" || extension !== ".js") {
+    return false;
+  }
+
+  return nearestPackageType(file) !== "module";
+}
+
+function nearestPackageType(file: string): string | undefined {
+  let directory = dirname(file);
+
+  while (true) {
+    const packageJson = join(directory, "package.json");
+
+    if (packageTypeCache.has(packageJson)) {
+      return packageTypeCache.get(packageJson);
+    }
+
+    if (existsSync(packageJson)) {
+      const type = readPackageType(packageJson);
+      packageTypeCache.set(packageJson, type);
+      return type;
+    }
+
+    const parent = dirname(directory);
+
+    if (parent === directory) {
+      return undefined;
+    }
+
+    directory = parent;
+  }
+}
+
+function readPackageType(packageJson: string): string | undefined {
+  try {
+    const parsed = JSON.parse(readFileSync(packageJson, "utf8")) as { type?: unknown };
+
+    return typeof parsed.type === "string" ? parsed.type : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function commonJsImportClauseToRequireStatements(
+  clause: string,
+  requireExpression: string,
+  importIndex: number,
+): string {
+  if (clause.startsWith("* as ")) {
+    return `const ${clause.slice(5).trim()} = ${requireExpression};`;
+  }
+
+  if (clause.startsWith("{")) {
+    return namedCommonJsImportsToRequireStatements(clause, requireExpression);
+  }
+
+  const commaIndex = clause.indexOf(",");
+
+  if (commaIndex === -1) {
+    return `const ${clause} = ${requireExpression};`;
+  }
+
+  const defaultName = clause.slice(0, commaIndex).trim();
+  const namedOrNamespace = clause.slice(commaIndex + 1).trim();
+  const temporaryName = `__mreactExternalCommonJs${importIndex}`;
+  const statements = [`const ${temporaryName} = ${requireExpression};`, `const ${defaultName} = ${temporaryName};`];
+
+  if (namedOrNamespace.startsWith("* as ")) {
+    statements.push(`const ${namedOrNamespace.slice(5).trim()} = ${temporaryName};`);
+  } else if (namedOrNamespace.startsWith("{")) {
+    statements.push(namedCommonJsImportsToRequireStatements(namedOrNamespace, temporaryName));
+  }
+
+  return statements.join("\n");
+}
+
+function esmImportClauseToNativeImportStatements(
+  clause: string,
+  specifier: string,
+  importIndex: number,
+): { bindings: Map<string, string>; code: string } {
+  const bindings = new Map<string, string>();
+  const temporaryName = `__mreactExternalModule${importIndex}`;
+  const statements = [
+    `const ${temporaryName} = await __mreactNativeImport(${JSON.stringify(specifier)});`,
+  ];
+
+  if (clause.startsWith("* as ")) {
+    statements.push(`const ${clause.slice(5).trim()} = ${temporaryName};`);
+  } else if (clause.startsWith("{")) {
+    collectNamedEsmImportBindings(clause, temporaryName, bindings);
+  } else {
+    const commaIndex = clause.indexOf(",");
+
+    if (commaIndex === -1) {
+      bindings.set(clause, `${temporaryName}.default`);
+    } else {
+      const defaultName = clause.slice(0, commaIndex).trim();
+      const namedOrNamespace = clause.slice(commaIndex + 1).trim();
+      bindings.set(defaultName, `${temporaryName}.default`);
+
+      if (namedOrNamespace.startsWith("* as ")) {
+        statements.push(`const ${namedOrNamespace.slice(5).trim()} = ${temporaryName};`);
+      } else if (namedOrNamespace.startsWith("{")) {
+        collectNamedEsmImportBindings(namedOrNamespace, temporaryName, bindings);
+      }
+    }
+  }
+
+  return { bindings, code: statements.join("\n") };
+}
+
+function collectNamedEsmImportBindings(
+  clause: string,
+  moduleName: string,
+  bindings: Map<string, string>,
+): void {
+  for (const binding of namedImportBindings(clause)) {
+    const replacement =
+      binding.imported === "default"
+        ? `${moduleName}.default`
+        : `${moduleName}[${JSON.stringify(binding.imported)}]`;
+    bindings.set(binding.local, replacement);
+  }
+}
+
+function namedCommonJsImportsToRequireStatements(
+  clause: string,
+  sourceExpression: string,
+): string {
+  const objectBindings: string[] = [];
+  const statements: string[] = [];
+
+  for (const binding of namedImportBindings(clause)) {
+    if (binding.imported === "default") {
+      statements.push(`const ${binding.local} = ${sourceExpression};`);
+    } else if (binding.imported === binding.local) {
+      objectBindings.push(binding.imported);
+    } else {
+      objectBindings.push(`${JSON.stringify(binding.imported)}: ${binding.local}`);
+    }
+  }
+
+  if (objectBindings.length > 0) {
+    statements.unshift(`const { ${objectBindings.join(", ")} } = ${sourceExpression};`);
+  }
+
+  return statements.join("\n");
+}
+
+function namedImportBindings(clause: string): Array<{ imported: string; local: string }> {
+  return clause
+    .slice(1, -1)
+    .split(",")
+    .map((binding) => binding.trim())
+    .filter((binding) => binding.length > 0)
+    .map((binding) => {
+      const alias = binding.match(/^(.+?)\s+as\s+(.+)$/);
+      const imported = alias?.[1]?.trim() ?? binding;
+      const local = alias?.[2]?.trim() ?? binding;
+
+      return { imported, local };
+    });
+}
+
+function replaceImportedIdentifiers(code: string, bindings: ReadonlyMap<string, string>): string {
+  let rewritten = "";
+  let index = 0;
+
+  while (index < code.length) {
+    const char = code[index];
+    const next = code[index + 1];
+
+    if (char === '"' || char === "'") {
+      const end = quotedStringEnd(code, index, char);
+      rewritten += code.slice(index, end);
+      index = end;
+      continue;
+    }
+
+    if (char === "`") {
+      const end = templateLiteralEnd(code, index);
+      rewritten += code.slice(index, end);
+      index = end;
+      continue;
+    }
+
+    if (char === "/" && next === "/") {
+      const end = lineCommentEnd(code, index);
+      rewritten += code.slice(index, end);
+      index = end;
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      const end = blockCommentEnd(code, index);
+      rewritten += code.slice(index, end);
+      index = end;
+      continue;
+    }
+
+    if (isIdentifierStart(char)) {
+      const end = identifierEnd(code, index);
+      const identifier = code.slice(index, end);
+      const replacement = bindings.get(identifier);
+
+      if (replacement !== undefined && shouldReplaceImportedIdentifier(code, index, end)) {
+        rewritten += importedIdentifierReplacement(code, index, end, identifier, replacement);
+      } else {
+        rewritten += identifier;
+      }
+
+      index = end;
+      continue;
+    }
+
+    rewritten += char;
+    index += 1;
+  }
+
+  return rewritten;
+}
+
+function shouldReplaceImportedIdentifier(code: string, start: number, end: number): boolean {
+  const previous = previousNonWhitespace(code, start);
+  const next = nextNonWhitespace(code, end);
+
+  return previous !== "." && previous !== "?" && next !== ":";
+}
+
+function importedIdentifierReplacement(
+  code: string,
+  start: number,
+  end: number,
+  identifier: string,
+  replacement: string,
+): string {
+  const previous = previousNonWhitespace(code, start);
+  const next = nextNonWhitespace(code, end);
+
+  return (previous === "{" || previous === ",") && (next === "," || next === "}")
+    ? `${identifier}: ${replacement}`
+    : replacement;
+}
+
+function previousNonWhitespace(code: string, index: number): string | undefined {
+  for (let position = index - 1; position >= 0; position -= 1) {
+    if (!/\s/u.test(code[position] ?? "")) {
+      return code[position];
+    }
+  }
+
+  return undefined;
+}
+
+function nextNonWhitespace(code: string, index: number): string | undefined {
+  for (let position = index; position < code.length; position += 1) {
+    if (!/\s/u.test(code[position] ?? "")) {
+      return code[position];
+    }
+  }
+
+  return undefined;
+}
+
+function quotedStringEnd(code: string, start: number, quote: string): number {
+  for (let index = start + 1; index < code.length; index += 1) {
+    if (code[index] === "\\") {
+      index += 1;
+    } else if (code[index] === quote) {
+      return index + 1;
+    }
+  }
+
+  return code.length;
+}
+
+function templateLiteralEnd(code: string, start: number): number {
+  for (let index = start + 1; index < code.length; index += 1) {
+    if (code[index] === "\\") {
+      index += 1;
+    } else if (code[index] === "`") {
+      return index + 1;
+    }
+  }
+
+  return code.length;
+}
+
+function lineCommentEnd(code: string, start: number): number {
+  const end = code.indexOf("\n", start + 2);
+
+  return end === -1 ? code.length : end;
+}
+
+function blockCommentEnd(code: string, start: number): number {
+  const end = code.indexOf("*/", start + 2);
+
+  return end === -1 ? code.length : end + 2;
+}
+
+function identifierEnd(code: string, start: number): number {
+  let end = start + 1;
+
+  while (end < code.length && isIdentifierPart(code[end] ?? "")) {
+    end += 1;
+  }
+
+  return end;
+}
+
+function isIdentifierStart(char: string | undefined): boolean {
+  return char !== undefined && /[A-Za-z_$]/u.test(char);
+}
+
+function isIdentifierPart(char: string): boolean {
+  return /[A-Za-z0-9_$]/u.test(char);
+}
+
 function workspacePackageResolutionPlugin() {
   const currentDir = dirname(fileURLToPath(import.meta.url));
   const packageRoot = dirname(currentDir);