astro 1.6.2 → 1.6.4

package/dist/vite-plugin-astro-server/index.js

@@ -1,338 +1,9 @@
-import mime from "mime";
-import { Readable } from "stream";
-import { attachToResponse, getSetCookiesFromResponse } from "../core/cookies/index.js";
-import { call as callEndpoint } from "../core/endpoint/dev/index.js";
-import { collectErrorMetadata, getViteErrorPayload } from "../core/errors/dev/index.js";
-import { createSafeError } from "../core/errors/index.js";
-import { error, info, warn } from "../core/logger/core.js";
-import * as msg from "../core/messages.js";
-import { appendForwardSlash } from "../core/path.js";
-import { createDevelopmentEnvironment, preload, renderPage } from "../core/render/dev/index.js";
-import { getParamsAndProps, GetParamsAndPropsError } from "../core/render/index.js";
-import { createRequest } from "../core/request.js";
-import { createRouteManifest, matchAllRoutes } from "../core/routing/index.js";
-import { resolvePages } from "../core/util.js";
-import notFoundTemplate, { subpathNotUsedTemplate } from "../template/4xx.js";
-function writeHtmlResponse(res, statusCode, html) {
-  res.writeHead(statusCode, {
-    "Content-Type": "text/html; charset=utf-8",
-    "Content-Length": Buffer.byteLength(html, "utf-8")
-  });
-  res.write(html);
-  res.end();
-}
-async function writeWebResponse(res, webResponse) {
-  const { status, headers, body } = webResponse;
-  let _headers = {};
-  if ("raw" in headers) {
-    for (const [key, value] of Object.entries(headers.raw())) {
-      res.setHeader(key, value);
-    }
-  } else {
-    _headers = Object.fromEntries(headers.entries());
-  }
-  const setCookieHeaders = Array.from(getSetCookiesFromResponse(webResponse));
-  if (setCookieHeaders.length) {
-    res.setHeader("Set-Cookie", setCookieHeaders);
-  }
-  res.writeHead(status, _headers);
-  if (body) {
-    if (Symbol.for("astro.responseBody") in webResponse) {
-      let stream = webResponse[Symbol.for("astro.responseBody")];
-      for await (const chunk of stream) {
-        res.write(chunk.toString());
-      }
-    } else if (body instanceof Readable) {
-      body.pipe(res);
-      return;
-    } else if (typeof body === "string") {
-      res.write(body);
-    } else {
-      const reader = body.getReader();
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        if (value) {
-          res.write(value);
-        }
-      }
-    }
-  }
-  res.end();
-}
-async function writeSSRResult(webResponse, res) {
-  return writeWebResponse(res, webResponse);
-}
-async function handle404Response(origin, req, res) {
-  const pathname = decodeURI(new URL(origin + req.url).pathname);
-  const html = notFoundTemplate({
-    statusCode: 404,
-    title: "Not found",
-    tabTitle: "404: Not Found",
-    pathname
-  });
-  writeHtmlResponse(res, 404, html);
-}
-async function handle500Response(viteServer, origin, req, res, err) {
-  res.on("close", () => setTimeout(() => viteServer.ws.send(getViteErrorPayload(err)), 200));
-  if (res.headersSent) {
-    res.write(`<script type="module" src="/@vite/client"><\/script>`);
-    res.end();
-  } else {
-    writeHtmlResponse(
-      res,
-      500,
-      `<title>${err.name}</title><script type="module" src="/@vite/client"><\/script>`
-    );
-  }
-}
-function getCustom404Route({ config }, manifest) {
-  const relPages = resolvePages(config).href.replace(config.root.href, "");
-  const pattern = new RegExp(`${appendForwardSlash(relPages)}404.(astro|md)`);
-  return manifest.routes.find((r) => r.component.match(pattern));
-}
-function log404(logging, pathname) {
-  info(logging, "serve", msg.req({ url: pathname, statusCode: 404 }));
-}
-function baseMiddleware(settings, logging) {
-  const { config } = settings;
-  const site = config.site ? new URL(config.base, config.site) : void 0;
-  const devRoot = site ? site.pathname : "/";
-  return function devBaseMiddleware(req, res, next) {
-    var _a;
-    const url = req.url;
-    const pathname = decodeURI(new URL(url, "http://vitejs.dev").pathname);
-    if (pathname.startsWith(devRoot)) {
-      req.url = url.replace(devRoot, "/");
-      return next();
-    }
-    if (pathname === "/" || pathname === "/index.html") {
-      log404(logging, pathname);
-      const html = subpathNotUsedTemplate(devRoot, pathname);
-      return writeHtmlResponse(res, 404, html);
-    }
-    if ((_a = req.headers.accept) == null ? void 0 : _a.includes("text/html")) {
-      log404(logging, pathname);
-      const html = notFoundTemplate({
-        statusCode: 404,
-        title: "Not found",
-        tabTitle: "404: Not Found",
-        pathname
-      });
-      return writeHtmlResponse(res, 404, html);
-    }
-    next();
-  };
-}
-async function matchRoute(pathname, env, manifest) {
-  const { logging, settings, routeCache } = env;
-  const matches = matchAllRoutes(pathname, manifest);
-  for await (const maybeRoute of matches) {
-    const filePath = new URL(`./${maybeRoute.component}`, settings.config.root);
-    const preloadedComponent = await preload({ env, filePath });
-    const [, mod] = preloadedComponent;
-    const paramsAndPropsRes = await getParamsAndProps({
-      mod,
-      route: maybeRoute,
-      routeCache,
-      pathname,
-      logging,
-      ssr: settings.config.output === "server"
-    });
-    if (paramsAndPropsRes !== GetParamsAndPropsError.NoMatchingStaticPath) {
-      return {
-        route: maybeRoute,
-        filePath,
-        preloadedComponent,
-        mod
-      };
-    }
-  }
-  if (matches.length) {
-    warn(
-      logging,
-      "getStaticPaths",
-      `Route pattern matched, but no matching static path found. (${pathname})`
-    );
-  }
-  log404(logging, pathname);
-  const custom404 = getCustom404Route(settings, manifest);
-  if (custom404) {
-    const filePath = new URL(`./${custom404.component}`, settings.config.root);
-    const preloadedComponent = await preload({ env, filePath });
-    const [, mod] = preloadedComponent;
-    return {
-      route: custom404,
-      filePath,
-      preloadedComponent,
-      mod
-    };
-  }
-  return void 0;
-}
-async function handleRequest(env, manifest, req, res) {
-  var _a;
-  const { settings, viteServer } = env;
-  const { config } = settings;
-  const origin = `${viteServer.config.server.https ? "https" : "http"}://${req.headers.host}`;
-  const buildingToSSR = config.output === "server";
-  const url = new URL(origin + ((_a = req.url) == null ? void 0 : _a.replace(/(index)?\.html$/, "")));
-  const pathname = decodeURI(url.pathname);
-  url.pathname = config.base.substring(0, config.base.length - 1) + url.pathname;
-  if (!buildingToSSR && pathname !== "/_image") {
-    const allSearchParams = Array.from(url.searchParams);
-    for (const [key] of allSearchParams) {
-      url.searchParams.delete(key);
-    }
-  }
-  let body = void 0;
-  if (!(req.method === "GET" || req.method === "HEAD")) {
-    let bytes = [];
-    await new Promise((resolve) => {
-      req.on("data", (part) => {
-        bytes.push(part);
-      });
-      req.on("end", resolve);
-    });
-    body = Buffer.concat(bytes);
-  }
-  try {
-    const matchedRoute = await matchRoute(pathname, env, manifest);
-    return await handleRoute(matchedRoute, url, pathname, body, origin, env, manifest, req, res);
-  } catch (_err) {
-    const err = createSafeError(_err);
-    const errorWithMetadata = collectErrorMetadata(err);
-    error(env.logging, null, msg.formatErrorMessage(errorWithMetadata));
-    handle500Response(viteServer, origin, req, res, errorWithMetadata);
-  }
-}
-function isRedirect(statusCode) {
-  return statusCode >= 300 && statusCode < 400;
-}
-function throwIfRedirectNotAllowed(response, config) {
-  if (config.output !== "server" && isRedirect(response.status)) {
-    throw new Error(
-      `Redirects are only available when using output: 'server'. Update your Astro config if you need SSR features.`
-    );
-  }
-}
-async function handleRoute(matchedRoute, url, pathname, body, origin, env, manifest, req, res) {
-  const { logging, settings } = env;
-  if (!matchedRoute) {
-    return handle404Response(origin, req, res);
-  }
-  const { config } = settings;
-  const filePath = matchedRoute.filePath;
-  const { route, preloadedComponent, mod } = matchedRoute;
-  const buildingToSSR = config.output === "server";
-  const request = createRequest({
-    url,
-    headers: buildingToSSR ? req.headers : new Headers(),
-    method: req.method,
-    body,
-    logging,
-    ssr: buildingToSSR,
-    clientAddress: buildingToSSR ? req.socket.remoteAddress : void 0
-  });
-  const paramsAndPropsRes = await getParamsAndProps({
-    mod,
-    route,
-    routeCache: env.routeCache,
-    pathname,
-    logging,
-    ssr: config.output === "server"
-  });
-  const options = {
-    env,
-    filePath,
-    origin,
-    preload: preloadedComponent,
-    pathname,
-    request,
-    route
-  };
-  if (route.type === "endpoint") {
-    const result = await callEndpoint(options);
-    if (result.type === "response") {
-      if (result.response.headers.get("X-Astro-Response") === "Not-Found") {
-        const fourOhFourRoute = await matchRoute("/404", env, manifest);
-        return handleRoute(
-          fourOhFourRoute,
-          new URL("/404", url),
-          "/404",
-          body,
-          origin,
-          env,
-          manifest,
-          req,
-          res
-        );
-      }
-      throwIfRedirectNotAllowed(result.response, config);
-      await writeWebResponse(res, result.response);
-    } else {
-      let contentType = "text/plain";
-      const filepath = route.pathname || route.segments.map((segment) => segment.map((p) => p.content).join("")).join("/");
-      const computedMimeType = mime.getType(filepath);
-      if (computedMimeType) {
-        contentType = computedMimeType;
-      }
-      const response = new Response(result.body, {
-        status: 200,
-        headers: {
-          "Content-Type": `${contentType};charset=utf-8`
-        }
-      });
-      attachToResponse(response, result.cookies);
-      await writeWebResponse(res, response);
-    }
-  } else {
-    const result = await renderPage(options);
-    throwIfRedirectNotAllowed(result, config);
-    return await writeSSRResult(result, res);
-  }
-}
-function createPlugin({ settings, logging }) {
-  return {
-    name: "astro:server",
-    configureServer(viteServer) {
-      let env = createDevelopmentEnvironment(settings, logging, viteServer);
-      let manifest = createRouteManifest({ settings }, logging);
-      function rebuildManifest(needsManifestRebuild, file) {
-        env.routeCache.clearAll();
-        if (needsManifestRebuild) {
-          manifest = createRouteManifest({ settings }, logging);
-        }
-      }
-      viteServer.watcher.on("add", rebuildManifest.bind(null, true));
-      viteServer.watcher.on("unlink", rebuildManifest.bind(null, true));
-      viteServer.watcher.on("change", rebuildManifest.bind(null, false));
-      return () => {
-        if (settings.config.base !== "/") {
-          viteServer.middlewares.stack.unshift({
-            route: "",
-            handle: baseMiddleware(settings, logging)
-          });
-        }
-        viteServer.middlewares.use(async (req, res) => {
-          if (!req.url || !req.method) {
-            throw new Error("Incomplete request");
-          }
-          handleRequest(env, manifest, req, res);
-        });
-      };
-    },
-    transform(code, id, opts = {}) {
-      if (opts.ssr)
-        return;
-      if (!id.includes("vite/dist/client/client.mjs"))
-        return;
-      return code.replace(/\.tip \{[^}]*\}/gm, ".tip {\n  display: none;\n}").replace(/\[vite\]/g, "[astro]");
-    }
-  };
-}
+import { createController, runWithErrorHandling } from "./controller.js";
+import { default as default2 } from "./plugin.js";
+import { handleRequest } from "./request.js";
 export {
-  baseMiddleware,
-  createPlugin as default
+  createController,
+  handleRequest,
+  runWithErrorHandling,
+  default2 as vitePluginAstroServer
 };

