astro 4.3.7 → 4.4.1

package/dist/core/render/params-and-props.js

@@ -1,17 +1,16 @@
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { routeIsFallback } from "../redirects/helpers.js";
 import { routeIsRedirect } from "../redirects/index.js";
-import { getParams } from "../routing/params.js";
 import { callGetStaticPaths, findPathItemByKey } from "./route-cache.js";
-async function getParamsAndProps(opts) {
-  const { logger, mod, route, routeCache, pathname, ssr } = opts;
+async function getProps(opts) {
+  const { logger, mod, routeData: route, routeCache, pathname, serverLike } = opts;
   if (!route || route.pathname) {
-    return [{}, {}];
+    return {};
   }
-  const params = getRouteParams(route, pathname) ?? {};
   if (routeIsRedirect(route) || routeIsFallback(route)) {
-    return [params, {}];
+    return {};
   }
+  const params = getParams(route, pathname);
   if (mod) {
     validatePrerenderEndpointCollision(route, mod, params);
   }
@@ -20,10 +19,10 @@ async function getParamsAndProps(opts) {
     route,
     routeCache,
     logger,
-    ssr
+    ssr: serverLike
   });
   const matchedStaticPath = findPathItemByKey(staticPaths, params, route, logger);
-  if (!matchedStaticPath && (ssr ? route.prerender : true)) {
+  if (!matchedStaticPath && (serverLike ? route.prerender : true)) {
     throw new AstroError({
       ...AstroErrorData.NoMatchingStaticPathFound,
       message: AstroErrorData.NoMatchingStaticPathFound.message(pathname),
@@ -31,15 +30,23 @@ async function getParamsAndProps(opts) {
     });
   }
   const props = matchedStaticPath?.props ? { ...matchedStaticPath.props } : {};
-  return [params, props];
+  return props;
 }
-function getRouteParams(route, pathname) {
-  if (route.params.length) {
-    const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
-    if (paramsMatch) {
-      return getParams(route.params)(paramsMatch);
+function getParams(route, pathname) {
+  if (!route.params.length)
+    return {};
+  const paramsMatch = route.pattern.exec(decodeURIComponent(pathname));
+  if (!paramsMatch)
+    return {};
+  const params = {};
+  route.params.forEach((key, i) => {
+    if (key.startsWith("...")) {
+      params[key.slice(3)] = paramsMatch[i + 1] ? paramsMatch[i + 1] : void 0;
+    } else {
+      params[key] = paramsMatch[i + 1];
     }
-  }
+  });
+  return params;
 }
 function validatePrerenderEndpointCollision(route, mod, params) {
   if (route.type === "endpoint" && mod.getStaticPaths) {
@@ -59,5 +66,6 @@ function validatePrerenderEndpointCollision(route, mod, params) {
   }
 }
 export {
-  getParamsAndProps
+  getParams,
+  getProps
 };

package/dist/core/render/result.d.ts

@@ -23,16 +23,17 @@ export interface CreateResultArgs {
      * Used for `Astro.site`
      */
     site: string | undefined;
-    links?: Set<SSRElement>;
-    scripts?: Set<SSRElement>;
-    styles?: Set<SSRElement>;
-    componentMetadata?: SSRResult['componentMetadata'];
+    links: Set<SSRElement>;
+    scripts: Set<SSRElement>;
+    styles: Set<SSRElement>;
+    componentMetadata: SSRResult['componentMetadata'];
     request: Request;
     status: number;
     locals: App.Locals;
-    cookies?: AstroCookies;
+    cookies: AstroCookies;
     locales: Locales | undefined;
     defaultLocale: string | undefined;
+    route: string;
     routingStrategy: RoutingStrategies | undefined;
 }
 export declare function createResult(args: CreateResultArgs): SSRResult;

package/dist/core/render/result.js

@@ -7,9 +7,8 @@ import {
   computeCurrentLocale,
   computePreferredLocale,
   computePreferredLocaleList
-} from "./context.js";
-const clientAddressSymbol = Symbol.for("astro.clientAddress");
-const responseSentSymbol = Symbol.for("astro.responseSent");
+} from "../../i18n/utils.js";
+import { clientAddressSymbol, responseSentSymbol } from "../constants.js";
 function getFunctionExpression(slot) {
   if (!slot)
     return;
@@ -160,7 +159,7 @@ function createResult(args) {
           }
           if (args.locales) {
             currentLocale = computeCurrentLocale(
-              request,
+              url.pathname,
               args.locales,
               args.routingStrategy,
               args.defaultLocale

package/dist/core/render-context.d.ts

@@ -0,0 +1,32 @@
+import type { APIContext, ComponentInstance, MiddlewareHandler, RouteData } from '../@types/astro.js';
+import { AstroCookies } from './cookies/index.js';
+import { type Pipeline } from './render/index.js';
+export declare class RenderContext {
+    #private;
+    readonly pipeline: Pipeline;
+    locals: App.Locals;
+    readonly middleware: MiddlewareHandler;
+    readonly pathname: string;
+    readonly request: Request;
+    readonly routeData: RouteData;
+    status: number;
+    readonly cookies: AstroCookies;
+    readonly params: import("../@types/astro.js").Params;
+    private constructor();
+    static create({ locals, middleware, pathname, pipeline, request, routeData, status, }: Pick<RenderContext, 'pathname' | 'pipeline' | 'request' | 'routeData'> & Partial<Pick<RenderContext, 'locals' | 'middleware' | 'status'>>): RenderContext;
+    /**
+     * 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
+     */
+    render(componentInstance: ComponentInstance | undefined): Promise<Response>;
+    createAPIContext(props: APIContext['props']): APIContext;
+    createResult(mod: ComponentInstance): Promise<import("../@types/astro.js").SSRResult>;
+    get i18nData(): Pick<APIContext<Record<string, any>, Record<string, string | undefined>>, "currentLocale" | "preferredLocale" | "preferredLocaleList">;
+}

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/manifest/create.js

@@ -121,33 +121,19 @@ function routeComparator(a, b) {
       return aHasSpread ? 1 : -1;
     }
   }
-  if (Math.abs(a.segments.length - b.segments.length) === 1) {
+  const aLength = a.segments.length;
+  const bLength = b.segments.length;
+  if (aLength !== bLength) {
     const aEndsInRest = a.segments.at(-1)?.some((part) => part.spread);
     const bEndsInRest = b.segments.at(-1)?.some((part) => part.spread);
-    if (a.segments.length > b.segments.length && !bEndsInRest) {
-      return 1;
-    }
-    if (b.segments.length > a.segments.length && !aEndsInRest) {
-      return -1;
-    }
-  }
-  if (a.isIndex !== b.isIndex) {
-    if (a.isIndex) {
-      const followingBSegment = b.segments.at(a.segments.length);
-      const followingBSegmentIsStatic = followingBSegment?.every(
-        (part) => !part.dynamic && !part.spread
-      );
-      return followingBSegmentIsStatic ? 1 : -1;
+    if (aEndsInRest !== bEndsInRest && Math.abs(aLength - bLength) === 1) {
+      if (aLength > bLength && aEndsInRest) {
+        return 1;
+      }
+      if (bLength > aLength && bEndsInRest) {
+        return -1;
+      }
     }
-    const followingASegment = a.segments.at(b.segments.length);
-    const followingASegmentIsStatic = followingASegment?.every(
-      (part) => !part.dynamic && !part.spread
-    );
-    return followingASegmentIsStatic ? -1 : 1;
-  }
-  const aLength = a.isIndex ? a.segments.length + 1 : a.segments.length;
-  const bLength = b.isIndex ? b.segments.length + 1 : b.segments.length;
-  if (aLength !== bLength) {
     return aLength > bLength ? -1 : 1;
   }
   if (a.type === "endpoint" !== (b.type === "endpoint")) {
@@ -492,9 +478,7 @@ function createRouteManifest(params, logger) {
     if (i18n.routing === "pathname-prefix-always") {
       const defaultLocaleRoutes = routesByLocale.get(i18n.defaultLocale);
       if (defaultLocaleRoutes) {
-        const indexDefaultRoute = defaultLocaleRoutes.find((routeData) => {
-          return routeData.component.includes("index");
-        });
+        const indexDefaultRoute = defaultLocaleRoutes.find(({ route }) => route === "/") ?? defaultLocaleRoutes.find(({ route }) => route === `/${i18n.defaultLocale}`);
         if (indexDefaultRoute) {
           const pathname = "/";
           const route = "/";

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;