astro 7.2.2 → 7.2.4

package/dist/vite-plugin-app/app.js

@@ -1,237 +0,0 @@
-import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
-import { BaseApp } from "../core/app/entrypoints/index.js";
-import { shouldAppendForwardSlash } from "../core/build/util.js";
-import { clientLocalsSymbol } from "../core/constants.js";
-import { createSafeError } from "../core/errors/index.js";
-import { DevErrorHandler } from "../core/errors/dev-handler.js";
-import { createRequest } from "../core/request.js";
-import { recordServerError } from "../vite-plugin-astro-server/error.js";
-import { runWithErrorHandling } from "../vite-plugin-astro-server/index.js";
-import { handle500Response, writeSSRResult } from "../vite-plugin-astro-server/response.js";
-import { RunnablePipeline } from "./pipeline.js";
-import { ensure404Route } from "../core/routing/astro-designed-error-pages.js";
-import { matchRoute } from "../core/routing/dev.js";
-import { req } from "../core/messages/runtime.js";
-class AstroServerApp extends BaseApp {
-  settings;
-  loader;
-  manifestData;
-  constructor(manifest, streaming = true, logger, manifestData, loader, settings, getDebugInfo) {
-    super(manifest, streaming, settings, logger, loader, manifestData, getDebugInfo);
-    this.settings = settings;
-    this.loader = loader;
-    this.manifestData = manifestData;
-  }
-  /**
-   * Loads the user's `src/fetch.ts` (via `virtual:astro:fetchable`) and
-   * sets it as the fetch handler. Called on every request so that HMR
-   * invalidation of the virtual module is picked up automatically.
-   * Vite caches the module internally so repeated calls are cheap.
-   */
-  async #loadFetchHandler() {
-    try {
-      const mod = await this.loader.import("virtual:astro:fetchable");
-      if (mod?.default) {
-        this.setFetchHandler(mod.default);
-      }
-    } catch {
-    }
-  }
-  isDev() {
-    return true;
-  }
-  /**
-   * Updates the routes list when files change during development.
-   * Called via HMR when new pages are added/removed.
-   */
-  updateRoutes(newRoutesList) {
-    this.manifestData = newRoutesList;
-    this.pipeline.setManifestData(newRoutesList);
-    ensure404Route(this.manifestData);
-  }
-  /**
-   * Clears the route cache so that getStaticPaths() is re-evaluated.
-   * Called via HMR when content collection data changes.
-   */
-  clearRouteCache() {
-    this.pipeline.clearRouteCache();
-  }
-  /**
-   * Clears the cached middleware so it is re-resolved on the next request.
-   * Called via HMR when middleware files change.
-   */
-  clearMiddleware() {
-    this.pipeline.clearMiddleware();
-  }
-  /**
-   * Clears the cached actions so they are re-resolved on the next request.
-   * Called via HMR when action files change.
-   */
-  clearActions() {
-    this.pipeline.clearActions();
-  }
-  async devMatch(pathname, { prerenderOnly } = {}) {
-    const matchedRoute = await matchRoute(
-      pathname,
-      this.manifestData,
-      this.pipeline,
-      this.manifest,
-      { prerenderOnly }
-    );
-    if (!matchedRoute) {
-      return void 0;
-    }
-    return {
-      routeData: matchedRoute.route,
-      resolvedPathname: matchedRoute.resolvedPathname
-    };
-  }
-  static async create(manifest, routesList, logger, loader, settings, getDebugInfo) {
-    return new AstroServerApp(manifest, true, logger, routesList, loader, settings, getDebugInfo);
-  }
-  createPipeline(_streaming, manifest, settings, logger, loader, manifestData, getDebugInfo) {
-    const pipeline = RunnablePipeline.create(manifestData, {
-      loader,
-      logger,
-      manifest,
-      settings,
-      getDebugInfo
-    });
-    return pipeline;
-  }
-  /**
-   * Handle a request.
-   * @returns The return value indicates whether or not the request was handled
-   * by this handler. If the result is not `true`, then the request has not
-   * been handled yet and other handlers can be run.
-   */
-  async handleRequest({
-    controller,
-    incomingRequest,
-    incomingResponse,
-    isHttps,
-    prerenderOnly
-  }) {
-    const protocol = isHttps ? "https" : "http";
-    const host = incomingRequest.headers[":authority"] ?? incomingRequest.headers.host;
-    const origin = `${protocol}://${host}`;
-    const url = new URL(origin + incomingRequest.url);
-    let pathname;
-    if (this.manifest.trailingSlash === "never" && !incomingRequest.url) {
-      pathname = "";
-    } else {
-      pathname = decodeURI(url.pathname);
-    }
-    url.pathname = removeTrailingForwardSlash(this.manifest.base) + url.pathname;
-    if (url.pathname.endsWith("/") && !shouldAppendForwardSlash(this.manifest.trailingSlash, this.manifest.buildFormat)) {
-      url.pathname = url.pathname.slice(0, -1);
-    }
-    const self = this;
-    await self.#loadFetchHandler();
-    let handled = true;
-    await runWithErrorHandling({
-      controller,
-      pathname,
-      async run() {
-        const matchedRoute = await self.devMatch(pathname, { prerenderOnly });
-        if (!matchedRoute) {
-          if (prerenderOnly) {
-            handled = false;
-            return;
-          }
-          throw new Error("No route matched, and default 404 route was not found.");
-        }
-        if (prerenderOnly && !matchedRoute.routeData.prerender) {
-          handled = false;
-          return;
-        }
-        let body = void 0;
-        if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
-          let bytes = [];
-          await new Promise((resolve) => {
-            incomingRequest.on("data", (part) => {
-              bytes.push(part);
-            });
-            incomingRequest.on("end", resolve);
-          });
-          body = Buffer.concat(bytes);
-        }
-        const abortController = new AbortController();
-        const socket = incomingRequest.socket;
-        const onSocketClose = () => {
-          if (!abortController.signal.aborted) {
-            abortController.abort();
-          }
-        };
-        if (socket.destroyed) {
-          onSocketClose();
-        } else {
-          socket.on("close", onSocketClose);
-        }
-        try {
-          const request = createRequest({
-            url,
-            headers: incomingRequest.headers,
-            method: incomingRequest.method,
-            body,
-            logger: self.logger,
-            isPrerendered: matchedRoute.routeData.prerender,
-            routePattern: matchedRoute.routeData.component,
-            init: { signal: abortController.signal }
-          });
-          const locals = Reflect.get(incomingRequest, clientLocalsSymbol);
-          for (const [name, value] of Object.entries(self.settings.config.server.headers ?? {})) {
-            if (value) incomingResponse.setHeader(name, value);
-          }
-          const clientAddress = incomingRequest.socket.remoteAddress;
-          const response = await self.render(request, {
-            locals,
-            routeData: matchedRoute.routeData,
-            clientAddress
-          });
-          await writeSSRResult(request, response, incomingResponse);
-        } finally {
-          socket.off("close", onSocketClose);
-        }
-      },
-      onError(_err) {
-        const error = createSafeError(_err);
-        if (self.loader) {
-          const { errorWithMetadata } = recordServerError(
-            self.loader,
-            self.manifest,
-            self.logger,
-            error
-          );
-          handle500Response(self.loader, incomingResponse, errorWithMetadata);
-        }
-        return error;
-      }
-    });
-    return handled;
-  }
-  match(request, _allowPrerenderedRoutes) {
-    return super.match(request, true);
-  }
-  createErrorHandler() {
-    return new DevErrorHandler(this, { shouldInjectCspMetaTags: true });
-  }
-  logRequest({ pathname, method, statusCode, isRewrite, reqTime }) {
-    if (pathname === "/favicon.ico") {
-      return;
-    }
-    this.logger.info(
-      null,
-      req({
-        url: pathname,
-        method,
-        statusCode,
-        isRewrite,
-        reqTime
-      })
-    );
-  }
-}
-export {
-  AstroServerApp
-};