package/dist/vite-plugin-astro-server/plugin.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import type * as vite from 'vite';
+import type { AstroSettings } from '../@types/astro';
+import type fs from 'fs';
+import { LogOptions } from '../core/logger/core.js';
+export interface AstroPluginOptions {
+    settings: AstroSettings;
+    logging: LogOptions;
+    fs: typeof fs;
+}
+export default function createVitePluginAstroServer({ settings, logging, fs: fsMod, }: AstroPluginOptions): vite.Plugin;

package/dist/vite-plugin-astro-server/plugin.js

@@ -0,0 +1,54 @@
+import { createViteLoader } from "../core/module-loader/index.js";
+import { createDevelopmentEnvironment } from "../core/render/dev/index.js";
+import { createRouteManifest } from "../core/routing/index.js";
+import { baseMiddleware } from "./base.js";
+import { createController } from "./controller.js";
+import { handleRequest } from "./request.js";
+function createVitePluginAstroServer({
+  settings,
+  logging,
+  fs: fsMod
+}) {
+  return {
+    name: "astro:server",
+    configureServer(viteServer) {
+      const loader = createViteLoader(viteServer);
+      let env = createDevelopmentEnvironment(settings, logging, loader);
+      let manifest = createRouteManifest({ settings, fsMod }, logging);
+      const serverController = createController({ loader });
+      function rebuildManifest(needsManifestRebuild, _file) {
+        env.routeCache.clearAll();
+        if (needsManifestRebuild) {
+          manifest = createRouteManifest({ settings }, logging);
+        }
+      }
+      viteServer.watcher.on("add", rebuildManifest.bind(null, true));
+      viteServer.watcher.on("unlink", rebuildManifest.bind(null, true));
+      viteServer.watcher.on("change", rebuildManifest.bind(null, false));
+      return () => {
+        if (settings.config.base !== "/") {
+          viteServer.middlewares.stack.unshift({
+            route: "",
+            handle: baseMiddleware(settings, logging)
+          });
+        }
+        viteServer.middlewares.use(async (req, res) => {
+          if (!req.url || !req.method) {
+            throw new Error("Incomplete request");
+          }
+          handleRequest(env, manifest, serverController, req, res);
+        });
+      };
+    },
+    transform(code, id, opts = {}) {
+      if (opts.ssr)
+        return;
+      if (!id.includes("vite/dist/client/client.mjs"))
+        return;
+      return code.replace(/\.tip \{[^}]*\}/gm, ".tip {\n  display: none;\n}").replace(/\[vite\]/g, "[astro]");
+    }
+  };
+}
+export {
+  createVitePluginAstroServer as default
+};

