@marko/run 0.1.15 → 0.2.0

package/dist/adapter/middleware.js

@@ -1,60 +1,19 @@
 // src/adapter/polyfill.ts
-import { ReadableStream as ReadableStream2, TransformStream, WritableStream } from "stream/web";
-import { webcrypto as crypto } from "crypto";
-import { fetch, Response, Request as Request2, Headers, FormData, File } from "undici";
-import { OutgoingMessage } from "http";
-var globals = {
-  crypto,
-  fetch,
-  Response,
-  Request: Request2,
-  Headers,
-  ReadableStream: ReadableStream2,
-  TransformStream,
-  WritableStream,
-  FormData,
-  File
-};
-if (typeof OutgoingMessage.prototype.appendHeader !== "function") {
-  const messageHeaders = /* @__PURE__ */ new WeakMap();
-  OutgoingMessage.prototype.appendHeader = function(name, value) {
-    let headers = messageHeaders.get(this);
-    if (!headers) {
-      headers = /* @__PURE__ */ new Map();
-      messageHeaders.set(this, headers);
-    }
-    const key = name.toLowerCase();
-    let existing = headers.get(key);
-    if (existing) {
-      if (Array.isArray(existing)) {
-        existing.push(value);
-      } else {
-        existing = [existing, value];
-      }
-      this.setHeader(name, existing);
-      headers.set(key, existing);
-    } else {
-      this.setHeader(name, value);
-      headers.set(key, value);
-    }
-    return this;
-  };
-}
-function installPolyfills() {
-  for (const name in globals) {
-    if (!(name in globalThis)) {
-      Object.defineProperty(globalThis, name, {
-        enumerable: true,
-        configurable: true,
-        writable: true,
-        value: globals[name]
-      });
-    }
-  }
-}
+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
-installPolyfills();
 function getForwardedHeader(req, name) {
   const value = req.headers["x-forwarded-" + name];
   if (value) {
@@ -65,10 +24,9 @@ function getForwardedHeader(req, name) {
     return value[0];
   }
 }
-function getOrigin(req, protocol, host, trustProxy) {
-  var _a;
-  protocol ?? (protocol = req.protocol || trustProxy && getForwardedHeader(req, "proto") || ((_a = req.socket) == null ? void 0 : _a.encrypted) && "https" || "http");
-  host ?? (host = trustProxy && getForwardedHeader(req, "host") || req.headers.host);
+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";
@@ -86,70 +44,116 @@ function getOrigin(req, protocol, host, trustProxy) {
 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") {
-      let sepIndex = value.indexOf(",") + 1;
-      if (!sepIndex) {
-        res.setHeader(key, value);
+    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 {
-        let index = 0;
-        do {
-          const valuePart = value.slice(index, sepIndex - 1);
-          if (!inExpiresDateRgs.test(valuePart)) {
-            res.appendHeader(key, valuePart);
-            index = sepIndex;
-          }
-          sepIndex = value.indexOf(",", sepIndex) + 1;
-        } while (sepIndex);
-        res.appendHeader(key, value.slice(index));
+        setCookie = valuePart;
       }
-    } else {
-      res.setHeader(key, value);
+      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 { trustProxy = process.env.TRUST_PROXY === "1", devServer } = options;
-  let { origin = process.env.ORIGIN } = options;
-  let protocol;
-  let host;
-  if (origin) {
-    ({ protocol, host } = new URL(origin));
-    protocol = protocol.slice(0, -1);
-  }
+  const {
+    origin = process.env.ORIGIN,
+    trustProxy = process.env.TRUST_PROXY === "1",
+    devServer
+  } = options;
   return async (req, res, next) => {
-    origin ?? (origin = getOrigin(req, protocol, host, trustProxy));
-    const url = new URL(req.url, origin);
+    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 || "";
     const headers = req.headers;
-    const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
-      start(controller) {
-        req.on("data", (chunk) => controller.enqueue(chunk));
-        req.on("end", () => controller.close());
-        req.on("error", (err) => controller.error(err));
-      }
-    });
+    req.on("error", onError);
+    res.on("error", onError);
+    req.socket.on("error", onError);
+    function onError(err) {
+      req.off("error", onError);
+      res.off("error", onError);
+      req.socket.off("error", onError);
+      controller.abort(err);
+    }
+    if (process.env.NODE_ENV !== "production" && devServer) {
+      devServer.ws.on("connection", function onConnection(ws) {
+        devServer.ws.off("connection", onConnection);
+        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 }
+            })
+          );
+        }
+      });
+    } else {
+      signal.addEventListener("abort", () => {
+        if (!res.destroyed && res.socket) {
+          res.socket.destroySoon();
+        }
+      });
+    }
     const request = new Request(url, {
       method: req.method,
       headers,
-      body,
-      duplex: "half"
+      body: req.method === "GET" || req.method === "HEAD" ? void 0 : req,
+      duplex: "half",
+      signal
     });
     const response = await fetch2(request, {
       ip,
       request: req,
-      response: res,
-      setCookie(cookie) {
-        res.appendHeader("set-cookie", cookie);
-      }
+      response: res
     });
     if (!response) {
       if (next) {
         next();
-      } else {
-        res.statusCode = 404;
-        res.setHeader("content-length", "0");
-        res.end();
-        return;
       }
       return;
     }