package/dist/vite-plugin-app/pipeline.d.ts

@@ -1,25 +0,0 @@
-import { type HeadElements, Pipeline, type TryRewriteResult } from '../core/base-pipeline.js';
-import type { ModuleLoader } from '../core/module-loader/index.js';
-import type { AstroSettings, ComponentInstance, RoutesList } from '../types/astro.js';
-import type { RewritePayload, RouteData, SSRLoadedRenderer } from '../types/public/index.js';
-/**
- * This Pipeline is used when the Vite SSR environment is runnable.
- */
-export declare class RunnablePipeline extends Pipeline {
-    getName(): string;
-    renderers: SSRLoadedRenderer[];
-    routesList: RoutesList | undefined;
-    readonly loader: ModuleLoader;
-    readonly settings: AstroSettings;
-    readonly getDebugInfo: () => Promise<string>;
-    private constructor();
-    static create(manifestData: RoutesList, { loader, logger, manifest, settings, getDebugInfo, }: Pick<RunnablePipeline, 'loader' | 'logger' | 'manifest' | 'settings' | 'getDebugInfo'>): RunnablePipeline;
-    clearActions(): void;
-    headElements(routeData: RouteData): Promise<HeadElements>;
-    componentMetadata(routeData: RouteData): Promise<Map<string, import("../types/public/internal.js").SSRComponentMetadata>>;
-    preload(routeData: RouteData, filePath: URL): Promise<ComponentInstance>;
-    clearRouteCache(): void;
-    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
-    tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
-    setManifestData(manifestData: RoutesList): void;
-}

