astro 7.2.2 → 7.2.3

package/dist/core/i18n/handler.js

@@ -1,116 +1,116 @@
 import { appendForwardSlash } from "@astrojs/internal-helpers/path";
 import { computeFallbackRoute } from "../../i18n/fallback.js";
 import { I18nRouter } from "../../i18n/router.js";
-import { PipelineFeatures } from "../base-pipeline.js";
+import { markFeatureUsed, FetchFeatures } from "../fetch/features.js";
 import { shouldAppendForwardSlash } from "../build/util.js";
-class I18n {
-  #i18n;
-  #base;
-  #trailingSlash;
-  #format;
-  #router;
-  constructor(i18n, base, trailingSlash, format) {
-    this.#i18n = i18n;
-    this.#base = base;
-    this.#trailingSlash = trailingSlash;
-    this.#format = format;
-    this.#router = new I18nRouter({
-      strategy: i18n.strategy,
-      defaultLocale: i18n.defaultLocale,
-      locales: i18n.locales,
-      base,
-      domains: i18n.domainLookupTable ? Object.keys(i18n.domainLookupTable).reduce(
-        (acc, domain) => {
-          const locale = i18n.domainLookupTable[domain];
-          if (!acc[domain]) {
-            acc[domain] = [];
-          }
-          acc[domain].push(locale);
-          return acc;
-        },
-        {}
-      ) : void 0
-    });
+import { createManifestMemo } from "../manifest/memo.js";
+function compileI18n(i18n, base, trailingSlash, format) {
+  const router = new I18nRouter({
+    strategy: i18n.strategy,
+    defaultLocale: i18n.defaultLocale,
+    locales: i18n.locales,
+    base,
+    domains: i18n.domainLookupTable ? Object.keys(i18n.domainLookupTable).reduce(
+      (acc, domain) => {
+        const locale = i18n.domainLookupTable[domain];
+        if (!acc[domain]) {
+          acc[domain] = [];
+        }
+        acc[domain].push(locale);
+        return acc;
+      },
+      {}
+    ) : void 0
+  });
+  return { config: i18n, base, trailingSlash, format, router };
+}
+const i18nMemo = createManifestMemo((manifest) => {
+  const config = manifest.i18n;
+  return config && config.strategy !== "manual" ? compileI18n(config, manifest.base, manifest.trailingSlash, manifest.buildFormat) : null;
+});
+function getI18n(manifest) {
+  return i18nMemo.get(manifest);
+}
+async function finalizeI18n(compiled, state, response) {
+  markFeatureUsed(state.manifest, FetchFeatures.i18n);
+  const i18n = compiled.config;
+  if (state.skipErrorReroute && typeof i18n.fallback === "undefined") {
+    return response;
   }
-  async finalize(state, response) {
-    state.pipeline.usedFeatures |= PipelineFeatures.i18n;
-    const i18n = this.#i18n;
-    if (state.skipErrorReroute && typeof i18n.fallback === "undefined") {
-      return response;
-    }
-    if (state.responseRouteType !== "page" && state.responseRouteType !== "fallback") {
-      return response;
+  if (state.responseRouteType !== "page" && state.responseRouteType !== "fallback") {
+    return response;
+  }
+  const url = state.url;
+  const currentLocale = state.computeCurrentLocale();
+  const isPrerendered = state.routeData.prerender;
+  const routerContext = {
+    currentLocale,
+    currentDomain: url.hostname,
+    routeType: state.responseRouteType,
+    isReroute: false
+  };
+  const routeDecision = compiled.router.match(url.pathname, routerContext);
+  switch (routeDecision.type) {
+    case "redirect": {
+      let location = routeDecision.location;
+      if (shouldAppendForwardSlash(compiled.trailingSlash, compiled.format)) {
+        location = appendForwardSlash(location);
+      }
+      return new Response(null, {
+        status: routeDecision.status ?? 302,
+        headers: { Location: location }
+      });
     }
-    const url = state.url;
-    const currentLocale = state.computeCurrentLocale();
-    const isPrerendered = state.routeData.prerender;
-    const routerContext = {
-      currentLocale,
-      currentDomain: url.hostname,
-      routeType: state.responseRouteType,
-      isReroute: false
-    };
-    const routeDecision = this.#router.match(url.pathname, routerContext);
-    switch (routeDecision.type) {
-      case "redirect": {
-        let location = routeDecision.location;
-        if (shouldAppendForwardSlash(this.#trailingSlash, this.#format)) {
-          location = appendForwardSlash(location);
-        }
-        return new Response(null, {
-          status: routeDecision.status ?? 302,
-          headers: { Location: location }
+    case "notFound": {
+      if (isPrerendered) {
+        const prerenderedRes = new Response(response.body, {
+          status: 404,
+          headers: response.headers
         });
-      }
-      case "notFound": {
-        if (isPrerendered) {
-          const prerenderedRes = new Response(response.body, {
-            status: 404,
-            headers: response.headers
-          });
-          state.skipErrorReroute = true;
-          if (routeDecision.location) {
-            prerenderedRes.headers.set("Location", routeDecision.location);
-          }
-          return prerenderedRes;
-        }
-        const headers = new Headers();
+        state.skipErrorReroute = true;
         if (routeDecision.location) {
-          headers.set("Location", routeDecision.location);
+          prerenderedRes.headers.set("Location", routeDecision.location);
         }
-        return new Response(null, { status: 404, headers });
+        return prerenderedRes;
       }
-      case "continue":
-        break;
-    }
-    if (i18n.fallback && i18n.fallbackType) {
-      const effectiveStatus = state.responseRouteType === "fallback" ? 404 : response.status;
-      const fallbackDecision = computeFallbackRoute({
-        pathname: url.pathname,
-        responseStatus: effectiveStatus,
-        currentLocale,
-        fallback: i18n.fallback,
-        fallbackType: i18n.fallbackType,
-        locales: i18n.locales,
-        defaultLocale: i18n.defaultLocale,
-        strategy: i18n.strategy,
-        base: this.#base
-      });
-      switch (fallbackDecision.type) {
-        case "redirect":
-          return new Response(null, {
-            status: 302,
-            headers: { Location: fallbackDecision.pathname + url.search }
-          });
-        case "rewrite":
-          return await state.rewrite(fallbackDecision.pathname + url.search);
-        case "none":
-          break;
+      const headers = new Headers();
+      if (routeDecision.location) {
+        headers.set("Location", routeDecision.location);
       }
+      return new Response(null, { status: 404, headers });
+    }
+    case "continue":
+      break;
+  }
+  if (i18n.fallback && i18n.fallbackType) {
+    const effectiveStatus = state.responseRouteType === "fallback" ? 404 : response.status;
+    const fallbackDecision = computeFallbackRoute({
+      pathname: url.pathname,
+      responseStatus: effectiveStatus,
+      currentLocale,
+      fallback: i18n.fallback,
+      fallbackType: i18n.fallbackType,
+      locales: i18n.locales,
+      defaultLocale: i18n.defaultLocale,
+      strategy: i18n.strategy,
+      base: compiled.base
+    });
+    switch (fallbackDecision.type) {
+      case "redirect":
+        return new Response(null, {
+          status: 302,
+          headers: { Location: fallbackDecision.pathname + url.search }
+        });
+      case "rewrite":
+        return await state.rewrite(fallbackDecision.pathname + url.search);
+      case "none":
+        break;
     }
-    return response;
   }
+  return response;
 }
 export {
-  I18n
+  compileI18n,
+  finalizeI18n,
+  getI18n
 };

package/dist/core/logger/manifest-logger.d.ts

@@ -0,0 +1,31 @@
+import type { SSRManifest } from '../app/types.js';
+import type { AstroLogger } from './core.js';
+/**
+ * One identity-stable logger per manifest. Created on first access as a
+ * console logger at `manifest.logLevel`.
+ *
+ * The instance is never replaced: `getResolvedLogger` swaps the
+ * destination in place via `AstroLogger.setDestination`, so every holder
+ * (state-captured logger, adapterLogger's retained options) writes to the
+ * new destination immediately.
+ */
+export declare function getLogger(manifest: SSRManifest): AstroLogger;
+/**
+ * Composition-time injection (dev server logger, DevApp console logger, an
+ * App facade constructed with a custom logger path, tests). Must be called
+ * before the first `getLogger()` read to take effect deterministically;
+ * replaces the stored instance either way.
+ */
+export declare function setLogger(manifest: SSRManifest, logger: AstroLogger): void;
+/**
+ * The manifest's logger with the user-configured destination (the
+ * `manifest.logger` thunk) resolved and applied via `setDestination` on the
+ * identity-stable logger. Memoized single-flight; awaited at request entry.
+ *
+ * Never rejects: a destination that fails to load is reported through the
+ * unswapped (console) logger, which stays in place — a broken custom
+ * destination cannot fail a request. Because the derivation always resolves,
+ * the memo's delete-on-rejection retry path never triggers: the thunk runs
+ * at most once per manifest.
+ */
+export declare function getResolvedLogger(manifest: SSRManifest): Promise<AstroLogger>;

package/dist/core/logger/manifest-logger.js

@@ -0,0 +1,37 @@
+import { createAsyncManifestMemo } from "../manifest/memo.js";
+import { createConsoleLogger } from "./impls/console.js";
+const loggers = /* @__PURE__ */ new WeakMap();
+function getLogger(manifest) {
+  let logger = loggers.get(manifest);
+  if (!logger) {
+    logger = createConsoleLogger({ level: manifest.logLevel });
+    loggers.set(manifest, logger);
+  }
+  return logger;
+}
+function setLogger(manifest, logger) {
+  loggers.set(manifest, logger);
+}
+const resolvedLogger = createAsyncManifestMemo(async (manifest) => {
+  const logger = getLogger(manifest);
+  try {
+    const destination = (await manifest.logger?.())?.default;
+    if (destination) {
+      logger.setDestination(destination);
+    }
+  } catch (error) {
+    logger.error(
+      "config",
+      "Failed to load the configured logger destination; continuing with the console logger.\n" + (error instanceof Error ? error.stack ?? error.message : String(error))
+    );
+  }
+  return logger;
+});
+function getResolvedLogger(manifest) {
+  return resolvedLogger.get(manifest);
+}
+export {
+  getLogger,
+  getResolvedLogger,
+  setLogger
+};

package/dist/core/manifest/ambient-source.d.ts

@@ -0,0 +1,2 @@
+import type { SSRManifest } from '../app/types.js';
+export declare const manifest: SSRManifest | undefined;

package/dist/core/manifest/ambient-source.js

@@ -0,0 +1,4 @@
+const manifest = void 0;
+export {
+  manifest
+};

package/dist/core/manifest/ambient.d.ts

@@ -0,0 +1,16 @@
+import type { SSRManifest } from '../app/types.js';
+/**
+ * Registers a manifest for environments where `virtual:astro:manifest` cannot
+ * resolve (plain Node: unit tests, embedders). Internal API — deliberately not
+ * exported from any public entrypoint.
+ * Pass `undefined` to clear (test teardown).
+ */
+export declare function setAmbientManifest(manifest: SSRManifest | undefined): void;
+/**
+ * The ambient manifest: the explicitly registered one, else the virtual
+ * module's. Throws lazily when neither is available, so merely importing a
+ * module that uses this never fails — only actually handling a request does.
+ */
+export declare function getAmbientManifest(): SSRManifest;
+/** The ambient manifest if one is available, else `undefined`. Never throws. */
+export declare function tryGetAmbientManifest(): SSRManifest | undefined;

package/dist/core/manifest/ambient.js

@@ -0,0 +1,22 @@
+import { NoManifestAvailable } from "../errors/errors-data.js";
+import { AstroError } from "../errors/index.js";
+import { manifest as viteManifest } from "#astro-internal/ambient-manifest";
+let registered;
+function setAmbientManifest(manifest) {
+  registered = manifest;
+}
+function getAmbientManifest() {
+  const manifest = registered ?? viteManifest;
+  if (!manifest) {
+    throw new AstroError(NoManifestAvailable);
+  }
+  return manifest;
+}
+function tryGetAmbientManifest() {
+  return registered ?? viteManifest;
+}
+export {
+  getAmbientManifest,
+  setAmbientManifest,
+  tryGetAmbientManifest
+};

package/dist/core/manifest/derived.d.ts

@@ -0,0 +1,3 @@
+import type { SSRManifest } from '../app/types.js';
+/** The manifest's `site` as a `URL` (used for `Astro.site`). */
+export declare function getSite(manifest: SSRManifest): URL | undefined;

package/dist/core/manifest/derived.js

@@ -0,0 +1,10 @@
+import { createManifestMemo } from "./memo.js";
+const sites = createManifestMemo(
+  (manifest) => manifest.site ? new URL(manifest.site) : void 0
+);
+function getSite(manifest) {
+  return sites.get(manifest);
+}
+export {
+  getSite
+};

package/dist/core/manifest/memo.d.ts

@@ -0,0 +1,31 @@
+import type { SSRManifest } from '../app/types.js';
+/**
+ * Shared helpers for "derived once per process per manifest" memoization.
+ * Manifest-keyed WeakMaps are the sanctioned memoization primitive of the
+ * request core: each derivation lives in its owning module with its own memo —
+ * there is deliberately no central registry and no "get all derived state"
+ * function anywhere.
+ *
+ * Note: values are scoped per manifest OBJECT. Two `App`s constructed over the
+ * same manifest object (e.g. the cloudflare custom-fetch worker) share every
+ * memoized derivation.
+ */
+export interface ManifestMemo<T> {
+    get(manifest: SSRManifest): T;
+    /** Whether a value is currently stored for the manifest (derived or set). */
+    has(manifest: SSRManifest): boolean;
+    /** Replaces the stored value atomically (HMR replacement). */
+    set(manifest: SSRManifest, value: T): void;
+    invalidate(manifest: SSRManifest): void;
+}
+export declare function createManifestMemo<T>(derive: (manifest: SSRManifest) => T): ManifestMemo<T>;
+export interface AsyncManifestMemo<T> {
+    get(manifest: SSRManifest): Promise<T>;
+    invalidate(manifest: SSRManifest): void;
+}
+/**
+ * Caches the PROMISE (single-flight: concurrent callers share one derivation).
+ * On rejection the entry is DELETED so the next call retries a failed lazy
+ * resolve instead of caching the failure forever.
+ */
+export declare function createAsyncManifestMemo<T>(derive: (manifest: SSRManifest) => Promise<T>): AsyncManifestMemo<T>;

package/dist/core/manifest/memo.js

@@ -0,0 +1,47 @@
+function createManifestMemo(derive) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return {
+    get(manifest) {
+      if (cache.has(manifest)) {
+        return cache.get(manifest);
+      }
+      const value = derive(manifest);
+      cache.set(manifest, value);
+      return value;
+    },
+    has(manifest) {
+      return cache.has(manifest);
+    },
+    set(manifest, value) {
+      cache.set(manifest, value);
+    },
+    invalidate(manifest) {
+      cache.delete(manifest);
+    }
+  };
+}
+function createAsyncManifestMemo(derive) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return {
+    get(manifest) {
+      let promise = cache.get(manifest);
+      if (!promise) {
+        promise = derive(manifest);
+        cache.set(manifest, promise);
+        promise.catch(() => {
+          if (cache.get(manifest) === promise) {
+            cache.delete(manifest);
+          }
+        });
+      }
+      return promise;
+    },
+    invalidate(manifest) {
+      cache.delete(manifest);
+    }
+  };
+}
+export {
+  createAsyncManifestMemo,
+  createManifestMemo
+};

package/dist/core/messages/runtime.js

@@ -270,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.2.2"}`
+        `v${"7.2.3"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/astro-middleware.d.ts

@@ -1,46 +1,36 @@
 import type { FetchState } from '../fetch/fetch-state.js';
 import type { APIContext } from '../../types/public/context.js';
-import type { BaseApp } from '../app/base.js';
-import { type Pipeline } from '../base-pipeline.js';
 /**
  * Callback invoked at the bottom of the middleware chain to dispatch the
  * request to the matched route (endpoint / redirect / page / fallback).
  *
- * Callers of `AstroMiddleware.handle` pass their owned `PagesHandler`'s
- * `handle` method (bound) so route dispatch logic stays out of the
- * middleware layer.
+ * Callers of `handleMiddleware` pass `handlePages` (or a wrapper around it)
+ * so route dispatch logic stays out of the middleware layer.
  */
 export type RenderRouteCallback = (state: FetchState, ctx: APIContext) => Promise<Response>;
 /**
- * Handles the execution of Astro's middleware chain (internal + user) for a
- * single render. Holds a reference to the `Pipeline` and composes the
- * internal and user middleware at render time.
+ * Runs Astro's middleware chain (origin check + user `onRequest`) for a
+ * single render, reading the composed middleware from the manifest and
+ * per-request data (componentInstance, slots, props, API contexts) off the
+ * supplied `FetchState`. The actual route dispatch (endpoint / redirect /
+ * page / fallback) is supplied by the caller as `renderRouteCallback` —
+ * typically `handlePages`.
+ */
+export declare function handleMiddleware(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
+/**
+ * Like `handleMiddleware`, but mirrors the app-level error handling that
+ * `handleRequest` provides on the standard path, the same way
+ * `handlePagesWithErrorFallback` does for `pages()`. When no route matched
+ * it returns a 404 marked with `X-Astro-Error` for the app's post-check;
+ * when Astro's own middleware chain throws it logs the error and renders
+ * the custom `500.astro`.
+ *
+ * Errors surfaced through `renderRouteCallback` (the host framework's
+ * `next`, e.g. host middleware mounted below `middleware()`) are re-thrown
+ * instead, so the host's own error handling still runs rather than being
+ * swallowed into Astro's 500 page. A sentinel tells the two apart.
  *
- * Reads per-request data (componentInstance, slots, props, API contexts)
- * off the supplied `FetchState`. The actual route dispatch (endpoint /
- * redirect / page / fallback) is supplied by the caller as
- * `renderRouteCallback` — typically bound to a `PagesHandler.handle`.
+ * Used by the composable `astro/fetch` `middleware()` entry point, where
+ * there is no surrounding `handleRequest` to supply this fallback.
  */
-export declare class AstroMiddleware {
-    #private;
-    constructor(pipeline: Pipeline);
-    handle(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
-    /**
-     * Like `handle`, but mirrors the app-level error handling that
-     * `AstroHandler` provides on the standard path, the same way
-     * `PagesHandler.handleWithErrorFallback` does for `pages()`. When no
-     * route matched it returns a 404 marked with `X-Astro-Error` for the
-     * app's post-check; when Astro's own middleware chain throws it logs the
-     * error and renders the custom `500.astro`.
-     *
-     * Errors surfaced through `renderRouteCallback` (the host framework's
-     * `next`, e.g. host middleware mounted below `middleware()`) are
-     * re-thrown instead, so the host's own error handling still runs rather
-     * than being swallowed into Astro's 500 page. A sentinel tells the two
-     * apart.
-     *
-     * Used by the composable `astro/fetch` `middleware()` entry point, where
-     * there is no surrounding `AstroHandler` to supply this fallback.
-     */
-    handleWithErrorFallback(app: BaseApp<Pipeline>, state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;
-}
+export declare function handleMiddlewareWithErrorFallback(state: FetchState, renderRouteCallback: RenderRouteCallback): Promise<Response>;