evolit 0.1.0-alpha.13 → 0.1.0-alpha.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evolit",
-  "version": "0.1.0-alpha.13",
+  "version": "0.1.0-alpha.15",
   "description": "A convention-driven application framework for LitSX and web components.",
   "type": "module",
   "packageManager": "yarn@4.10.3",

package/src/client-assets.js

@@ -36,6 +36,23 @@ const sharedRuntimeBuildCache = new Map();
 const clientVendorSpecifierCache = new Map();
 const clientModuleMetadataCache = new Map();
 
+export function resetDevelopmentAssetCaches(projectRoot) {
+  const normalizedProjectRoot = path.resolve(projectRoot);
+  const developmentPrefix = `${normalizedProjectRoot}::development::`;
+
+  for (const cache of [
+    sharedRuntimeBuildCache,
+    clientVendorSpecifierCache,
+    clientModuleMetadataCache,
+  ]) {
+    for (const key of cache.keys()) {
+      if (key.startsWith(developmentPrefix)) {
+        cache.delete(key);
+      }
+    }
+  }
+}
+
 function isBareSpecifier(specifier) {
   return (
     typeof specifier === "string" &&
@@ -69,6 +86,19 @@ function resolveRelativeClientImportPath(fromClientModule, specifier) {
     .join("/");
 }
 
+function normalizeClientMetadataAssetPath(fromClientModule, importedAsset) {
+  if (typeof importedAsset !== "string") {
+    return null;
+  }
+
+  const normalizedAsset = stripImportSearchAndHash(importedAsset);
+  if (isRelativeSpecifier(normalizedAsset)) {
+    return resolveRelativeClientImportPath(fromClientModule, normalizedAsset);
+  }
+
+  return path.normalize(normalizedAsset).split(path.sep).join("/");
+}
+
 function parsePackageSpecifier(specifier) {
   if (!isBareSpecifier(specifier)) {
     return null;
@@ -738,10 +768,16 @@ async function collectTransitiveClientModuleMetadata(projectRoot, mode, clientMo
     }
 
     for (const styleImport of metadata.styleImports) {
-      styleImports.add(styleImport);
+      const normalizedStyleImport = normalizeClientMetadataAssetPath(currentModule, styleImport);
+      if (normalizedStyleImport) {
+        styleImports.add(normalizedStyleImport);
+      }
     }
     for (const assetImport of metadata.assetImports) {
-      assetImports.add(assetImport);
+      const normalizedAssetImport = normalizeClientMetadataAssetPath(currentModule, assetImport);
+      if (normalizedAssetImport) {
+        assetImports.add(normalizedAssetImport);
+      }
     }
     for (const importedModule of metadata.moduleImports) {
       pendingModules.push(importedModule);
@@ -1395,8 +1431,12 @@ export async function emitHashedClientAssets(projectRoot, options = {}) {
     if (entry.type === "script") {
       try {
         const metadata = JSON.parse(await fs.readFile(`${entry.filePath}.meta.json`, "utf8"));
-        styleImports = Array.isArray(metadata?.styleImports) ? metadata.styleImports : [];
-        assetImports = Array.isArray(metadata?.assetImports) ? metadata.assetImports : [];
+        styleImports = (Array.isArray(metadata?.styleImports) ? metadata.styleImports : [])
+          .map((importedStyle) => normalizeClientMetadataAssetPath(entry.relativePath, importedStyle))
+          .filter((importedStyle) => typeof importedStyle === "string");
+        assetImports = (Array.isArray(metadata?.assetImports) ? metadata.assetImports : [])
+          .map((importedAsset) => normalizeClientMetadataAssetPath(entry.relativePath, importedAsset))
+          .filter((importedAsset) => typeof importedAsset === "string");
       } catch {
         styleImports = [];
         assetImports = [];

package/src/compiler.js

@@ -25,6 +25,7 @@ const developmentGraphCache = new Map();
 const developmentGraphDependencies = new Map();
 const developmentModuleNamespaceCache = new Map();
 const developmentGraphVersions = new Map();
+const developmentExternalImportWarnings = new Set();
 
 function isRelativeSpecifier(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../");
@@ -60,6 +61,27 @@ 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 warnForDevelopmentExternalImport(projectRoot, sourcePath, resolvedImportPath) {
+  const warningKey = `${path.resolve(projectRoot)}::${sourcePath}::${resolvedImportPath}`;
+  if (developmentExternalImportWarnings.has(warningKey)) {
+    return;
+  }
+
+  developmentExternalImportWarnings.add(warningKey);
+  console.warn(
+    `[evolit] Development import ${JSON.stringify(resolvedImportPath)} from ${JSON.stringify(sourcePath)} is outside the project root. It will be emitted under /_evolit/static/__external__/.`,
+  );
+}
+
 function createStaticAssetStubSource(relativeAssetPath, mode, target = "server", staticAssetPublicUrls = null) {
   const normalizedAssetPath = relativeAssetPath.split(path.sep).join("/");
   if (normalizedAssetPath.endsWith(".css")) {
@@ -112,7 +134,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`);
@@ -124,6 +146,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(
+    "__external__",
+    ...relativePath.split(path.sep).map((segment) => segment === ".." ? "__up__" : segment),
+  );
+}
+
 async function rewriteRelativeSpecifiers({
   projectRoot,
   outputRoot,
@@ -169,13 +207,17 @@ async function rewriteRelativeSpecifiers({
       continue;
     }
 
+    if (mode === "development" && isPathOutsideProject(projectRoot, resolvedImportPath)) {
+      warnForDevelopmentExternalImport(projectRoot, sourcePath, resolvedImportPath);
+    }
+
     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`;
 
@@ -293,6 +335,14 @@ export function invalidateDevelopmentCompilationCache(projectRoot, changedPaths
     : null;
   let invalidated = false;
 
+  if (normalizedChangedPaths == null) {
+    for (const warningKey of developmentExternalImportWarnings) {
+      if (warningKey.startsWith(prefix)) {
+        developmentExternalImportWarnings.delete(warningKey);
+      }
+    }
+  }
+
   for (const key of developmentGraphCache.keys()) {
     if (!key.startsWith(prefix)) {
       continue;

package/src/deployment-runtime.js

@@ -10,17 +10,20 @@ import {
   createAssetResolver,
   createHydrationBootstrap,
   createStaticAssetPublicUrlMap,
+  buildSharedVendorRuntime,
   emitBundledClientAssetsWithState,
   getAssetByPublicUrl,
   getSharedOutputRoot,
   normalizeHydrationDataForClient,
   normalizeClientAssetManifest,
+  resetDevelopmentAssetCaches,
   resolveRouteClientImports,
   resolveSharedVendorModuleUrl,
   resolveBrowserPackageAssetFilePath,
   rewriteHydrationDataScript,
 } from "./client-assets.js";
 import { loadEvolitConfig } from "./config.js";
+import { DEV_DIRECTORY, INTERNAL_DIRECTORY } from "./constants.js";
 import { createRouteResolver } from "./render.js";
 import {
   createCachedRouteResponse,
@@ -454,6 +457,16 @@ export async function createDeploymentRuntime({
   responseCacheRuntime,
   routeResolver,
 } = {}) {
+  if (mode === "development") {
+    const developmentRoot = path.join(projectRoot, INTERNAL_DIRECTORY, DEV_DIRECTORY);
+    await fs.rm(developmentRoot, { recursive: true, force: true });
+    invalidateDevelopmentCompilationCache(projectRoot);
+    resetDevelopmentAssetCaches(projectRoot);
+    await buildSharedVendorRuntime(projectRoot, "development", {
+      additionalEntrySpecifiers: [],
+    });
+  }
+
   const effectiveResponseCacheRuntime = responseCacheRuntime
     ?? await resolveResponseCacheRuntime(
       projectRoot,
@@ -461,7 +474,7 @@ export async function createDeploymentRuntime({
       await loadEvolitConfig(projectRoot),
     );
   const runtimeState = {
-    assetManifest: normalizeClientAssetManifest(assetManifest),
+    assetManifest: mode === "development" ? null : normalizeClientAssetManifest(assetManifest),
   };
   const assets = createPublicAssetOrigin({
     projectRoot,