package/dist/vite-plugin-app/pipeline.js

@@ -1,189 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { Pipeline } from "../core/base-pipeline.js";
-import { ASTRO_VERSION } from "../core/constants.js";
-import { enhanceViteSSRError } from "../core/errors/dev/index.js";
-import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
-import { RedirectComponentInstance } from "../core/redirects/index.js";
-import { loadRenderer } from "../core/render/index.js";
-import { routeIsRedirect } from "../core/routing/helpers.js";
-import { findRouteToRewrite } from "../core/routing/rewrite.js";
-import { isPage } from "../core/util.js";
-import { stringifyForScript } from "../runtime/server/escape.js";
-import { getComponentMetadata } from "../vite-plugin-astro-server/metadata.js";
-import { createResolve } from "../vite-plugin-astro-server/resolve.js";
-import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
-class RunnablePipeline extends Pipeline {
-  getName() {
-    return "RunnablePipeline";
-  }
-  // renderers are loaded on every request,
-  // so it needs to be mutable here unlike in other environments
-  renderers = new Array();
-  routesList;
-  loader;
-  settings;
-  getDebugInfo;
-  constructor(loader, logger, manifest, settings, getDebugInfo, defaultRoutes) {
-    const resolve = createResolve(loader, manifest.rootDir);
-    const streaming = true;
-    super(
-      logger,
-      manifest,
-      "development",
-      [],
-      resolve,
-      streaming,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      void 0,
-      defaultRoutes
-    );
-    this.loader = loader;
-    this.settings = settings;
-    this.getDebugInfo = getDebugInfo;
-  }
-  static create(manifestData, {
-    loader,
-    logger,
-    manifest,
-    settings,
-    getDebugInfo
-  }) {
-    const pipeline = new RunnablePipeline(loader, logger, manifest, settings, getDebugInfo);
-    pipeline.routesList = manifestData;
-    return pipeline;
-  }
-  // Called via HMR when action files change. Not available on production.
-  clearActions() {
-    this.resolvedActions = void 0;
-  }
-  async headElements(routeData) {
-    const { manifest, runtimeMode, settings } = this;
-    const filePath = new URL(`${routeData.component}`, manifest.rootDir);
-    const scripts = /* @__PURE__ */ new Set();
-    if (settings) {
-      if (isPage(filePath, settings) && runtimeMode === "development") {
-        scripts.add({
-          props: { type: "module", src: "/@vite/client" },
-          children: ""
-        });
-        if (this.manifest.devToolbar.enabled) {
-          scripts.add({
-            props: {
-              type: "module",
-              src: "/@id/astro/runtime/client/dev-toolbar/entrypoint.js"
-            },
-            children: ""
-          });
-          const additionalMetadata = {
-            root: fileURLToPath(settings.config.root),
-            version: ASTRO_VERSION,
-            latestAstroVersion: settings.latestAstroVersion,
-            // TODO: Currently the debug info is always fetched, which slows things down.
-            // We should look into not loading it if the dev toolbar is disabled. And when
-            // enabled, it would nice to request the debug info through import.meta.hot
-            // when the button is click to defer execution as much as possible
-            debugInfo: await this.getDebugInfo(),
-            placement: settings.config.devToolbar.placement
-          };
-          const children = `window.__astro_dev_toolbar__ = ${stringifyForScript(additionalMetadata)}`;
-          scripts.add({ props: {}, children });
-        }
-      }
-      for (const script of settings.scripts) {
-        if (script.stage === "head-inline") {
-          scripts.add({
-            props: {},
-            children: script.content
-          });
-        } else if (script.stage === "page" && isPage(filePath, settings)) {
-          scripts.add({
-            props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
-            children: ""
-          });
-        }
-      }
-    }
-    const { devCSSMap } = await import("virtual:astro:dev-css-all");
-    const importer = devCSSMap.get(routeData.component);
-    let css = /* @__PURE__ */ new Set();
-    if (importer) {
-      const cssModule = await importer();
-      css = cssModule.css;
-    } else {
-      this.logger.warn(
-        "assets",
-        `Unable to find CSS for ${routeData.component}. This is likely a bug in Astro.`
-      );
-    }
-    const links = /* @__PURE__ */ new Set();
-    const styles = /* @__PURE__ */ new Set();
-    for (const { id, url: src, content } of css) {
-      scripts.add({ props: { type: "module", src }, children: "" });
-      styles.add({ props: { "data-vite-dev-id": id }, children: content });
-    }
-    return { scripts, styles, links };
-  }
-  componentMetadata(routeData) {
-    const filePath = new URL(`${routeData.component}`, this.manifest.rootDir);
-    return getComponentMetadata(filePath, this.loader);
-  }
-  async preload(routeData, filePath) {
-    if (routeIsRedirect(routeData)) {
-      return RedirectComponentInstance;
-    }
-    const { loader } = this;
-    for (const route of this.defaultRoutes) {
-      if (route.matchesComponent(filePath)) {
-        return route.instance;
-      }
-    }
-    if (this.settings) {
-      const renderers__ = this.settings.renderers.map((r) => loadRenderer(r, loader));
-      const renderers_ = await Promise.all(renderers__);
-      this.renderers = renderers_.filter((r) => Boolean(r));
-    }
-    try {
-      return await loader.import(filePath.toString());
-    } catch (error) {
-      if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
-        throw error;
-      }
-      throw enhanceViteSSRError({ error, filePath, loader });
-    }
-  }
-  clearRouteCache() {
-    this.routeCache.clearAll();
-  }
-  async getComponentByRoute(routeData) {
-    const filePath = new URL(`${routeData.component}`, this.manifest.rootDir);
-    return await this.preload(routeData, filePath);
-  }
-  async tryRewrite(payload, request) {
-    if (!this.routesList) {
-      throw new Error("Missing manifest data. This is an internal error, please file an issue.");
-    }
-    const { routeData, pathname, newUrl } = findRouteToRewrite({
-      payload,
-      request,
-      routes: this.routesList?.routes,
-      trailingSlash: this.manifest.trailingSlash,
-      buildFormat: this.manifest.buildFormat,
-      base: this.manifest.base,
-      outDir: this.manifest.outDir
-    });
-    const componentInstance = await this.getComponentByRoute(routeData);
-    return { newUrl, pathname, componentInstance, routeData };
-  }
-  setManifestData(manifestData) {
-    this.routesList = manifestData;
-  }
-}
-export {
-  RunnablePipeline
-};