@@ -161,57 +165,34 @@ function createMiddleware(fetch2, options = {}) {
       }
       res.end();
       return;
-    }
-    const reader = response.body.getReader();
-    if (res.destroyed) {
-      reader.cancel();
+    } else if (res.destroyed) {
+      controller.abort(new Error("Response stream destroyed"));
       return;
     }
-    res.on("close", cancel);
-    res.on("error", cancel);
-    write();
-    function cancel(error) {
-      res.off("close", cancel);
-      res.off("error", cancel);
-      reader.cancel(error).catch(() => {
-      });
-      if (error) {
-        if (process.env.NODE_ENV !== "production" && devServer) {
-          res.end();
-          devServer.ws.send({
-            type: "error",
-            err: { message: error.message, stack: error.stack || "" }
-          });
-        } else {
-          res.destroy(error);
-        }
-      }
-    }
-    async function write() {
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            res.end();
-            return;
-          } else if (!res.write(value)) {
-            res.once("drain", write);
-            return;
-          } else if (res.flush) {
-            res.flush();
-          }
-        }
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error("Error while writing to node response", {
-          cause: err
-        });
-        cancel(error);
+    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);
+  }
 }
 export {
   createMiddleware,
   getOrigin,
+  getSetCookie_fallback,
   setResponseHeaders
 };

package/dist/adapter/polyfill.d.ts

