@marko/run 0.8.1 → 0.9.1

package/dist/vite/index.js

@@ -63,7 +63,6 @@ var httpVerbs = [
   "patch",
   "options"
 ];
-var serverEntryQuery = "?marko-server-entry";
 var RoutableFileTypes = {
   Page: "page",
   Layout: "layout",
@@ -99,6 +98,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");
@@ -350,7 +354,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) {
@@ -483,7 +487,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(
@@ -1327,7 +1331,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();
@@ -1458,12 +1462,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,
@@ -1499,7 +1504,7 @@ async function buildRoutes(sources, outDir) {
   }
 }
 function replaceInvalidFilenameChars(str) {
-  return str.replace(/[<>:"/\\|?*]+/g, "_");
+  return str.replace(/[<>:"/\\|?*_]+/g, "-");
 }
 
 // src/vite/routes/walk.ts
@@ -1614,7 +1619,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"];
@@ -1648,7 +1653,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];
@@ -1670,9 +1679,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([
       {
@@ -1684,16 +1724,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;
@@ -1811,9 +1849,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 = {
@@ -1847,6 +1888,7 @@ function markoRun(opts = {}) {
   let buildVirtualFilesResult;
   function buildVirtualFiles() {
     return buildVirtualFilesResult ?? (buildVirtualFilesResult = (async () => {
+      var _a, _b;
       virtualFiles.clear();
       if (fs3.existsSync(resolvedRoutesDir)) {
         routes = await buildRoutes(
@@ -1868,16 +1910,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;
     })());
   }
@@ -1984,6 +2053,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);
@@ -2016,6 +2093,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");
@@ -2034,23 +2115,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`
           };
@@ -2204,16 +2271,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}`)) {
@@ -2233,9 +2298,6 @@ function markoRun(opts = {}) {
         }
       },
       async load(id) {
-        if (id.endsWith(serverEntryQuery)) {
-          id = id.slice(0, -serverEntryQuery.length);
-        }
         if (!renderVirtualFilesResult) {
           await renderVirtualFiles(this);
         }
@@ -2284,8 +2346,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() {
@@ -2358,10 +2420,22 @@ 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 getApi(config2) {
+  const plugin = getPlugin(config2);
+  if (!plugin) {
+    throw new Error("Marko Run vite plugin not found");
+  }
+  return plugin.api;
 }
 function getImporters(module, fileName, seen = /* @__PURE__ */ new Set()) {
   for (const importer of module.importers) {
@@ -2524,6 +2598,7 @@ function sleep(ms) {
 export {
   markoRun as default,
   defaultConfigPlugin,
+  getApi,
   getAvailablePort,
   getPackageData,
   isPortInUse,

package/dist/vite/plugin.d.ts

@@ -1,5 +1,5 @@
 import { type Plugin, type ResolvedConfig } from "vite";
-import type { Adapter, Options, PackageData } from "./types";
+import type { Adapter, ExternalRoutes, Options, PackageData } from "./types";
 export declare const defaultPort: number;
 declare module "vite" {
     interface TransformResult {
@@ -10,4 +10,7 @@ export default function markoRun(opts?: Options): Plugin[];
 export declare function getPackageData(dir: string): Promise<PackageData | null>;
 export declare function resolveAdapter(root: string, options?: Options, log?: boolean): Promise<Adapter | null>;
 export declare function isPluginIncluded(config: ResolvedConfig): boolean;
+export declare function getApi(config: ResolvedConfig): {
+    addExternalRoutes(routes: ExternalRoutes): () => void;
+};
 export declare const defaultConfigPlugin: Plugin;

package/dist/vite/routes/builder.d.ts

@@ -7,4 +7,3 @@ export interface RouteSource {
     basePath?: string;
 }
 export declare function buildRoutes(sources: RouteSource | RouteSource[], outDir: string): Promise<BuiltRoutes>;
-export declare function replaceInvalidFilenameChars(str: string): string;

package/dist/vite/types.d.ts

@@ -53,6 +53,10 @@ export interface Adapter {
         virtualFiles: Map<string, string>;
         meta: RouteGenerationData;
     }): Promise<void> | void;
+    isEntryTemplate?(event: {
+        template: string;
+        importer: string;
+    }): boolean;
 }
 export interface RouterOptions {
     trailingSlashes: "Ignore" | "RedirectWithout" | "RedirectWith" | "RewriteWithout" | "RewriteWith";
@@ -112,3 +116,11 @@ export interface ExplorerData {
     routes: Record<string, Route>;
     files: Record<string, string>;
 }
+export interface ExternalRoutes {
+    name: string;
+    routes: {
+        path: string;
+        entryFile: string;
+        verbs: HttpVerb[];
+    }[];
+}

package/dist/vite/utils/log.d.ts

@@ -1,3 +1,3 @@
 import type { OutputBundle } from "rollup";
-import type { BuiltRoutes } from "../types";
-export declare function logRoutesTable(routes: BuiltRoutes, bundle: OutputBundle): void;
+import type { BuiltRoutes, ExternalRoutes } from "../types";
+export declare function logRoutesTable(routes: BuiltRoutes, externalRoutes: ExternalRoutes[], bundle: OutputBundle): void;

package/dist/vite/utils/route.d.ts

@@ -1,4 +1,5 @@
 import type { HttpVerb, Route } from "../types";
 export declare function getVerbs(route: Route, noAutoHead?: boolean): HttpVerb[];
+export declare function getUniqueSortedVerbs(verbs: HttpVerb[]): HttpVerb[];
 export declare function hasVerb(route: Route, verb: HttpVerb): boolean;
 export declare function getRouteVirtualFileName(route: Route): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/run",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "description": "The Marko application framework.",
   "keywords": [
     "marko"
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "@marko/run-explorer": "^2.0.1",
-    "@marko/vite": "^5.1.7",
+    "@marko/vite": "^5.3.2",
     "browserslist": "^4.24.4",
     "cli-table3": "^0.6.5",
     "compression": "^1.8.0",