astro 7.2.2 → 7.2.4

package/dist/core/environment/dev-nonrunnable.js

@@ -0,0 +1,170 @@
+import { stringifyForScript } from "../../runtime/server/escape.js";
+import { ASTRO_VERSION } from "../constants.js";
+import { getLogger } from "../logger/manifest-logger.js";
+import { req } from "../messages/runtime.js";
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
+import { createModuleScriptElement, createStylesheetElementSet } from "../render/ssr-element.js";
+import { getDefaultRoutes } from "../routing/default.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
+import { getRouteTable } from "../routing/route-table.js";
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  if (route.type === "redirect") {
+    return RedirectSinglePageBuiltModule;
+  } else {
+    if (manifest.pageMap) {
+      const importComponentInstance = manifest.pageMap.get(route.component);
+      if (!importComponentInstance) {
+        throw new Error(
+          `Unexpectedly unable to find a component instance for route ${route.route}`
+        );
+      }
+      return await importComponentInstance();
+    } else if (manifest.pageModule) {
+      return manifest.pageModule;
+    }
+    throw new Error(
+      "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+    );
+  }
+}
+async function getComponentByRoute(manifest, routeData) {
+  try {
+    const module2 = await getModuleForRoute(manifest, routeData);
+    return module2.page();
+  } catch {
+  }
+  const url = new URL(routeData.component, manifest.rootDir);
+  const module = await import(
+    /* @vite-ignore */
+    url.toString()
+  );
+  return module;
+}
+function createNonRunnableEnvironment() {
+  return {
+    name: "dev-nonrunnable",
+    runtimeMode: "development",
+    // Dev always streams.
+    defaultStreaming: () => true,
+    async resolve(_manifest, specifier) {
+      if (specifier.startsWith("/")) {
+        return specifier;
+      } else {
+        return "/@id/" + specifier;
+      }
+    },
+    async headElements(manifest, routeData) {
+      const { componentMetadataEntries } = await import("virtual:astro:component-metadata");
+      for (const [id, entry] of componentMetadataEntries) {
+        manifest.componentMetadata.set(id, entry);
+      }
+      const { assetsPrefix, base } = manifest;
+      const routeInfo = manifest.routes.find((route) => route.routeData === routeData);
+      const links = /* @__PURE__ */ new Set();
+      const scripts = /* @__PURE__ */ new Set();
+      const styles = createStylesheetElementSet(routeInfo?.styles ?? [], base, assetsPrefix);
+      for (const script of routeInfo?.scripts ?? []) {
+        if ("stage" in script) {
+          if (script.stage === "head-inline") {
+            scripts.add({
+              props: {},
+              children: script.children
+            });
+          }
+        } else {
+          scripts.add(createModuleScriptElement(script));
+        }
+      }
+      scripts.add({
+        props: { type: "module", src: "/@vite/client" },
+        children: ""
+      });
+      if (manifest.devToolbar.enabled) {
+        scripts.add({
+          props: {
+            type: "module",
+            src: "/@id/astro/runtime/client/dev-toolbar/entrypoint.js"
+          },
+          children: ""
+        });
+        const additionalMetadata = {
+          root: manifest.rootDir.toString(),
+          version: ASTRO_VERSION,
+          latestAstroVersion: manifest.devToolbar.latestAstroVersion,
+          debugInfo: manifest.devToolbar.debugInfoOutput ?? "",
+          placement: manifest.devToolbar.placement
+        };
+        const children = `window.__astro_dev_toolbar__ = ${stringifyForScript(additionalMetadata)}`;
+        scripts.add({ props: {}, 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 {
+        getLogger(manifest).warn(
+          "assets",
+          `Unable to find CSS for ${routeData.component}. This is likely a bug in Astro.`
+        );
+      }
+      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() {
+    },
+    getComponentByRoute,
+    getModuleForRoute,
+    async tryRewrite(manifest, payload, request) {
+      const { newUrl, pathname, routeData } = findRouteToRewrite({
+        payload,
+        request,
+        // The single fresh route table: HMR route updates are visible
+        // to rewrites at the same instant as every other consumer.
+        routes: getRouteTable(manifest).routes,
+        trailingSlash: manifest.trailingSlash,
+        buildFormat: manifest.buildFormat,
+        base: manifest.base,
+        outDir: manifest.serverLike ? manifest.buildClientDir : manifest.outDir
+      });
+      const componentInstance = await getComponentByRoute(manifest, routeData);
+      return { newUrl, pathname, componentInstance, routeData };
+    },
+    getRenderers(manifest) {
+      return manifest.renderers;
+    },
+    errorStrategy: "dev",
+    injectCspMetaTagsOnErrorPages: false,
+    logRequest(manifest, payload) {
+      const { pathname, method, statusCode, isRewrite, timeStart } = payload;
+      if (pathname === "/favicon.ico") {
+        return;
+      }
+      const reqTime = performance.now() - timeStart;
+      getLogger(manifest).info(
+        null,
+        req({
+          url: pathname,
+          method,
+          statusCode,
+          isRewrite,
+          reqTime
+        })
+      );
+    }
+  };
+}
+export {
+  createNonRunnableEnvironment
+};

package/dist/core/environment/index.d.ts

@@ -0,0 +1,90 @@
+import type { ComponentInstance } from '../../types/astro.js';
+import type { RewritePayload } from '../../types/public/common.js';
+import type { RuntimeMode } from '../../types/public/config.js';
+import type { RouteData, SSRLoadedRenderer, SSRManifest, SSRResult } from '../../types/public/internal.js';
+import type { LogRequestPayload } from '../app/base.js';
+import type { SinglePageBuiltModule } from '../build/types.js';
+/**
+ * The scripts, styles and links a rendering environment injects into a page's
+ * head for a given route. (Rehomed here from the deleted Pipeline base class.)
+ */
+export interface HeadElements extends Pick<SSRResult, 'scripts' | 'styles' | 'links'> {
+}
+/**
+ * The result of a successful `tryRewrite` environment call.
+ * (Rehomed here from the deleted Pipeline base class.)
+ */
+export interface TryRewriteResult {
+    routeData: RouteData;
+    componentInstance: ComponentInstance;
+    newUrl: URL;
+    pathname: string;
+}
+/**
+ * The payload chain sites pass to request logging (`logRequestFromState`).
+ * `reqTime` is computed by the receiver (facade `logThisRequest` or the env
+ * record) from `timeStart`.
+ */
+export type RequestLogPayload = Omit<LogRequestPayload, 'reqTime'> & {
+    timeStart: number;
+};
+/**
+ * The behavior that varies between rendering environments (production SSR,
+ * the two dev paths, build/prerender, the container), expressed as a plain
+ * record of functions and flags instead of a class hierarchy. Environments
+ * register their record for a manifest with `setEnvironment`; readers use
+ * `getEnvironment`, which falls back to the production record.
+ *
+ * When adding a member:
+ * - Only behavior that genuinely differs between environments belongs here
+ *   (e.g. request logging: production is silent, dev prints request lines).
+ *   If the build can emit it as data or a module thunk, put it on the
+ *   manifest instead; only behavior needing live services goes here.
+ * - The record is stateless and shared. Mutable per-app state belongs in a
+ *   manifest-keyed memo in the module that owns it, not here.
+ * - Members must not capture an App instance. Environment-private services
+ *   captured at setup time (the dev ModuleLoader, BuildInternals) are fine —
+ *   request handling can't reach them.
+ * - Behavior tied to one App instance — a public method a user may override
+ *   on their app — cannot live here, because the record is shared by every
+ *   app in the environment. The facade forwards that per request, via the
+ *   hooks it passes to the FetchState constructor.
+ */
+export interface RenderEnvironment {
+    /** Debug label. */
+    readonly name: string;
+    readonly runtimeMode: RuntimeMode;
+    /** Default streaming when the facade hooks don't specify a flag. */
+    defaultStreaming(manifest: SSRManifest): boolean;
+    resolve(manifest: SSRManifest, specifier: string): Promise<string>;
+    headElements(manifest: SSRManifest, routeData: RouteData): Promise<HeadElements> | HeadElements;
+    componentMetadata(manifest: SSRManifest, routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
+    getComponentByRoute(manifest: SSRManifest, routeData: RouteData): Promise<ComponentInstance>;
+    getModuleForRoute(manifest: SSRManifest, route: RouteData): Promise<SinglePageBuiltModule>;
+    tryRewrite(manifest: SSRManifest, payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
+    /** Renderers for `createResult`. Sync — render sites read it without awaiting. */
+    getRenderers(manifest: SSRManifest): SSRLoadedRenderer[];
+    /** Which error-page strategy `renderErrorPage` dispatches to. */
+    readonly errorStrategy: 'default' | 'dev' | 'build';
+    /** Dev-only CSP meta-tag injection flag for error pages. */
+    readonly injectCspMetaTagsOnErrorPages: boolean;
+    /**
+     * Request logging as environment behavior: prod/build/container are
+     * no-ops; both dev environments emit the request lines. This is the
+     * fallback for states not built by a facade; the facade fast path's
+     * `hooks.logRequest` takes precedence so subclass overrides keep working.
+     * Computes `reqTime` from `payload.timeStart`.
+     */
+    logRequest(manifest: SSRManifest, payload: RequestLogPayload): void;
+}
+/**
+ * Registers the environment for a manifest. Idempotent; last registration wins
+ * (build may re-register after internals/options injection if it prefers).
+ */
+export declare function setEnvironment(manifest: SSRManifest, env: RenderEnvironment): void;
+/**
+ * The environment for a manifest. Defaults to the production (bundled)
+ * implementation, which is derivable from the manifest alone — so a bare
+ * `new FetchState(request)` in a bundled worker needs no registration.
+ */
+export declare function getEnvironment(manifest: SSRManifest): RenderEnvironment;

package/dist/core/environment/index.js

@@ -0,0 +1,12 @@
+import { productionEnvironment } from "./production.js";
+const environments = /* @__PURE__ */ new WeakMap();
+function setEnvironment(manifest, env) {
+  environments.set(manifest, env);
+}
+function getEnvironment(manifest) {
+  return environments.get(manifest) ?? productionEnvironment;
+}
+export {
+  getEnvironment,
+  setEnvironment
+};

package/dist/core/environment/production.d.ts

@@ -0,0 +1,6 @@
+import type { RenderEnvironment } from './index.js';
+/**
+ * The production / bundled environment — the default when nothing is
+ * registered. A stateless module constant derived from the manifest alone.
+ */
+export declare const productionEnvironment: RenderEnvironment;

package/dist/core/environment/production.js

@@ -0,0 +1,117 @@
+import { RedirectSinglePageBuiltModule } from "../redirects/index.js";
+import {
+  createAssetLink,
+  createModuleScriptElement,
+  createStylesheetElementSet
+} from "../render/ssr-element.js";
+import { getDefaultRoutes } from "../routing/default.js";
+import { getFallbackRoute, routeIsFallback, routeIsRedirect } from "../routing/helpers.js";
+import { findRouteToRewrite } from "../routing/rewrite.js";
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  let routeToProcess = route;
+  if (routeIsRedirect(route)) {
+    if (route.redirectRoute) {
+      routeToProcess = route.redirectRoute;
+    } else {
+      return RedirectSinglePageBuiltModule;
+    }
+  } else if (routeIsFallback(route)) {
+    routeToProcess = getFallbackRoute(route, manifest.routes);
+  }
+  if (manifest.pageMap) {
+    const importComponentInstance = manifest.pageMap.get(routeToProcess.component);
+    if (!importComponentInstance) {
+      throw new Error(`Unexpectedly unable to find a component instance for route ${route.route}`);
+    }
+    return await importComponentInstance();
+  } else if (manifest.pageModule) {
+    return manifest.pageModule;
+  }
+  throw new Error(
+    "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+  );
+}
+async function getComponentByRoute(manifest, routeData) {
+  const module = await getModuleForRoute(manifest, routeData);
+  return module.page();
+}
+const productionEnvironment = {
+  name: "production",
+  runtimeMode: "production",
+  defaultStreaming: () => true,
+  async resolve(manifest, specifier) {
+    if (!(specifier in manifest.entryModules)) {
+      throw new Error(`Unable to resolve [${specifier}]`);
+    }
+    const bundlePath = manifest.entryModules[specifier];
+    if (bundlePath.startsWith("data:") || bundlePath.length === 0) {
+      return bundlePath;
+    } else {
+      return createAssetLink(bundlePath, manifest.base, manifest.assetsPrefix);
+    }
+  },
+  async headElements(manifest, routeData) {
+    const { assetsPrefix, base } = manifest;
+    const routeInfo = manifest.routes.find((route) => route.routeData.route === routeData.route);
+    const links = /* @__PURE__ */ new Set();
+    const scripts = /* @__PURE__ */ new Set();
+    const styles = createStylesheetElementSet(routeInfo?.styles ?? [], base, assetsPrefix);
+    for (const script of routeInfo?.scripts ?? []) {
+      if ("stage" in script) {
+        if (script.stage === "head-inline") {
+          scripts.add({
+            props: {},
+            children: script.children
+          });
+        }
+      } else {
+        scripts.add(createModuleScriptElement(script, base, assetsPrefix));
+      }
+    }
+    return { links, styles, scripts };
+  },
+  // The manifest's componentMetadata fallback stays in `createResult`.
+  componentMetadata() {
+  },
+  getComponentByRoute,
+  getModuleForRoute,
+  async tryRewrite(manifest, payload, request) {
+    const { newUrl, pathname, routeData } = findRouteToRewrite({
+      payload,
+      request,
+      // RAW manifest routes, NOT the derived route table: production
+      // manifests deliberately do not carry
+      // the default 404 route (`createRoutesList` ensures it in dev only),
+      // and `findRouteToRewrite` gives an existing `/404` list entry
+      // precedence over dynamic routes that also match the path — so the
+      // ensured table would let the synthetic default-404 entry shadow a
+      // catch-all route on an explicit rewrite to `/404`. The no-match
+      // fallback already returns `DEFAULT_404_ROUTE`, so the raw list loses
+      // nothing.
+      routes: manifest.routes.map((r) => r.routeData),
+      trailingSlash: manifest.trailingSlash,
+      buildFormat: manifest.buildFormat,
+      base: manifest.base,
+      outDir: manifest.serverLike ? manifest.buildClientDir : manifest.outDir
+    });
+    const componentInstance = await getComponentByRoute(manifest, routeData);
+    return { newUrl, pathname, componentInstance, routeData };
+  },
+  getRenderers(manifest) {
+    return manifest.renderers;
+  },
+  errorStrategy: "default",
+  injectCspMetaTagsOnErrorPages: false,
+  logRequest() {
+  }
+};
+export {
+  productionEnvironment
+};

package/dist/core/errors/build-handler.d.ts

@@ -1,17 +1,12 @@
-import type { BaseApp, RenderErrorOptions } from '../app/base.js';
-import type { Pipeline } from '../base-pipeline.js';
-import type { ErrorHandler } from './handler.js';
+import type { RenderErrorOptions } from '../app/base.js';
+import type { SSRManifest } from '../app/types.js';
 /**
- * The error handler used during static build / prerendering.
+ * The error strategy used during static build / prerendering.
  *
  * - For 500 errors, returns the original response if present, otherwise
  *   throws so the build surfaces the underlying error to the developer.
- * - For other errors (e.g. 404), delegates to `DefaultErrorHandler` with
+ * - For other errors (e.g. 404), delegates to `renderDefaultError` with
  *   `prerenderedErrorPageFetch` cleared (the build pipeline can't fetch
  *   prerendered pages the way production SSR can).
  */
-export declare class BuildErrorHandler implements ErrorHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>);
-    renderError(request: Request, options: RenderErrorOptions): Promise<Response>;
-}
+export declare function renderBuildError(manifest: SSRManifest, request: Request, options: RenderErrorOptions): Promise<Response>;

package/dist/core/errors/build-handler.js

@@ -1,22 +1,16 @@
-import { DefaultErrorHandler } from "./default-handler.js";
-class BuildErrorHandler {
-  #default;
-  constructor(app) {
-    this.#default = new DefaultErrorHandler(app);
-  }
-  async renderError(request, options) {
-    if (options.status === 500) {
-      if (options.response) {
-        return options.response;
-      }
-      throw options.error;
+import { renderDefaultError } from "./default-handler.js";
+async function renderBuildError(manifest, request, options) {
+  if (options.status === 500) {
+    if (options.response) {
+      return options.response;
     }
-    return this.#default.renderError(request, {
-      ...options,
-      prerenderedErrorPageFetch: void 0
-    });
+    throw options.error;
   }
+  return renderDefaultError(manifest, request, {
+    ...options,
+    prerenderedErrorPageFetch: void 0
+  });
 }
 export {
-  BuildErrorHandler
+  renderBuildError
 };

package/dist/core/errors/default-handler.d.ts

@@ -1,14 +1,9 @@
-import type { BaseApp, RenderErrorOptions } from '../app/base.js';
-import type { Pipeline } from '../base-pipeline.js';
-import { type ErrorHandler } from './handler.js';
+import type { RenderErrorOptions } from '../app/base.js';
+import type { SSRManifest } from '../app/types.js';
 /**
- * The default error handler used in production SSR. Attempts to render the
+ * The default error strategy used in production SSR. Attempts to render the
  * matching error route (404.astro / 500.astro), falling back to a plain
  * response with the given status. Handles prerendered error pages via
  * `prerenderedErrorPageFetch`.
  */
-export declare class DefaultErrorHandler implements ErrorHandler {
-    #private;
-    constructor(app: BaseApp<Pipeline>);
-    renderError(request: Request, { status, response: originalResponse, skipMiddleware, error, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;
-}
+export declare function renderDefaultError(manifest: SSRManifest, request: Request, { status, response: originalResponse, skipMiddleware, error, pathname, ...resolvedRenderOptions }: RenderErrorOptions): Promise<Response>;