astro 4.4.0 → 4.4.1

package/dist/core/render-context.js

@@ -0,0 +1,219 @@
+import { renderEndpoint } from "../runtime/server/endpoint.js";
+import { attachCookiesToResponse } from "./cookies/index.js";
+import { callMiddleware } from "./middleware/callMiddleware.js";
+import { sequence } from "./middleware/index.js";
+import { AstroCookies } from "./cookies/index.js";
+import { createResult } from "./render/index.js";
+import { renderPage } from "../runtime/server/index.js";
+import {
+  ASTRO_VERSION,
+  ROUTE_TYPE_HEADER,
+  clientAddressSymbol,
+  clientLocalsSymbol
+} from "./constants.js";
+import { getParams, getProps } from "./render/index.js";
+import { AstroError, AstroErrorData } from "./errors/index.js";
+import {
+  computeCurrentLocale,
+  computePreferredLocale,
+  computePreferredLocaleList
+} from "../i18n/utils.js";
+import { renderRedirect } from "./redirects/render.js";
+class RenderContext {
+  constructor(pipeline, locals, middleware, pathname, request, routeData, status, cookies = new AstroCookies(request), params = getParams(routeData, pathname)) {
+    this.pipeline = pipeline;
+    this.locals = locals;
+    this.middleware = middleware;
+    this.pathname = pathname;
+    this.request = request;
+    this.routeData = routeData;
+    this.status = status;
+    this.cookies = cookies;
+    this.params = params;
+  }
+  static create({
+    locals = {},
+    middleware,
+    pathname,
+    pipeline,
+    request,
+    routeData,
+    status = 200
+  }) {
+    return new RenderContext(
+      pipeline,
+      locals,
+      sequence(...pipeline.internalMiddleware, middleware ?? pipeline.middleware),
+      pathname,
+      request,
+      routeData,
+      status
+    );
+  }
+  /**
+   * The main function of the RenderContext.
+   *
+   * Use this function to render any route known to Astro.
+   * It attempts to render a route. A route can be a:
+   *
+   * - page
+   * - redirect
+   * - endpoint
+   * - fallback
+   */
+  async render(componentInstance) {
+    const { cookies, middleware, pathname, pipeline, routeData } = this;
+    const { logger, routeCache, serverLike, streaming } = pipeline;
+    const props = await getProps({
+      mod: componentInstance,
+      routeData,
+      routeCache,
+      pathname,
+      logger,
+      serverLike
+    });
+    const apiContext = this.createAPIContext(props);
+    const { type } = routeData;
+    const lastNext = type === "endpoint" ? () => renderEndpoint(componentInstance, apiContext, serverLike, logger) : type === "redirect" ? () => renderRedirect(this) : type === "page" ? async () => {
+      const result = await this.createResult(componentInstance);
+      const response2 = await renderPage(
+        result,
+        componentInstance?.default,
+        props,
+        {},
+        streaming,
+        routeData
+      );
+      response2.headers.set(ROUTE_TYPE_HEADER, "page");
+      return response2;
+    } : type === "fallback" ? () => new Response(null, { status: 500, headers: { [ROUTE_TYPE_HEADER]: "fallback" } }) : () => {
+      throw new Error("Unknown type of route: " + type);
+    };
+    const response = await callMiddleware(middleware, apiContext, lastNext);
+    if (response.headers.get(ROUTE_TYPE_HEADER)) {
+      response.headers.delete(ROUTE_TYPE_HEADER);
+    }
+    attachCookiesToResponse(response, cookies);
+    return response;
+  }
+  createAPIContext(props) {
+    const renderContext = this;
+    const { cookies, i18nData, params, pipeline, request } = this;
+    const { currentLocale, preferredLocale, preferredLocaleList } = i18nData;
+    const generator = `Astro v${ASTRO_VERSION}`;
+    const redirect = (path, status = 302) => new Response(null, { status, headers: { Location: path } });
+    const site = pipeline.site ? new URL(pipeline.site) : void 0;
+    const url = new URL(request.url);
+    return {
+      cookies,
+      currentLocale,
+      generator,
+      params,
+      preferredLocale,
+      preferredLocaleList,
+      props,
+      redirect,
+      request,
+      site,
+      url,
+      get clientAddress() {
+        if (clientAddressSymbol in request) {
+          return Reflect.get(request, clientAddressSymbol);
+        }
+        if (pipeline.adapterName) {
+          throw new AstroError({
+            ...AstroErrorData.ClientAddressNotAvailable,
+            message: AstroErrorData.ClientAddressNotAvailable.message(pipeline.adapterName)
+          });
+        } else {
+          throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
+        }
+      },
+      get locals() {
+        return renderContext.locals;
+      },
+      // TODO(breaking): disallow replacing the locals object
+      set locals(val) {
+        if (typeof val !== "object") {
+          throw new AstroError(AstroErrorData.LocalsNotAnObject);
+        } else {
+          renderContext.locals = val;
+          Reflect.set(request, clientLocalsSymbol, val);
+        }
+      }
+    };
+  }
+  async createResult(mod) {
+    const { cookies, locals, params, pathname, pipeline, request, routeData, status } = this;
+    const {
+      adapterName,
+      clientDirectives,
+      compressHTML,
+      i18n,
+      manifest,
+      logger,
+      renderers,
+      resolve,
+      site,
+      serverLike
+    } = pipeline;
+    const { links, scripts, styles } = await pipeline.headElements(routeData);
+    const componentMetadata = await pipeline.componentMetadata(routeData) ?? manifest.componentMetadata;
+    const { defaultLocale, locales, routing: routingStrategy } = i18n ?? {};
+    const partial = Boolean(mod.partial);
+    return createResult({
+      adapterName,
+      clientDirectives,
+      componentMetadata,
+      compressHTML,
+      cookies,
+      defaultLocale,
+      locales,
+      locals,
+      logger,
+      links,
+      params,
+      partial,
+      pathname,
+      renderers,
+      resolve,
+      request,
+      route: routeData.route,
+      routingStrategy,
+      site,
+      scripts,
+      ssr: serverLike,
+      status,
+      styles
+    });
+  }
+  /**
+   * API Context may be created multiple times per request, i18n data needs to be computed only once.
+   * So, it is computed and saved here on creation of the first APIContext and reused for later ones.
+   */
+  #i18nData;
+  get i18nData() {
+    if (this.#i18nData)
+      return this.#i18nData;
+    const {
+      pipeline: { i18n },
+      request,
+      routeData
+    } = this;
+    if (!i18n)
+      return {
+        currentLocale: void 0,
+        preferredLocale: void 0,
+        preferredLocaleList: void 0
+      };
+    const { defaultLocale, locales, routing } = i18n;
+    return this.#i18nData = {
+      currentLocale: computeCurrentLocale(routeData.route, locales, routing, defaultLocale),
+      preferredLocale: computePreferredLocale(request, locales),
+      preferredLocaleList: computePreferredLocaleList(request, locales)
+    };
+  }
+}
+export {
+  RenderContext
+};

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

