astro 4.3.7 → 4.4.1

package/dist/core/build/types.d.ts

@@ -2,7 +2,6 @@ import type * as vite from 'vite';
 import type { InlineConfig } from 'vite';
 import type { AstroConfig, AstroSettings, ComponentInstance, ManifestData, MiddlewareHandler, RouteData, RuntimeMode, SSRLoadedRenderer } from '../../@types/astro.js';
 import type { Logger } from '../logger/core.js';
-import type { RouteCache } from '../render/route-cache.js';
 export type ComponentPath = string;
 export type ViteID = string;
 export type PageOutput = AstroConfig['output'];
@@ -40,7 +39,6 @@ export interface StaticBuildOptions {
     mode: RuntimeMode;
     origin: string;
     pageNames: string[];
-    routeCache: RouteCache;
     viteConfig: InlineConfig;
     teardownCompiler: boolean;
 }

package/dist/core/constants.d.ts

@@ -1,4 +1,13 @@
 export declare const ASTRO_VERSION: string;
+export declare const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
+export declare const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
+/**
+ * A response with one of these status codes will be rewritten
+ * with the result of rendering the respective error page.
+ */
+export declare const REROUTABLE_STATUS_CODES: number[];
+export declare const clientAddressSymbol: unique symbol;
+export declare const clientLocalsSymbol: unique symbol;
+export declare const responseSentSymbol: unique symbol;
 export declare const SUPPORTED_MARKDOWN_FILE_EXTENSIONS: readonly [".markdown", ".mdown", ".mkdn", ".mkd", ".mdwn", ".md"];
 export declare const MIDDLEWARE_PATH_SEGMENT_NAME = "middleware";
-export declare const ROUTE_DATA_SYMBOL = "astro.routeData";

package/dist/core/constants.js

@@ -1,4 +1,10 @@
-const ASTRO_VERSION = "4.3.7";
+const ASTRO_VERSION = "4.4.1";
+const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
+const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
+const REROUTABLE_STATUS_CODES = [404, 500];
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+const clientLocalsSymbol = Symbol.for("astro.locals");
+const responseSentSymbol = Symbol.for("astro.responseSent");
 const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".markdown",
   ".mdown",
@@ -8,10 +14,14 @@ const SUPPORTED_MARKDOWN_FILE_EXTENSIONS = [
   ".md"
 ];
 const MIDDLEWARE_PATH_SEGMENT_NAME = "middleware";
-const ROUTE_DATA_SYMBOL = "astro.routeData";
 export {
   ASTRO_VERSION,
   MIDDLEWARE_PATH_SEGMENT_NAME,
-  ROUTE_DATA_SYMBOL,
-  SUPPORTED_MARKDOWN_FILE_EXTENSIONS
+  REROUTABLE_STATUS_CODES,
+  REROUTE_DIRECTIVE_HEADER,
+  ROUTE_TYPE_HEADER,
+  SUPPORTED_MARKDOWN_FILE_EXTENSIONS,
+  clientAddressSymbol,
+  clientLocalsSymbol,
+  responseSentSymbol
 };

package/dist/core/dev/dev.js

@@ -23,7 +23,7 @@ async function dev(inlineConfig) {
       base: restart.container.settings.config.base
     })
   );
-  const currentVersion = "4.3.7";
+  const currentVersion = "4.4.1";
   if (currentVersion.includes("-")) {
     logger.warn("SKIP_FORMAT", msg.prerelease({ currentVersion }));
   }

package/dist/core/dev/restart.js

@@ -54,7 +54,7 @@ async function restartContainer(container) {
         formatErrorMessage(collectErrorMetadata(error), logger.level() === "debug") + "\n"
       );
     }
