@marko/run 0.5.0 → 0.5.2

package/dist/vite/index.js

@@ -705,16 +705,19 @@ function hasVerb(route, verb) {
 }
 
 // src/vite/codegen/index.ts
-function renderRouteTemplate(route) {
+function renderRouteTemplate(route, getRelativePath) {
   if (!route.page) {
     throw new Error(`Route ${route.key} has no page to render`);
   }
   return renderEntryTemplate(
     route.entryName,
-    [...route.layouts, route.page].map((file) => `./${file.importPath}`)
+    [...route.layouts, route.page].map(
+      (file) => getRelativePath(file.importPath)
+    ),
+    route.key === RoutableFileTypes.Error ? ["error"] : []
   );
 }
-function renderEntryTemplate(name, files) {
+function renderEntryTemplate(name, files, pageInputs = []) {
   if (!name) {
     throw new Error(`Invalid argument - 'name' cannot be empty`);
   }
@@ -722,27 +725,28 @@ function renderEntryTemplate(name, files) {
     throw new Error(`Invalid argument - 'files' cannot be empty`);
   }
   const writer = createStringWriter();
-  writer.writeLines(`// ${virtualFilePrefix}/${name}.marko`);
+  writer.writeLines(`// ${name}.marko`);
   writer.branch("imports");
   writer.writeLines("");
-  writeEntryTemplateTag(writer, files);
+  writeEntryTemplateTag(writer, files, pageInputs);
   return writer.end();
 }
-function writeEntryTemplateTag(writer, [file, ...rest], index = 1) {
+function writeEntryTemplateTag(writer, [file, ...rest], pageInputs, index = 1) {
   if (file) {
     const isLast = !rest.length;
     const tag = isLast ? "Page" : `Layout${index}`;
     writer.branch("imports").writeLines(`import ${tag} from '${file}';`);
     if (isLast) {
-      writer.writeLines(`<${tag} ...input/>`);
+      const attributes = pageInputs.length ? " " + pageInputs.map((name) => `${name}=input.${name}`).join(" ") : "";
+      writer.writeLines(`<${tag}${attributes}/>`);
     } else {
-      writer.writeBlockStart(`<${tag} ...input>`);
-      writeEntryTemplateTag(writer, rest, index + 1);
+      writer.writeBlockStart(`<${tag}>`);
+      writeEntryTemplateTag(writer, rest, pageInputs, index + 1);
       writer.writeBlockEnd(`</>`);
     }
   }
 }
-function renderRouteEntry(route) {
+function renderRouteEntry(route, entriesDir) {
   var _a;
   const { key, index, handler, page, middleware, meta, entryName } = route;
   const verbs = getVerbs(route);
@@ -795,9 +799,8 @@ function renderRouteEntry(route) {
     );
   }
   if (page) {
-    imports.writeLines(
-      `import page from '${virtualFilePrefix}/${entryName}.marko${serverEntryQuery}';`
-    );
+    const importPath = route.layouts.length ? `./${entriesDir}/${entryName}.marko` : `./${page.importPath}`;
+    imports.writeLines(`import page from '${importPath}${serverEntryQuery}';`);
   }
   if (meta) {
     imports.writeLines(
@@ -885,7 +888,7 @@ function writeRouteEntryHandler(writer, route, verb) {
   continuations.join();
   writer.writeBlockEnd("}");
 }
-function renderRouter(routes, options = {
+function renderRouter(routes, entriesDir, options = {
   trailingSlashes: "RedirectWithout"
 }) {
   const writer = createStringWriter();
@@ -902,9 +905,10 @@ function renderRouter(routes, options = {
       `import { ${names.join(", ")} } from '${virtualFilePrefix}/${route.entryName}.js';`
     );
   }
-  for (const { key, entryName } of Object.values(routes.special)) {
+  for (const page of Object.values(routes.special)) {
+    const importPath = page.layouts.length ? `./${entriesDir}/${page.entryName}.marko` : `./${page.importPath}`;
     imports.writeLines(
-      `import page${key} from '${virtualFilePrefix}/${entryName}.marko${serverEntryQuery}';`
+      `import page${page.key} from '${importPath}${serverEntryQuery}';`
     );
   }
   writer.writeLines(
@@ -1692,18 +1696,23 @@ function prepareError(err) {
 }
 
 // src/vite/plugin.ts
+import { createHash } from "crypto";
 var debug = createDebug("@marko/run");
 var __dirname = path3.dirname(fileURLToPath(import.meta.url));
 var PLUGIN_NAME_PREFIX = "marko-run-vite";
 var POSIX_SEP = "/";
 var WINDOWS_SEP = "\\";
 var CLIENT_OUT_DIR = "public";
+var MIDDLEWARE_FILENAME = `${markoRunFilePrefix}middleware.js`;
+var ROUTER_FILENAME = `${markoRunFilePrefix}router.js`;
 var normalizePath = path3.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
 function markoRun(opts = {}) {
   let { routesDir, adapter, ...markoVitePluginOptions } = opts;
   let store;
   let root;
   let resolvedRoutesDir;
+  let entryFilesDir;
+  let relativeEntryFilesDir;
   let typesDir;
   let isBuild = false;
   let isSSRBuild = false;
@@ -1723,6 +1732,9 @@ function markoRun(opts = {}) {
     routesBuild: 0,
     routesRender: 0
   };
+  function getEntryFileRelativePath(to) {
+    return path3.relative(entryFilesDir, to);
+  }
   async function writeTypesFile(routes2) {
     if (routes2 && (tsConfigExists ?? (tsConfigExists = await globFileExists(
       root,
@@ -1753,27 +1765,12 @@ function markoRun(opts = {}) {
           throw new Error("No routes generated");
         }
         for (const route of routes.list) {
-          if (route.page) {
-            virtualFiles.set(
-              path3.posix.join(root, `${route.entryName}.marko`),
-              ""
-            );
-          }
           virtualFiles.set(path3.posix.join(root, `${route.entryName}.js`), "");
         }
-        for (const route of Object.values(routes.special)) {
-          virtualFiles.set(
-            path3.posix.join(root, `${route.entryName}.marko`),
-            ""
-          );
-        }
         if (routes.middleware.length) {
-          virtualFiles.set(
-            path3.posix.join(root, `${markoRunFilePrefix}middleware.js`),
-            ""
-          );
+          virtualFiles.set(path3.posix.join(root, MIDDLEWARE_FILENAME), "");
         }
-        virtualFiles.set("@marko/run/router", "");
+        virtualFiles.set(path3.posix.join(root, ROUTER_FILENAME), "");
         resolve(routes);
       } catch (err) {
         reject(err);
@@ -1784,11 +1781,12 @@ function markoRun(opts = {}) {
   function renderVirtualFiles(context) {
     return renderVirtualFilesResult ?? (renderVirtualFilesResult = new Promise(async (resolve) => {
       var _a;
-      const routerOptions = {
-        trailingSlashes: opts.trailingSlashes || "RedirectWithout"
-      };
       try {
         const routes2 = await buildVirtualFiles();
+        let entryFilesDirExists = false;
+        if (fs3.existsSync(entryFilesDir)) {
+          fs3.rmSync(entryFilesDir, { recursive: true });
+        }
         for (const route of routes2.list) {
           if (route.handler) {
             const exports = await getExportsFromFile(
@@ -1808,22 +1806,30 @@ function markoRun(opts = {}) {
               );
             }
           }
-          if (route.page) {
-            virtualFiles.set(
-              path3.posix.join(root, `${route.entryName}.marko`),
-              renderRouteTemplate(route)
+          if (route.page && route.layouts.length) {
+            entryFilesDirExists || (entryFilesDirExists = !!fs3.mkdirSync(entryFilesDir, {
+              recursive: true
+            }));
+            fs3.writeFileSync(
+              path3.posix.join(entryFilesDir, `${route.entryName}.marko`),
+              renderRouteTemplate(route, getEntryFileRelativePath)
             );
           }
           virtualFiles.set(
             path3.posix.join(root, `${route.entryName}.js`),
-            renderRouteEntry(route)
+            renderRouteEntry(route, relativeEntryFilesDir)
           );
         }
         for (const route of Object.values(routes2.special)) {
-          virtualFiles.set(
-            path3.posix.join(root, `${route.entryName}.marko`),
-            renderRouteTemplate(route)
-          );
+          if (route.layouts.length) {
+            entryFilesDirExists || (entryFilesDirExists = !!fs3.mkdirSync(entryFilesDir, {
+              recursive: true
+            }));
+            fs3.writeFileSync(
+              path3.posix.join(entryFilesDir, `${route.entryName}.marko`),
+              renderRouteTemplate(route, getEntryFileRelativePath)
+            );
+          }
         }
         if (routes2.middleware.length) {
           for (const middleware of routes2.middleware) {
@@ -1834,13 +1840,15 @@ function markoRun(opts = {}) {
             }
           }
           virtualFiles.set(
-            path3.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+            path3.posix.join(root, MIDDLEWARE_FILENAME),
             renderMiddleware(routes2.middleware)
           );
         }
         virtualFiles.set(
-          "@marko/run/router",
-          renderRouter(routes2, routerOptions)
+          path3.posix.join(root, ROUTER_FILENAME),
+          renderRouter(routes2, relativeEntryFilesDir, {
+            trailingSlashes: opts.trailingSlashes || "RedirectWithout"
+          })
         );
         await writeTypesFile(routes2);
         if (adapter == null ? void 0 : adapter.routesGenerated) {
@@ -1861,7 +1869,7 @@ function markoRun(opts = {}) {
           throw err;
         }
         virtualFiles.set(
-          "@marko/run/router",
+          path3.posix.join(root, ROUTER_FILENAME),
           `throw ${JSON.stringify(prepareError(err))}`
         );
       }
@@ -1904,6 +1912,13 @@ function markoRun(opts = {}) {
         markoVitePluginOptions.runtimeId = opts.runtimeId;
         markoVitePluginOptions.basePathVar = opts.basePathVar;
         resolvedRoutesDir = path3.resolve(root, routesDir);
+        const modulesDir = getModulesDir(root);
+        entryFilesDir = path3.join(
+          modulesDir,
+          ".marko",
+          createHash("shake256", { outputLength: 4 }).update(root).digest("hex")
+        );
+        relativeEntryFilesDir = path3.relative(root, entryFilesDir);
         typesDir = path3.join(root, ".marko-run");
         devEntryFile = path3.join(root, "index.html");
         devEntryFilePosix = normalizePath(devEntryFile);
@@ -2089,7 +2104,9 @@ function markoRun(opts = {}) {
       async resolveId(importee, importer) {
         let resolved;
         let virtualFilePath;
-        if (importee.startsWith(virtualFilePrefix)) {
+        if (importee === "@marko/run/router") {
+          importee = path3.resolve(root, ROUTER_FILENAME);
+        } else if (importee.startsWith(virtualFilePrefix)) {
           virtualFilePath = importee.slice(virtualFilePrefix.length + 1);
           importee = path3.resolve(root, virtualFilePath);
         } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
@@ -2119,7 +2136,7 @@ function markoRun(opts = {}) {
         }
         if (virtualFiles.has(id)) {
           return virtualFiles.get(id);
-        } else if (/[/\\]__marko-run__[^?/\\]+\.(js|marko)$/.exec(id)) {
+        } else if (!id.startsWith(entryFilesDir) && /[/\\]__marko-run__[^?/\\]+\.(js|marko)$/.exec(id)) {
           return "";
         }
       }
@@ -2253,6 +2270,15 @@ function getImporters(module, fileName, seen = /* @__PURE__ */ new Set()) {
   }
   return seen;
 }
+function getModulesDir(root, dir = __dirname) {
+  if (dir.startsWith(root)) {
+    const index = dir.indexOf("node_modules");
+    if (index >= 0) {
+      return dir.slice(0, index + 12);
+    }
+  }
+  return path3.join(root, "node_modules");
+}
 
 // src/vite/utils/server.ts
 import net from "net";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/run",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "The Marko application framework.",
   "license": "MIT",
   "homepage": "https://github.com/marko-js/run/tree/main/packages/run",
@@ -98,6 +98,7 @@
     "acorn": "^8.14.0",
     "body-parser": "^1.20.3",
     "cross-env": "^7.0.3",
+    "diff": "^7.0.0",
     "esbuild": "^0.24.0",
     "express": "^4.21.1",
     "jsdom": "^25.0.1",
@@ -109,11 +110,11 @@
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "tsx": "^4.19.2",
-    "typescript": "^5.6.3"
+    "typescript": "^5.7.2"
   },
   "dependencies": {
     "@marko/run-explorer": "^0.1.2",
-    "@marko/vite": "^5.0.2",
+    "@marko/vite": "^5.0.5",
     "browserslist": "^4.24.2",
     "cli-table3": "^0.6.5",
     "compression": "^1.7.5",