@@ -1,6 +1,6 @@
-declare module 'http' {
-    interface OutgoingMessage {
-        appendHeader(this: OutgoingMessage, name: string, value: string): this;
+declare global {
+    interface Headers {
+        getSetCookie: () => string[];
     }
 }
-export declare function installPolyfills(): void;
+export {};

package/dist/cli/index.mjs

@@ -1,4 +1,28 @@
 #!/usr/bin/env node
+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;
+};
 
 // src/cli/index.ts
 import sade from "sade";
@@ -48,11 +72,154 @@ var RoutableFileTypes = {
   Error: "500"
 };
 
+// src/vite/routes/vdir.ts
+var _dirs, _pathlessDirs;
+var _VDir = class {
+  constructor(parent, segment, source) {
+    __privateAdd(this, _dirs, void 0);
+    __privateAdd(this, _pathlessDirs, void 0);
+    __publicField(this, "parent");
+    __publicField(this, "source");
+    __publicField(this, "path");
+    __publicField(this, "fullPath");
+    __publicField(this, "segment");
+    __publicField(this, "files");
+    if (!parent || !segment) {
+      this.parent = null;
+      this.source = null;
+      this.path = "/";
+      this.fullPath = "/";
+      this.segment = {
+        raw: "",
+        name: ""
+      };
+    } else {
+      this.parent = parent;
+      this.source = source;
+      this.path = parent.path + (parent.path === "/" ? segment.name : `/${segment.name}`);
+      this.fullPath = parent.fullPath + (parent.fullPath === "/" ? segment.name : `/${segment.name}`);
+      if (segment.param) {
+        this.fullPath += segment.param;
+      }
+      this.segment = segment;
+    }
+  }
+  get pathInfo() {
+    const value = {
+      id: "/",
+      path: "/",
+      segments: []
+    };
+    let sep = "";
+    for (const { segment } of this) {
+      const { type, name, param } = segment;
+      if (name && type !== "_") {
+        value.id += sep + (type || name);
+        value.path += sep + name;
+        value.isEnd = type === "$$";
+        if (param) {
+          value.path += param;
+          let index = type === "$$" ? null : value.segments.length;
+          if (!value.params) {
+            value.params = { [param]: index };
+          } else if (!(param in value.params)) {
+            value.params[param] = index;
+          }
+        }
+        value.segments.push(name);
+        sep = "/";
+      }
+    }
+    Object.defineProperty(this, "pathInfo", {
+      value,
+      enumerable: true
+    });
+    return value;
+  }
+  addDir(path4, segment) {
+    const map = segment.type === "_" ? __privateGet(this, _pathlessDirs) ?? __privateSet(this, _pathlessDirs, /* @__PURE__ */ new Map()) : __privateGet(this, _dirs) ?? __privateSet(this, _dirs, /* @__PURE__ */ new Map());
+    if (!map.has(segment.name)) {
+      const dir = new _VDir(this, segment, path4);
+      map.set(segment.name, dir);
+      return dir;
+    }
+    return map.get(segment.name);
+  }
+  addFile(file) {
+    if (!this.files) {
+      this.files = /* @__PURE__ */ new Map();
+      this.files.set(file.type, file);
+    } else if (!this.files.has(file.type)) {
+      this.files.set(file.type, file);
+    } else {
+      const existing = this.files.get(file.type);
+      if (existing !== file) {
+        throw new Error(
+          `Duplicate file type '${file.type}' added at path '${this.path}'. File '${file.filePath}' collides with '${existing.filePath}'.`
+        );
+      } else if (file.type === RoutableFileTypes.Page || file.type === RoutableFileTypes.Handler) {
+        throw new Error(
+          `Ambiguous path definition: route '${this.path}' is defined multiple times by ${file.filePath}`
+        );
+      }
+      throw new Error(
+        `Ambiguous path definition: file '${this.path}' is included multiple times by ${file.filePath}`
+      );
+    }
+  }
+  *dirs() {
+    if (__privateGet(this, _pathlessDirs)) {
+      yield* __privateGet(this, _pathlessDirs).values();
+    }
+    if (__privateGet(this, _dirs)) {
+      yield* __privateGet(this, _dirs).values();
+    }
+  }
+  *[Symbol.iterator]() {
+    if (this.parent) {
+      yield* this.parent;
+    }
+    yield this;
+  }
+  static addPaths(roots, paths) {
+    const dirs = [];
+    const unique = /* @__PURE__ */ new Set();
+    for (const root of roots) {
+      for (const path4 of paths) {
+        let dir = root;
+        for (const segment of path4.segments) {
+          dir = dir.addDir(path4, segment);
+        }
+        if (unique.has(dir.path)) {
+          const sources = /* @__PURE__ */ new Set();
+          let sourcePath = "";
+          for (const { source } of dir) {
+            if (source && !sources.has(source.source)) {
+              sources.add(source.source);
+              sourcePath += source.source + "/";
+            }
+          }
+          throw new Error(
+            `Ambiguous directory structure: '${sourcePath}${path4.source}' defines '${dir.path}' multiple times.`
+          );
+        } else {
+          unique.add(dir.path);
+          dirs.push(dir);
+        }
+      }
+    }
+    return dirs;
+  }
+};
+var VDir = _VDir;
+_dirs = new WeakMap();
+_pathlessDirs = new WeakMap();
+
 // src/vite/routes/builder.ts
 var markoFiles = `(${RoutableFileTypes.Layout}|${RoutableFileTypes.Page}|${RoutableFileTypes.NotFound}|${RoutableFileTypes.Error})\\.(?:.*\\.)?(marko)`;
 var nonMarkoFiles = `(${RoutableFileTypes.Middleware}|${RoutableFileTypes.Handler}|${RoutableFileTypes.Meta})\\.(?:.*\\.)?(.+)`;
 var routeableFileRegex = new RegExp(
-  `^[+](?:${markoFiles}|${nonMarkoFiles})$`,
+  `[+](?:${markoFiles}|${nonMarkoFiles})$`,
   "i"
 );