-    container.viteServer.ws.send({
+    container.viteServer.hot.send({
       type: "error",
       err: {
         message: error.message,

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

@@ -1,5 +1,5 @@
-import type { APIContext, EndpointHandler, Locales, MiddlewareHandler, Params } from '../../@types/astro.js';
-import { type Environment, type RenderContext } from '../render/index.js';
+import type { APIContext, Locales, Params } from '../../@types/astro.js';
+import type { AstroCookies } from '../cookies/index.js';
 import type { RoutingStrategies } from '../config/schema.js';
 type CreateAPIContext = {
     request: Request;
@@ -10,12 +10,13 @@ type CreateAPIContext = {
     locales: Locales | undefined;
     routingStrategy: RoutingStrategies | undefined;
     defaultLocale: string | undefined;
+    route: string;
+    cookies: AstroCookies;
 };
 /**
  * Creates a context that holds all the information needed to handle an Astro endpoint.
  *
  * @param {CreateAPIContext} payload
  */
-export declare function createAPIContext({ request, params, site, props, adapterName, locales, routingStrategy, defaultLocale, }: CreateAPIContext): APIContext;
-export declare function callEndpoint(mod: EndpointHandler, env: Environment, ctx: RenderContext, onRequest: MiddlewareHandler | undefined): Promise<Response>;
+export declare function createAPIContext({ request, params, site, props, adapterName, locales, routingStrategy, defaultLocale, route, cookies, }: CreateAPIContext): APIContext;
 export {};

package/dist/core/endpoint/index.js

@@ -1,16 +1,10 @@
-import { renderEndpoint } from "../../runtime/server/index.js";
-import { ASTRO_VERSION } from "../constants.js";
-import { AstroCookies, attachCookiesToResponse } from "../cookies/index.js";
+import { ASTRO_VERSION, clientAddressSymbol, clientLocalsSymbol } from "../constants.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
-import { callMiddleware } from "../middleware/callMiddleware.js";
 import {
   computeCurrentLocale,
   computePreferredLocale,
   computePreferredLocaleList
-} from "../render/context.js";
-import {} from "../render/index.js";
-const clientAddressSymbol = Symbol.for("astro.clientAddress");
-const clientLocalsSymbol = Symbol.for("astro.locals");
+} from "../../i18n/utils.js";
 function createAPIContext({
   request,
   params,
@@ -19,13 +13,15 @@ function createAPIContext({
   adapterName,
   locales,
   routingStrategy,
-  defaultLocale
+  defaultLocale,
+  route,
+  cookies
 }) {
   let preferredLocale = void 0;
   let preferredLocaleList = void 0;
   let currentLocale = void 0;
   const context = {
-    cookies: new AstroCookies(request),
+    cookies,
     request,
     params,
     site: site ? new URL(site) : void 0,
@@ -64,7 +60,7 @@ function createAPIContext({
         return currentLocale;
       }
       if (locales) {
-        currentLocale = computeCurrentLocale(request, locales, routingStrategy, defaultLocale);
+        currentLocale = computeCurrentLocale(route, locales, routingStrategy, defaultLocale);
       }
       return currentLocale;
     },
@@ -104,29 +100,6 @@ function createAPIContext({
   };
   return context;
 }
-async function callEndpoint(mod, env, ctx, onRequest) {
-  const context = createAPIContext({
-    request: ctx.request,
-    params: ctx.params,
-    props: ctx.props,
-    site: env.site,
-    adapterName: env.adapterName,
-    routingStrategy: ctx.routing,
-    defaultLocale: ctx.defaultLocale,
-    locales: ctx.locales
-  });
-  let response;
-  if (onRequest) {
-    response = await callMiddleware(onRequest, context, async () => {
-      return await renderEndpoint(mod, context, env.ssr, env.logger);
-    });
-  } else {
-    response = await renderEndpoint(mod, context, env.ssr, env.logger);
-  }
-  attachCookiesToResponse(response, context.cookies);
-  return response;
-}
 export {
-  callEndpoint,
   createAPIContext
 };

package/dist/core/errors/errors-data.d.ts

@@ -453,12 +453,12 @@ export declare const InvalidImageService: {
 /**
  * @docs
  * @message
- * Missing width and height attributes for `IMAGE_URL`. When using remote images, both dimensions are always required in order to avoid cumulative layout shift (CLS).
+ * Missing width and height attributes for `IMAGE_URL`. When using remote images, both dimensions are required in order to avoid cumulative layout shift (CLS).
  * @see
  * - [Images](https://docs.astro.build/en/guides/images/)
- * - [Image component#width-and-height-required](https://docs.astro.build/en/guides/images/#width-and-height-required-for-public-and-remote-images)
+ * - [Image component#width-and-height-required](https://docs.astro.build/en/guides/images/#width-and-height-required-for-images-in-public)
  * @description
- * For remote images, `width` and `height` cannot be inferred from the original file. As such, in order to avoid CLS, those two properties are always required.
+ * For remote images, `width` and `height` cannot automatically be inferred from the original file. To avoid cumulative layout shift (CLS), either specify these two properties, or set [`inferSize`](https://docs.astro.build/en/guides/images/#infersize) to `true` to fetch a remote image's original dimensions.
  *
  * If your image is inside your `src` folder, you probably meant to import it instead. See [the Imports guide for more information](https://docs.astro.build/en/guides/imports/#other-assets).
  */
@@ -468,6 +468,19 @@ export declare const MissingImageDimension: {
     message: (missingDimension: 'width' | 'height' | 'both', imageURL: string) => string;
     hint: string;
 };
+/**
+ * @docs
+ * @message
+ * Failed to get the dimensions for `IMAGE_URL`.
+ * @description
+ * Determining the remote image's dimensions failed. This is typically caused by an incorrect URL or attempting to infer the size of an image in the public folder which is not possible.
+ */
+export declare const FailedToFetchRemoteImageDimensions: {
+    name: string;
+    title: string;
+    message: (imageURL: string) => string;
+    hint: string;
+};
 /**
  * @docs
  * @description

package/dist/core/errors/errors-data.js

@@ -164,8 +164,14 @@ const InvalidImageService = {
 const MissingImageDimension = {
   name: "MissingImageDimension",
   title: "Missing image dimensions",
-  message: (missingDimension, imageURL) => `Missing ${missingDimension === "both" ? "width and height attributes" : `${missingDimension} attribute`} for ${imageURL}. When using remote images, both dimensions are always required in order to avoid CLS.`,
-  hint: "If your image is inside your `src` folder, you probably meant to import it instead. See [the Imports guide for more information](https://docs.astro.build/en/guides/imports/#other-assets)."
+  message: (missingDimension, imageURL) => `Missing ${missingDimension === "both" ? "width and height attributes" : `${missingDimension} attribute`} for ${imageURL}. When using remote images, both dimensions are required unless in order to avoid CLS.`,
+  hint: "If your image is inside your `src` folder, you probably meant to import it instead. See [the Imports guide for more information](https://docs.astro.build/en/guides/imports/#other-assets). You can also use `inferSize={true}` for remote images to get the original dimensions."
+};
+const FailedToFetchRemoteImageDimensions = {
+  name: "FailedToFetchRemoteImageDimensions",
+  title: "Failed to retrieve remote image dimensions",
+  message: (imageURL) => `Failed to get the dimensions for ${imageURL}.`,
+  hint: "Verify your remote image URL is accurate, and that you are not using `inferSize` with a file located in your `public/` folder."
 };
 const UnsupportedImageFormat = {
   name: "UnsupportedImageFormat",
@@ -490,6 +496,7 @@ export {
   DuplicateContentEntrySlugError,
   ExpectedImage,
   ExpectedImageOptions,
+  FailedToFetchRemoteImageDimensions,
   FailedToFindPageMapSSR,
   FailedToLoadModuleSSR,
   GenerateContentTypesError,

package/dist/core/messages.js

@@ -36,7 +36,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "4.3.7";
+  const version = "4.4.1";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -261,7 +261,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"4.3.7"}`
+        `v${"4.4.1"}`
       )} ${headline}`
     );
   }

package/dist/core/middleware/callMiddleware.d.ts

@@ -33,4 +33,4 @@ import type { APIContext, MiddlewareHandler } from '../../@types/astro.js';
  * @param apiContext The API context
  * @param responseFunction A callback function that should return a promise with the response
  */
-export declare function callMiddleware(onRequest: MiddlewareHandler, apiContext: APIContext, responseFunction: () => Promise<Response>): Promise<Response>;
+export declare function callMiddleware(onRequest: MiddlewareHandler, apiContext: APIContext, responseFunction: () => Promise<Response> | Response): Promise<Response>;

package/dist/core/middleware/callMiddleware.js

@@ -1,4 +1,3 @@
-import { attachCookiesToResponse, responseHasCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 async function callMiddleware(onRequest, apiContext, responseFunction) {
   let nextCalled = false;
@@ -15,7 +14,7 @@ async function callMiddleware(onRequest, apiContext, responseFunction) {
         if (value instanceof Response === false) {
           throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
         }
-        return ensureCookiesAttached(apiContext, value);
+        return value;
       } else {
         if (responseFunctionPromise) {
           return responseFunctionPromise;
@@ -28,16 +27,10 @@ async function callMiddleware(onRequest, apiContext, responseFunction) {
     } else if (value instanceof Response === false) {
       throw new AstroError(AstroErrorData.MiddlewareNotAResponse);
     } else {
-      return ensureCookiesAttached(apiContext, value);
+      return value;
     }
   });
 }
-function ensureCookiesAttached(apiContext, response) {
-  if (apiContext.cookies !== void 0 && !responseHasCookies(response)) {
-    attachCookiesToResponse(response, apiContext.cookies);
-  }
-  return response;
-}
 export {
   callMiddleware
 };

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

@@ -1,4 +1,4 @@
-import type { MiddlewareHandler, Params } from '../../@types/astro.js';
+import type { APIContext, MiddlewareHandler, Params } from '../../@types/astro.js';
 import { sequence } from './sequence.js';
 declare function defineMiddleware(fn: MiddlewareHandler): MiddlewareHandler;
 /**
@@ -21,7 +21,7 @@ export type CreateContext = {
 /**
  * Creates a context to be passed to Astro middleware `onRequest` function.
  */
-declare function createContext({ request, params, userDefinedLocales }: CreateContext): import("../../@types/astro.js").APIContext<Record<string, any>, Record<string, string | undefined>>;
+declare function createContext({ request, params, userDefinedLocales, }: CreateContext): APIContext;
 /**
  * It attempts to serialize `value` and return it as a string.
  *

package/dist/core/middleware/index.js

@@ -1,18 +1,83 @@
-import { createAPIContext } from "../endpoint/index.js";
+import { AstroCookies } from "../cookies/index.js";
 import { sequence } from "./sequence.js";
+import { ASTRO_VERSION } from "../constants.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import {
+  computeCurrentLocale,
+  computePreferredLocale,
+  computePreferredLocaleList
+} from "../../i18n/utils.js";
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+const clientLocalsSymbol = Symbol.for("astro.locals");
 function defineMiddleware(fn) {
   return fn;
 }
-function createContext({ request, params, userDefinedLocales = [] }) {
-  return createAPIContext({
+function createContext({
+  request,
+  params = {},
+  userDefinedLocales = []
+}) {
+  let preferredLocale = void 0;
+  let preferredLocaleList = void 0;
+  let currentLocale = void 0;
+  const url = new URL(request.url);
+  const route = url.pathname;
+  return {
+    cookies: new AstroCookies(request),
     request,
-    params: params ?? {},
-    props: {},
+    params,
     site: void 0,
-    locales: userDefinedLocales,
-    defaultLocale: void 0,
-    routingStrategy: void 0
-  });
+    generator: `Astro v${ASTRO_VERSION}`,
+    props: {},
+    redirect(path, status) {
+      return new Response(null, {
+        status: status || 302,
+        headers: {
+          Location: path
+        }
+      });
+    },
+    get preferredLocale() {
+      return preferredLocale ??= computePreferredLocale(request, userDefinedLocales);
+    },
+    get preferredLocaleList() {
+      return preferredLocaleList ??= computePreferredLocaleList(request, userDefinedLocales);
+    },
+    get currentLocale() {
+      return currentLocale ??= computeCurrentLocale(
+        route,
+        userDefinedLocales,
+        void 0,
+        void 0
+      );
+    },
+    url,
+    get clientAddress() {
+      if (clientAddressSymbol in request) {
+        return Reflect.get(request, clientAddressSymbol);
+      }
+      throw new AstroError(AstroErrorData.StaticClientAddressNotAvailable);
+    },
+    get locals() {
+      let locals = Reflect.get(request, clientLocalsSymbol);
+      if (locals === void 0) {
+        locals = {};
+        Reflect.set(request, clientLocalsSymbol, locals);
+      }
+      if (typeof locals !== "object") {
+        throw new AstroError(AstroErrorData.LocalsNotAnObject);
+      }
+      return locals;
+    },
+    // We define a custom property, so we can check the value passed to locals
+    set locals(val) {
+      if (typeof val !== "object") {
+        throw new AstroError(AstroErrorData.LocalsNotAnObject);
+      } else {
+        Reflect.set(request, clientLocalsSymbol, val);
+      }
+    }
+  };
 }
 function isLocalsSerializable(value) {
   let type = typeof value;

package/dist/core/module-loader/vite.js

@@ -24,8 +24,8 @@ function createViteLoader(viteServer) {
       events.emit("file-change", args);
     }
   });
-  const _wsSend = viteServer.ws.send;
-  viteServer.ws.send = function(...args) {
+  const _wsSend = viteServer.hot.send;
+  viteServer.hot.send = function(...args) {
     if (isTsconfigUpdated) {
       isTsconfigUpdated = false;
       return;
@@ -63,13 +63,13 @@ function createViteLoader(viteServer) {
       return viteServer.ssrFixStacktrace(err);
     },
     clientReload() {
-      viteServer.ws.send({
+      viteServer.hot.send({
         type: "full-reload",
         path: "*"
       });
     },
     webSocketSend(msg) {
-      return viteServer.ws.send(msg);
+      return viteServer.hot.send(msg);
     },
     isHttps() {
       return !!viteServer.config.server.https;

package/dist/core/preview/index.js

@@ -11,7 +11,9 @@ import { createSettings } from "../config/settings.js";
 import createStaticPreviewServer from "./static-preview-server.js";
 import { getResolvedHostForHttpServer } from "./util.js";
 import { ensureProcessNodeEnv } from "../util.js";
+import { apply as applyPolyfills } from "../polyfill.js";
 async function preview(inlineConfig) {
+  applyPolyfills();
   ensureProcessNodeEnv("production");
   const logger = createNodeLogger(inlineConfig);
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig ?? {}, "preview");

package/dist/core/preview/static-preview-server.js

@@ -1,6 +1,5 @@
 import { fileURLToPath } from "node:url";
 import { performance } from "perf_hooks";
-import enableDestroy from "server-destroy";
 import { preview } from "vite";
 import * as msg from "../messages.js";
 import { getResolvedHostForHttpServer } from "./util.js";
@@ -30,7 +29,6 @@ async function createStaticPreviewServer(settings, logger) {
     }
     throw err;
   }
-  enableDestroy(previewServer.httpServer);
   logger.info(
     "SKIP_FORMAT",
     msg.serverStart({
@@ -51,11 +49,7 @@ async function createStaticPreviewServer(settings, logger) {
     port: settings.config.server.port,
     closed,
     server: previewServer.httpServer,
-    stop: async () => {
-      await new Promise((resolve, reject) => {
-        previewServer.httpServer.destroy((err) => err ? reject(err) : resolve(void 0));
-      });
-    }
+    stop: previewServer.close.bind(previewServer)
   };
 }
 export {

package/dist/core/redirects/helpers.d.ts

@@ -1,5 +1,3 @@
-import type { Params, RedirectRouteData, RouteData, ValidRedirectStatus } from '../../@types/astro.js';
+import type { RedirectRouteData, RouteData } from '../../@types/astro.js';
 export declare function routeIsRedirect(route: RouteData | undefined): route is RedirectRouteData;
 export declare function routeIsFallback(route: RouteData | undefined): route is RedirectRouteData;
-export declare function redirectRouteGenerate(redirectRoute: RouteData, data: Params): string;
-export declare function redirectRouteStatus(redirectRoute: RouteData, method?: string): ValidRedirectStatus;

package/dist/core/redirects/helpers.js

@@ -4,36 +4,7 @@ function routeIsRedirect(route) {
 function routeIsFallback(route) {
   return route?.type === "fallback";
 }
-function redirectRouteGenerate(redirectRoute, data) {
-  const routeData = redirectRoute.redirectRoute;
-  const route = redirectRoute.redirect;
-  if (typeof routeData !== "undefined") {
-    return routeData?.generate(data) || routeData?.pathname || "/";
-  } else if (typeof route === "string") {
-    let target = route;
-    for (const param of Object.keys(data)) {
-      const paramValue = data[param];
-      target = target.replace(`[${param}]`, paramValue);
-      target = target.replace(`[...${param}]`, paramValue);
-    }
-    return target;
-  } else if (typeof route === "undefined") {
-    return "/";
-  }
-  return route.destination;
-}
-function redirectRouteStatus(redirectRoute, method = "GET") {
-  const routeData = redirectRoute.redirectRoute;
-  if (routeData && typeof redirectRoute.redirect === "object") {
-    return redirectRoute.redirect.status;
-  } else if (method !== "GET") {
-    return 308;
-  }
-  return 301;
-}
 export {
-  redirectRouteGenerate,
-  redirectRouteStatus,
   routeIsFallback,
   routeIsRedirect
 };

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

@@ -1,3 +1,4 @@
 export { RedirectComponentInstance, RedirectSinglePageBuiltModule } from './component.js';
-export { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from './helpers.js';
+export { routeIsRedirect } from './helpers.js';
 export { getRedirectLocationOrThrow } from './validate.js';
+export { renderRedirect } from './render.js';

package/dist/core/redirects/index.js

@@ -1,11 +1,11 @@
 import { RedirectComponentInstance, RedirectSinglePageBuiltModule } from "./component.js";
-import { redirectRouteGenerate, redirectRouteStatus, routeIsRedirect } from "./helpers.js";
+import { routeIsRedirect } from "./helpers.js";
 import { getRedirectLocationOrThrow } from "./validate.js";
+import { renderRedirect } from "./render.js";
 export {
   RedirectComponentInstance,
   RedirectSinglePageBuiltModule,
   getRedirectLocationOrThrow,
-  redirectRouteGenerate,
-  redirectRouteStatus,
+  renderRedirect,
   routeIsRedirect
 };

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

@@ -0,0 +1,2 @@
+import type { RenderContext } from '../render-context.js';
+export declare function renderRedirect(renderContext: RenderContext): Promise<Response>;

package/dist/core/redirects/render.js

@@ -0,0 +1,33 @@
+async function renderRedirect(renderContext) {
+  const {
+    request: { method },
+    routeData
+  } = renderContext;
+  const { redirect, redirectRoute } = routeData;
+  const status = redirectRoute && typeof redirect === "object" ? redirect.status : method === "GET" ? 301 : 308;
+  const headers = { location: redirectRouteGenerate(renderContext) };
+  return new Response(null, { status, headers });
+}
+function redirectRouteGenerate(renderContext) {
+  const {
+    params,
+    routeData: { redirect, redirectRoute }
+  } = renderContext;
+  if (typeof redirectRoute !== "undefined") {
+    return redirectRoute?.generate(params) || redirectRoute?.pathname || "/";
+  } else if (typeof redirect === "string") {
+    let target = redirect;
+    for (const param of Object.keys(params)) {
+      const paramValue = params[param];
+      target = target.replace(`[${param}]`, paramValue);
+      target = target.replace(`[...${param}]`, paramValue);
+    }
+    return target;
+  } else if (typeof redirect === "undefined") {
+    return "/";
+  }
+  return redirect.destination;
+}
+export {
+  renderRedirect
+};

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

@@ -1,14 +1,12 @@
-import type { AstroMiddlewareInstance, ComponentInstance, RouteData } from '../../@types/astro.js';
-import type { Environment } from './environment.js';
-export { computePreferredLocale, createRenderContext } from './context.js';
-export type { RenderContext } from './context.js';
-export { createEnvironment } from './environment.js';
-export { getParamsAndProps } from './params-and-props.js';
+import type { ComponentInstance, RouteData } from '../../@types/astro.js';
+import type { Pipeline } from '../base-pipeline.js';
+export { Pipeline } from '../base-pipeline.js';
+export { getParams, getProps } from './params-and-props.js';
 export { loadRenderer } from './renderer.js';
-export type { Environment };
+export { createResult } from './result.js';
 export interface SSROptions {
-    /** The environment instance */
-    env: Environment;
+    /** The pipeline instance */
+    pipeline: Pipeline;
     /** location of file on disk */
     filePath: URL;
     /** the web request (needed for dynamic routes) */
@@ -19,8 +17,4 @@ export interface SSROptions {
     request: Request;
     /** optional, in case we need to render something outside a dev server */
     route: RouteData;
-    /**
-     * Optional middlewares
-     */
-    middleware?: AstroMiddlewareInstance;
 }

package/dist/core/render/index.js

@@ -1,11 +1,11 @@
-import { computePreferredLocale, createRenderContext } from "./context.js";
-import { createEnvironment } from "./environment.js";
-import { getParamsAndProps } from "./params-and-props.js";
+import { Pipeline } from "../base-pipeline.js";
+import { getParams, getProps } from "./params-and-props.js";
 import { loadRenderer } from "./renderer.js";
+import { createResult } from "./result.js";
 export {
-  computePreferredLocale,
-  createEnvironment,
-  createRenderContext,
-  getParamsAndProps,
+  Pipeline,
+  createResult,
+  getParams,
+  getProps,
   loadRenderer
 };

package/dist/core/render/params-and-props.d.ts

@@ -3,11 +3,16 @@ import type { Logger } from '../logger/core.js';
 import type { RouteCache } from './route-cache.js';
 interface GetParamsAndPropsOptions {
     mod: ComponentInstance | undefined;
-    route?: RouteData | undefined;
+    routeData?: RouteData | undefined;
     routeCache: RouteCache;
     pathname: string;
     logger: Logger;
-    ssr: boolean;
+    serverLike: boolean;
 }
-export declare function getParamsAndProps(opts: GetParamsAndPropsOptions): Promise<[Params, Props]>;
+export declare function getProps(opts: GetParamsAndPropsOptions): Promise<Props>;
+/**
+ * When given a route with the pattern `/[x]/[y]/[z]/svelte`, and a pathname `/a/b/c/svelte`,
+ * returns the params object: { x: "a", y: "b", z: "c" }.
+ */
+export declare function getParams(route: RouteData, pathname: string): Params;
 export {};