@marko/run 0.8.1 → 0.9.1

package/dist/cli/index.mjs

@@ -79,7 +79,6 @@ var httpVerbs = [
   "patch",
   "options"
 ];
-var serverEntryQuery = "?marko-server-entry";
 var RoutableFileTypes = {
   Page: "page",
   Layout: "layout",
@@ -115,6 +114,11 @@ function getVerbs(route, noAutoHead) {
   }
   return [...verbs].sort((a, b) => httpVerbOrder[a] - httpVerbOrder[b]);
 }
+function getUniqueSortedVerbs(verbs) {
+  return [...new Set(verbs)].sort(
+    (a, b) => httpVerbOrder[a] - httpVerbOrder[b]
+  );
+}
 function hasVerb(route, verb) {
   var _a, _b;
   return verb === "get" && !!route.page || ((_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.includes(verb)) || verb === "head" && hasVerb(route, "get");
@@ -366,7 +370,7 @@ function renderRouteEntry(route, rootDir) {
   }
   if (page) {
     imports.writeLines(
-      `import page from "${normalizedRelativePath(rootDir, route.templateFilePath || page.filePath)}${serverEntryQuery}";`
+      `import page from "${normalizedRelativePath(rootDir, route.templateFilePath || page.filePath)}";`
     );
   }
   if (meta) {
@@ -499,7 +503,7 @@ function renderRouter(routes, rootDir, runtimeInclude, options = {
   }
   for (const route of Object.values(routes.special)) {
     imports.writeLines(
-      `import page${route.key} from "${normalizedRelativePath(rootDir, route.templateFilePath || route.page.filePath)}${serverEntryQuery}";`
+      `import page${route.key} from "${normalizedRelativePath(rootDir, route.templateFilePath || route.page.filePath)}";`
     );
   }
   writer.writeLines(
@@ -1343,7 +1347,7 @@ async function buildRoutes(sources, outDir) {
   const uniqueRoutes = /* @__PURE__ */ new Map();
   const routes = [];
   const special = {};
-  const seenKeys = /* @__PURE__ */ new Map();
+  const seenKeys = /* @__PURE__ */ new Set();
   const middlewares = /* @__PURE__ */ new Set();
   const unusedFiles = /* @__PURE__ */ new Set();
   const currentLayouts = /* @__PURE__ */ new Set();
@@ -1474,12 +1478,13 @@ async function buildRoutes(sources, outDir) {
           );
         }
         uniqueRoutes.set(pathInfo.id, { dir, index: routes.length });
-        let key = pathInfo.segments.map(replaceInvalidFilenameChars).concat("route").join("/");
-        const keyCount = (seenKeys.get(key) || 0) + 1;
-        seenKeys.set(key, keyCount);
-        if (keyCount > 1) {
-          key += keyCount;
+        const keyBase = pathInfo.segments.map(replaceInvalidFilenameChars).join(".") || "index";
+        let count = 2;
+        let key = keyBase;
+        while (seenKeys.has(key)) {
+          key = keyBase + count++;
         }
+        seenKeys.add(key);
         routes.push({
           index: nextRouteIndex++,
           key,
@@ -1515,7 +1520,7 @@ async function buildRoutes(sources, outDir) {
   }
 }
 function replaceInvalidFilenameChars(str) {
-  return str.replace(/[<>:"/\\|?*]+/g, "_");
+  return str.replace(/[<>:"/\\|?*_]+/g, "-");
 }
 
 // src/vite/routes/walk.ts
@@ -1631,7 +1636,7 @@ var HttpVerbColors = {
 function verbColor(verb) {
   return verb in HttpVerbColors ? HttpVerbColors[verb] : kleur2.gray;
 }
-function logRoutesTable(routes, bundle) {
+function logRoutesTable(routes, externalRoutes, bundle) {
   const hasMiddleware = routes.list.some((route) => route.middleware.length);
   const hasMeta = routes.list.some((route) => route.meta);
   const headings = ["Method", "Path", "Entry"];
@@ -1665,7 +1670,11 @@ function logRoutesTable(routes, bundle) {
       if (route.page && (verb === "get" || verb === "head")) {
         entryType.push(kleur2.yellow("page"));
         if (verb === "get") {
-          size = prettySize(computeRouteSize(route, bundle));
+          const routeSize = computeRouteSize(
+            route.templateFilePath,
+            bundle
+          ) || [0, 0];
+          size = prettySize(routeSize);
         }
       }
       const row = [verbCell];
@@ -1687,9 +1696,40 @@ function logRoutesTable(routes, bundle) {
     const row = [kleur2.bold(kleur2.white("*")), key, kleur2.yellow("page")];
     hasMiddleware && row.push("");
     hasMeta && row.push("");
-    row.push(prettySize(computeRouteSize(route, bundle)));
+    const routeSize = computeRouteSize(route.templateFilePath, bundle) || [
+      0,
+      0
+    ];
+    row.push(prettySize(routeSize));
     table.push(row);
   }
+  for (const external of externalRoutes) {
+    for (const route of external.routes) {
+      const verbs = getUniqueSortedVerbs(route.verbs);
+      let firstRow = true;
+      for (const verb of verbs) {
+        let size = "";
+        const verbCell = verbColor(verb)(verb.toUpperCase());
+        const row = [verbCell];
+        if (verbs.length === 1 || firstRow) {
+          const routeSize = computeRouteSize(route.entryFile, bundle);
+          if (routeSize) {
+            size = prettySize(routeSize);
+          }
+          row.push({
+            rowSpan: verbs.length,
+            content: prettyPath(route.path)
+          });
+          firstRow = false;
+        }
+        row.push(kleur2.magenta(external.name));
+        hasMiddleware && row.push("");
+        hasMeta && row.push("");
+        row.push(size || "");
+        table.push(row);
+      }
+    }
+  }
   if (!table.length) {
     table.push([
       {
@@ -1701,16 +1741,14 @@ function logRoutesTable(routes, bundle) {
   }
   console.log(table.toString());
 }
-function computeRouteSize(route, bundle) {
-  const facadeModuleId = route.templateFilePath && `${route.templateFilePath}.html`;
-  if (facadeModuleId) {
+function computeRouteSize(filePath, bundle) {
+  if (filePath) {
     for (const chunk of Object.values(bundle)) {
-      if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId === facadeModuleId) {
+      if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId === `${filePath}.html`) {
         return computeChunkSize(chunk, bundle);
       }
     }
   }
-  return [0, 0];
 }
 function gzipSize(source) {
   return zlib.gzipSync(source, { level: 9 }).length;
@@ -1828,9 +1866,12 @@ function markoRun(opts = {}) {
   let devEntryFilePosix;
   let devServer;
   let routes;
+  let entryTemplates;
+  let entryTemplateImporters;
   let routeData;
   let resolvedConfig;
   let typesFile;
+  const externalRoutes = /* @__PURE__ */ new Set();
   const seenErrors = /* @__PURE__ */ new Set();
   const virtualFiles = /* @__PURE__ */ new Map();
   let times = {
@@ -1864,6 +1905,7 @@ function markoRun(opts = {}) {
   let buildVirtualFilesResult;
   function buildVirtualFiles() {
     return buildVirtualFilesResult ?? (buildVirtualFilesResult = (async () => {
+      var _a, _b;
       virtualFiles.clear();
       if (fs3.existsSync(resolvedRoutesDir)) {
         routes = await buildRoutes(
@@ -1885,16 +1927,43 @@ function markoRun(opts = {}) {
           console.warn(`Routes directory ${resolvedRoutesDir} does not exist`);
         }
       }
+      entryTemplates = /* @__PURE__ */ new Set();
+      entryTemplateImporters = /* @__PURE__ */ new Set();
       for (const route of routes.list) {
+        const routeEntryPath = route.templateFilePath || ((_a = route.page) == null ? void 0 : _a.filePath);
+        if (routeEntryPath) {
+          entryTemplates.add(normalizePath(routeEntryPath));
+        }
+        for (const middleware of route.middleware) {
+          entryTemplateImporters.add(normalizePath(middleware.filePath));
+        }
+        if (route.handler) {
+          entryTemplateImporters.add(normalizePath(route.handler.filePath));
+        }
         virtualFiles.set(
           path6.posix.join(root, getRouteVirtualFileName(route)),
           ""
         );
       }
+      for (const route of Object.values(routes.special)) {
+        const routeEntryPath = route.templateFilePath || ((_b = route.page) == null ? void 0 : _b.filePath);
+        if (routeEntryPath) {
+          entryTemplates.add(normalizePath(routeEntryPath));
+        }
+      }
       if (routes.middleware.length) {
         virtualFiles.set(path6.posix.join(root, MIDDLEWARE_FILENAME), "");
       }
       virtualFiles.set(path6.posix.join(root, ROUTER_FILENAME), "");
+      for (const externalRoute of externalRoutes) {
+        for (const { entryFile } of externalRoute.routes) {
+          if (/\.marko(\?.*)?$/i.test(entryFile)) {
+            entryTemplates.add(normalizePath(entryFile));
+          } else {
+            entryTemplateImporters.add(normalizePath(entryFile));
+          }
+        }
+      }
       return routes;
     })());
   }
@@ -2001,6 +2070,14 @@ function markoRun(opts = {}) {
     {
       name: `${PLUGIN_NAME_PREFIX}:pre`,
       enforce: "pre",
+      api: {
+        addExternalRoutes(routes2) {
+          externalRoutes.add(routes2);
+          return () => {
+            externalRoutes.delete(routes2);
+          };
+        }
+      },
       async config(config2, env) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B;
         const externalPluginOptions = getExternalPluginOptions(config2);
@@ -2033,6 +2110,10 @@ function markoRun(opts = {}) {
         );
         markoVitePluginOptions.runtimeId = opts.runtimeId;
         markoVitePluginOptions.basePathVar = opts.basePathVar;
+        markoVitePluginOptions.isEntry = (importee, importer) => {
+          var _a2;
+          return entryTemplates.has(importee) || entryTemplateImporters.has(importer) || ((_a2 = adapter == null ? void 0 : adapter.isEntryTemplate) == null ? void 0 : _a2.call(adapter, { template: importee, importer })) || false;
+        };
         resolvedRoutesDir = path6.resolve(root, routesDir);
         outputDir = path6.join(root, ((_d = config2.build) == null ? void 0 : _d.outDir) || "dist");
         entryFilesDir = path6.join(outputDir, ".marko-run");
@@ -2051,23 +2132,9 @@ function markoRun(opts = {}) {
             outDir = path6.join(outDir, CLIENT_OUT_DIR);
           }
           const defaultRollupOutputOptions = {
-            assetFileNames({ name }) {
-              if (name && name.indexOf("_marko-virtual_id_") < 0) {
-                return `${assetsDir}/${getEntryFileName(name) || "[name]"}-[hash].[ext]`;
-              }
-              return `${assetsDir}/_[hash].[ext]`;
-            },
+            assetFileNames: `${assetsDir}/[name]-[hash].[ext]`,
             entryFileNames(info) {
-              let name = getEntryFileName(info.facadeModuleId);
-              if (!name) {
-                for (const id of info.moduleIds) {
-                  name = getEntryFileName(id);
-                  if (name) {
-                    break;
-                  }
-                }
-              }
-              return `${assetsDir}/${name || "[name]"}-[hash].js`;
+              return `${assetsDir}/${getEntryFileName(info.name) || "[name]"}-[hash].js`;
             },
             chunkFileNames: isSSRBuild ? `_[hash].js` : `${assetsDir}/_[hash].js`
           };
@@ -2221,16 +2288,14 @@ function markoRun(opts = {}) {
         }
       },
       async resolveId(importee, importer) {
+        let virtualFilePath;
         if (importee === "@marko/run/router") {
           return normalizePath(path6.resolve(root, ROUTER_FILENAME));
         } else if (importee.endsWith(".marko") && importee.includes(relativeEntryFilesDirPosix)) {
           if (!importee.startsWith(root)) {
             importee = path6.resolve(root, "." + importee);
           }
-          return normalizePath(importee);
-        }
-        let virtualFilePath;
-        if (importee.startsWith(virtualFilePrefix)) {
+        } else if (importee.startsWith(virtualFilePrefix)) {
           virtualFilePath = importee.slice(virtualFilePrefix.length + 1);
           importee = path6.resolve(root, virtualFilePath);
         } else if (!isBuild && importer && (importer === devEntryFile || normalizePath(importer) === devEntryFilePosix) && importee.startsWith(`/${markoRunFilePrefix}`)) {
@@ -2250,9 +2315,6 @@ function markoRun(opts = {}) {
         }
       },
       async load(id) {
-        if (id.endsWith(serverEntryQuery)) {
-          id = id.slice(0, -serverEntryQuery.length);
-        }
         if (!renderVirtualFilesResult) {
           await renderVirtualFiles(this);
         }
@@ -2301,8 +2363,8 @@ function markoRun(opts = {}) {
           }
           store.write(routeData);
           await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
-        } else if (process.env.MR_EXPLORER !== "true") {
-          logRoutesTable(routes, bundle);
+        } else {
+          logRoutesTable(routes, [...externalRoutes], bundle);
         }
       },
       async closeBundle() {
@@ -2375,15 +2437,18 @@ async function resolveAdapter(root, options, log) {
   log && debug("Using default adapter");
   return module.default();
 }
-var markoEntryFileRegex = /__marko-run__([^.]+)(?:\.(.+))?\.marko\.([^.]+)$/;
+var markoEntryFileRegex = /([^/\\]+)\.marko$/;
 function getEntryFileName(file) {
   const match = file && markoEntryFileRegex.exec(file);
-  return match ? match[2] || "index" : void 0;
+  return match ? match[1] : void 0;
+}
+function getPlugin(config2) {
+  return config2.plugins.find(
+    (plugin) => plugin.name === `${PLUGIN_NAME_PREFIX}:pre`
+  );
 }
 function isPluginIncluded(config2) {
-  return config2.plugins.some((plugin) => {
-    return plugin.name === `${PLUGIN_NAME_PREFIX}:pre`;
-  });
+  return !!getPlugin(config2);
 }
 function getImporters(module, fileName, seen = /* @__PURE__ */ new Set()) {
   for (const importer of module.importers) {

package/dist/vite/constants.d.ts

@@ -2,8 +2,6 @@ type ValuesOf<T> = T[keyof T];
 export declare const markoRunFilePrefix = "__marko-run__";
 export declare const virtualFilePrefix = "virtual:marko-run";
 export declare const httpVerbs: readonly ["get", "head", "post", "put", "delete", "patch", "options"];
-export declare const serverEntryQuery = "?marko-server-entry";
-export declare const browserEntryQuery = "?marko-browser-entry";
 export declare const RoutableFileTypes: {
     readonly Page: "page";
     readonly Layout: "layout";