nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_chunks/app.mjs

@@ -1,600 +0,0 @@
-import { existsSync } from 'node:fs';
-import { rm, readFile } from 'node:fs/promises';
-import { Worker } from 'node:worker_threads';
-import consola from 'consola';
-import { a, T } from './_deps/std-env.mjs';
-import { fromNodeHandler, HTTPError, defineHandler, getRequestIP, getRequestURL, H3, toEventHandler, withBase } from 'h3';
-import { s as serveStatic } from './_deps/serve-static.mjs';
-import { joinURL } from 'ufo';
-import { c as createProxyServer } from './_deps/httpxy.mjs';
-import { Agent } from 'undici';
-import { resolve, dirname } from 'node:path';
-import { ErrorParser } from 'youch-core';
-import { Youch } from 'youch';
-import { SourceMapConsumer } from 'source-map';
-import { FastResponse } from 'srvx';
-
-function createHTTPProxy(defaults = {}) {
-  const proxy = createProxyServer(defaults);
-  proxy.on("proxyReq", (proxyReq, req) => {
-    if (!proxyReq.hasHeader("x-forwarded-for")) {
-      const address = req.socket.remoteAddress;
-      if (address) {
-        proxyReq.appendHeader("x-forwarded-for", address);
-      }
-    }
-    if (!proxyReq.hasHeader("x-forwarded-port")) {
-      const localPort = req?.socket?.localPort;
-      if (localPort) {
-        proxyReq.setHeader("x-forwarded-port", req.socket.localPort);
-      }
-    }
-    if (!proxyReq.hasHeader("x-forwarded-Proto")) {
-      const encrypted = req?.connection?.encrypted;
-      proxyReq.setHeader("x-forwarded-proto", encrypted ? "https" : "http");
-    }
-  });
-  return {
-    proxy,
-    async handleEvent(event, opts) {
-      try {
-        return await fromNodeHandler(
-          (req, res) => proxy.web(req, res, opts)
-        )(event);
-      } catch (error) {
-        event.res.headers.set("refresh", "3");
-        throw new HTTPError({
-          status: 503,
-          message: "Dev server is unavailable.",
-          cause: error
-        });
-      }
-    }
-  };
-}
-function fetchAddress(addr, input, inputInit) {
-  let url;
-  let init;
-  if (input instanceof Request) {
-    url = new URL(input.url);
-    init = {
-      method: input.method,
-      headers: input.headers,
-      body: input.body,
-      ...inputInit
-    };
-  } else {
-    url = new URL(input);
-    init = inputInit;
-  }
-  init = {
-    duplex: "half",
-    redirect: "manual",
-    ...init
-  };
-  if (addr.socketPath) {
-    url.protocol = "http:";
-    return fetch(url, {
-      ...init,
-      ...fetchSocketOptions(addr.socketPath)
-    });
-  }
-  const origin = `http://${addr.host}${addr.port ? `:${addr.port}` : ""}`;
-  const outURL = new URL(url.pathname + url.search, origin);
-  return fetch(outURL, init);
-}
-function fetchSocketOptions(socketPath) {
-  if ("Bun" in globalThis) {
-    return { unix: socketPath };
-  }
-  if ("Deno" in globalThis) {
-    return {
-      // @ts-ignore
-      client: Deno.createHttpClient({
-        // @ts-ignore Missing types?
-        transport: "unix",
-        path: socketPath
-      })
-    };
-  }
-  return {
-    dispatcher: new Agent({ connect: { socketPath } })
-  };
-}
-
-class NodeDevWorker {
-  closed = false;
-  #name;
-  #entry;
-  #data;
-  #hooks;
-  #worker;
-  #address;
-  #proxy;
-  #messageListeners;
-  constructor(opts) {
-    this.#name = opts.name;
-    this.#entry = opts.entry;
-    this.#data = opts.data;
-    this.#hooks = opts.hooks;
-    this.#proxy = createHTTPProxy();
-    this.#messageListeners = /* @__PURE__ */ new Set();
-    this.#initWorker();
-  }
-  get ready() {
-    return Boolean(
-      !this.closed && this.#address && this.#proxy && this.#worker
-    );
-  }
-  // #region Public methods
-  async fetch(input, init) {
-    for (let i = 0; i < 5 && !(this.#address && this.#proxy); i++) {
-      await new Promise((r) => setTimeout(r, 100 * Math.pow(2, i)));
-    }
-    if (!(this.#address && this.#proxy)) {
-      return new Response("Dev worker is unavailable", { status: 503 });
-    }
-    return fetchAddress(this.#address, input, init);
-  }
-  upgrade(req, socket, head) {
-    if (!this.ready) {
-      return;
-    }
-    return this.#proxy.proxy.ws(
-      req,
-      socket,
-      { target: this.#address, xfwd: true },
-      head
-    );
-  }
-  sendMessage(message) {
-    if (!this.#worker) {
-      throw new Error(
-        "Dev worker should be initialized before sending messages."
-      );
-    }
-    this.#worker.postMessage(message);
-  }
-  onMessage(listener) {
-    this.#messageListeners.add(listener);
-  }
-  offMessage(listener) {
-    this.#messageListeners.delete(listener);
-  }
-  async close(cause) {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    this.#hooks.onClose?.(this, cause);
-    this.#hooks = {};
-    const onError = (error) => consola.error(error);
-    await this.#closeWorker().catch(onError);
-    await this.#closeProxy().catch(onError);
-    await this.#closeSocket().catch(onError);
-  }
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    const status = this.closed ? "closed" : this.ready ? "ready" : "pending";
-    return `NodeDevWorker#${this.#name}(${status})`;
-  }
-  // #endregion
-  // #region Private methods
-  #initWorker() {
-    if (!existsSync(this.#entry)) {
-      this.close(`worker entry not found in "${this.#entry}".`);
-      return;
-    }
-    const worker = new Worker(this.#entry, {
-      env: {
-        ...process.env
-      },
-      workerData: {
-        name: this.#name,
-        ...this.#data
-      }
-    });
-    worker.once("exit", (code) => {
-      worker._exitCode = code;
-      this.close(`worker exited with code ${code}`);
-    });
-    worker.once("error", (error) => {
-      consola.error(`Worker error:`, error);
-      this.close(error);
-    });
-    worker.on("message", (message) => {
-      if (message?.address) {
-        this.#address = message.address;
-        this.#hooks.onReady?.(this, this.#address);
-      }
-      for (const listener of this.#messageListeners) {
-        listener(message);
-      }
-    });
-    this.#worker = worker;
-  }
-  async #closeProxy() {
-    this.#proxy?.proxy?.close(() => {
-    });
-    this.#proxy = void 0;
-  }
-  async #closeSocket() {
-    const socketPath = this.#address?.socketPath;
-    if (socketPath && socketPath[0] !== "\0" && !socketPath.startsWith(String.raw`\\.\pipe`)) {
-      await rm(socketPath).catch(() => {
-      });
-    }
-    this.#address = void 0;
-  }
-  async #closeWorker() {
-    if (!this.#worker) {
-      return;
-    }
-    this.#worker.postMessage({ event: "shutdown" });
-    if (!this.#worker._exitCode && !a && !T) {
-      await new Promise((resolve) => {
-        const gracefulShutdownTimeoutMs = Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 5e3;
-        const timeout = setTimeout(() => {
-          if (process.env.DEBUG) {
-            consola.warn(`force closing dev worker...`);
-          }
-        }, gracefulShutdownTimeoutMs);
-        this.#worker?.on("message", (message) => {
-          if (message.event === "exit") {
-            clearTimeout(timeout);
-            resolve();
-          }
-        });
-      });
-    }
-    this.#worker.removeAllListeners();
-    await this.#worker.terminate().catch((error) => {
-      consola.error(error);
-    });
-    this.#worker = void 0;
-  }
-  // #endregion
-}
-
-function createVFSHandler(nitro) {
-  return defineHandler(async (event) => {
-    const { socket } = event.runtime?.node?.req || {};
-    const isUnixSocket = (
-      // No network addresses
-      !socket?.remoteAddress && !socket?.localAddress && // Empty address object
-      Object.keys(socket?.address?.() || {}).length === 0 && // Socket is readable/writable but has no port info
-      socket?.readable && socket?.writable && !socket?.remotePort
-    );
-    const ip = getRequestIP(event, { xForwardedFor: isUnixSocket });
-    const isLocalRequest = ip && /^::1$|^127\.\d+\.\d+\.\d+$/.test(ip);
-    if (!isLocalRequest) {
-      throw new HTTPError({
-        statusText: `Forbidden IP: "${ip || "?"}"`,
-        status: 403
-      });
-    }
-    const vfsEntries = {
-      ...nitro.vfs,
-      ...nitro.options.virtual
-    };
-    const url = event.context.params?._ || "";
-    const isJson = url.endsWith(".json") || event.req.headers.get("accept")?.includes("application/json");
-    const id = decodeURIComponent(url.replace(/^(\.json)?\/?/, "") || "");
-    if (id && !(id in vfsEntries)) {
-      throw new HTTPError({ message: "File not found", status: 404 });
-    }
-    let content = id ? vfsEntries[id] : void 0;
-    if (typeof content === "function") {
-      content = await content();
-    }
-    if (isJson) {
-      return {
-        rootDir: nitro.options.rootDir,
-        entries: Object.keys(vfsEntries).map((id2) => ({
-          id: id2,
-          path: "/_vfs.json/" + encodeURIComponent(id2)
-        })),
-        current: id ? {
-          id,
-          content
-        } : null
-      };
-    }
-    const directories = { [nitro.options.rootDir]: {} };
-    const fpaths = Object.keys(vfsEntries);
-    for (const item of fpaths) {
-      const segments = item.replace(nitro.options.rootDir, "").split("/").filter(Boolean);
-      let currentDir = item.startsWith(nitro.options.rootDir) ? directories[nitro.options.rootDir] : directories;
-      for (const segment of segments) {
-        if (!currentDir[segment]) {
-          currentDir[segment] = {};
-        }
-        currentDir = currentDir[segment];
-      }
-    }
-    const generateHTML = (directory, path = []) => Object.entries(directory).map(([fname, value = {}]) => {
-      const subpath = [...path, fname];
-      const key = subpath.join("/");
-      const encodedUrl = encodeURIComponent(key);
-      const linkClass = url === `/${encodedUrl}` ? "bg-gray-700 text-white" : "hover:bg-gray-800 text-gray-200";
-      return Object.keys(value).length === 0 ? `
-            <li class="flex flex-nowrap">
-              <a href="/_vfs/${encodedUrl}" class="w-full text-sm px-2 py-1 border-b border-gray-10 ${linkClass}">
-                ${fname}
-              </a>
-            </li>
-            ` : `
-            <li>
-              <details ${url.startsWith(`/${encodedUrl}`) ? "open" : ""}>
-                <summary class="w-full text-sm px-2 py-1 border-b border-gray-10 hover:bg-gray-800 text-gray-200">
-                  ${fname}
-                </summary>
-                <ul class="ml-4">
-                  ${generateHTML(value, subpath)}
-                </ul>
-              </details>
-            </li>
-            `;
-    }).join("");
-    const rootDirectory = directories[nitro.options.rootDir];
-    delete directories[nitro.options.rootDir];
-    const items = generateHTML(rootDirectory, [nitro.options.rootDir]) + generateHTML(directories);
-    const files = `
-      <div class="h-full overflow-auto border-r border-gray:10">
-        <p class="text-white text-bold text-center py-1 opacity-50">Virtual Files</p>
-        <ul class="flex flex-col">${items}</ul>
-      </div>
-      `;
-    const file = id ? editorTemplate({
-      readOnly: true,
-      language: id.endsWith("html") ? "html" : "javascript",
-      theme: "vs-dark",
-      value: content,
-      wordWrap: "wordWrapColumn",
-      wordWrapColumn: 80
-    }) : `
-        <div class="w-full h-full flex opacity-50">
-          <h1 class="text-white m-auto">Select a virtual file to inspect</h1>
-        </div>
-      `;
-    event.res.headers.set("Content-Type", "text/html; charset=utf-8");
-    return (
-      /* html */
-      `
-<!doctype html>
-<html>
-<head>
-  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@unocss/reset/tailwind.min.css" />
-  <link rel="stylesheet" data-name="vs/editor/editor.main" href="${vsUrl}/editor/editor.main.min.css">
-  <script src="https://cdn.jsdelivr.net/npm/@unocss/runtime"><\/script>
-  <style>
-    html {
-      background: #1E1E1E;
-      color: white;
-    }
-    [un-cloak] {
-      display: none;
-    }
-  </style>
-</head>
-<body class="bg-[#1E1E1E]">
-  <div un-cloak class="h-screen grid grid-cols-[300px_1fr]">
-    ${files}
-    ${file}
-  </div>
-</body>
-</html>`
-    );
-  });
-}
-const monacoVersion = "0.30.0";
-const monacoUrl = `https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/${monacoVersion}/min`;
-const vsUrl = `${monacoUrl}/vs`;
-const editorTemplate = (options) => `
-<div id="editor" class="min-h-screen w-full h-full"></div>
-<script src="${vsUrl}/loader.min.js"><\/script>
-<script>
-  require.config({ paths: { vs: '${vsUrl}' } })
-
-  const proxy = URL.createObjectURL(new Blob([\`
-    self.MonacoEnvironment = { baseUrl: '${monacoUrl}' }
-    importScripts('${vsUrl}/base/worker/workerMain.min.js')
-  \`], { type: 'text/javascript' }))
-  window.MonacoEnvironment = { getWorkerUrl: () => proxy }
-
-  setTimeout(() => {
-    require(['vs/editor/editor.main'], function () {
-      monaco.editor.create(document.getElementById('editor'), ${JSON.stringify(
-  options
-)})
-    })
-  }, 0);
-<\/script>
-`;
-
-function defineNitroErrorHandler(handler) {
-  return handler;
-}
-
-const devErrorHandler = defineNitroErrorHandler(
-  async function defaultNitroErrorHandler(error, event) {
-    const res = await defaultHandler(error, event);
-    return new FastResponse(
-      typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2),
-      res
-    );
-  }
-);
-async function defaultHandler(error, event, opts) {
-  const isSensitive = error.unhandled;
-  const status = error.status || 500;
-  const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true });
-  if (status === 404) {
-    const baseURL = import.meta.baseURL || "/";
-    if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
-      const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`;
-      return {
-        status: 302,
-        statusText: "Found",
-        headers: { location: redirectTo },
-        body: `Redirecting...`
-      };
-    }
-  }
-  await loadStackTrace(error).catch(consola.error);
-  const youch = new Youch();
-  if (isSensitive && !opts?.silent) {
-    const tags = [error.unhandled && "[unhandled]"].filter(Boolean).join(" ");
-    const ansiError = await (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
-    consola.error(
-      `[request error] ${tags} [${event.req.method}] ${url}
-
-`,
-      ansiError
-    );
-  }
-  const useJSON = opts?.json || !event.req.headers.get("accept")?.includes("text/html");
-  const headers = {
-    "content-type": useJSON ? "application/json" : "text/html",
-    // Prevent browser from guessing the MIME types of resources.
-    "x-content-type-options": "nosniff",
-    // Prevent error page from being embedded in an iframe
-    "x-frame-options": "DENY",
-    // Prevent browsers from sending the Referer header
-    "referrer-policy": "no-referrer",
-    // Disable the execution of any js
-    "content-security-policy": "script-src 'self' 'unsafe-inline'; object-src 'none'; base-uri 'self';"
-  };
-  if (status === 404 || !event.res.headers.has("cache-control")) {
-    headers["cache-control"] = "no-cache";
-  }
-  const body = useJSON ? {
-    error: true,
-    url,
-    status,
-    statusText: error.statusText,
-    message: error.message,
-    data: error.data,
-    stack: error.stack?.split("\n").map((line) => line.trim())
-  } : await youch.toHTML(error, {
-    request: {
-      url: url.href,
-      method: event.req.method,
-      headers: Object.fromEntries(event.req.headers.entries())
-    }
-  });
-  return {
-    status,
-    statusText: error.statusText,
-    headers,
-    body
-  };
-}
-async function loadStackTrace(error) {
-  if (!(error instanceof Error)) {
-    return;
-  }
-  const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
-  const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
-  Object.defineProperty(error, "stack", { value: stack });
-  if (error.cause) {
-    await loadStackTrace(error.cause).catch(consola.error);
-  }
-}
-async function sourceLoader(frame) {
-  if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
-    return;
-  }
-  if (frame.type === "app") {
-    const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {
-    });
-    if (rawSourceMap) {
-      const consumer = await new SourceMapConsumer(rawSourceMap);
-      const originalPosition = consumer.originalPositionFor({ line: frame.lineNumber, column: frame.columnNumber });
-      if (originalPosition.source && originalPosition.line) {
-        frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
-        frame.lineNumber = originalPosition.line;
-        frame.columnNumber = originalPosition.column || 0;
-      }
-    }
-  }
-  const contents = await readFile(frame.fileName, "utf8").catch(() => {
-  });
-  return contents ? { contents } : void 0;
-}
-function fmtFrame(frame) {
-  if (frame.type === "native") {
-    return frame.raw;
-  }
-  const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
-  return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
-}
-
-class NitroDevApp {
-  nitro;
-  fetch;
-  constructor(nitro, catchAllHandler) {
-    this.nitro = nitro;
-    const app = this.#createApp(catchAllHandler);
-    this.fetch = app.fetch.bind(app);
-  }
-  #createApp(catchAllHandler) {
-    const app = new H3({
-      debug: true,
-      onError: async (error, event) => {
-        const errorHandler = this.nitro.options.devErrorHandler || devErrorHandler;
-        await loadStackTrace(error).catch(() => {
-        });
-        return errorHandler(error, event, {
-          defaultHandler: defaultHandler
-        });
-      }
-    });
-    for (const h of this.nitro.options.devHandlers) {
-      const handler = toEventHandler(h.handler);
-      if (!handler) {
-        this.nitro.logger.warn("Invalid dev handler:", h);
-        continue;
-      }
-      if (h.middleware || !h.route) {
-        if (h.route) {
-          app.use(h.route, handler, { method: h.method });
-        } else {
-          app.use(handler, { method: h.method });
-        }
-      } else {
-        app.on(h.method || "", h.route, handler, { meta: h.meta });
-      }
-    }
-    app.get("/_vfs/**", createVFSHandler(this.nitro));
-    for (const asset of this.nitro.options.publicAssets) {
-      const assetRoute = joinURL(
-        this.nitro.options.runtimeConfig.app.baseURL,
-        asset.baseURL || "/",
-        "**"
-      );
-      let handler = fromNodeHandler(
-        // @ts-expect-error (HTTP2 types)
-        serveStatic(asset.dir, { dotfiles: "allow" })
-      );
-      if (asset.baseURL?.length || 0 > 1) {
-        handler = withBase(asset.baseURL, handler);
-      }
-      app.use(assetRoute, handler);
-    }
-    const routes = Object.keys(this.nitro.options.devProxy).sort().reverse();
-    for (const route of routes) {
-      let opts = this.nitro.options.devProxy[route];
-      if (typeof opts === "string") {
-        opts = { target: opts };
-      }
-      const proxy = createHTTPProxy(opts);
-      app.all(route, proxy.handleEvent);
-    }
-    if (catchAllHandler) {
-      app.all("/**", catchAllHandler);
-    }
-    return app;
-  }
-}
-
-export { NitroDevApp as N, NodeDevWorker as a };