@marko/run 0.2.6 → 0.2.8

package/dist/adapter/index.js

@@ -4,8 +4,228 @@ import { fileURLToPath } from "url";
 
 // src/adapter/dev-server.ts
 import { createServer } from "vite";
+
+// src/adapter/polyfill.ts
+import * as webStream from "stream/web";
+import { webcrypto } from "crypto";
+import * as undici from "undici";
+globalThis.crypto ?? (globalThis.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
 import stripAnsi from "strip-ansi";
-var activeDevServers = /* @__PURE__ */ new Set();
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -34,34 +254,239 @@ async function createViteDevServer(config2) {
     appType: "custom",
     server: { ...config2 == null ? void 0 : config2.server, middlewareMode: true }
   });
-  const originalClose = devServer.close;
-  devServer.close = () => {
-    activeDevServers.delete(devServer);
-    return originalClose.call(devServer);
-  };
-  activeDevServers.add(devServer);
+  getDevGlobal().addDevServer(devServer);
   return devServer;
 }
 async function createDevServer(config2) {
   const devServer = await createViteDevServer(config2);
-  const { createMiddleware } = await devServer.ssrLoadModule(
-    "@marko/run/adapter/middleware"
+  const routerMiddleware = createMiddleware(
+    (request, platform) => globalThis.__marko_run__.fetch(request, platform)
   );
-  let fetch;
-  const nodeMiddleware = createMiddleware(
-    (request, platform) => fetch(request, platform),
-    { devServer }
-  );
-  const middleware = createViteDevMiddleware(
-    devServer,
-    async () => await devServer.ssrLoadModule("@marko/run/router"),
-    (module) => {
-      fetch = module.fetch;
-      return nodeMiddleware;
+  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 && stripAnsi(err.stack));
+        } else {
+          res.end();
+        }
+      } else {
+        next == null ? void 0 : next();
+      }
+    });
+  });
+  return devServer;
+}
+var ClientIdCookieName = "marko-run-client-id";
+function getClientId(req) {
+  if (req.headers.cookie) {
+    const cookie = req.headers.cookie.split(/;\s+/).find((c) => c.startsWith(ClientIdCookieName));
+    if (cookie) {
+      return cookie.slice(ClientIdCookieName.length + 1);
     }
+  }
+}
+var devGlobal;
+function getDevGlobal() {
+  if (!devGlobal) {
+    let handleConnection2 = function(ws, req) {
+      if (callbacks == null ? void 0 : callbacks.length) {
+        const id = getClientId(req);
+        const now = Date.now();
+        const nextCallbacks = [];
+        for (const entry of callbacks) {
+          if (entry.id === id) {
+            entry.callback(ws);
+          } else if (entry.expires > now) {
+            nextCallbacks.push(entry);
+          }
+        }
+        callbacks = nextCallbacks;
+      }
+    };
+    var handleConnection = handleConnection2;
+    const devServers = /* @__PURE__ */ new Set();
+    let callbacks = [];
+    globalThis.__marko_run_dev__ = devGlobal = {
+      devServers,
+      addDevServer(devServer) {
+        const originalClose = devServer.close;
+        devServer.close = () => {
+          devServers.delete(devServer);
+          return originalClose.call(devServer);
+        };
+        devServers.add(devServer);
+        devServer.ws.on("connection", handleConnection2);
+      },
+      clear() {
+        callbacks = [];
+        for (const devServer of devServers) {
+          devServer.ws.off("connection", handleConnection2);
+          devServer.close();
+        }
+      },
+      onClient(callback) {
+        const expires = Date.now() + 1e3;
+        const id = Math.floor(Math.random() * expires).toString(36);
+        callbacks.push({
+          id,
+          expires,
+          callback
+        });
+        return (response) => {
+          response.headers.append(
+            "set-cookie",
+            `${ClientIdCookieName}=${id}; Path=/; Max-Age=100; HttpOnly`
+          );
+        };
+      }
+    };
+  }
+  return devGlobal;
+}
+
+// src/adapter/utils.ts
+import supporsColor from "supports-color";
+import kleur from "kleur";
+function logInfoBox(address) {
+  const color = !!supporsColor.stdout;
+  let message = kleur.bold("Marko Run");
+  if (true) {
+    message += ` v${"0.2.8"}`;
+  }
+  message += "\n\n";
+  message += kleur.dim("Server listening at");
+  message += "\n";
+  message += kleur.cyan(kleur.underline(address));
+  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
   );
-  devServer.middlewares.use(middleware);
-  return devServer;
+  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.floor(lineDiff / 2) : 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
@@ -219,6 +644,7 @@ function adapter() {
     },
     async startDev(entry, config2, options) {
       const { port = 3e3, envFile } = options;
+      globalThis.__marko_run_vite_config__ = config2;
       if (entry) {
         const { nodeArgs } = parseNodeArgs(options.args);
         let worker;
@@ -262,7 +688,7 @@ function adapter() {
       return new Promise((resolve) => {
         const listener = devServer.middlewares.listen(port, () => {
           const address = listener.address();
-          console.log(`Dev server started: http://localhost:${address.port}`);
+          logInfoBox(`http://localhost:${address.port}`);
           resolve({
             port,
             async close() {
@@ -277,15 +703,17 @@ function adapter() {
       const { nodeArgs } = parseNodeArgs(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;
     }
   };
 }
 export {
-  activeDevServers,
   createDevServer,
   createViteDevMiddleware,
   createViteDevServer,
-  adapter as default
+  adapter as default,
+  getDevGlobal
 };

package/dist/adapter/load-dev-worker.mjs

@@ -1,6 +1,5 @@
 import { createServer } from "vite";
-
-let activeDevServers;
+import { getDevGlobal } from "@marko/run/adapter";
 
 process
   .on("message", (message) => {
@@ -16,8 +15,12 @@ process
 async function start(entry, config) {
   globalThis.__marko_run_vite_config__ = config;
   let changed = false;
-  const loader = await createServer({ ...config, ssr: { external: ['@marko/run/router'] }});
-  ({ activeDevServers } = await import("@marko/run/adapter"));
+  const loader = await createServer({
+    ...config,
+    ssr: { external: ["@marko/run/router"] },
+  })
+
+  await loader.listen(0);
   await loader.ssrLoadModule(entry);
 
   loader.watcher.on("change", (path) => {
@@ -29,10 +32,9 @@ async function start(entry, config) {
 }
 
 function shutdown() {
-  if (activeDevServers) {
-    for (const devServer of activeDevServers) {
-      devServer.ws.send({ type: "full-reload" });
-    }
-    activeDevServers.clear();
+  const devGlobal = getDevGlobal();
+  for (const devServer of devGlobal.devServers) {
+    devServer.ws.send({ type: "full-reload" });
   }
+  devGlobal.clear();
 }