evolit 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/compiler.js

@@ -17,6 +17,15 @@ import { ensureDirectory } from "./fs-utils.js";
 
 const MODULE_SPECIFIER_PATTERN =
   /\b(?:import|export)\s+(?:[^"']*?\s+from\s+)?["']([^"']+)["']|\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+const RESOLVABLE_IMPORT_EXTENSIONS = [
+  ...MODULE_EXTENSIONS,
+  ...STATIC_ASSET_EXTENSIONS,
+];
+const developmentGraphCache = new Map();
+const developmentGraphDependencies = new Map();
+const developmentModuleNamespaceCache = new Map();
+const developmentGraphVersions = new Map();
+const developmentUnmanagedImportWarnings = new Set();
 
 function isRelativeSpecifier(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../");
@@ -44,10 +53,37 @@ function isStaticAssetPath(filePath) {
   return STATIC_ASSET_EXTENSIONS.some((extension) => filePath.endsWith(extension));
 }
 
+function hasResolvableImportExtension(filePath) {
+  return RESOLVABLE_IMPORT_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+
 function isStyleAssetPath(filePath) {
   return filePath.endsWith(".css");
 }
 
+function isPathOutsideProject(projectRoot, filePath) {
+  const relativePath = path.relative(projectRoot, filePath);
+  return (
+    relativePath === ".." ||
+    relativePath.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relativePath)
+  );
+}
+
+function reportDevelopmentUnmanagedImport(projectRoot, sourcePath, resolvedImportPath, onDevelopmentEvent) {
+  const warningKey = `${path.resolve(projectRoot)}::${sourcePath}::${resolvedImportPath}`;
+  if (developmentUnmanagedImportWarnings.has(warningKey)) {
+    return;
+  }
+
+  developmentUnmanagedImportWarnings.add(warningKey);
+  onDevelopmentEvent?.({
+    type: "unmanaged-import",
+    sourcePath,
+    resolvedImportPath,
+  });
+}
+
 function createStaticAssetStubSource(relativeAssetPath, mode, target = "server", staticAssetPublicUrls = null) {
   const normalizedAssetPath = relativeAssetPath.split(path.sep).join("/");
   if (normalizedAssetPath.endsWith(".css")) {
@@ -65,8 +101,8 @@ async function resolveImportPath(importerPath, specifier) {
   const basePath = path.resolve(path.dirname(importerPath), specifier);
   const candidates = [basePath];
 
-  if (!path.extname(basePath)) {
-    for (const extension of [...MODULE_EXTENSIONS, ...STATIC_ASSET_EXTENSIONS]) {
+  if (!hasResolvableImportExtension(basePath)) {
+    for (const extension of RESOLVABLE_IMPORT_EXTENSIONS) {
       candidates.push(`${basePath}${extension}`);
       candidates.push(path.join(basePath, `index${extension}`));
     }
@@ -100,7 +136,7 @@ function getTypedOutputRoot(projectRoot, mode, target = "server") {
 }
 
 function toOutputPath(projectRoot, outputRoot, sourcePath) {
-  const relativePath = path.relative(projectRoot, sourcePath);
+  const relativePath = toOutputRelativePath(projectRoot, sourcePath);
   const extension = path.extname(relativePath);
   if (!extension) {
     return path.join(outputRoot, `${relativePath}.mjs`);
@@ -112,6 +148,22 @@ function toOutputPath(projectRoot, outputRoot, sourcePath) {
   );
 }
 
+function toOutputRelativePath(projectRoot, sourcePath) {
+  const relativePath = path.relative(projectRoot, sourcePath);
+  const isOutsideProject =
+    relativePath === ".." ||
+    relativePath.startsWith(`..${path.sep}`) ||
+    path.isAbsolute(relativePath);
+  if (!isOutsideProject) {
+    return relativePath;
+  }
+
+  return path.join(
+    "__unmanaged__",
+    ...relativePath.split(path.sep).map((segment) => segment === ".." ? "__up__" : segment),
+  );
+}
+
 async function rewriteRelativeSpecifiers({
   projectRoot,
   outputRoot,
@@ -126,6 +178,7 @@ async function rewriteRelativeSpecifiers({
   sourceMaps,
   outputPath,
   inputSourceMap,
+  onDevelopmentEvent,
 }) {
   const magicSource = new MagicString(code);
   let didRewrite = false;
@@ -157,13 +210,17 @@ async function rewriteRelativeSpecifiers({
       continue;
     }
 
+    if (mode === "development" && isPathOutsideProject(projectRoot, resolvedImportPath)) {
+      reportDevelopmentUnmanagedImport(projectRoot, sourcePath, resolvedImportPath, onDevelopmentEvent);
+    }
+
     const importerOutputPath = toOutputPath(projectRoot, outputRoot, sourcePath);
     let compiledImportPath = null;
 
     if (shouldCompileModule(resolvedImportPath)) {
       compiledImportPath = await compileModule(resolvedImportPath);
     } else if (isStaticAssetPath(resolvedImportPath)) {
-      const relativeAssetPath = path.relative(projectRoot, resolvedImportPath);
+      const relativeAssetPath = toOutputRelativePath(projectRoot, resolvedImportPath);
       const assetOutputPath = path.join(outputRoot, relativeAssetPath);
       const stubOutputPath = `${assetOutputPath}.mjs`;
 
@@ -264,7 +321,54 @@ async function rewriteRelativeSpecifiers({
   };
 }
 
-export async function compileModuleGraph(entryPath, options = {}) {
+function getDevelopmentGraphCacheKey(entryPath, options) {
+  return [
+    options.projectRoot,
+    entryPath,
+    options.target ?? "server",
+    options.ssr === true ? "ssr" : "client",
+    options.sourceMaps === false ? "without-maps" : "with-maps",
+  ].join("::");
+}
+
+export function invalidateDevelopmentCompilationCache(projectRoot, changedPaths = null) {
+  const prefix = `${path.resolve(projectRoot)}::`;
+  const normalizedChangedPaths = Array.isArray(changedPaths) && changedPaths.length > 0
+    ? new Set(changedPaths.map((changedPath) => path.resolve(changedPath)))
+    : null;
+  let invalidated = false;
+
+  if (normalizedChangedPaths == null) {
+    for (const warningKey of developmentUnmanagedImportWarnings) {
+      if (warningKey.startsWith(prefix)) {
+        developmentUnmanagedImportWarnings.delete(warningKey);
+      }
+    }
+  }
+
+  for (const key of developmentGraphCache.keys()) {
+    if (!key.startsWith(prefix)) {
+      continue;
+    }
+
+    const dependencies = developmentGraphDependencies.get(key);
+    const shouldInvalidate =
+      normalizedChangedPaths == null ||
+      !dependencies ||
+      [...dependencies].some((dependency) => normalizedChangedPaths.has(dependency));
+    if (shouldInvalidate) {
+      developmentGraphCache.delete(key);
+      developmentGraphDependencies.delete(key);
+      developmentModuleNamespaceCache.delete(key);
+      developmentGraphVersions.set(key, (developmentGraphVersions.get(key) ?? 0) + 1);
+      invalidated = true;
+    }
+  }
+
+  return invalidated;
+}
+
+async function compileModuleGraphUncached(entryPath, options = {}) {
   const {
     projectRoot,
     mode = "development",
@@ -272,6 +376,7 @@ export async function compileModuleGraph(entryPath, options = {}) {
     ssr = false,
     target = "server",
     staticAssetPublicUrls = null,
+    onDevelopmentEvent,
   } = options;
 
   const outputRoot = getTypedOutputRoot(projectRoot, mode, target);
@@ -310,6 +415,7 @@ export async function compileModuleGraph(entryPath, options = {}) {
       sourceMaps,
       outputPath,
       inputSourceMap: transformed.map ?? null,
+      onDevelopmentEvent,
     });
 
     await fs.writeFile(outputPath, rewritten.code, "utf8");
@@ -338,16 +444,77 @@ export async function compileModuleGraph(entryPath, options = {}) {
   return {
     entrypoint: await compileModule(entryPath),
     outputRoot,
+    sourceFiles: [...visited.keys()],
+  };
+}
+
+export async function compileModuleGraph(entryPath, options = {}) {
+  const mode = options.mode ?? "development";
+  if (mode !== "development") {
+    return compileModuleGraphUncached(entryPath, options);
+  }
+
+  const normalizedOptions = {
+    ...options,
+    projectRoot: path.resolve(options.projectRoot ?? process.cwd()),
   };
+  const cacheKey = getDevelopmentGraphCacheKey(
+    path.resolve(entryPath),
+    normalizedOptions,
+  );
+  let pendingCompile = developmentGraphCache.get(cacheKey);
+  if (!pendingCompile) {
+    pendingCompile = compileModuleGraphUncached(entryPath, normalizedOptions);
+    developmentGraphCache.set(cacheKey, pendingCompile);
+    pendingCompile.then((result) => {
+      if (developmentGraphCache.get(cacheKey) === pendingCompile) {
+        developmentGraphDependencies.set(cacheKey, new Set(result.sourceFiles));
+      }
+    }, () => {});
+  }
+
+  try {
+    return await pendingCompile;
+  } catch (error) {
+    if (developmentGraphCache.get(cacheKey) === pendingCompile) {
+      developmentGraphCache.delete(cacheKey);
+      developmentGraphDependencies.delete(cacheKey);
+    }
+    throw error;
+  }
 }
 
 export async function importCompiledModule(entryPath, options = {}) {
-  const { entrypoint } = await compileModuleGraph(entryPath, options);
+  const mode = options.mode ?? "development";
+  const normalizedOptions = mode === "development"
+    ? { ...options, projectRoot: path.resolve(options.projectRoot ?? process.cwd()) }
+    : options;
+  const cacheKey = mode === "development"
+    ? getDevelopmentGraphCacheKey(path.resolve(entryPath), normalizedOptions)
+    : null;
+  const cachedModule = cacheKey ? developmentModuleNamespaceCache.get(cacheKey) : null;
+  if (cachedModule) {
+    return cachedModule;
+  }
+
+  const { entrypoint } = await compileModuleGraph(entryPath, normalizedOptions);
   const moduleUrl = new URL(pathToFileURL(entrypoint).href);
 
-  if (options.mode === "development") {
-    moduleUrl.searchParams.set("t", String(Date.now()));
+  if (mode === "development") {
+    moduleUrl.searchParams.set("t", String(developmentGraphVersions.get(cacheKey) ?? 0));
   }
 
-  return import(moduleUrl.href);
+  const pendingModule = import(moduleUrl.href);
+  if (cacheKey) {
+    developmentModuleNamespaceCache.set(cacheKey, pendingModule);
+  }
+
+  try {
+    return await pendingModule;
+  } catch (error) {
+    if (developmentModuleNamespaceCache.get(cacheKey) === pendingModule) {
+      developmentModuleNamespaceCache.delete(cacheKey);
+    }
+    throw error;
+  }
 }