@marko/run 0.4.4 → 0.4.6

package/dist/vite/index.js

@@ -1,27 +1,13 @@
 var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
+var __typeError = (msg) => {
+  throw TypeError(msg);
 };
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 
 // src/vite/plugin.ts
 import path3 from "path";
@@ -30,7 +16,7 @@ import { glob } from "glob";
 import { fileURLToPath } from "url";
 import browserslist from "browserslist";
 import { resolveToEsbuildTarget } from "esbuild-plugin-browserslist";
-import { mergeConfig } from "vite";
+import { buildErrorMessage, mergeConfig } from "vite";
 import markoVitePlugin from "@marko/vite";
 
 // src/vite/constants.ts
@@ -52,8 +38,8 @@ var RoutableFileTypes = {
 var _dirs, _pathlessDirs;
 var _VDir = class _VDir {
   constructor(parent, segment, source) {
-    __privateAdd(this, _dirs, void 0);
-    __privateAdd(this, _pathlessDirs, void 0);
+    __privateAdd(this, _dirs);
+    __privateAdd(this, _pathlessDirs);
     __publicField(this, "parent");
     __publicField(this, "source");
     __publicField(this, "path");
@@ -193,8 +179,7 @@ var VDir = _VDir;
 
 // src/vite/routes/parse.ts
 function parseFlatRoute(pattern) {
-  if (!pattern)
-    throw new Error("Empty pattern");
+  if (!pattern) throw new Error("Empty pattern");
   const len = pattern.length;
   let i = 0;
   return parse2([
@@ -900,45 +885,6 @@ function writeRouteEntryHandler(writer, route, verb) {
   continuations.join();
   writer.writeBlockEnd("}");
 }
-function renderErrorRouter(error, options = {
-  trailingSlashes: "RedirectWithout"
-}) {
-  const writer = createStringWriter();
-  writer.write(`
-// @marko/run/router
-import { createContext } from '${virtualFilePrefix}/runtime/internal';
-import errorPage from '${virtualFilePrefix}/${markoRunFilePrefix}error.marko${serverEntryQuery}';
-
-const error = new Error(\`${error.message}\`);
-error.name = '${error.name}';`);
-  if (error.stack) {
-    writer.write(`
-error.stack = \`${error.stack}\`;`);
-  }
-  writer.write(`
-
-globalThis.__marko_run__ = { match, fetch, invoke };
-
-export function match() {
-  return { handler: errorPage, params: {}, meta: {}, path: '/*' }; // /$$
-}
-
-export async function invoke(route, request, platform, url) {
-  const [context, buildInput] = createContext(route, request, platform, url);
-  if (context.request.headers.get('Accept')?.includes('text/html')) {
-    return new Response(errorPage.stream(buildInput({ error })), {
-      status: 500,
-      headers: { "content-type": "text/html;charset=UTF-8" },
-    });
-  }
-  return new Response(error, {
-    status: 500,
-  });
-}
-`);
-  renderFetch(writer, options);
-  return writer.end();
-}
 function renderRouter(routes, options = {
   trailingSlashes: "RedirectWithout"
 }) {
@@ -1071,15 +1017,7 @@ export async function fetch(request, platform) {
     return await invoke(route, request, platform, url);
   } catch (error) {
     if (import.meta.env.DEV) {
-      let body;
-      if (error.cause) {
-        body = error.cause.stack || error.cause.message || error.cause;
-      } else {
-        body = error.stack || error.message || "Internal Server Error";
-      }
-      return new Response(body, {
-        status: 500
-      });
+      throw error;
     }
     return new Response(null, {
       status: 500
@@ -1519,6 +1457,29 @@ function getExportIdentifiers(astProgramNode) {
   }
   return result;
 }
+function getViteSSRExportIdentifiers(astProgramNode, exportObjectName = "__vite_ssr_exports__") {
+  const result = [];
+  if (t.isProgram(astProgramNode)) {
+    for (const node of astProgramNode.body) {
+      if (t.isExpressionStatement(node)) {
+        if (t.isAssignmentExpression(node.expression) && t.isMemberExpression(node.expression.left)) {
+          const { object, property } = node.expression.left;
+          if (t.isIdentifier(object) && object.name === exportObjectName && t.isIdentifier(property)) {
+            result.push(property.name);
+          }
+        } else if (t.isCallExpression(node.expression) && t.isMemberExpression(node.expression.callee)) {
+          const {
+            arguments: [arg0, arg1]
+          } = node.expression;
+          if (t.isIdentifier(arg0) && arg0.name === exportObjectName && (t.isStringLiteral(arg1) || "value" in arg1 && typeof arg1.value === "string")) {
+            result.push(arg1.value);
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
 
 // src/vite/utils/log.ts
 import zlib from "node:zlib";
@@ -1639,12 +1600,9 @@ function prettySize([bytes, compBytes]) {
   const [size, prefix] = format(bytes, { decimals: 1 }).split(/\s+/);
   const compSize = format(compBytes, { decimals: 1, prefix, unit: "B" });
   let str = kleur.white(size) + kleur.gray("/");
-  if (compBytes < 20 * 1e3)
-    str += kleur.green(compSize);
-  else if (compBytes < 50 * 1e3)
-    str += kleur.yellow(compSize);
-  else
-    str += kleur.bold(kleur.red(compSize));
+  if (compBytes < 20 * 1e3) str += kleur.green(compSize);
+  else if (compBytes < 50 * 1e3) str += kleur.yellow(compSize);
+  else str += kleur.bold(kleur.red(compSize));
   return str;
 }
 function prettyPath(path4) {
@@ -1714,6 +1672,31 @@ process.once("beforeExit", (code) => {
   }
 });
 
+// src/adapter/utils.ts
+import supporsColor from "supports-color";
+import kleur2 from "kleur";
+function stripAnsi(string) {
+  return string.replace(
+    /([\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><])/g,
+    ""
+  );
+}
+function cleanStack(stack) {
+  return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
+}
+function prepareError(err) {
+  var _a;
+  return {
+    message: stripAnsi(err.message),
+    stack: stripAnsi(cleanStack(err.stack || "")),
+    id: err.id,
+    frame: stripAnsi(err.frame || ""),
+    plugin: err.plugin,
+    pluginCode: (_a = err.pluginCode) == null ? void 0 : _a.toString(),
+    loc: err.loc
+  };
+}
+
 // src/vite/plugin.ts
 var debug = createDebug("@marko/run");
 var __dirname = path3.dirname(fileURLToPath(import.meta.url));
@@ -1737,11 +1720,10 @@ function markoRun(opts = {}) {
   let devServer;
   let routes;
   let routeData;
-  let extractVerbs;
+  let getExportsFromFile;
   let resolvedConfig;
   let typesFile;
-  let isStale = true;
-  let isRendered = false;
+  let seenErrors = /* @__PURE__ */ new Set();
   const virtualFiles = /* @__PURE__ */ new Map();
   let times = {
     routesBuild: 0,
@@ -1764,97 +1746,134 @@ function markoRun(opts = {}) {
       }
     }
   }
-  const buildVirtualFiles = single(async (render) => {
-    var _a;
-    const routerOptions = {
-      trailingSlashes: opts.trailingSlashes || "RedirectWithout"
-    };
-    try {
-      if (isStale) {
+  let buildVirtualFilesResult;
+  function buildVirtualFiles() {
+    return buildVirtualFilesResult ?? (buildVirtualFilesResult = new Promise(async (resolve, reject) => {
+      try {
         virtualFiles.clear();
-        isRendered = false;
-        const buildStartTime = performance.now();
         routes = await buildRoutes({
           walker: createFSWalker(resolvedRoutesDir),
           importPrefix: routesDir
         });
-        times.routesBuild = performance.now() - buildStartTime;
         if (!routes.list.length) {
           throw new Error("No routes generated");
         }
-      }
-      const renderStartTime = performance.now();
-      for (const route of routes.list) {
-        if (render && route.handler) {
-          route.handler.verbs = await extractVerbs(route.handler.filePath);
-          if (!route.handler.verbs.length) {
-            throw new Error(
-              `Did not find any valid exports in middleware entry file:'${route.handler.filePath}' - expected to find any of 'GET', 'POST', 'PUT' or 'DELETE'`
+        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`), "");
         }
-        if (route.page) {
+        for (const route of Object.values(routes.special)) {
           virtualFiles.set(
             path3.posix.join(root, `${route.entryName}.marko`),
-            render ? renderRouteTemplate(route) : ""
+            ""
           );
         }
-        virtualFiles.set(
-          path3.posix.join(root, `${route.entryName}.js`),
-          render ? renderRouteEntry(route) : ""
-        );
-      }
-      for (const route of Object.values(routes.special)) {
-        virtualFiles.set(
-          path3.posix.join(root, `${route.entryName}.marko`),
-          render ? renderRouteTemplate(route) : ""
-        );
+        if (routes.middleware.length) {
+          virtualFiles.set(
+            path3.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+            ""
+          );
+        }
+        virtualFiles.set("@marko/run/router", "");
+        resolve(routes);
+      } catch (err) {
+        reject(err);
       }
-      if (routes.middleware.length) {
+    }));
+  }
+  let renderVirtualFilesResult;
+  function renderVirtualFiles(context) {
+    return renderVirtualFilesResult ?? (renderVirtualFilesResult = new Promise(async (resolve) => {
+      var _a;
+      const routerOptions = {
+        trailingSlashes: opts.trailingSlashes || "RedirectWithout"
+      };
+      try {
+        const routes2 = await buildVirtualFiles();
+        for (const route of routes2.list) {
+          if (route.handler) {
+            const exports = await getExportsFromFile(
+              context,
+              route.handler.filePath
+            );
+            route.handler.verbs = [];
+            for (const name of exports) {
+              const verb = name.toLowerCase();
+              if (name === verb.toUpperCase() && httpVerbs.includes(verb)) {
+                route.handler.verbs.push(verb);
+              }
+            }
+            if (!route.handler.verbs.length) {
+              context.warn(
+                `Did not find any http verb exports in handler '${path3.relative(root, route.handler.filePath)}' - expected ${httpVerbs.map((v) => v.toUpperCase()).join(", ")}`
+              );
+            }
+          }
+          if (route.page) {
+            virtualFiles.set(
+              path3.posix.join(root, `${route.entryName}.marko`),
+              renderRouteTemplate(route)
+            );
+          }
+          virtualFiles.set(
+            path3.posix.join(root, `${route.entryName}.js`),
+            renderRouteEntry(route)
+          );
+        }
+        for (const route of Object.values(routes2.special)) {
+          virtualFiles.set(
+            path3.posix.join(root, `${route.entryName}.marko`),
+            renderRouteTemplate(route)
+          );
+        }
+        if (routes2.middleware.length) {
+          for (const middleware of routes2.middleware) {
+            if (!(await getExportsFromFile(context, middleware.filePath)).includes("default")) {
+              context.warn(
+                `Did not find a default export in middleware '${path3.relative(root, middleware.filePath)}'`
+              );
+            }
+          }
+          virtualFiles.set(
+            path3.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+            renderMiddleware(routes2.middleware)
+          );
+        }
         virtualFiles.set(
-          path3.posix.join(root, `${markoRunFilePrefix}middleware.js`),
-          render ? renderMiddleware(routes.middleware) : ""
+          "@marko/run/router",
+          renderRouter(routes2, routerOptions)
         );
-      }
-      virtualFiles.set(
-        "@marko/run/router",
-        render ? renderRouter(routes, routerOptions) : ""
-      );
-      times.routesRender = performance.now() - renderStartTime;
-      if (render) {
-        await writeTypesFile(routes);
+        await writeTypesFile(routes2);
         if (adapter == null ? void 0 : adapter.routesGenerated) {
           await adapter.routesGenerated(
-            routes,
+            routes2,
             new Map(virtualFiles.entries()),
             {
               buildTime: times.routesBuild,
               renderTime: times.routesRender
             }
           );
+          if (!isBuild) {
+            await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes2.list));
+          }
         }
-        if (!isBuild) {
-          await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
+      } catch (err) {
+        if (isBuild) {
+          throw err;
         }
-        isRendered = true;
-      }
-    } catch (err) {
-      if (isBuild) {
-        throw err;
+        virtualFiles.set(
+          "@marko/run/router",
+          `throw ${JSON.stringify(prepareError(err))}`
+        );
       }
-      console.error(err);
-      virtualFiles.set(
-        path3.posix.join(root, `${markoRunFilePrefix}error.marko`),
-        renderEntryTemplate(`${markoRunFilePrefix}error`, ["<dev-error-page>"])
-      );
-      virtualFiles.set(
-        "@marko/run/router",
-        renderErrorRouter(err, routerOptions)
-      );
-      isRendered = true;
-    }
-    isStale = false;
-  });
+      resolve();
+    }));
+  }
   return [
     {
       name: `${PLUGIN_NAME_PREFIX}:pre`,
@@ -1890,12 +1909,6 @@ function markoRun(opts = {}) {
             template: normalizePath(
               path3.resolve(__dirname, "../components/dev-error-page.marko")
             )
-          },
-          "<*>": {
-            transform: path3.resolve(
-              __dirname,
-              "../components/src-attributes-transformer.cjs"
-            )
           }
         });
         routesDir = opts.routesDir || "src/routes";
@@ -1980,7 +1993,12 @@ function markoRun(opts = {}) {
             ] : void 0
           },
           resolve: isBuild ? {
-            mainFields: (isSSRBuild ? [] : ["browser"]).concat(["module", "jsnext:main", "jsnext", "main"]),
+            mainFields: (isSSRBuild ? [] : ["browser"]).concat([
+              "module",
+              "jsnext:main",
+              "jsnext",
+              "main"
+            ]),
             conditions: [
               isSSRBuild ? "node" : "browser",
               "import",
@@ -2015,29 +2033,44 @@ function markoRun(opts = {}) {
         } else {
           ssrEntryFiles = [];
         }
+        const baseError = config2.logger.error;
+        config2.logger.error = function(msg, options) {
+          var _a;
+          if (!((_a = options == null ? void 0 : options.error) == null ? void 0 : _a.message)) {
+            baseError.call(this, msg, options);
+          } else if (!seenErrors.has(options.error.message)) {
+            seenErrors.add(options.error.message);
+            console.error(buildErrorMessage(options.error));
+          }
+        };
       },
       configureServer(_server) {
         devServer = _server;
         devServer.watcher.on("all", async (type, filename) => {
-          const routableFileType = matchRoutableFile(path3.parse(filename).base);
+          seenErrors.clear();
+          const routableFileType = matchRoutableFile(
+            path3.parse(filename).base
+          );
           if (filename.startsWith(resolvedRoutesDir) && routableFileType) {
-            if (type === "add") {
-              isStale = true;
-            } else if (type === "unlink") {
-              isStale = true;
-            } else if (type === "change") {
-              if (routableFileType === RoutableFileTypes.Handler) {
-                isStale = true;
-              }
-            }
-            if (isStale) {
-              for (const id of virtualFiles.keys()) {
-                devServer.watcher.emit("change", id);
-                break;
+            if (type === "add" || type === "unlink" || type === "change" && (routableFileType === RoutableFileTypes.Handler || routableFileType === RoutableFileTypes.Middleware)) {
+              buildVirtualFilesResult = void 0;
+              renderVirtualFilesResult = void 0;
+              const module = devServer.moduleGraph.getModuleById(filename);
+              const importers = module && getImporters(module, filename);
+              if (importers == null ? void 0 : importers.size) {
+                for (const file of importers) {
+                  devServer.watcher.emit("change", file);
+                }
+              } else {
+                for (const file of virtualFiles.keys()) {
+                  if (!file.endsWith(".marko")) {
+                    devServer.watcher.emit("change", file);
+                  }
+                }
               }
             }
           }
-        });
+        }).unwatch(typesDir + "/*");
       },
       async buildStart(_options) {
         if (isBuild && !isSSRBuild) {
@@ -2053,10 +2086,10 @@ function markoRun(opts = {}) {
           for (const { key, code } of routeData.files) {
             virtualFiles.set(key, code);
           }
-          isStale = false;
-          isRendered = true;
+          buildVirtualFilesResult = Promise.resolve(routes);
+          renderVirtualFilesResult = Promise.resolve();
         } else {
-          extractVerbs = isBuild ? getVerbsFromFileBuild.bind(null, this) : getVerbsFromFileDev.bind(null, devServer);
+          getExportsFromFile = isBuild ? getExportsFromFileBuild : getExportsFromFileDev.bind(null, devServer);
         }
       },
       async resolveId(importee, importer) {
@@ -2069,8 +2102,8 @@ function markoRun(opts = {}) {
           importee = path3.resolve(root, "." + importee);
         }
         importee = normalizePath(importee);
-        if (isStale) {
-          await buildVirtualFiles(false);
+        if (!buildVirtualFilesResult) {
+          await buildVirtualFiles();
         }
         if (virtualFiles.has(importee)) {
           resolved = importee;
@@ -2087,11 +2120,13 @@ function markoRun(opts = {}) {
         if (id.endsWith(serverEntryQuery)) {
           id = id.slice(0, -serverEntryQuery.length);
         }
+        if (!renderVirtualFilesResult) {
+          await renderVirtualFiles(this);
+        }
         if (virtualFiles.has(id)) {
-          if (isStale || !isRendered) {
-            await buildVirtualFiles(true);
-          }
           return virtualFiles.get(id);
+        } else if (path3.basename(id).startsWith(markoRunFilePrefix) && /^\.(js|marko)$/.test(path3.extname(id))) {
+          return "";
         }
       }
     },
@@ -2149,57 +2184,20 @@ function markoRun(opts = {}) {
     }
   ];
 }
-async function getVerbsFromFileBuild(context, filePath) {
-  const verbs = [];
+async function getExportsFromFileBuild(context, filePath) {
   const result = await context.load({
     id: filePath,
     resolveDependencies: false
   });
-  if (result) {
-    const exportIds = getExportIdentifiers(result.ast);
-    for (const id of exportIds) {
-      const verb = id.toLowerCase();
-      if (id === verb.toUpperCase() && httpVerbs.includes(verb)) {
-        verbs.push(verb);
-      }
-    }
-  }
-  return verbs;
+  return result ? getExportIdentifiers(result.ast) : [];
 }
-async function getVerbsFromFileDev(devServer, filePath) {
-  const verbs = [];
+async function getExportsFromFileDev(devServer, context, filePath) {
   const result = await devServer.transformRequest(filePath, { ssr: true });
-  if (result && result.code) {
-    const verbMatchReg = /__vite_ssr_exports__,\s+["'](GET|POST|PUT|DELETE)["']/gi;
-    let match = verbMatchReg.exec(result.code);
-    while (match) {
-      const id = match[1];
-      const verb = id.toLowerCase();
-      if (httpVerbs.includes(verb)) {
-        if (id === verb.toUpperCase()) {
-          verbs.push(verb);
-        } else {
-          console.warn(
-            `Found export '${id}' in handler ${filePath} which is close to '${verb.toUpperCase()}'. Exported handlers need to be uppercase: GET, POST, PUT or DELETE.`
-          );
-        }
-      }
-      match = verbMatchReg.exec(result.code);
-    }
+  if (result) {
+    const ast = context.parse(result.code);
+    return getViteSSRExportIdentifiers(ast);
   }
-  return verbs;
-}
-function single(fn) {
-  let promise;
-  return async (...args) => {
-    if (promise) {
-      return promise;
-    }
-    promise = fn(...args);
-    const result = await promise;
-    promise = void 0;
-    return result;
-  };
+  return [];
 }
 async function globFileExists(root, pattern) {
   return (await glob(pattern, { root })).length > 0;
@@ -2252,6 +2250,15 @@ function getEntryFileName(file) {
   const match = file && markoEntryFileRegex.exec(file);
   return match ? match[2] || "index" : void 0;
 }
+function getImporters(module, fileName, seen = /* @__PURE__ */ new Set()) {
+  for (const importer of module.importers) {
+    if (importer.id && !seen.has(importer.id)) {
+      seen.add(importer.id);
+      getImporters(importer, fileName, seen);
+    }
+  }
+  return seen;
+}
 
 // src/vite/utils/server.ts
 import net from "net";

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

@@ -1 +1,2 @@
 export declare function getExportIdentifiers(astProgramNode: any): string[];
+export declare function getViteSSRExportIdentifiers(astProgramNode: any, exportObjectName?: string): string[];

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

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
 import { type Socket } from "net";
 import { type ChildProcess, type StdioOptions } from "child_process";
 import { type Worker } from "cluster";