package/dist/vite-plugin-astro-server/request.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import type http from 'http';
+import type { ManifestData } from '../@types/astro';
+import type { DevelopmentEnvironment } from '../core/render/dev/index';
+import type { DevServerController } from './controller';
+/** The main logic to route dev server requests to pages in Astro. */
+export declare function handleRequest(env: DevelopmentEnvironment, manifest: ManifestData, controller: DevServerController, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;

package/dist/vite-plugin-astro-server/request.js

@@ -0,0 +1,52 @@
+import { collectErrorMetadata } from "../core/errors/dev/index.js";
+import { createSafeError } from "../core/errors/index.js";
+import { error } from "../core/logger/core.js";
+import * as msg from "../core/messages.js";
+import { runWithErrorHandling } from "./controller.js";
+import { handle500Response } from "./response.js";
+import { handleRoute, matchRoute } from "./route.js";
+async function handleRequest(env, manifest, controller, req, res) {
+  var _a;
+  const { settings, loader: moduleLoader } = env;
+  const { config } = settings;
+  const origin = `${moduleLoader.isHttps() ? "https" : "http"}://${req.headers.host}`;
+  const buildingToSSR = config.output === "server";
+  const url = new URL(origin + ((_a = req.url) == null ? void 0 : _a.replace(/(index)?\.html$/, "")));
+  const pathname = decodeURI(url.pathname);
+  url.pathname = config.base.substring(0, config.base.length - 1) + url.pathname;
+  if (!buildingToSSR && pathname !== "/_image") {
+    const allSearchParams = Array.from(url.searchParams);
+    for (const [key] of allSearchParams) {
+      url.searchParams.delete(key);
+    }
+  }
+  let body = void 0;
+  if (!(req.method === "GET" || req.method === "HEAD")) {
+    let bytes = [];
+    await new Promise((resolve) => {
+      req.on("data", (part) => {
+        bytes.push(part);
+      });
+      req.on("end", resolve);
+    });
+    body = Buffer.concat(bytes);
+  }
+  await runWithErrorHandling({
+    controller,
+    pathname,
+    async run() {
+      const matchedRoute = await matchRoute(pathname, env, manifest);
+      return await handleRoute(matchedRoute, url, pathname, body, origin, env, manifest, req, res);
+    },
+    onError(_err) {
+      const err = createSafeError(_err);
+      const errorWithMetadata = collectErrorMetadata(err);
+      error(env.logging, null, msg.formatErrorMessage(errorWithMetadata));
+      handle500Response(moduleLoader, res, errorWithMetadata);
+      return err;
+    }
+  });
+}
+export {
+  handleRequest
+};

package/dist/vite-plugin-astro-server/response.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type http from 'http';
+import type { ErrorWithMetadata } from '../core/errors/index.js';
+import type { ModuleLoader } from '../core/module-loader/index';
+export declare function handle404Response(origin: string, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export declare function handle500Response(loader: ModuleLoader, res: http.ServerResponse, err: ErrorWithMetadata): Promise<void>;
+export declare function writeHtmlResponse(res: http.ServerResponse, statusCode: number, html: string): void;
+export declare function writeWebResponse(res: http.ServerResponse, webResponse: Response): Promise<void>;
+export declare function writeSSRResult(webResponse: Response, res: http.ServerResponse): Promise<void>;

package/dist/vite-plugin-astro-server/response.js

@@ -0,0 +1,85 @@
+import { Readable } from "stream";
+import { getSetCookiesFromResponse } from "../core/cookies/index.js";
+import { getViteErrorPayload } from "../core/errors/dev/index.js";
+import notFoundTemplate from "../template/4xx.js";
+async function handle404Response(origin, req, res) {
+  const pathname = decodeURI(new URL(origin + req.url).pathname);
+  const html = notFoundTemplate({
+    statusCode: 404,
+    title: "Not found",
+    tabTitle: "404: Not Found",
+    pathname
+  });
+  writeHtmlResponse(res, 404, html);
+}
+async function handle500Response(loader, res, err) {
+  res.on("close", () => setTimeout(() => loader.webSocketSend(getViteErrorPayload(err)), 200));
+  if (res.headersSent) {
+    res.write(`<script type="module" src="/@vite/client"><\/script>`);
+    res.end();
+  } else {
+    writeHtmlResponse(
+      res,
+      500,
+      `<title>${err.name}</title><script type="module" src="/@vite/client"><\/script>`
+    );
+  }
+}
+function writeHtmlResponse(res, statusCode, html) {
+  res.writeHead(statusCode, {
+    "Content-Type": "text/html; charset=utf-8",
+    "Content-Length": Buffer.byteLength(html, "utf-8")
+  });
+  res.write(html);
+  res.end();
+}
+async function writeWebResponse(res, webResponse) {
+  const { status, headers, body } = webResponse;
+  let _headers = {};
+  if ("raw" in headers) {
+    for (const [key, value] of Object.entries(headers.raw())) {
+      res.setHeader(key, value);
+    }
+  } else {
+    _headers = Object.fromEntries(headers.entries());
+  }
+  const setCookieHeaders = Array.from(getSetCookiesFromResponse(webResponse));
+  if (setCookieHeaders.length) {
+    res.setHeader("Set-Cookie", setCookieHeaders);
+  }
+  res.writeHead(status, _headers);
+  if (body) {
+    if (Symbol.for("astro.responseBody") in webResponse) {
+      let stream = webResponse[Symbol.for("astro.responseBody")];
+      for await (const chunk of stream) {
+        res.write(chunk.toString());
+      }
+    } else if (body instanceof Readable) {
+      body.pipe(res);
+      return;
+    } else if (typeof body === "string") {
+      res.write(body);
+    } else {
+      const reader = body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        if (value) {
+          res.write(value);
+        }
+      }
+    }
+  }
+  res.end();
+}
+async function writeSSRResult(webResponse, res) {
+  return writeWebResponse(res, webResponse);
+}
+export {
+  handle404Response,
+  handle500Response,
+  writeHtmlResponse,
+  writeSSRResult,
+  writeWebResponse
+};

package/dist/vite-plugin-astro-server/route.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type http from 'http';
+import type { ManifestData } from '../@types/astro';
+import { DevelopmentEnvironment } from '../core/render/dev/index';
+declare type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (...args: any) => Promise<infer R> ? R : any;
+export declare function matchRoute(pathname: string, env: DevelopmentEnvironment, manifest: ManifestData): Promise<{
+    route: import("../@types/astro").RouteData;
+    filePath: URL;
+    preloadedComponent: import("../core/render/dev/index").ComponentPreload;
+    mod: import("../@types/astro").ComponentInstance;
+} | undefined>;
+export declare function handleRoute(matchedRoute: AsyncReturnType<typeof matchRoute>, url: URL, pathname: string, body: ArrayBuffer | undefined, origin: string, env: DevelopmentEnvironment, manifest: ManifestData, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
+export {};