@marko/run 0.2.7 → 0.2.9

package/dist/adapter/index.cjs

@@ -44,10 +44,232 @@ var __importMetaURL = (0, import_url.pathToFileURL)(__filename);
 
 // src/adapter/index.ts
 var import_path = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
 var import_url2 = require("url");
 
 // src/adapter/dev-server.ts
 var import_vite = require("vite");
+
+// src/adapter/polyfill.ts
+var webStream = __toESM(require("stream/web"), 1);
+var import_crypto = require("crypto");
+var undici = __toESM(require("undici"), 1);
+globalThis.crypto ?? (globalThis.crypto = import_crypto.webcrypto);
+globalThis.fetch ?? (globalThis.fetch = undici.fetch);
+globalThis.Response ?? (globalThis.Response = undici.Response);
+globalThis.Request ?? (globalThis.Request = undici.Request);
+globalThis.Headers ?? (globalThis.Headers = undici.Headers);
+globalThis.ReadableStream ?? (globalThis.ReadableStream = webStream.ReadableStream);
+globalThis.TransformStream ?? (globalThis.TransformStream = webStream.TransformStream);
+globalThis.WritableStream ?? (globalThis.WritableStream = webStream.WritableStream);
+globalThis.FormData ?? (globalThis.FormData = undici.FormData);
+globalThis.File ?? (globalThis.File = undici.File);
+
+// src/adapter/middleware.ts
+function getForwardedHeader(req, name) {
+  const value = req.headers["x-forwarded-" + name];
+  if (value) {
+    if (typeof value === "string") {
+      const index = value.indexOf(",");
+      return index < 0 ? value : value.slice(0, index);
+    }
+    return value[0];
+  }
+}
+function getOrigin(req, trustProxy) {
+  const protocol = req.protocol || trustProxy && getForwardedHeader(req, "proto") || (req.socket.encrypted ? "https" : "http");
+  let host = req.headers.host || trustProxy && getForwardedHeader(req, "host");
+  if (!host) {
+    if (process.env.NODE_ENV !== "production") {
+      host = "localhost";
+      console.warn(
+        `Could not automatically determine the origin host, using 'localhost'. Use the 'origin' option or the 'ORIGIN' environment variable to set the origin explicitly.`
+      );
+    } else {
+      throw new Error(
+        `Could not automatically determine the origin host. Use the 'origin' option or the 'ORIGIN' environment variable to set the origin explicitly.`
+      );
+    }
+  }
+  return `${protocol}://${host}`;
+}
+var inExpiresDateRgs = /Expires\s*=\s*(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s*$/i;
+function setResponseHeaders(response, res) {
+  for (const [key, value] of response.headers) {
+    if (key !== "set-cookie") {
+      res.setHeader(key, value);
+    }
+  }
+  const setCookies = getSetCookie(response.headers);
+  if (setCookies == null ? void 0 : setCookies.length) {
+    res.setHeader("set-cookie", setCookies);
+  }
+}
+var getSetCookie = Headers.prototype.getSetCookie ? getSetCookie_platform : getSetCookie_fallback;
+function getSetCookie_platform(headers) {
+  return headers.getSetCookie();
+}
+function getSetCookie_fallback(headers) {
+  const value = headers.get("set-cookie");
+  if (!value)
+    return void 0;
+  let sepIndex = value.indexOf(",") + 1;
+  if (!sepIndex)
+    return value;
+  let index = 0;
+  let setCookie = void 0;
+  let setCookies = void 0;
+  do {
+    const valuePart = value.slice(index, sepIndex - 1);
+    if (!inExpiresDateRgs.test(valuePart)) {
+      if (setCookies) {
+        setCookies.push(valuePart);
+      } else if (setCookie) {
+        setCookies = [setCookie, valuePart];
+      } else {
+        setCookie = valuePart;
+      }
+      index = sepIndex;
+      while (value.charCodeAt(index) === 32)
+        index++;
+    }
+    sepIndex = value.indexOf(",", sepIndex) + 1;
+  } while (sepIndex);
+  if (index) {
+    const valuePart = value.slice(index);
+    if (setCookies) {
+      setCookies.push(valuePart);
+      return setCookies;
+    }
+    return [setCookie, valuePart];
+  }
+  return value;
+}
+function createMiddleware(fetch2, options = {}) {
+  const {
+    origin = process.env.ORIGIN,
+    trustProxy = process.env.TRUST_PROXY === "1"
+  } = options;
+  return async (req, res, next) => {
+    var _a;
+    const controller = new AbortController();
+    const { signal } = controller;
+    const url = new URL(req.url, origin || getOrigin(req, trustProxy));
+    const ip = req.ip || trustProxy && getForwardedHeader(req, "for") || req.socket.remoteAddress || "";
+    req.on("error", onErrorOrClose);
+    req.socket.on("error", onErrorOrClose);
+    res.on("error", onErrorOrClose);
+    res.on("close", onErrorOrClose);
+    signal.addEventListener("abort", onSignalAborted);
+    function onErrorOrClose(err) {
+      req.off("error", onErrorOrClose);
+      req.socket.off("error", onErrorOrClose);
+      res.off("error", onErrorOrClose);
+      res.off("close", onErrorOrClose);
+      if (err) {
+        signal.removeEventListener("abort", onSignalAborted);
+        controller.abort(err);
+      }
+    }
+    function onSignalAborted() {
+      if (next) {
+        next(signal.reason);
+      } else {
+        if (!res.destroyed && res.socket) {
+          res.socket.destroySoon();
+        }
+        console.error(signal.reason);
+      }
+    }
+    let setDevClientId;
+    if (process.env.NODE_ENV !== "production" && globalThis.__marko_run_dev__ && ((_a = req.headers.accept) == null ? void 0 : _a.includes("text/html"))) {
+      setDevClientId = globalThis.__marko_run_dev__.onClient((ws) => {
+        if (signal.aborted) {
+          sendError();
+        } else {
+          signal.addEventListener("abort", sendError);
+        }
+        function sendError() {
+          const { message, stack = "" } = signal.reason;
+          ws.send(
+            JSON.stringify({
+              type: "error",
+              err: { message, stack }
+            })
+          );
+        }
+      });
+    }
+    let body;
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      if (req.readableDidRead) {
+        body = bodyConsumedErrorStream;
+      } else {
+        body = req;
+      }
+    }
+    const request = new Request(url, {
+      method: req.method,
+      headers: req.headers,
+      body,
+      // @ts-expect-error: Node requires this for streams
+      duplex: "half",
+      signal
+    });
+    const response = await fetch2(request, {
+      ip,
+      request: req,
+      response: res
+    });
+    if (!response) {
+      if (next) {
+        next();
+      }
+      return;
+    }
+    if (process.env.NODE_ENV !== "production" && setDevClientId) {
+      setDevClientId(response);
+    }
+    res.statusCode = response.status;
+    setResponseHeaders(response, res);
+    if (!response.body) {
+      if (!response.headers.has("content-length")) {
+        res.setHeader("content-length", "0");
+      }
+      res.end();
+      return;
+    } else if (res.destroyed) {
+      controller.abort(new Error("Response stream destroyed"));
+      return;
+    }
+    writeResponse(response.body.getReader(), res, controller);
+  };
+}
+async function writeResponse(reader, res, controller) {
+  try {
+    while (!controller.signal.aborted) {
+      const { done, value } = await reader.read();
+      if (done) {
+        res.end();
+        return;
+      } else if (!res.write(value)) {
+        res.once("drain", () => writeResponse(reader, res, controller));
+        return;
+      } else if (res.flush) {
+        res.flush();
+      }
+    }
+  } catch (err) {
+    controller.abort(err);
+  }
+}
+var bodyConsumedErrorStream = new ReadableStream({
+  start(controller) {
+    controller.error(new Error("The request body stream was already consumed by something before Marko Run."));
+  }
+});
+
+// src/adapter/dev-server.ts
 var import_strip_ansi = __toESM(require("strip-ansi"), 1);
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
@@ -82,22 +304,25 @@ async function createViteDevServer(config2) {
 }
 async function createDevServer(config2) {
   const devServer = await createViteDevServer(config2);
-  const { createMiddleware } = await devServer.ssrLoadModule(
-    "@marko/run/adapter/middleware"
-  );
-  let fetch;
-  const nodeMiddleware = createMiddleware(
-    (request, platform) => fetch(request, platform)
+  const routerMiddleware = createMiddleware(
+    (request, platform) => globalThis.__marko_run__.fetch(request, platform)
   );
-  const middleware = createViteDevMiddleware(
-    devServer,
-    async () => await devServer.ssrLoadModule("@marko/run/router"),
-    (module2) => {
-      fetch = module2.fetch;
-      return nodeMiddleware;
-    }
-  );
-  devServer.middlewares.use(middleware);
+  devServer.middlewares.use(async (req, res, next) => {
+    await devServer.ssrLoadModule("@marko/run/router");
+    routerMiddleware(req, res, (err) => {
+      if (err) {
+        res.statusCode = 500;
+        if (err instanceof Error) {
+          devServer.ssrFixStacktrace(err);
+          res.end(err.stack && (0, import_strip_ansi.default)(err.stack));
+        } else {
+          res.end();
+        }
+      } else {
+        next == null ? void 0 : next();
+      }
+    });
+  });
   return devServer;
 }
 var ClientIdCookieName = "marko-run-client-id";
@@ -168,6 +393,153 @@ function getDevGlobal() {
   return devGlobal;
 }
 
+// src/adapter/utils.ts
+var import_supports_color = __toESM(require("supports-color"), 1);
+var import_kleur = __toESM(require("kleur"), 1);
+function logInfoBox(address, explorer) {
+  const color = !!import_supports_color.default.stdout;
+  let message = import_kleur.default.bold("Marko Run");
+  if (true) {
+    message += ` v${"0.2.9"}`;
+  }
+  message += "\n\n";
+  message += import_kleur.default.dim("Server listening at");
+  message += "\n";
+  message += import_kleur.default.cyan(import_kleur.default.underline(address));
+  if (explorer) {
+    message += "\n\n";
+    message += import_kleur.default.dim("Explore your routes at");
+    message += "\n";
+    message += import_kleur.default.dim(import_kleur.default.green(import_kleur.default.underline(explorer)));
+  }
+  const lines = drawMarkoBox(message, { color, fill: color });
+  console.log(lines.join("\n"));
+}
+function drawMarkoBox(message, options) {
+  const textPaddingWidth = 3;
+  const logoPaddingWidth = 2;
+  const textPadding = " ".repeat(textPaddingWidth);
+  const logoPadding = " ".repeat(logoPaddingWidth);
+  const logo = drawMarkoLogo(options);
+  const textLines = message.split(/\n/);
+  const textWidths = textLines.map(
+    (line) => line.replace(/\x1b\[\d+m/g, "").length
+  );
+  const textWidth = Math.max(...textWidths);
+  const height = Math.max(textLines.length + 2, logo.lines.length);
+  const width = textPaddingWidth * 2 + logoPaddingWidth + textWidth + logo.width;
+  const hBorder = "\u2500".repeat(width);
+  const vBorder = "\u2502";
+  const lineDiff = logo.lines.length - textLines.length;
+  const textStartLine = lineDiff > 0 ? Math.max(Math.floor(lineDiff / 2), 1) : 1;
+  const textEndLine = height - (lineDiff > 0 ? Math.ceil(lineDiff / 2) : 1);
+  const logoEndLine = logo.lines.length;
+  const logoFill = " ".repeat(logo.width);
+  const textFill = " ".repeat(textWidth);
+  const lines = [`\u256D${hBorder}\u256E`];
+  for (let i = 0; i < height; i++) {
+    let line = vBorder;
+    line += logoPadding;
+    if (i < logoEndLine) {
+      line += logo.lines[i];
+    } else {
+      line += logoFill;
+    }
+    line += textPadding;
+    if (i >= textStartLine && i < textEndLine) {
+      let index = i - textStartLine;
+      line += textLines[index];
+      line += " ".repeat(textWidth - textWidths[index]);
+    } else {
+      line += textFill;
+    }
+    line += textPadding;
+    line += vBorder;
+    lines.push(line);
+  }
+  lines.push(`\u2570${hBorder}\u256F`);
+  return lines;
+}
+function drawMarkoLogo(options = {}) {
+  const { fill = true, color = true } = options;
+  const source = `
+   TT____  YY____  R____
+  C\u2571T\u2572   \u2572G\u2571Y\u2572   \u2572 R\u2572   \u2572
+ C\u2571  T\u2572  G\u2571  Y\u2572   \u2572 R\u2572   \u2572
+C\u2571   \u2571T\u2572G\u2571   \u2571Y\u2572   \u2572 R\u2572   \u2572
+B\u2572   \u2572 GG\u203E\u203E\u203E\u203E O\u2571   \u2571 P\u2571   \u2571
+ B\u2572   \u2572    OOO\u2571   \u2571 P\u2571   \u2571
+  B\u2572   \u2572  OOO\u2571   \u2571 P\u2571   \u2571
+   B\u203E\u203E\u203E\u203E  OOO\u203E\u203E\u203E\u203E  P\u203E\u203E\u203E\u203E
+`;
+  const resetEscape = "\x1B[0m";
+  const colorEscapeCodes = Object.entries({
+    B: "#06cfe5",
+    C: "#05a5f0",
+    T: "#19d89c",
+    G: "#81dc09",
+    Y: "#ffd900",
+    O: "#ff9500",
+    R: "#f3154d",
+    P: "#ce176c"
+  }).reduce((acc, [key, hex]) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    acc[key] = `\x1B[38;2;${r};${g};${b}m`;
+    return acc;
+  }, {});
+  const lines = [];
+  const lineWidths = [];
+  let line = "";
+  let lineWidth = 0;
+  let width = 0;
+  for (let i = 0; i < source.length; i++) {
+    let char = source[i];
+    if (char === "\n") {
+      if (line) {
+        if (color) {
+          line += resetEscape;
+        }
+        width = Math.max(lineWidth, width);
+        lines.push(line);
+        lineWidths.push(lineWidth);
+        line = "";
+        lineWidth = 0;
+      }
+    } else if (/[A-Z]/.test(char)) {
+      while (source[i + 1] === char)
+        i++;
+      if (color) {
+        line += colorEscapeCodes[char];
+      }
+      if (fill) {
+        let fillChar = "";
+        for (; i < source.length; i++) {
+          char = source[i + 1];
+          if (fillChar && char !== " ") {
+            break;
+          } else if (!fillChar) {
+            fillChar = char;
+          }
+          line += fillChar;
+          lineWidth++;
+        }
+      }
+    } else {
+      line += char;
+      lineWidth++;
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const padding = width - lineWidths[i];
+    if (padding > 0) {
+      lines[i] += " ".repeat(width - lineWidths[i]);
+    }
+  }
+  return { lines, width };
+}
+
 // src/vite/utils/server.ts
 var import_net = __toESM(require("net"), 1);
 var import_child_process = __toESM(require("child_process"), 1);
@@ -311,7 +683,14 @@ function sleep(ms) {
 }
 
 // src/adapter/index.ts
+var import_module = require("module");
 var import_parse_node_args = __toESM(require("parse-node-args"), 1);
+
+// src/vite/constants.ts
+var markoRunFilePrefix = "__marko-run__";
+var virtualFilePrefix = "virtual:marko-run";
+
+// src/adapter/index.ts
 var __dirname = import_path.default.dirname((0, import_url2.fileURLToPath)(__importMetaURL));
 var defaultEntry = import_path.default.join(__dirname, "default-entry");
 var loadDevWorker = import_path.default.join(__dirname, "load-dev-worker.mjs");
@@ -323,6 +702,8 @@ function adapter() {
     },
     async startDev(entry, config2, options) {
       const { port = 3e3, envFile } = options;
+      globalThis.__marko_run_vite_config__ = config2;
+      const explorerPromise = startExplorer();
       if (entry) {
         const { nodeArgs } = (0, import_parse_node_args.default)(options.args);
         let worker;
@@ -353,39 +734,99 @@ function adapter() {
           }
           worker = nextWorker;
         }
-        await start();
+        const [explorer2] = await Promise.all([explorerPromise, start()]);
         return {
           port,
-          close() {
-            worker.kill();
+          async close() {
+            await Promise.all([worker.kill(), explorer2 == null ? void 0 : explorer2.close()]);
           }
         };
       }
       const devServer = await createDevServer(config2);
       envFile && await loadEnv(envFile);
-      return new Promise((resolve) => {
+      const listen = new Promise((resolve) => {
         const listener = devServer.middlewares.listen(port, () => {
-          const address = listener.address();
-          console.log(`Dev server started: http://localhost:${address.port}`);
-          resolve({
-            port,
-            async close() {
-              await devServer.close();
-            }
-          });
+          resolve(listener.address());
         });
       });
+      const [explorer, address] = await Promise.all([explorerPromise, listen]);
+      logInfoBox(
+        `http://localhost:${address.port}`,
+        explorer && `http://localhost:${explorer.port}`
+      );
+      return {
+        port: address.port,
+        async close() {
+          await Promise.all([devServer.close(), explorer == null ? void 0 : explorer.close()]);
+        }
+      };
     },
     async startPreview(entry, options) {
       const { port = 3e3, envFile } = options;
       const { nodeArgs } = (0, import_parse_node_args.default)(options.args);
       const args = [...nodeArgs, entry];
       const server = await spawnServer("node", args, port, envFile);
-      console.log(`Preview server started: http://localhost:${server.port}`);
+      if (!options.sourceEntry) {
+        logInfoBox(`http://localhost:${port}`);
+      }
       return server;
+    },
+    async routesGenerated(routes, virtualFiles, meta) {
+      if (process.env.MR_EXPLORER !== "true") {
+        return;
+      }
+      const promises = [];
+      const cacheDir = import_path.default.resolve(__dirname, "../../.cache/explorer");
+      const codeDir = import_path.default.join(cacheDir, "code");
+      if (import_fs2.default.existsSync(codeDir)) {
+        await import_fs2.default.promises.rm(codeDir, { recursive: true });
+      }
+      await import_fs2.default.promises.mkdir(codeDir, { recursive: true });
+      const data = {
+        meta,
+        routes: {},
+        files: {}
+      };
+      for (const [name, code] of virtualFiles) {
+        let fileName = "";
+        let index = name.indexOf(markoRunFilePrefix);
+        if (index >= 0) {
+          fileName = name.slice(index);
+          data.files[fileName] = `${virtualFilePrefix}/${fileName}`;
+        } else if (name.startsWith("@marko/run")) {
+          fileName = name.slice(11);
+          data.files[fileName] = name;
+        }
+        if (fileName) {
+          promises.push(
+            import_fs2.default.promises.writeFile(import_path.default.join(codeDir, fileName), code, {})
+          );
+        }
+      }
+      for (const route of routes.list) {
+        data.routes[route.index] = route;
+      }
+      for (const [id, route] of Object.entries(routes.special)) {
+        data.routes["s" + id] = route;
+      }
+      promises.push(
+        import_fs2.default.promises.writeFile(
+          import_path.default.join(cacheDir, "data.json"),
+          JSON.stringify(data),
+          {}
+        )
+      );
+      await Promise.all(promises);
     }
   };
 }
+var require2 = (0, import_module.createRequire)(__importMetaURL);
+async function startExplorer() {
+  if (process.env.MR_EXPLORER === "true") {
+    const entry = require2.resolve("@marko/run-explorer");
+    return await spawnServer("node", [entry], 1234);
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createDevServer,

package/dist/adapter/index.d.ts

@@ -1,7 +1,7 @@
 import type { Adapter } from "../vite";
 import { type MarkoRunDev } from "./dev-server";
 import { type SpawnedServer } from "../vite/utils/server";
-export { getDevGlobal, createDevServer, createViteDevServer, createViteDevMiddleware, type MarkoRunDev } from "./dev-server";
+export { getDevGlobal, createDevServer, createViteDevServer, createViteDevMiddleware, type MarkoRunDev, } from "./dev-server";
 export type { Adapter, SpawnedServer };
 export type { NodePlatformInfo } from "./middleware";
 export type MarkoRunDevAccessor = () => MarkoRunDev;