@@ -1,5 +1,4 @@
 export { createRouteManifest } from './manifest/create.js';
 export { deserializeRouteData, serializeRouteData } from './manifest/serialization.js';
 export { matchAllRoutes, matchRoute } from './match.js';
-export { getParams } from './params.js';
 export { validateDynamicRouteModule, validateGetStaticPathsResult } from './validation.js';

package/dist/core/routing/index.js

@@ -1,12 +1,10 @@
 import { createRouteManifest } from "./manifest/create.js";
 import { deserializeRouteData, serializeRouteData } from "./manifest/serialization.js";
 import { matchAllRoutes, matchRoute } from "./match.js";
-import { getParams } from "./params.js";
 import { validateDynamicRouteModule, validateGetStaticPathsResult } from "./validation.js";
 export {
   createRouteManifest,
   deserializeRouteData,
-  getParams,
   matchAllRoutes,
   matchRoute,
   serializeRouteData,

package/dist/core/routing/params.d.ts

@@ -1,10 +1,4 @@
-import type { GetStaticPathsItem, Params, RouteData } from '../../@types/astro.js';
-/**
- * given an array of params like `['x', 'y', 'z']` for
- * src/routes/[x]/[y]/[z]/svelte, create a function
- * that turns a RegExpExecArray into ({ x, y, z })
- */
-export declare function getParams(array: string[]): (match: RegExpExecArray) => Params;
+import type { GetStaticPathsItem, RouteData } from '../../@types/astro.js';
 /**
  * given a route's Params object, validate parameter
  * values and create a stringified key for the route

package/dist/core/routing/params.js

@@ -1,19 +1,5 @@
 import { trimSlashes } from "../path.js";
 import { validateGetStaticPathsParameter } from "./validation.js";
-function getParams(array) {
-  const fn = (match) => {
-    const params = {};
-    array.forEach((key, i) => {
-      if (key.startsWith("...")) {
-        params[key.slice(3)] = match[i + 1] ? match[i + 1] : void 0;
-      } else {
-        params[key] = match[i + 1];
-      }
-    });
-    return params;
-  };
-  return fn;
-}
 function stringifyParams(params, route) {
   const validatedParams = Object.entries(params).reduce((acc, next) => {
     validateGetStaticPathsParameter(next, route.component);
@@ -26,6 +12,5 @@ function stringifyParams(params, route) {
   return JSON.stringify(route.generate(validatedParams));
 }
 export {
-  getParams,
   stringifyParams
 };

package/dist/core/sync/index.js

@@ -53,12 +53,12 @@ async function syncInternal(settings, { logger, fs }) {
       { settings, logger, mode: "build", command: "build", fs }
     )
   );
-  const wsSend = tempViteServer.ws.send;
-  tempViteServer.ws.send = (payload) => {
+  const hotSend = tempViteServer.hot.send;
+  tempViteServer.hot.send = (payload) => {
     if (payload.type === "error") {
       throw payload.err;
     }
-    return wsSend(payload);
+    return hotSend(payload);
   };
   try {
     const contentTypesGenerator = await createContentTypesGenerator({

package/dist/i18n/middleware.d.ts

@@ -1,7 +1,2 @@
 import type { MiddlewareHandler, SSRManifest } from '../@types/astro.js';
-import type { PipelineHookFunction } from '../core/pipeline.js';
 export declare function createI18nMiddleware(i18n: SSRManifest['i18n'], base: SSRManifest['base'], trailingSlash: SSRManifest['trailingSlash'], buildFormat: SSRManifest['buildFormat']): MiddlewareHandler;
-/**
- * This pipeline hook attaches a `RouteData` object to the `Request`
- */
-export declare const i18nPipelineHook: PipelineHookFunction;

package/dist/i18n/middleware.js

@@ -1,8 +1,7 @@
 import { appendForwardSlash, joinPaths } from "@astrojs/internal-helpers/path";
 import { getPathByLocale, normalizeTheLocale } from "./index.js";
 import { shouldAppendForwardSlash } from "../core/build/util.js";
-import { ROUTE_DATA_SYMBOL } from "../core/constants.js";
-const routeDataSymbol = Symbol.for(ROUTE_DATA_SYMBOL);
+import { ROUTE_TYPE_HEADER } from "../core/constants.js";
 function pathnameHasLocale(pathname, locales) {
   const segments = pathname.split("/");
   for (const segment of segments) {
@@ -65,99 +64,93 @@ function createI18nMiddleware(i18n, base, trailingSlash, buildFormat) {
     return void 0;
   };
   return async (context, next) => {
-    const routeData = Reflect.get(context.request, routeDataSymbol);
-    if (routeData?.type !== "page" && routeData?.type !== "fallback") {
-      return await next();
+    const response = await next();
+    const type = response.headers.get(ROUTE_TYPE_HEADER);
+    if (type !== "page" && type !== "fallback") {
+      return response;
     }
-    const currentLocale = context.currentLocale;
-    const url = context.url;
+    const { url, currentLocale } = context;
     const { locales, defaultLocale, fallback, routing } = i18n;
-    const response = await next();
-    if (response instanceof Response) {
-      switch (i18n.routing) {
-        case "domains-prefix-other-locales": {
-          if (localeHasntDomain(i18n, currentLocale)) {
-            const result = prefixOtherLocales(url, response);
-            if (result) {
-              return result;
-            }
-          }
-          break;
-        }
-        case "pathname-prefix-other-locales": {
+    switch (i18n.routing) {
+      case "domains-prefix-other-locales": {
+        if (localeHasntDomain(i18n, currentLocale)) {
           const result = prefixOtherLocales(url, response);
           if (result) {
             return result;
           }
-          break;
         }
-        case "domains-prefix-always-no-redirect": {
-          if (localeHasntDomain(i18n, currentLocale)) {
-            const result = prefixAlwaysNoRedirect(url, response);
-            if (result) {
-              return result;
-            }
-          }
-          break;
+        break;
+      }
+      case "pathname-prefix-other-locales": {
+        const result = prefixOtherLocales(url, response);
+        if (result) {
+          return result;
         }
-        case "pathname-prefix-always-no-redirect": {
+        break;
+      }
+      case "domains-prefix-always-no-redirect": {
+        if (localeHasntDomain(i18n, currentLocale)) {
           const result = prefixAlwaysNoRedirect(url, response);
           if (result) {
             return result;
           }
-          break;
         }
-        case "pathname-prefix-always": {
+        break;
+      }
+      case "pathname-prefix-always-no-redirect": {
+        const result = prefixAlwaysNoRedirect(url, response);
+        if (result) {
+          return result;
+        }
+        break;
+      }
+      case "pathname-prefix-always": {
+        const result = prefixAlways(url, response, context);
+        if (result) {
+          return result;
+        }
+        break;
+      }
+      case "domains-prefix-always": {
+        if (localeHasntDomain(i18n, currentLocale)) {
           const result = prefixAlways(url, response, context);
           if (result) {
             return result;
           }
-          break;
-        }
-        case "domains-prefix-always": {
-          if (localeHasntDomain(i18n, currentLocale)) {
-            const result = prefixAlways(url, response, context);
-            if (result) {
-              return result;
-            }
-          }
-          break;
         }
+        break;
       }
-      if (response.status >= 300 && fallback) {
-        const fallbackKeys = i18n.fallback ? Object.keys(i18n.fallback) : [];
-        const segments = url.pathname.split("/");
-        const urlLocale = segments.find((segment) => {
-          for (const locale of locales) {
-            if (typeof locale === "string") {
-              if (locale === segment) {
-                return true;
-              }
-            } else if (locale.path === segment) {
+    }
+    if (response.status >= 300 && fallback) {
+      const fallbackKeys = i18n.fallback ? Object.keys(i18n.fallback) : [];
+      const segments = url.pathname.split("/");
+      const urlLocale = segments.find((segment) => {
+        for (const locale of locales) {
+          if (typeof locale === "string") {
+            if (locale === segment) {
               return true;
             }
+          } else if (locale.path === segment) {
+            return true;
           }
-          return false;
-        });
-        if (urlLocale && fallbackKeys.includes(urlLocale)) {
-          const fallbackLocale = fallback[urlLocale];
-          const pathFallbackLocale = getPathByLocale(fallbackLocale, locales);
-          let newPathname;
-          if (pathFallbackLocale === defaultLocale && routing === "pathname-prefix-other-locales") {
-            newPathname = url.pathname.replace(`/${urlLocale}`, ``);
-          } else {
-            newPathname = url.pathname.replace(`/${urlLocale}`, `/${pathFallbackLocale}`);
-          }
-          return context.redirect(newPathname);
         }
+        return false;
+      });
+      if (urlLocale && fallbackKeys.includes(urlLocale)) {
+        const fallbackLocale = fallback[urlLocale];
+        const pathFallbackLocale = getPathByLocale(fallbackLocale, locales);
+        let newPathname;
+        if (pathFallbackLocale === defaultLocale && routing === "pathname-prefix-other-locales") {
+          newPathname = url.pathname.replace(`/${urlLocale}`, ``);
+        } else {
+          newPathname = url.pathname.replace(`/${urlLocale}`, `/${pathFallbackLocale}`);
+        }
+        return context.redirect(newPathname);
       }
     }
     return response;
   };
 }
-const i18nPipelineHook = (ctx) => {
-  Reflect.set(ctx.request, routeDataSymbol, ctx.route);
-};
 function localeHasntDomain(i18n, currentLocale) {
   for (const domainLocale of Object.values(i18n.domainLookupTable)) {
     if (domainLocale === currentLocale) {
@@ -167,6 +160,5 @@ function localeHasntDomain(i18n, currentLocale) {
   return true;
 }
 export {
-  createI18nMiddleware,
-  i18nPipelineHook
+  createI18nMiddleware
 };

package/dist/i18n/utils.d.ts

@@ -0,0 +1,25 @@
+import type { Locales } from '../@types/astro.js';
+import type { RoutingStrategies } from '../core/config/schema.js';
+type BrowserLocale = {
+    locale: string;
+    qualityValue: number | undefined;
+};
+/**
+ * Parses the value of the `Accept-Header` language:
+ *
+ * More info: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language
+ *
+ * Complex example: `fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5`
+ *
+ */
+export declare function parseLocale(header: string): BrowserLocale[];
+/**
+ * Set the current locale by parsing the value passed from the `Accept-Header`.
+ *
+ * If multiple locales are present in the header, they are sorted by their quality value and the highest is selected as current locale.
+ *
+ */
+export declare function computePreferredLocale(request: Request, locales: Locales): string | undefined;
+export declare function computePreferredLocaleList(request: Request, locales: Locales): string[];
+export declare function computeCurrentLocale(pathname: string, locales: Locales, routingStrategy: RoutingStrategies | undefined, defaultLocale: string | undefined): undefined | string;
+export {};

package/dist/{core/render/context.js → i18n/utils.js}

@@ -1,44 +1,4 @@
-import { normalizeTheLocale, toCodes } from "../../i18n/index.js";
-import { AstroError, AstroErrorData } from "../errors/index.js";
-import { getParamsAndProps } from "./params-and-props.js";
-import { ROUTE_DATA_SYMBOL } from "../constants.js";
-const clientLocalsSymbol = Symbol.for("astro.locals");
-const routeDataSymbol = Symbol.for(ROUTE_DATA_SYMBOL);
-async function createRenderContext(options) {
-  const request = options.request;
-  const pathname = options.pathname ?? new URL(request.url).pathname;
-  const [params, props] = await getParamsAndProps({
-    mod: options.mod,
-    route: options.route,
-    routeCache: options.env.routeCache,
-    pathname,
-    logger: options.env.logger,
-    ssr: options.env.ssr
-  });
-  const context = {
-    ...options,
-    pathname,
-    params,
-    props,
-    locales: options.locales,
-    routing: options.routing,
-    defaultLocale: options.defaultLocale
-  };
-  Object.defineProperty(context, "locals", {
-    enumerable: true,
-    get() {
-      return Reflect.get(request, clientLocalsSymbol);
-    },
-    set(val) {
-      if (typeof val !== "object") {
-        throw new AstroError(AstroErrorData.LocalsNotAnObject);
-      } else {
-        Reflect.set(request, clientLocalsSymbol, val);
-      }
-    }
-  });
-  return context;
-}
+import { normalizeTheLocale, toCodes } from "./index.js";
 function parseLocale(header) {
   if (header === "*") {
     return [{ locale: header, qualityValue: void 0 }];
@@ -149,13 +109,8 @@ function computePreferredLocaleList(request, locales) {
   }
   return result;
 }
-function computeCurrentLocale(request, locales, routingStrategy, defaultLocale) {
-  const routeData = Reflect.get(request, routeDataSymbol);
-  if (!routeData) {
-    return defaultLocale;
-  }
-  const pathname = routeData.pathname ?? new URL(request.url).pathname;
-  for (const segment of pathname.split("/").filter(Boolean)) {
+function computeCurrentLocale(pathname, locales, routingStrategy, defaultLocale) {
+  for (const segment of pathname.split("/")) {
     for (const locale of locales) {
       if (typeof locale === "string") {
         if (!segment.includes(locale))
@@ -185,6 +140,5 @@ export {
   computeCurrentLocale,
   computePreferredLocale,
   computePreferredLocaleList,
-  createRenderContext,
   parseLocale
 };

package/dist/prerender/routing.d.ts

@@ -1,5 +1,5 @@
 import type { AstroSettings, ComponentInstance, RouteData } from '../@types/astro.js';
-import type DevPipeline from '../vite-plugin-astro-server/devPipeline.js';
+import type { DevPipeline } from '../vite-plugin-astro-server/pipeline.js';
 type GetSortedPreloadedMatchesParams = {
     pipeline: DevPipeline;
     matches: RouteData[];

package/dist/prerender/routing.js

@@ -1,5 +1,4 @@
 import { RedirectComponentInstance, routeIsRedirect } from "../core/redirects/index.js";
-import { preload } from "../vite-plugin-astro-server/index.js";
 import { getPrerenderStatus } from "./metadata.js";
 async function getSortedPreloadedMatches({
   pipeline,
@@ -28,10 +27,10 @@ async function preloadAndSetPrerenderStatus({
       });
       continue;
     }
-    const preloadedComponent = await preload({ pipeline, filePath });
+    const preloadedComponent = await pipeline.preload(filePath);
     const prerenderStatus = getPrerenderStatus({
       filePath,
-      loader: pipeline.getModuleLoader()
+      loader: pipeline.loader
     });
     if (prerenderStatus !== void 0) {
       route.prerender = prerenderStatus;

package/dist/runtime/client/dev-toolbar/apps/astro.js

@@ -10,23 +10,27 @@ var astro_default = {
   async init(canvas, eventTarget) {
     createCanvas();
     document.addEventListener("astro:after-swap", createCanvas);
+    document.addEventListener("astro:after-swap", fetchIntegrationData);
     eventTarget.addEventListener("app-toggled", async (event) => {
       resetDebugButton();
       if (!(event instanceof CustomEvent))
         return;
       if (event.detail.state === true) {
         if (!integrationData)
-          fetch("https://astro.build/api/v1/dev-overlay/", {
-            cache: "no-cache"
-          }).then((res) => res.json()).then((data) => {
-            integrationData = data;
-            integrationData.data = integrationData.data.map((integration) => {
-              return integration;
-            });
-            refreshIntegrationList();
-          });
+          fetchIntegrationData();
       }
     });
+    function fetchIntegrationData() {
+      fetch("https://astro.build/api/v1/dev-overlay/", {
+        cache: "no-cache"
+      }).then((res) => res.json()).then((data) => {
+        integrationData = data;
+        integrationData.data = integrationData.data.map((integration) => {
+          return integration;
+        });
+        refreshIntegrationList();
+      });
+    }
     function createCanvas() {
       const links = [
         {

package/dist/runtime/client/dev-toolbar/apps/audit/a11y.js

@@ -307,8 +307,8 @@ const a11y = [
     message: "Headings and anchors must have an accessible name, which can come from: inner text, aria-label, aria-labelledby, an img with alt property, or an svg with a tag <title></title>.",
     selector: a11y_required_content.join(","),
     match(element) {
-      const innerText = element.innerText.trim();
-      if (innerText !== "")
+      const innerText = element.innerText?.trim();
+      if (innerText && innerText !== "")
         return false;
       const ariaLabel = element.getAttribute("aria-label")?.trim();
       if (ariaLabel && ariaLabel !== "")

package/dist/runtime/server/endpoint.js

@@ -1,5 +1,5 @@
 import { bold } from "kleur/colors";
-import { REROUTE_DIRECTIVE_HEADER } from "./consts.js";
+import { REROUTABLE_STATUS_CODES, REROUTE_DIRECTIVE_HEADER } from "../../core/constants.js";
 async function renderEndpoint(mod, context, ssr, logger) {
   const { request, url } = context;
   const method = request.method.toUpperCase();
@@ -30,7 +30,7 @@ Found handlers: ${Object.keys(mod).map((exp) => JSON.stringify(exp)).join(", ")}
     return new Response(null, { status: 500 });
   }
   const response = await handler.call(mod, context);
-  if (response.status === 404 || response.status === 500) {
+  if (REROUTABLE_STATUS_CODES.includes(response.status)) {
     response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
   }
   return response;

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

@@ -9,3 +9,4 @@ export interface HandleHotUpdateOptions {
     astroFileToCompileMetadata: Map<string, CompileMetadata>;
 }
 export declare function handleHotUpdate(ctx: HmrContext, { logger, compile, astroFileToCssAstroDeps, astroFileToCompileMetadata }: HandleHotUpdateOptions): Promise<import("vite").ModuleNode[] | undefined>;
+export declare function isStyleOnlyChanged(oldCode: string, newCode: string): boolean;