@marko/run 0.8.1 → 0.9.0

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(
@@ -1614,7 +1618,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 +1652,7 @@ function logRoutesTable(routes, bundle) {
       if (route.page && (verb === "get" || verb === "head")) {
         entryType.push(kleur2.yellow("page"));
         if (verb === "get") {
-          size = prettySize(computeRouteSize(route, bundle));
+          size = prettySize(computeRouteSize(route.templateFilePath, bundle));
         }
       }
       const row = [verbCell];
@@ -1670,9 +1674,35 @@ 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)));
+    row.push(prettySize(computeRouteSize(route.templateFilePath, bundle)));
     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());
+        if (verb === "get") {
+          size = prettySize(computeRouteSize(route.entryFile, bundle));
+        }
+        const row = [verbCell];
+        if (verbs.length === 1 || firstRow) {
+          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,11 +1714,10 @@ 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);
       }
     }
@@ -1811,9 +1840,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 +1879,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 +1901,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 +2044,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 +2084,9 @@ function markoRun(opts = {}) {
         );
         markoVitePluginOptions.runtimeId = opts.runtimeId;
         markoVitePluginOptions.basePathVar = opts.basePathVar;
+        markoVitePluginOptions.isEntry = (importee, importer) => {
+          return entryTemplates.has(importee) || entryTemplateImporters.has(importer);
+        };
         resolvedRoutesDir = path6.resolve(root, routesDir);
         outputDir = path6.join(root, ((_d = config2.build) == null ? void 0 : _d.outDir) || "dist");
         entryFilesDir = path6.join(outputDir, ".marko-run");
@@ -2204,16 +2275,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 +2302,6 @@ function markoRun(opts = {}) {
         }
       },
       async load(id) {
-        if (id.endsWith(serverEntryQuery)) {
-          id = id.slice(0, -serverEntryQuery.length);
-        }
         if (!renderVirtualFilesResult) {
           await renderVirtualFiles(this);
         }
@@ -2285,7 +2351,7 @@ 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);
+          logRoutesTable(routes, [...externalRoutes], bundle);
         }
       },
       async closeBundle() {
@@ -2363,6 +2429,18 @@ function getEntryFileName(file) {
   const match = file && markoEntryFileRegex.exec(file);
   return match ? match[2] || "index" : 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) {
     if (importer.id && !seen.has(importer.id)) {
@@ -2524,6 +2602,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/types.d.ts

@@ -112,3 +112,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.0",
   "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",